OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [ltmain.sh] - Diff between revs 157 and 225

Go to most recent revision | Show entire file | Details | Blame | View Log

Rev 157 Rev 225
Line 1... Line 1...
# Generated from ltmain.m4sh; do not edit by hand
# Generated from ltmain.m4sh.
 
 
# ltmain.sh (GNU libtool 1.2435 2007/03/18 18:44:42) 2.1a
# ltmain.sh (GNU libtool) 2.2.6
# Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
# Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
 
 
# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007 2008 Free Software Foundation, Inc.
# This is free software; see the source for copying conditions.  There is NO
# This is free software; see the source for copying conditions.  There is NO
# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
 
# This program is free software; you can redistribute it and/or modify
# GNU Libtool is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
# (at your option) any later version.
#
#
# This program is distributed in the hope that it will be useful, but
# As a special exception to the GNU General Public License,
 
# if you distribute this file as part of a program or library that
 
# is built using GNU Libtool, you may include this file under the
 
# same distribution terms that you use for the rest of that program.
 
#
 
# GNU Libtool is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# General Public License for more details.
# General Public License for more details.
#
#
# You should have received a copy of the GNU General Public License
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# along with GNU Libtool; see the file COPYING.  If not, a copy
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
# can be downloaded from http://www.gnu.org/licenses/gpl.html,
#
# or obtained by writing to the Free Software Foundation, Inc.,
# As a special exception to the GNU General Public License, if you
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
# 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.
 
 
 
# Usage: $progname [OPTION]... [MODE-ARG]...
# Usage: $progname [OPTION]... [MODE-ARG]...
#
#
# Provide generalized library-building support services.
# Provide generalized library-building support services.
#
#
Line 61... Line 63...
#       host-triplet:   $host
#       host-triplet:   $host
#       shell:          $SHELL
#       shell:          $SHELL
#       compiler:               $LTCC
#       compiler:               $LTCC
#       compiler flags:         $LTCFLAGS
#       compiler flags:         $LTCFLAGS
#       linker:         $LD (gnu? $with_gnu_ld)
#       linker:         $LD (gnu? $with_gnu_ld)
#       $progname:              (GNU libtool 1.2435 2007/03/18 18:44:42) 2.1a
#       $progname:              (GNU libtool) 2.2.6
#       automake:               $automake_version
#       automake:               $automake_version
#       autoconf:               $autoconf_version
#       autoconf:               $autoconf_version
#
#
# Report bugs to <bug-libtool@gnu.org>.
# Report bugs to <bug-libtool@gnu.org>.
 
 
PROGRAM=ltmain.sh
PROGRAM=ltmain.sh
PACKAGE=libtool
PACKAGE=libtool
VERSION=2.1a
VERSION=2.2.6
TIMESTAMP=" 1.2435 2007/03/18 18:44:42"
TIMESTAMP=""
package_revision=1.2435
package_revision=1.3012
 
 
# Be Bourne compatible
# Be Bourne compatible
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
  emulate sh
  emulate sh
  NULLCMD=:
  NULLCMD=:
Line 91... Line 93...
 
 
# NLS nuisances: We save the old values to restore during execute mode.
# NLS nuisances: We save the old values to restore during execute mode.
# Only set LANG and LC_ALL to C if already set.
# Only set LANG and LC_ALL to C if already set.
# These must not be set unconditionally because not all systems understand
# These must not be set unconditionally because not all systems understand
# e.g. LANG=C (notably SCO).
# e.g. LANG=C (notably SCO).
for lt_var in LANG LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
lt_user_locale=
 
lt_safe_locale=
 
for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
do
do
  eval "if test \"\${$lt_var+set}\" = set; then
  eval "if test \"\${$lt_var+set}\" = set; then
          save_$lt_var=\$$lt_var
          save_$lt_var=\$$lt_var
          $lt_var=C
          $lt_var=C
          export $lt_var
          export $lt_var
 
          lt_user_locale=\"$lt_var=\\\$save_\$lt_var; \$lt_user_locale\"
 
          lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\"
        fi"
        fi"
done
done
 
 
$lt_unset CDPATH
$lt_unset CDPATH
 
 
Line 108... Line 114...
 
 
 
 
 
 
: ${CP="cp -f"}
: ${CP="cp -f"}
: ${ECHO="echo"}
: ${ECHO="echo"}
: ${EGREP="/bin/grep -E"}
: ${EGREP="/usr/bin/grep -E"}
: ${FGREP="/bin/grep -F"}
: ${FGREP="/usr/bin/grep -F"}
: ${GREP="/bin/grep"}
: ${GREP="/usr/bin/grep"}
: ${LN_S="ln -s"}
: ${LN_S="ln -s"}
: ${MAKE="make"}
: ${MAKE="make"}
: ${MKDIR="mkdir"}
: ${MKDIR="mkdir"}
: ${MV="mv -f"}
: ${MV="mv -f"}
: ${RM="rm -f"}
: ${RM="rm -f"}
: ${SED="/bin/sed"}
: ${SED="/opt/local/bin/gsed"}
: ${SHELL="${CONFIG_SHELL-/bin/sh}"}
: ${SHELL="${CONFIG_SHELL-/bin/sh}"}
: ${Xsed="$SED -e 1s/^X//"}
: ${Xsed="$SED -e 1s/^X//"}
 
 
# Global variables:
# Global variables:
EXIT_SUCCESS=0
EXIT_SUCCESS=0
Line 136... Line 142...
IFS="   $lt_nl"
IFS="   $lt_nl"
 
 
dirname="s,/[^/]*$,,"
dirname="s,/[^/]*$,,"
basename="s,^.*/,,"
basename="s,^.*/,,"
 
 
 
# func_dirname_and_basename file append nondir_replacement
 
# perform func_basename and func_dirname in a single function
 
# call:
 
#   dirname:  Compute the dirname of FILE.  If nonempty,
 
#             add APPEND to the result, otherwise set result
 
#             to NONDIR_REPLACEMENT.
 
#             value returned in "$func_dirname_result"
 
#   basename: Compute filename of FILE.
 
#             value retuned in "$func_basename_result"
 
# Implementation must be kept synchronized with func_dirname
 
# and func_basename. For efficiency, we do not delegate to
 
# those functions but instead duplicate the functionality here.
 
func_dirname_and_basename ()
 
{
 
  # Extract subdirectory from the argument.
 
  func_dirname_result=`$ECHO "X${1}" | $Xsed -e "$dirname"`
 
  if test "X$func_dirname_result" = "X${1}"; then
 
    func_dirname_result="${3}"
 
  else
 
    func_dirname_result="$func_dirname_result${2}"
 
  fi
 
  func_basename_result=`$ECHO "X${1}" | $Xsed -e "$basename"`
 
}
 
 
 
# Generated shell functions inserted here.
 
 
 
# These SED scripts presuppose an absolute path with a trailing slash.
 
pathcar="s,^/\([^/]*\).*$,\1,"
 
pathcdr="s,^/[^/]*,,"
 
removedotparts="s@/\(\./\)\{1,\}@/@g;s,/\.$,/,"
 
collapseslashes="s@/\{1,\}@/@g"
 
finalslash="s,/*$,/,"
 
 
 
# func_normal_abspath PATH
 
# Remove doubled-up and trailing slashes, "." path components,
 
# and cancel out any ".." path components in PATH after making
 
# it an absolute path.
 
#             value returned in "$func_normal_abspath_result"
 
func_normal_abspath ()
 
{
 
  # Start from root dir and reassemble the path.
 
  func_normal_abspath_result=
 
  func_normal_abspath_tpath=$1
 
  func_normal_abspath_altnamespace=
 
  case $func_normal_abspath_tpath in
 
    "")
 
      # Empty path, that just means $cwd.
 
      func_stripname '' '/' "`pwd`"
 
      func_normal_abspath_result=$func_stripname_result
 
      return
 
    ;;
 
    # The next three entries are used to spot a run of precisely
 
    # two leading slashes without using negated character classes;
 
    # we take advantage of case's first-match behaviour.
 
    ///*)
 
      # Unusual form of absolute path, do nothing.
 
    ;;
 
    //*)
 
      # Not necessarily an ordinary path; POSIX reserves leading '//'
 
      # and for example Cygwin uses it to access remote file shares
 
      # over CIFS/SMB, so we conserve a leading double slash if found.
 
      func_normal_abspath_altnamespace=/
 
    ;;
 
    /*)
 
      # Absolute path, do nothing.
 
    ;;
 
    *)
 
      # Relative path, prepend $cwd.
 
      func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath
 
    ;;
 
  esac
 
  # Cancel out all the simple stuff to save iterations.  We also want
 
  # the path to end with a slash for ease of parsing, so make sure
 
  # there is one (and only one) here.
 
  func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
 
        -e "$removedotparts" -e "$collapseslashes" -e "$finalslash"`
 
  while :; do
 
    # Processed it all yet?
 
    if test "$func_normal_abspath_tpath" = / ; then
 
      # If we ascended to the root using ".." the result may be empty now.
 
      if test -z "$func_normal_abspath_result" ; then
 
        func_normal_abspath_result=/
 
      fi
 
      break
 
    fi
 
    func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" | $SED \
 
        -e "$pathcar"`
 
    func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
 
        -e "$pathcdr"`
 
    # Figure out what to do with it
 
    case $func_normal_abspath_tcomponent in
 
      "")
 
        # Trailing empty path component, ignore it.
 
      ;;
 
      ..)
 
        # Parent dir; strip last assembled component from result.
 
        func_dirname "$func_normal_abspath_result"
 
        func_normal_abspath_result=$func_dirname_result
 
      ;;
 
      *)
 
        # Actual path component, append it.
 
        func_normal_abspath_result=$func_normal_abspath_result/$func_normal_abspath_tcomponent
 
      ;;
 
    esac
 
  done
 
  # Restore leading double-slash if one was found on entry.
 
  func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result
 
}
 
 
 
# func_relative_path SRCDIR DSTDIR
 
# generates a relative path from SRCDIR to DSTDIR, with a trailing
 
# slash if non-empty, suitable for immediately appending a filename
 
# without needing to append a separator.
 
#             value returned in "$func_relative_path_result"
 
func_relative_path ()
 
{
 
  func_relative_path_result=
 
  func_normal_abspath "$1"
 
  func_relative_path_tlibdir=$func_normal_abspath_result
 
  func_normal_abspath "$2"
 
  func_relative_path_tbindir=$func_normal_abspath_result
 
 
 
  # Ascend the tree starting from libdir
 
  while :; do
 
    # check if we have found a prefix of bindir
 
    case $func_relative_path_tbindir in
 
      $func_relative_path_tlibdir)
 
        # found an exact match
 
        func_relative_path_tcancelled=
 
        break
 
        ;;
 
      $func_relative_path_tlibdir*)
 
        # found a matching prefix
 
        func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir"
 
        func_relative_path_tcancelled=$func_stripname_result
 
        if test -z "$func_relative_path_result"; then
 
          func_relative_path_result=.
 
        fi
 
        break
 
        ;;
 
      *)
 
        func_dirname $func_relative_path_tlibdir
 
        func_relative_path_tlibdir=${func_dirname_result}
 
        if test "x$func_relative_path_tlibdir" = x ; then
 
          # Have to descend all the way to the root!
 
          func_relative_path_result=../$func_relative_path_result
 
          func_relative_path_tcancelled=$func_relative_path_tbindir
 
          break
 
        fi
 
        func_relative_path_result=../$func_relative_path_result
 
        ;;
 
    esac
 
  done
 
 
 
  # Now calculate path; take care to avoid doubling-up slashes.
 
  func_stripname '' '/' "$func_relative_path_result"
 
  func_relative_path_result=$func_stripname_result
 
  func_stripname '/' '/' "$func_relative_path_tcancelled"
 
  if test "x$func_stripname_result" != x ; then
 
    func_relative_path_result=${func_relative_path_result}/${func_stripname_result}
 
  fi
 
 
 
  # Normalisation. If bindir is libdir, return empty string,
 
  # else relative path ending with a slash; either way, target
 
  # file name can be directly appended.
 
  if test ! -z "$func_relative_path_result"; then
 
    func_stripname './' '' "$func_relative_path_result/"
 
    func_relative_path_result=$func_stripname_result
 
  fi
 
}
 
 
# Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
# 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
# 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
# the _XPG environment variable is not equal to 1 (one), the special
# positional parameter $0, within a function call, is the name of the
# positional parameter $0, within a function call, is the name of the
# function.
# function.
progpath="$0"
progpath="$0"
 
 
# The name of this program:
# The name of this program:
# In the unlikely event $progname began with a '-', it would play havoc with
# In the unlikely event $progname began with a '-', it would play havoc with
# func_echo (imagine progname=-n), so we prepend ./ in that case:
# func_echo (imagine progname=-n), so we prepend ./ in that case:
progname=`$ECHO "X$progpath" | $Xsed -e "$basename" -e 's,^-,./-,'`
func_dirname_and_basename "$progpath"
 
progname=$func_basename_result
 
case $progname in
 
  -*) progname=./$progname ;;
 
esac
 
 
# Make sure we have an absolute path for reexecution:
# Make sure we have an absolute path for reexecution:
case $progpath in
case $progpath in
  [\\/]*|[A-Za-z]:\\*) ;;
  [\\/]*|[A-Za-z]:\\*) ;;
  *[\\/]*)
  *[\\/]*)
     progdir=`$ECHO "X$progpath" | $Xsed -e "$dirname"`
     progdir=$func_dirname_result
     progdir=`cd "$progdir" && pwd`
     progdir=`cd "$progdir" && pwd`
     progpath="$progdir/$progname"
     progpath="$progdir/$progname"
     ;;
     ;;
  *)
  *)
     save_IFS="$IFS"
     save_IFS="$IFS"
Line 198... Line 379...
# Standard options:
# Standard options:
opt_dry_run=false
opt_dry_run=false
opt_help=false
opt_help=false
opt_quiet=false
opt_quiet=false
opt_verbose=false
opt_verbose=false
 
opt_warning=:
 
 
# func_echo arg...
# func_echo arg...
# Echo program name prefixed message, along with the current mode
# Echo program name prefixed message, along with the current mode
# name if it has been set yet.
# name if it has been set yet.
func_echo ()
func_echo ()
{
{
    $ECHO "$progname${mode+: }$mode: "${1+"$@"}
    $ECHO "$progname${mode+: }$mode: $*"
}
}
 
 
# func_verbose arg...
# func_verbose arg...
# Echo program name prefixed message in verbose mode only.
# Echo program name prefixed message in verbose mode only.
func_verbose ()
func_verbose ()
Line 230... Line 412...
 
 
# func_warning arg...
# func_warning arg...
# Echo program name prefixed warning message to standard error.
# Echo program name prefixed warning message to standard error.
func_warning ()
func_warning ()
{
{
    $ECHO "$progname${mode+: }$mode: warning: "${1+"$@"} 1>&2
    $opt_warning && $ECHO "$progname${mode+: }$mode: warning: "${1+"$@"} 1>&2
 
 
 
    # bash bug again:
 
    :
}
}
 
 
# func_fatal_error arg...
# func_fatal_error arg...
# Echo program name prefixed message to standard error, and exit.
# Echo program name prefixed message to standard error, and exit.
func_fatal_error ()
func_fatal_error ()
Line 421... Line 606...
      fi
      fi
    fi
    fi
}
}
 
 
 
 
 
# func_show_eval_locale cmd [fail_exp]
 
# Unless opt_silent is true, then output CMD.  Then, if opt_dryrun is
 
# not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP
 
# is given, then evaluate it.  Use the saved locale for evaluation.
 
func_show_eval_locale ()
 
{
 
    my_cmd="$1"
 
    my_fail_exp="${2-:}"
 
 
 
    ${opt_silent-false} || {
 
      func_quote_for_expand "$my_cmd"
 
      eval "func_echo $func_quote_for_expand_result"
 
    }
 
 
 
    if ${opt_dry_run-false}; then :; else
 
      eval "$lt_user_locale
 
            $my_cmd"
 
      my_status=$?
 
      eval "$lt_safe_locale"
 
      if test "$my_status" -eq 0; then :; else
 
        eval "(exit $my_status); $my_fail_exp"
 
      fi
 
    fi
 
}
 
 
 
 
 
 
 
 
 
 
# func_version
# func_version
# Echo version message to standard output and exit.
# Echo version message to standard output and exit.
Line 513... Line 724...
EOF
EOF
  exit $EXIT_SUCCESS
  exit $EXIT_SUCCESS
fi
fi
 
 
magic="%%%MAGIC variable%%%"
magic="%%%MAGIC variable%%%"
 
magic_exe="%%%MAGIC EXE variable%%%"
 
 
# Global variables.
# Global variables.
# $mode is unset
# $mode is unset
nonopt=
nonopt=
execute_dlfiles=
execute_dlfiles=
Line 624... Line 835...
      fi
      fi
      ;;
      ;;
  esac
  esac
}
}
 
 
 
 
func_mode_help ()
 
{
 
    # We need to display help for each of the modes.
 
    case $mode in
 
      "")
 
        # Generic help is extracted from the usage comments
 
        # at the start of this file.
 
        func_help
 
        ;;
 
 
 
      clean)
 
        $ECHO \
 
"Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
 
 
 
Remove files from the build directory.
 
 
 
RM is the name of the program to use to delete files associated with each FILE
 
(typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
 
to RM.
 
 
 
If FILE is a libtool library, object or program, all the files associated
 
with it are deleted. Otherwise, only FILE itself is deleted using RM."
 
        ;;
 
 
 
      compile)
 
      $ECHO \
 
"Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
 
 
 
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
 
  -no-suppress      do not suppress compiler output for multiple passes
 
  -prefer-pic       try to building PIC objects only
 
  -prefer-non-pic   try to building non-PIC objects only
 
  -shared           do not build a \`.o' file suitable for static linking
 
  -static           only build a \`.o' file suitable for static linking
 
 
 
COMPILE-COMMAND is a command to be used in creating a \`standard' object file
 
from the given SOURCEFILE.
 
 
 
The output file name is determined by removing the directory component from
 
SOURCEFILE, then substituting the C source code suffix \`.c' with the
 
library object suffix, \`.lo'."
 
        ;;
 
 
 
      execute)
 
        $ECHO \
 
"Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...
 
 
 
Automatically set library path, then run a program.
 
 
 
This mode accepts the following additional options:
 
 
 
  -dlopen FILE      add the directory containing FILE to the library path
 
 
 
This mode sets the library path environment variable according to \`-dlopen'
 
flags.
 
 
 
If any of the ARGS are libtool executable wrappers, then they are translated
 
into their corresponding uninstalled binary, and any of their required library
 
directories are added to the library path.
 
 
 
Then, COMMAND is executed, with ARGS as arguments."
 
        ;;
 
 
 
      finish)
 
        $ECHO \
 
"Usage: $progname [OPTION]... --mode=finish [LIBDIR]...
 
 
 
Complete the installation of libtool libraries.
 
 
 
Each LIBDIR is a directory that contains libtool libraries.
 
 
 
The commands that this mode executes may require superuser privileges.  Use
 
the \`--dry-run' option if you just want to see what would be executed."
 
        ;;
 
 
 
      install)
 
        $ECHO \
 
"Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...
 
 
 
Install executables or libraries.
 
 
 
INSTALL-COMMAND is the installation command.  The first component should be
 
either the \`install' or \`cp' program.
 
 
 
The following components of INSTALL-COMMAND are treated specially:
 
 
 
  -inst-prefix PREFIX-DIR  Use PREFIX-DIR as a staging area for installation
 
 
 
The rest of the components are interpreted as arguments to that command (only
 
BSD-compatible install options are recognized)."
 
        ;;
 
 
 
      link)
 
        $ECHO \
 
"Usage: $progname [OPTION]... --mode=link LINK-COMMAND...
 
 
 
Link object files or libraries together to form another library, or to
 
create an executable program.
 
 
 
LINK-COMMAND is a command using the C compiler that you would use to create
 
a program from several object files.
 
 
 
The following components of LINK-COMMAND are treated specially:
 
 
 
  -all-static       do not do any dynamic linking at all
 
  -avoid-version    do not add a version suffix if possible
 
  -dlopen FILE      \`-dlpreopen' FILE if it cannot be dlopened at runtime
 
  -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols
 
  -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
 
  -export-symbols SYMFILE
 
                    try to export only the symbols listed in SYMFILE
 
  -export-symbols-regex REGEX
 
                    try to export only the symbols matching REGEX
 
  -LLIBDIR          search LIBDIR for required installed libraries
 
  -lNAME            OUTPUT-FILE requires the installed library libNAME
 
  -module           build a library that can dlopened
 
  -no-fast-install  disable the fast-install mode
 
  -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
 
  -precious-files-regex REGEX
 
                    don't remove output files matching REGEX
 
  -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
 
  -shared           only do dynamic linking of libtool libraries
 
  -shrext SUFFIX    override the standard shared library file extension
 
  -static           do not do any dynamic linking of uninstalled libtool libraries
 
  -static-libtool-libs
 
                    do not do any dynamic linking of libtool libraries
 
  -version-info CURRENT[:REVISION[:AGE]]
 
                    specify library version info [each variable defaults to 0]
 
  -weak LIBNAME     declare that the target provides the LIBNAME interface
 
 
 
All other options (arguments beginning with \`-') are ignored.
 
 
 
Every other argument is treated as a filename.  Files ending in \`.la' are
 
treated as uninstalled libtool libraries, other files are standard or library
 
object files.
 
 
 
If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
 
only library objects (\`.lo' files) may be specified, and \`-rpath' is
 
required, except when creating a convenience library.
 
 
 
If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
 
using \`ar' and \`ranlib', or on Windows using \`lib'.
 
 
 
If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
 
is created, otherwise an executable program is created."
 
        ;;
 
 
 
      uninstall)
 
        $ECHO \
 
"Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
 
 
 
Remove libraries from an installation directory.
 
 
 
RM is the name of the program to use to delete files associated with each FILE
 
(typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
 
to RM.
 
 
 
If FILE is a libtool library, all the files associated with it are deleted.
 
Otherwise, only FILE itself is deleted using RM."
 
        ;;
 
 
 
      *)
 
        func_fatal_help "invalid operation mode \`$mode'"
 
        ;;
 
    esac
 
 
 
    $ECHO
 
    $ECHO "Try \`$progname --help' for more information about other modes."
 
 
 
    exit $?
 
}
 
 
 
# Generated shell functions inserted here.
 
 
 
 
 
# Parse options once, thoroughly.  This comes as soon as possible in
# Parse options once, thoroughly.  This comes as soon as possible in
# the script to make things like `libtool --version' happen quickly.
# the script to make things like `libtool --version' happen quickly.
{
{
 
 
  # Shorthand for --mode=foo, only valid as the first argument
  # Shorthand for --mode=foo, only valid as the first argument
Line 920... Line 946...
                        break
                        break
                        ;;
                        ;;
    esac
    esac
  done
  done
 
 
  # Now that we've collected a possible --mode arg, show help if necessary
 
  $opt_help && func_mode_help
 
 
 
  case $host in
  case $host in
    *cygwin* | *mingw* | *pw32*)
    *cygwin* | *mingw* | *pw32* | *cegcc*)
      # don't eliminate duplications in $postdeps and $predeps
      # don't eliminate duplications in $postdeps and $predeps
      opt_duplicate_compiler_generated_deps=:
      opt_duplicate_compiler_generated_deps=:
      ;;
      ;;
    *)
    *)
      opt_duplicate_compiler_generated_deps=$opt_duplicate_deps
      opt_duplicate_compiler_generated_deps=$opt_duplicate_deps
Line 978... Line 1002...
 
 
## ----------- ##
## ----------- ##
##    Main.    ##
##    Main.    ##
## ----------- ##
## ----------- ##
 
 
{
$opt_help || {
  # Sanity checks first:
  # Sanity checks first:
  func_check_version_match
  func_check_version_match
 
 
  if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
  if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
    func_fatal_configuration "not configured to build any kind of library"
    func_fatal_configuration "not configured to build any kind of library"
Line 1012... Line 1036...
# True iff FILE is a libtool `.la' library or `.lo' object file.
# True iff FILE is a libtool `.la' library or `.lo' object file.
# This function is only a basic sanity check; it will hardly flush out
# This function is only a basic sanity check; it will hardly flush out
# determined imposters.
# determined imposters.
func_lalib_p ()
func_lalib_p ()
{
{
 
    test -f "$1" &&
    $SED -e 4q "$1" 2>/dev/null \
    $SED -e 4q "$1" 2>/dev/null \
      | $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
      | $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
}
}
 
 
# func_lalib_unsafe_p file
# func_lalib_unsafe_p file
Line 1026... Line 1051...
# As a safety measure, use it only where a negative result would be
# As a safety measure, use it only where a negative result would be
# fatal anyway.  Works if `file' does not exist.
# fatal anyway.  Works if `file' does not exist.
func_lalib_unsafe_p ()
func_lalib_unsafe_p ()
{
{
    lalib_p=no
    lalib_p=no
    if test -r "$1" && exec 5<&1 <"$1"; then
    if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then
        for lalib_p_l in 1 2 3 4
        for lalib_p_l in 1 2 3 4
        do
        do
            read lalib_p_line
            read lalib_p_line
            case "$lalib_p_line" in
            case "$lalib_p_line" in
                \#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;
                \#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;
            esac
            esac
        done
        done
        exec 1<&5 5<&-
        exec 0<&5 5<&-
    fi
    fi
    test "$lalib_p" = yes
    test "$lalib_p" = yes
}
}
 
 
 
# func_ltwrapper_script_p file
 
# True iff FILE is a libtool wrapper script
 
# This function is only a basic sanity check; it will hardly flush out
 
# determined imposters.
 
func_ltwrapper_script_p ()
 
{
 
    func_lalib_p "$1"
 
}
 
 
 
# func_ltwrapper_executable_p file
 
# True iff FILE is a libtool wrapper executable
 
# This function is only a basic sanity check; it will hardly flush out
 
# determined imposters.
 
func_ltwrapper_executable_p ()
 
{
 
    func_ltwrapper_exec_suffix=
 
    case $1 in
 
    *.exe) ;;
 
    *) func_ltwrapper_exec_suffix=.exe ;;
 
    esac
 
    $GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1
 
}
 
 
 
# func_ltwrapper_scriptname file
 
# Assumes file is an ltwrapper_executable
 
# uses $file to determine the appropriate filename for a
 
# temporary ltwrapper_script.
 
func_ltwrapper_scriptname ()
 
{
 
    func_ltwrapper_scriptname_result=""
 
    if func_ltwrapper_executable_p "$1"; then
 
        func_dirname_and_basename "$1" "" "."
 
        func_stripname '' '.exe' "$func_basename_result"
 
        func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"
 
    fi
 
}
 
 
# func_ltwrapper_p file
# func_ltwrapper_p file
# True iff FILE is a libtool wrapper script.
# True iff FILE is a libtool wrapper script or wrapper executable
# This function is only a basic sanity check; it will hardly flush out
# This function is only a basic sanity check; it will hardly flush out
# determined imposters.
# determined imposters.
func_ltwrapper_p ()
func_ltwrapper_p ()
{
{
    func_lalib_p "$1"
    func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1"
}
}
 
 
 
 
# func_execute_cmds commands fail_cmd
# func_execute_cmds commands fail_cmd
# Execute tilde-delimited COMMANDS.
# Execute tilde-delimited COMMANDS.
Line 1082... Line 1144...
    *)          . "./$1" ;;
    *)          . "./$1" ;;
    esac
    esac
}
}
 
 
 
 
# 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 ()
 
{
 
  $opt_debug
 
  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 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then
 
      win32_nmres=`eval $NM -f posix -A $1 |
 
        $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
 
    ;;
 
  *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
# func_infer_tag arg
# Infer tagged configuration to use if any are available and
# Infer tagged configuration to use if any are available and
# if one wasn't chosen via the "--tag" command line option.
# if one wasn't chosen via the "--tag" command line option.
# Only attempt this if the compiler in the base compile
# Only attempt this if the compiler in the base compile
# command doesn't match the default compiler.
# command doesn't match the default compiler.
Line 1190... Line 1203...
    fi
    fi
}
}
 
 
 
 
 
 
# func_generate_dlsyms outputname originator pic_p
# func_write_libtool_object output_name pic_name nonpic_name
# Extract symbols from dlprefiles and create ${outputname}S.o with
# Create a libtool object file (analogous to a ".la" file),
# a dlpreopen symbol table.
# but don't create it if we're doing a dry run.
func_generate_dlsyms ()
func_write_libtool_object ()
{
{
    $opt_debug
    write_libobj=${1}
    my_outputname="$1"
    if test "$build_libtool_libs" = yes; then
    my_originator="$2"
      write_lobj=\'${2}\'
    my_pic_p="${3-no}"
 
    my_prefix=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'`
 
    my_dlsyms=
 
 
 
    if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
 
      if test -n "$NM" && test -n "$global_symbol_pipe"; then
 
        my_dlsyms="${my_outputname}S.c"
 
      else
      else
        func_error "not configured to extract global symbols from dlpreopened files"
      write_lobj=none
      fi
 
    fi
    fi
 
 
    if test -n "$my_dlsyms"; then
    if test "$build_old_libs" = yes; then
      case $my_dlsyms in
      write_oldobj=\'${3}\'
      "") ;;
    else
      *.c)
      write_oldobj=none
        # Discover the nlist of each of the dlfiles.
    fi
        nlist="$output_objdir/${my_outputname}.nm"
 
 
 
        func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
 
 
 
        # Parse the name list into a source file.
    $opt_dry_run || {
        func_echo "creating $output_objdir/$my_dlsyms"
      cat >${write_libobj}T <<EOF
 
# $write_libobj - a libtool object file
 
# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
 
#
 
# Please DO NOT delete this file!
 
# It is necessary for linking the library.
 
 
        $opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\
# Name of the PIC object.
/* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */
pic_object=$write_lobj
/* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */
 
 
 
#ifdef __cplusplus
# Name of the non-PIC object
extern \"C\" {
non_pic_object=$write_oldobj
#endif
 
 
 
/* External symbol declarations for the compiler. */\
EOF
"
      $MV "${write_libobj}T" "${write_libobj}"
 
    }
 
}
 
 
        if test "$dlself" = yes; then
# func_mode_compile arg...
          func_echo "generating symbol list for \`$output'"
func_mode_compile ()
 
{
 
    $opt_debug
 
    # 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=
 
    pie_flag=
 
 
          $opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
    for arg
 
    do
 
      case $arg_mode in
 
      arg  )
 
        # do not "continue".  Instead, add this to base_compile
 
        lastarg="$arg"
 
        arg_mode=normal
 
        ;;
 
 
          # Add our own program objects to the symbol list.
      target )
          progfiles=`$ECHO "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
        libobj="$arg"
          for progfile in $progfiles; do
        arg_mode=normal
            func_echo "extracting global C symbols from \`$progfile'"
        continue
            $opt_dry_run || eval "$NM $progfile | $global_symbol_pipe >> '$nlist'"
        ;;
          done
 
 
 
          if test -n "$exclude_expsyms"; then
      normal )
            $opt_dry_run || {
        # Accept any command-line options.
              eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
        case $arg in
              eval '$MV "$nlist"T "$nlist"'
        -o)
            }
          test -n "$libobj" && \
          fi
            func_fatal_error "you cannot specify \`-o' more than once"
 
          arg_mode=target
 
          continue
 
          ;;
 
 
          if test -n "$export_symbols_regex"; then
        -pie | -fpie | -fPIE)
            $opt_dry_run || {
          pie_flag="$pie_flag $arg"
              eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
          continue
              eval '$MV "$nlist"T "$nlist"'
          ;;
            }
 
          fi
 
 
 
          # Prepare the list of exported symbols
        -shared | -static | -prefer-pic | -prefer-non-pic)
          if test -z "$export_symbols"; then
          later="$later $arg"
            export_symbols="$output_objdir/$outputname.exp"
          continue
            $opt_dry_run || {
 
              $RM $export_symbols
 
              eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
 
              case $host in
 
              *cygwin* | *mingw* )
 
                eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
 
                eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
 
                ;;
                ;;
              esac
 
            }
        -no-suppress)
          else
          suppress_opt=no
            $opt_dry_run || {
          continue
              eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
 
              eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
 
              eval '$MV "$nlist"T "$nlist"'
 
              case $host in
 
                *cygwin | *mingw* )
 
                  eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
 
                  eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
 
                  ;;
                  ;;
              esac
 
            }
 
          fi
 
        fi
 
 
 
        for dlprefile in $dlprefiles; do
        -Xcompiler)
          func_echo "extracting global C symbols from \`$dlprefile'"
          arg_mode=arg  #  the next one goes into the "base_compile" arg list
          func_basename "$dlprefile"
          continue      #  The current "srcfile" will either be retained or
          name="$func_basename_result"
          ;;            #  replaced later.  I would guess that would be a bug.
          $opt_dry_run || {
 
            eval '$ECHO ": $name " >> "$nlist"'
 
            eval "$NM $dlprefile 2>/dev/null | $global_symbol_pipe >> '$nlist'"
 
          }
 
        done
 
 
 
        $opt_dry_run || {
        -Wc,*)
          # Make sure we have at least an empty file.
          func_stripname '-Wc,' '' "$arg"
          test -f "$nlist" || : > "$nlist"
          args=$func_stripname_result
 
          lastarg=
 
          save_ifs="$IFS"; IFS=','
 
          for arg in $args; do
 
            IFS="$save_ifs"
 
            func_quote_for_eval "$arg"
 
            lastarg="$lastarg $func_quote_for_eval_result"
 
          done
 
          IFS="$save_ifs"
 
          func_stripname ' ' '' "$lastarg"
 
          lastarg=$func_stripname_result
 
 
          if test -n "$exclude_expsyms"; then
          # Add the arguments to base_compile.
            $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
          base_compile="$base_compile $lastarg"
            $MV "$nlist"T "$nlist"
          continue
          fi
          ;;
 
 
          # Try sorting and uniquifying the output.
        *)
          if $GREP -v "^: " < "$nlist" |
          # Accept the current argument as the source file.
              if sort -k 3 </dev/null >/dev/null 2>&1; then
          # The previous "srcfile" becomes the current argument.
                sort -k 3
          #
              else
          lastarg="$srcfile"
                sort +2
          srcfile="$arg"
              fi |
          ;;
              uniq > "$nlist"S; then
        esac  #  case $arg
            :
        ;;
          else
      esac    #  case $arg_mode
            $GREP -v "^: " < "$nlist" > "$nlist"S
 
          fi
 
 
 
          if test -f "$nlist"S; then
 
            eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
 
          else
 
            $ECHO '/* NONE */' >> "$output_objdir/$my_dlsyms"
 
          fi
 
 
 
          $ECHO >> "$output_objdir/$my_dlsyms" "\
      # Aesthetically quote the previous argument.
 
      func_quote_for_eval "$lastarg"
 
      base_compile="$base_compile $func_quote_for_eval_result"
 
    done # for arg
 
 
/* The mapping between symbol names and symbols.  */
    case $arg_mode in
typedef struct {
    arg)
  const char *name;
      func_fatal_error "you must specify an argument for -Xcompile"
  void *address;
      ;;
} lt_dlsymlist;
    target)
"
      func_fatal_error "you must specify a target with \`-o'"
          case $host in
      ;;
          *cygwin* | *mingw* )
 
            $ECHO >> "$output_objdir/$my_dlsyms" "\
 
/* DATA imports from DLLs on WIN32 con't be const, because
 
   runtime relocations are performed -- see ld's documentation
 
   on pseudo-relocs.  */"
 
            lt_dlsym_const= ;;
 
          *osf5*)
 
            echo >> "$output_objdir/$my_dlsyms" "\
 
/* This system does not cope well with relocations in const data */"
 
            lt_dlsym_const= ;;
 
          *)
          *)
            lt_dlsym_const=const ;;
      # Get the name of the library object.
 
      test -z "$libobj" && {
 
        func_basename "$srcfile"
 
        libobj="$func_basename_result"
 
      }
 
      ;;
          esac
          esac
 
 
          $ECHO >> "$output_objdir/$my_dlsyms" "\
    # Recognize several different file suffixes.
extern $lt_dlsym_const lt_dlsymlist
    # If the user specifies -o file.o, it is replaced with file.lo
lt_${my_prefix}_LTX_preloaded_symbols[];
    case $libobj in
$lt_dlsym_const lt_dlsymlist
    *.[cCFSifmso] | \
lt_${my_prefix}_LTX_preloaded_symbols[] =
    *.ada | *.adb | *.ads | *.asm | \
{\
    *.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
  { \"$my_originator\", (void *) 0 },"
    *.[fF][09]? | *.for | *.java | *.obj | *.sx)
 
      func_xform "$libobj"
 
      libobj=$func_xform_result
 
      ;;
 
    esac
 
 
          eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
    case $libobj in
 
    *.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;
 
    *)
 
      func_fatal_error "cannot determine name of library object from \`$libobj'"
 
      ;;
 
    esac
 
 
          $ECHO >> "$output_objdir/$my_dlsyms" "\
    func_infer_tag $base_compile
  {0, (void *) 0}
 
};
 
 
 
/* This works around a problem in FreeBSD linker */
    for arg in $later; do
#ifdef FREEBSD_WORKAROUND
      case $arg in
static const void *lt_preloaded_setup() {
      -shared)
  return lt_${my_prefix}_LTX_preloaded_symbols;
        test "$build_libtool_libs" != yes && \
}
          func_fatal_configuration "can not build a shared library"
#endif
        build_old_libs=no
 
        continue
 
        ;;
 
 
#ifdef __cplusplus
      -static)
}
        build_libtool_libs=no
#endif\
        build_old_libs=yes
"
        continue
        } # !$opt_dry_run
        ;;
 
 
        pic_flag_for_symtable=
      -prefer-pic)
        case "$compile_command " in
        pic_mode=yes
        *" -static "*) ;;
        continue
        *)
 
          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
 
          # pic_flag when linking with -static.  The problem exists in
 
          # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
 
          *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
 
            pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
 
          *-*-hpux*)
 
            pic_flag_for_symtable=" $pic_flag"  ;;
 
          *)
 
            if test "X$my_pic_p" != Xno; then
 
              pic_flag_for_symtable=" $pic_flag"
 
            fi
 
            ;;
            ;;
          esac
 
 
      -prefer-non-pic)
 
        pic_mode=no
 
        continue
          ;;
          ;;
        esac
        esac
        symtab_cflags=
 
        for arg in $LTCFLAGS; do
 
          case $arg in
 
          -pie | -fpie | -fPIE) ;;
 
          *) symtab_cflags="$symtab_cflags $arg" ;;
 
          esac
 
        done
        done
 
 
        # Now compile the dynamic symbol file.
    func_quote_for_eval "$libobj"
        func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
    test "X$libobj" != "X$func_quote_for_eval_result" \
 
      && $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"'    &()|`$[]' \
 
      && func_warning "libobj name \`$libobj' may not contain shell special characters."
 
    func_dirname_and_basename "$obj" "/" ""
 
    objname="$func_basename_result"
 
    xdir="$func_dirname_result"
 
    lobj=${xdir}$objdir/$objname
 
 
        # Clean up the generated files.
    test -z "$base_compile" && \
        func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"'
      func_fatal_help "you must specify a compilation command"
 
 
        # Transform the symbol file into the correct name.
    # Delete any leftover library objects.
        symfileobj="$output_objdir/${my_outputname}S.$objext"
    if test "$build_old_libs" = yes; then
        case $host in
      removelist="$obj $lobj $libobj ${libobj}T"
        *cygwin* | *mingw* )
 
          if test -f "$output_objdir/$my_outputname.def"; then
 
            compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
 
            finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
 
          else
          else
            compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
      removelist="$lobj $libobj ${libobj}T"
            finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
 
          fi
          fi
          ;;
 
        *)
    # On Cygwin there's no "real" PIC flag so we must build both object types
          compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
    case $host_os in
          finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
    cygwin* | mingw* | pw32* | os2* | cegcc*)
          ;;
      pic_mode=default
        esac
 
        ;;
 
      *)
 
        func_fatal_error "unknown suffix for \`$my_dlsyms'"
 
        ;;
        ;;
      esac
      esac
    else
    if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
      # We keep going just in case the user didn't refer to
      # non-PIC code in shared libraries is not supported
      # lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
      pic_mode=default
      # really was required.
 
 
 
      # Nullify the symbol file.
 
      compile_command=`$ECHO "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
 
      finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
 
    fi
    fi
}
 
 
 
# func_extract_an_archive dir oldlib
    # Calculate the filename of the output object if compiler does
func_extract_an_archive ()
    # not support -o with -c
{
    if test "$compiler_c_o" = no; then
    $opt_debug
      output_obj=`$ECHO "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}
    f_ex_an_ar_dir="$1"; shift
      lockfile="$output_obj.lock"
    f_ex_an_ar_oldlib="$1"
 
    func_show_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
    else
      func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
      output_obj=
 
      need_locks=no
 
      lockfile=
    fi
    fi
}
 
 
 
 
 
# func_extract_archives gentop oldlib ...
    # Lock this critical section if it is needed
func_extract_archives ()
    # We use this script file to make the link, it avoids creating a new file
{
    if test "$need_locks" = yes; then
    $opt_debug
      until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
    my_gentop="$1"; shift
        func_echo "Waiting for $lockfile to be removed"
    my_oldlibs=${1+"$@"}
        sleep 2
    my_oldobjs=""
 
    my_xlib=""
 
    my_xabs=""
 
    my_xdir=""
 
 
 
    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
 
      func_basename "$my_xlib"
 
      my_xlib="$func_basename_result"
 
      my_xlib_u=$my_xlib
 
      while :; do
 
        case " $extracted_archives " in
 
        *" $my_xlib_u "*)
 
          extracted_serial=`expr $extracted_serial + 1`
 
          my_xlib_u=lt$extracted_serial-$my_xlib ;;
 
        *) break ;;
 
        esac
 
      done
      done
      extracted_archives="$extracted_archives $my_xlib_u"
    elif test "$need_locks" = warn; then
      my_xdir="$my_gentop/$my_xlib_u"
      if test -f "$lockfile"; then
 
        $ECHO "\
 
*** ERROR, $lockfile exists and contains:
 
`cat $lockfile 2>/dev/null`
 
 
      func_mkdir_p "$my_xdir"
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."
 
 
      case $host in
        $opt_dry_run || $RM $removelist
      *-darwin*)
        exit $EXIT_FAILURE
        func_echo "Extracting $my_xabs"
      fi
        # Do not bother doing anything if just a dry run
      removelist="$removelist $output_obj"
        $opt_dry_run || {
      $ECHO "$srcfile" > "$lockfile"
          darwin_orig_dir=`pwd`
    fi
          cd $my_xdir || exit $?
 
          darwin_archive=$my_xabs
 
          darwin_curdir=`pwd`
 
          darwin_base_archive=`basename $darwin_archive`
 
          darwin_arches=`lipo -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
 
          if test -n "$darwin_arches"; then
 
            darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
 
            darwin_arch=
 
            func_echo "$darwin_base_archive has multiple architectures $darwin_arches"
 
            for darwin_arch in  $darwin_arches ; do
 
              func_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}"
 
              func_extract_an_archive "`pwd`" "${darwin_base_archive}"
 
              cd "$darwin_curdir"
 
              $RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
 
            done # $darwin_arches
 
            ## Okay now we've a bunch of thin objects, gotta fatten them up :)
 
            darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print| xargs basename | sort -u | $NL2SP`
 
            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
 
            $RM -rf unfat-$$
 
            cd "$darwin_orig_dir"
 
          else
 
            cd $darwin_orig_dir
 
            func_extract_an_archive "$my_xdir" "$my_xabs"
 
          fi # $darwin_arches
 
        } # !$opt_dry_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"
 
}
 
 
 
 
    $opt_dry_run || $RM $removelist
 
    removelist="$removelist $lockfile"
 
    trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
 
 
 
    if test -n "$fix_srcfile_path"; then
 
      eval srcfile=\"$fix_srcfile_path\"
 
    fi
 
    func_quote_for_eval "$srcfile"
 
    qsrcfile=$func_quote_for_eval_result
 
 
# func_write_libtool_object output_name pic_name nonpic_name
    # Only build a PIC object if we are building libtool libraries.
# Create a libtool object file (analogous to a ".la" file),
 
# but don't create it if we're doing a dry run.
 
func_write_libtool_object ()
 
{
 
    write_libobj=${1}
 
    if test "$build_libtool_libs" = yes; then
    if test "$build_libtool_libs" = yes; then
      write_lobj=\'${2}\'
      # Without this assignment, base_compile gets emptied.
 
      fbsd_hideous_sh_bug=$base_compile
 
 
 
      if test "$pic_mode" != no; then
 
        command="$base_compile $qsrcfile $pic_flag"
    else
    else
      write_lobj=none
        # Don't build PIC code
 
        command="$base_compile $qsrcfile"
 
      fi
 
 
 
      func_mkdir_p "$xdir$objdir"
 
 
 
      if test -z "$output_obj"; then
 
        # Place PIC objects in $objdir
 
        command="$command -o $lobj"
 
      fi
 
 
 
      func_show_eval_locale "$command"  \
 
          'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'
 
 
 
      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."
 
 
 
        $opt_dry_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
 
        func_show_eval '$MV "$output_obj" "$lobj"' \
 
          'error=$?; $opt_dry_run || $RM $removelist; exit $error'
 
      fi
 
 
 
      # Allow error messages only from the first compilation.
 
      if test "$suppress_opt" = yes; then
 
        suppress_output=' >/dev/null 2>&1'
 
      fi
    fi
    fi
 
 
 
    # Only build a position-dependent object if we build old libraries.
    if test "$build_old_libs" = yes; then
    if test "$build_old_libs" = yes; then
      write_oldobj=\'${3}\'
      if test "$pic_mode" != yes; then
 
        # Don't build PIC code
 
        command="$base_compile $qsrcfile$pie_flag"
    else
    else
      write_oldobj=none
        command="$base_compile $qsrcfile $pic_flag"
 
      fi
 
      if test "$compiler_c_o" = yes; then
 
        command="$command -o $obj"
    fi
    fi
 
 
    $opt_dry_run || {
      # Suppress compiler output if we already did a PIC compilation.
      cat >${write_libobj}T <<EOF
      command="$command$suppress_output"
# $write_libobj - a libtool object file
      func_show_eval_locale "$command" \
# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
        '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
#
 
# Please DO NOT delete this file!
 
# It is necessary for linking the library.
 
 
 
# Name of the PIC object.
      if test "$need_locks" = warn &&
pic_object=$write_lobj
         test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
 
        $ECHO "\
 
*** ERROR, $lockfile contains:
 
`cat $lockfile 2>/dev/null`
 
 
# Name of the non-PIC object
but it should contain:
non_pic_object=$write_oldobj
$srcfile
 
 
EOF
This indicates that another process is trying to use the same
      mv -f "${write_libobj}T" "${write_libobj}"
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."
 
 
 
        $opt_dry_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
 
        func_show_eval '$MV "$output_obj" "$obj"' \
 
          'error=$?; $opt_dry_run || $RM $removelist; exit $error'
 
      fi
 
    fi
 
 
 
    $opt_dry_run || {
 
      func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"
 
 
 
      # Unlock the critical section if it was locked
 
      if test "$need_locks" != no; then
 
        removelist=$lockfile
 
        $RM "$lockfile"
 
      fi
    }
    }
 
 
 
    exit $EXIT_SUCCESS
}
}
 
 
# func_mode_compile arg...
$opt_help || {
func_mode_compile ()
test "$mode" = compile && func_mode_compile ${1+"$@"}
{
}
    $opt_debug
 
    # 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=
 
    pie_flag=
 
 
 
    for arg
func_mode_help ()
    do
{
      case $arg_mode in
    # We need to display help for each of the modes.
      arg  )
    case $mode in
        # do not "continue".  Instead, add this to base_compile
      "")
        lastarg="$arg"
        # Generic help is extracted from the usage comments
        arg_mode=normal
        # at the start of this file.
 
        func_help
        ;;
        ;;
 
 
      target )
      clean)
        libobj="$arg"
        $ECHO \
        arg_mode=normal
"Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
        continue
 
        ;;
 
 
 
      normal )
Remove files from the build directory.
        # Accept any command-line options.
 
        case $arg in
 
        -o)
 
          test -n "$libobj" && \
 
            func_fatal_error "you cannot specify \`-o' more than once"
 
          arg_mode=target
 
          continue
 
          ;;
 
 
 
        -pie | -fpie | -fPIE)
RM is the name of the program to use to delete files associated with each FILE
          pie_flag="$pie_flag $arg"
(typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
          continue
to RM.
          ;;
 
 
 
        -shared | -static | -prefer-pic | -prefer-non-pic)
If FILE is a libtool library, object or program, all the files associated
          later="$later $arg"
with it are deleted. Otherwise, only FILE itself is deleted using RM."
          continue
 
          ;;
          ;;
 
 
        -no-suppress)
      compile)
          suppress_opt=no
      $ECHO \
          continue
"Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
          ;;
 
 
 
        -Xcompiler)
Compile a source file into a libtool library object.
          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,*)
This mode accepts the following additional options:
          func_stripname '-Wc,' '' "$arg"
 
          args=$func_stripname_result
 
          lastarg=
 
          save_ifs="$IFS"; IFS=','
 
          for arg in $args; do
 
            IFS="$save_ifs"
 
            func_quote_for_eval "$arg"
 
            lastarg="$lastarg $func_quote_for_eval_result"
 
          done
 
          IFS="$save_ifs"
 
          func_stripname ' ' '' "$lastarg"
 
          lastarg=$func_stripname_result
 
 
 
          # Add the arguments to base_compile.
  -o OUTPUT-FILE    set the output file name to OUTPUT-FILE
          base_compile="$base_compile $lastarg"
  -no-suppress      do not suppress compiler output for multiple passes
          continue
  -prefer-pic       try to building PIC objects only
          ;;
  -prefer-non-pic   try to building non-PIC objects only
 
  -shared           do not build a \`.o' file suitable for static linking
 
  -static           only build a \`.o' file suitable for static linking
 
 
        *)
COMPILE-COMMAND is a command to be used in creating a \`standard' object file
          # Accept the current argument as the source file.
from the given SOURCEFILE.
          # The previous "srcfile" becomes the current argument.
 
          #
The output file name is determined by removing the directory component from
          lastarg="$srcfile"
SOURCEFILE, then substituting the C source code suffix \`.c' with the
          srcfile="$arg"
library object suffix, \`.lo'."
          ;;
 
        esac  #  case $arg
 
        ;;
        ;;
      esac    #  case $arg_mode
 
 
 
      # Aesthetically quote the previous argument.
      execute)
      func_quote_for_eval "$lastarg"
        $ECHO \
      base_compile="$base_compile $func_quote_for_eval_result"
"Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...
    done # for arg
 
 
 
    case $arg_mode in
Automatically set library path, then run a program.
    arg)
 
      func_fatal_error "you must specify an argument for -Xcompile"
 
      ;;
 
    target)
 
      func_fatal_error "you must specify a target with \`-o'"
 
      ;;
 
    *)
 
      # Get the name of the library object.
 
      test -z "$libobj" && {
 
        func_basename "$srcfile"
 
        libobj="$func_basename_result"
 
      }
 
      ;;
 
    esac
 
 
 
    # Recognize several different file suffixes.
This mode accepts the following additional options:
    # 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 ;;
 
    *.[fF][09]?) xform='[fF][09].' ;;
 
    *.for) xform=for ;;
 
    *.java) xform=java ;;
 
    *.obj) xform=obj ;;
 
    esac
 
 
 
    libobj=`$ECHO "X$libobj" | $Xsed -e "s/\.$xform$/.lo/"`
  -dlopen FILE      add the directory containing FILE to the library path
 
 
    case $libobj in
This mode sets the library path environment variable according to \`-dlopen'
    *.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;
flags.
    *)
 
      func_fatal_error "cannot determine name of library object from \`$libobj'"
 
      ;;
 
    esac
 
 
 
    func_infer_tag $base_compile
If any of the ARGS are libtool executable wrappers, then they are translated
 
into their corresponding uninstalled binary, and any of their required library
 
directories are added to the library path.
 
 
    for arg in $later; do
Then, COMMAND is executed, with ARGS as arguments."
      case $arg in
 
      -shared)
 
        test "$build_libtool_libs" != yes && \
 
          func_fatal_configuration "can not build a shared library"
 
        build_old_libs=no
 
        continue
 
        ;;
        ;;
 
 
      -static)
      finish)
        build_libtool_libs=no
        $ECHO \
        build_old_libs=yes
"Usage: $progname [OPTION]... --mode=finish [LIBDIR]...
        continue
 
        ;;
 
 
 
      -prefer-pic)
Complete the installation of libtool libraries.
        pic_mode=yes
 
        continue
 
        ;;
 
 
 
      -prefer-non-pic)
Each LIBDIR is a directory that contains libtool libraries.
        pic_mode=no
 
        continue
The commands that this mode executes may require superuser privileges.  Use
 
the \`--dry-run' option if you just want to see what would be executed."
        ;;
        ;;
      esac
 
    done
 
 
 
    func_quote_for_eval "$libobj"
      install)
    test "X$libobj" != "X$func_quote_for_eval_result" \
        $ECHO \
      && $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"'   &()|`$[]' \
"Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...
      && func_warning "libobj name \`$libobj' may not contain shell special characters."
 
    func_basename "$obj"
 
    objname="$func_basename_result"
 
    func_dirname "$obj" "/" ""
 
    xdir="$func_dirname_result"
 
    lobj=${xdir}$objdir/$objname
 
 
 
    test -z "$base_compile" && \
Install executables or libraries.
      func_fatal_help "you must specify a compilation command"
 
 
 
    # Delete any leftover library objects.
INSTALL-COMMAND is the installation command.  The first component should be
    if test "$build_old_libs" = yes; then
either the \`install' or \`cp' program.
      removelist="$obj $lobj $libobj ${libobj}T"
 
    else
 
      removelist="$lobj $libobj ${libobj}T"
 
    fi
 
 
 
    $opt_dry_run || $RM $removelist
The following components of INSTALL-COMMAND are treated specially:
    trap "$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE" 1 2 15
 
 
 
    # On Cygwin there's no "real" PIC flag so we must build both object types
  -inst-prefix PREFIX-DIR  Use PREFIX-DIR as a staging area for installation
    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
The rest of the components are interpreted as arguments to that command (only
    # not support -o with -c
BSD-compatible install options are recognized)."
    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 "$opt_dry_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
      link)
    # We use this script file to make the link, it avoids creating a new file
        $ECHO \
    if test "$need_locks" = yes; then
"Usage: $progname [OPTION]... --mode=link LINK-COMMAND...
      until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
 
        func_echo "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
Link object files or libraries together to form another library, or to
temporary object file, and libtool could not work around it because
create an executable program.
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."
 
 
 
        $opt_dry_run || $RM $removelist
LINK-COMMAND is a command using the C compiler that you would use to create
        exit $EXIT_FAILURE
a program from several object files.
      fi
 
      $ECHO "$srcfile" > "$lockfile"
 
    fi
 
 
 
    if test -n "$fix_srcfile_path"; then
The following components of LINK-COMMAND are treated specially:
      eval srcfile=\"$fix_srcfile_path\"
 
    fi
 
    func_quote_for_eval "$srcfile"
 
    qsrcfile=$func_quote_for_eval_result
 
 
 
    $opt_dry_run || $RM "$libobj" "${libobj}T"
  -all-static       do not do any dynamic linking at all
 
  -avoid-version    do not add a version suffix if possible
 
  -bindir BINDIR    specify path to binaries directory (for systems where
 
                    libraries must be found in the PATH setting at runtime)
 
  -dlopen FILE      \`-dlpreopen' FILE if it cannot be dlopened at runtime
 
  -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols
 
  -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
 
  -export-symbols SYMFILE
 
                    try to export only the symbols listed in SYMFILE
 
  -export-symbols-regex REGEX
 
                    try to export only the symbols matching REGEX
 
  -LLIBDIR          search LIBDIR for required installed libraries
 
  -lNAME            OUTPUT-FILE requires the installed library libNAME
 
  -module           build a library that can dlopened
 
  -no-fast-install  disable the fast-install mode
 
  -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
 
  -precious-files-regex REGEX
 
                    don't remove output files matching REGEX
 
  -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
 
  -shared           only do dynamic linking of libtool libraries
 
  -shrext SUFFIX    override the standard shared library file extension
 
  -static           do not do any dynamic linking of uninstalled libtool libraries
 
  -static-libtool-libs
 
                    do not do any dynamic linking of libtool libraries
 
  -version-info CURRENT[:REVISION[:AGE]]
 
                    specify library version info [each variable defaults to 0]
 
  -weak LIBNAME     declare that the target provides the LIBNAME interface
 
 
    # Only build a PIC object if we are building libtool libraries.
All other options (arguments beginning with \`-') are ignored.
    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
Every other argument is treated as a filename.  Files ending in \`.la' are
        command="$base_compile $qsrcfile $pic_flag"
treated as uninstalled libtool libraries, other files are standard or library
      else
object files.
        # Don't build PIC code
 
        command="$base_compile $qsrcfile"
 
      fi
 
 
 
      func_mkdir_p "$xdir$objdir"
If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
 
only library objects (\`.lo' files) may be specified, and \`-rpath' is
 
required, except when creating a convenience library.
 
 
      if test -z "$output_obj"; then
If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
        # Place PIC objects in $objdir
using \`ar' and \`ranlib', or on Windows using \`lib'.
        command="$command -o $lobj"
 
      fi
 
 
 
      $opt_dry_run || $RM "$lobj" "$output_obj"
If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
 
is created, otherwise an executable program is created."
 
        ;;
 
 
      func_show_eval "$command" \
      uninstall)
          'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'
        $ECHO \
 
"Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
 
 
      if test "$need_locks" = warn &&
Remove libraries from an installation directory.
         test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
 
        $ECHO "\
 
*** ERROR, $lockfile contains:
 
`cat $lockfile 2>/dev/null`
 
 
 
but it should contain:
RM is the name of the program to use to delete files associated with each FILE
$srcfile
(typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
 
to RM.
 
 
This indicates that another process is trying to use the same
If FILE is a libtool library, all the files associated with it are deleted.
temporary object file, and libtool could not work around it because
Otherwise, only FILE itself is deleted using RM."
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."
 
 
 
        $opt_dry_run || $RM $removelist
      *)
        exit $EXIT_FAILURE
        func_fatal_help "invalid operation mode \`$mode'"
      fi
        ;;
 
    esac
      # 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
 
        func_show_eval '$MV "$output_obj" "$lobj"' \
 
          'error=$?; $opt_dry_run || $RM $removelist; exit $error'
 
      fi
 
 
 
      # Allow error messages only from the first compilation.
 
      if test "$suppress_opt" = yes; then
 
        suppress_output=' >/dev/null 2>&1'
 
      fi
 
    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 $qsrcfile$pie_flag"
 
      else
 
        command="$base_compile $qsrcfile $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"
 
      $opt_dry_run || $RM "$obj" "$output_obj"
 
      func_show_eval "$command" \
 
        '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
 
 
 
      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."
 
 
 
        $opt_dry_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
 
        func_show_eval '$MV "$output_obj" "$obj"' \
 
          'error=$?; $opt_dry_run || $RM $removelist; exit $error'
 
      fi
 
    fi
 
 
 
    $opt_dry_run || {
 
      func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"
 
 
 
      # Unlock the critical section if it was locked
    $ECHO
      if test "$need_locks" != no; then
    $ECHO "Try \`$progname --help' for more information about other modes."
        $RM "$lockfile"
 
      fi
 
    }
 
 
 
    exit $EXIT_SUCCESS
    exit $?
}
}
 
 
test "$mode" = compile && func_mode_compile ${1+"$@"}
  # Now that we've collected a possible --mode arg, show help if necessary
 
  $opt_help && func_mode_help
 
 
 
 
# func_mode_execute arg...
# func_mode_execute arg...
func_mode_execute ()
func_mode_execute ()
{
{
Line 2027... Line 1860...
    do
    do
      case $file in
      case $file in
      -*) ;;
      -*) ;;
      *)
      *)
        # Do a test to see if this is really a libtool program.
        # Do a test to see if this is really a libtool program.
        if func_ltwrapper_p "$file"; then
        if func_ltwrapper_script_p "$file"; then
          func_source "$file"
          func_source "$file"
 
          # Transform arg to wrapped name.
 
          file="$progdir/$program"
 
        elif func_ltwrapper_executable_p "$file"; then
 
          func_ltwrapper_scriptname "$file"
 
          func_source "$func_ltwrapper_scriptname_result"
          # Transform arg to wrapped name.
          # Transform arg to wrapped name.
          file="$progdir/$program"
          file="$progdir/$program"
        fi
        fi
        ;;
        ;;
      esac
      esac
Line 2047... Line 1884...
        # Export the shlibpath_var.
        # Export the shlibpath_var.
        eval "export $shlibpath_var"
        eval "export $shlibpath_var"
      fi
      fi
 
 
      # Restore saved environment variables
      # Restore saved environment variables
      for lt_var in LANG LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
      for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
      do
      do
        eval "if test \"\${save_$lt_var+set}\" = set; then
        eval "if test \"\${save_$lt_var+set}\" = set; then
                $lt_var=\$save_$lt_var; export $lt_var
                $lt_var=\$save_$lt_var; export $lt_var
              else
              else
                $lt_unset $lt_var
                $lt_unset $lt_var
Line 2249... Line 2086...
    test -d "$dest" && isdir=yes
    test -d "$dest" && isdir=yes
    if test "$isdir" = yes; then
    if test "$isdir" = yes; then
      destdir="$dest"
      destdir="$dest"
      destname=
      destname=
    else
    else
      func_dirname "$dest" "" "."
      func_dirname_and_basename "$dest" "" "."
      destdir="$func_dirname_result"
      destdir="$func_dirname_result"
      func_basename "$dest"
 
      destname="$func_basename_result"
      destname="$func_basename_result"
 
 
      # Not a directory, so check to see that there is only one file specified.
      # Not a directory, so check to see that there is only one file specified.
      set dummy $files; shift
      set dummy $files; shift
      test "$#" -gt 1 && \
      test "$#" -gt 1 && \
Line 2356... Line 2192...
          # Install the shared library and build the symlinks.
          # Install the shared library and build the symlinks.
          func_show_eval "$install_prog $dir/$srcname $destdir/$realname" \
          func_show_eval "$install_prog $dir/$srcname $destdir/$realname" \
              'exit $?'
              'exit $?'
          tstripme="$stripme"
          tstripme="$stripme"
          case $host_os in
          case $host_os in
          cygwin* | mingw* | pw32*)
          cygwin* | mingw* | pw32* | cegcc*)
            case $realname in
            case $realname in
            *.dll.a)
            *.dll.a)
              tstripme=""
              tstripme=""
              ;;
              ;;
            esac
            esac
Line 2463... Line 2299...
        esac
        esac
 
 
        # Do a test to see if this is really a libtool program.
        # Do a test to see if this is really a libtool program.
        case $host in
        case $host in
        *cygwin*|*mingw*)
        *cygwin*|*mingw*)
 
            if func_ltwrapper_executable_p "$file"; then
 
              func_ltwrapper_scriptname "$file"
 
              wrapper=$func_ltwrapper_scriptname_result
 
            else
            func_stripname '' '.exe' "$file"
            func_stripname '' '.exe' "$file"
            wrapper=$func_stripname_result
            wrapper=$func_stripname_result
 
            fi
            ;;
            ;;
        *)
        *)
            wrapper=$file
            wrapper=$file
            ;;
            ;;
        esac
        esac
        if func_ltwrapper_p "$wrapper"; then
        if func_ltwrapper_script_p "$wrapper"; then
          notinst_deplibs=
          notinst_deplibs=
          relink_command=
          relink_command=
 
 
          func_source "$wrapper"
          func_source "$wrapper"
 
 
Line 2587... Line 2428...
}
}
 
 
test "$mode" = install && func_mode_install ${1+"$@"}
test "$mode" = install && func_mode_install ${1+"$@"}
 
 
 
 
# func_mode_link arg...
# func_generate_dlsyms outputname originator pic_p
func_mode_link ()
# Extract symbols from dlprefiles and create ${outputname}S.o with
 
# a dlpreopen symbol table.
 
func_generate_dlsyms ()
{
{
    $opt_debug
    $opt_debug
    case $host in
    my_outputname="$1"
    *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
    my_originator="$2"
      # It is impossible to link a dll without this setting, and
    my_pic_p="${3-no}"
      # we shouldn't force the makefile maintainer to figure out
    my_prefix=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'`
      # which system we are compiling for in order to pass an extra
    my_dlsyms=
      # flag for every libtool invocation.
 
      # allow_undefined=no
 
 
 
      # FIXME: Unfortunately, there are problems with the above when trying
    if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
      # to make a dll which has undefined symbols, in which case not
      if test -n "$NM" && test -n "$global_symbol_pipe"; then
      # even a static library is built.  For now, we need to specify
        my_dlsyms="${my_outputname}S.c"
      # -no-undefined on the libtool link line when we can be certain
      else
      # that all symbols are satisfied, otherwise we get a static library.
        func_error "not configured to extract global symbols from dlpreopened files"
      allow_undefined=yes
      fi
      ;;
    fi
    *)
 
      allow_undefined=yes
 
      ;;
 
    esac
 
    libtool_args=$nonopt
 
    base_compile="$nonopt $@"
 
    compile_command=$nonopt
 
    finalize_command=$nonopt
 
 
 
    compile_rpath=
    if test -n "$my_dlsyms"; then
    finalize_rpath=
      case $my_dlsyms in
    compile_shlibpath=
      "") ;;
    finalize_shlibpath=
      *.c)
    convenience=
        # Discover the nlist of each of the dlfiles.
    old_convenience=
        nlist="$output_objdir/${my_outputname}.nm"
    deplibs=
 
    old_deplibs=
 
    compiler_flags=
 
    linker_flags=
 
    dllsearchpath=
 
    lib_search_path=`pwd`
 
    inst_prefix_dir=
 
    new_inherited_linker_flags=
 
 
 
    avoid_version=no
        func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
    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
 
    weak_libs=
 
    single_module="${wl}-single_module"
 
    func_infer_tag $base_compile
 
 
 
    # We need to know -static, to get the right output filenames.
        # Parse the name list into a source file.
    for arg
        func_verbose "creating $output_objdir/$my_dlsyms"
    do
 
      case $arg in
 
      -shared)
 
        test "$build_libtool_libs" != yes && \
 
          func_fatal_configuration "can not build a shared library"
 
        build_old_libs=no
 
        break
 
        ;;
 
      -all-static | -static | -static-libtool-libs)
 
        case $arg in
 
        -all-static)
 
          if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
 
            func_warning "complete static linking is impossible in this configuration"
 
          fi
 
          if test -n "$link_static_flag"; then
 
            dlopen_self=$dlopen_self_static
 
            # See comment for -static flag below, for more details.
 
            func_append compile_command " $link_static_flag"
 
            func_append finalize_command " $link_static_flag"
 
          fi
 
          prefer_static_libs=yes
 
          ;;
 
        -static)
 
          if test -z "$pic_flag" && test -n "$link_static_flag"; then
 
            dlopen_self=$dlopen_self_static
 
          fi
 
          prefer_static_libs=built
 
          ;;
 
        -static-libtool-libs)
 
          if test -z "$pic_flag" && test -n "$link_static_flag"; then
 
            dlopen_self=$dlopen_self_static
 
          fi
 
          prefer_static_libs=yes
 
          ;;
 
        esac
 
        build_libtool_libs=no
 
        build_old_libs=yes
 
        break
 
        ;;
 
      esac
 
    done
 
 
 
    # See if our shared archives depend on static archives.
        $opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\
    test -n "$old_archive_from_new_cmds" && build_old_libs=yes
/* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */
 
/* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */
 
 
    # Go through the arguments, transforming them on the way.
#ifdef __cplusplus
    while test "$#" -gt 0; do
extern \"C\" {
      arg="$1"
#endif
      shift
 
      func_quote_for_eval "$arg"
 
      qarg=$func_quote_for_eval_unquoted_result
 
      func_append libtool_args " $func_quote_for_eval_result"
 
 
 
      # If the previous option needs an argument, assign it.
/* External symbol declarations for the compiler. */\
      if test -n "$prev"; then
"
        case $prev in
 
        output)
 
          func_append compile_command " @OUTPUT@"
 
          func_append finalize_command " @OUTPUT@"
 
          ;;
 
        esac
 
 
 
        case $prev in
        if test "$dlself" = yes; then
        dlfiles|dlprefiles)
          func_verbose "generating symbol list for \`$output'"
          if test "$preload" = no; then
 
            # Add the symbol object into the linking commands.
          $opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
            func_append compile_command " @SYMFILE@"
 
            func_append finalize_command " @SYMFILE@"
          # Add our own program objects to the symbol list.
            preload=yes
          progfiles=`$ECHO "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
          fi
          for progfile in $progfiles; do
          case $arg in
            func_verbose "extracting global C symbols from \`$progfile'"
          *.la | *.lo) ;;  # We handle these cases below.
            $opt_dry_run || eval "$NM $progfile | $global_symbol_pipe >> '$nlist'"
          force)
          done
            if test "$dlself" = no; then
 
              dlself=needless
          if test -n "$exclude_expsyms"; then
              export_dynamic=yes
            $opt_dry_run || {
            fi
              eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
            prev=
              eval '$MV "$nlist"T "$nlist"'
            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
            fi
            prev=
 
            continue
          if test -n "$export_symbols_regex"; then
            ;;
            $opt_dry_run || {
          *)
              eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
            if test "$prev" = dlfiles; then
              eval '$MV "$nlist"T "$nlist"'
              dlfiles="$dlfiles $arg"
            }
            else
 
              dlprefiles="$dlprefiles $arg"
 
            fi
            fi
            prev=
 
            continue
          # Prepare the list of exported symbols
            ;;
          if test -z "$export_symbols"; then
          esac
            export_symbols="$output_objdir/$outputname.exp"
          ;;
            $opt_dry_run || {
        expsyms)
              $RM $export_symbols
          export_symbols="$arg"
              eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
          test -f "$arg" \
 
            || func_fatal_error "symbol file \`$arg' does not exist"
 
          prev=
 
          continue
 
          ;;
 
        expsyms_regex)
 
          export_symbols_regex="$arg"
 
          prev=
 
          continue
 
          ;;
 
        framework)
 
          case $host in
          case $host in
            *-*-darwin*)
              *cygwin* | *mingw* | *cegcc* )
              case "$deplibs " in
                eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
                *" $qarg.ltframework "*) ;;
                eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
                *) deplibs="$deplibs $qarg.ltframework" # this is fixed later
 
                   ;;
                   ;;
              esac
              esac
 
            }
 
          else
 
            $opt_dry_run || {
 
              eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
 
              eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
 
              eval '$MV "$nlist"T "$nlist"'
 
              case $host in
 
                *cygwin | *mingw* | *cegcc* )
 
                  eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
 
                  eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
              ;;
              ;;
          esac
          esac
          prev=
            }
          continue
          fi
          ;;
        fi
        inst_prefix)
 
          inst_prefix_dir="$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.
        for dlprefile in $dlprefiles; do
              if func_lalib_unsafe_p "$arg"; then
          func_verbose "extracting global C symbols from \`$dlprefile'"
                pic_object=
          func_basename "$dlprefile"
                non_pic_object=
          name="$func_basename_result"
 
          $opt_dry_run || {
 
            eval '$ECHO ": $name " >> "$nlist"'
 
            eval "$NM $dlprefile 2>/dev/null | $global_symbol_pipe >> '$nlist'"
 
          }
 
        done
 
 
                # Read the .lo file
        $opt_dry_run || {
                func_source "$arg"
          # Make sure we have at least an empty file.
 
          test -f "$nlist" || : > "$nlist"
 
 
                if test -z "$pic_object" ||
          if test -n "$exclude_expsyms"; then
                   test -z "$non_pic_object" ||
            $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
                   test "$pic_object" = none &&
            $MV "$nlist"T "$nlist"
                   test "$non_pic_object" = none; then
 
                  func_fatal_error "cannot find name of object for \`$arg'"
 
                fi
                fi
 
 
                # Extract subdirectory from the argument.
          # Try sorting and uniquifying the output.
                func_dirname "$arg" "/" ""
          if $GREP -v "^: " < "$nlist" |
                xdir="$func_dirname_result"
              if sort -k 3 </dev/null >/dev/null 2>&1; then
 
                sort -k 3
                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
                    else
                      # If libtool objects are unsupported, then we need to preload.
                sort +2
                      prev=dlprefiles
              fi |
                    fi
              uniq > "$nlist"S; then
 
            :
 
          else
 
            $GREP -v "^: " < "$nlist" > "$nlist"S
                  fi
                  fi
 
 
                  # CHECK ME:  I think I busted this.  -Ossama
          if test -f "$nlist"S; then
                  if test "$prev" = dlprefiles; then
            eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
                    # Preload the old-style object.
          else
                    dlprefiles="$dlprefiles $pic_object"
            $ECHO '/* NONE */' >> "$output_objdir/$my_dlsyms"
                    prev=
 
                  fi
                  fi
 
 
                  # A PIC object.
          $ECHO >> "$output_objdir/$my_dlsyms" "\
                  func_append libobjs " $pic_object"
 
                  arg="$pic_object"
 
                fi
 
 
 
                # Non-PIC object.
/* The mapping between symbol names and symbols.  */
                if test "$non_pic_object" != none; then
typedef struct {
                  # Prepend the subdirectory the object is found in.
  const char *name;
                  non_pic_object="$xdir$non_pic_object"
  void *address;
 
} lt_dlsymlist;
 
"
 
          case $host in
 
          *cygwin* | *mingw* | *cegcc* )
 
            $ECHO >> "$output_objdir/$my_dlsyms" "\
 
/* DATA imports from DLLs on WIN32 con't be const, because
 
   runtime relocations are performed -- see ld's documentation
 
   on pseudo-relocs.  */"
 
            lt_dlsym_const= ;;
 
          *osf5*)
 
            echo >> "$output_objdir/$my_dlsyms" "\
 
/* This system does not cope well with relocations in const data */"
 
            lt_dlsym_const= ;;
 
          *)
 
            lt_dlsym_const=const ;;
 
          esac
 
 
                  # A standard non-PIC object
          $ECHO >> "$output_objdir/$my_dlsyms" "\
                  func_append non_pic_objects " $non_pic_object"
extern $lt_dlsym_const lt_dlsymlist
                  if test -z "$pic_object" || test "$pic_object" = none ; then
lt_${my_prefix}_LTX_preloaded_symbols[];
                    arg="$non_pic_object"
$lt_dlsym_const lt_dlsymlist
                  fi
lt_${my_prefix}_LTX_preloaded_symbols[] =
                else
{\
                  # If the PIC object exists, use it instead.
  { \"$my_originator\", (void *) 0 },"
                  # $xdir was prepended to $pic_object above.
 
                  non_pic_object="$pic_object"
 
                  func_append non_pic_objects " $non_pic_object"
 
                fi
 
              else
 
                # Only an error if not doing a dry-run.
 
                if $opt_dry_run; then
 
                  # Extract subdirectory from the argument.
 
                  func_dirname "$arg" "/" ""
 
                  xdir="$func_dirname_result"
 
 
 
                  func_lo2o "$arg"
          case $need_lib_prefix in
                  pic_object=$xdir$objdir/$func_lo2o_result
          no)
                  non_pic_object=$xdir$func_lo2o_result
            eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
                  func_append libobjs " $pic_object"
 
                  func_append non_pic_objects " $non_pic_object"
 
                else
 
                  func_fatal_error "\`$arg' is not a valid libtool object"
 
                fi
 
              fi
 
            done
 
          else
 
            func_fatal_error "link input file \`$arg' does not exist"
 
          fi
 
          arg=$save_arg
 
          prev=
 
          continue
 
          ;;
 
        precious_regex)
 
          precious_files_regex="$arg"
 
          prev=
 
          continue
 
          ;;
 
        release)
 
          release="-$arg"
 
          prev=
 
          continue
 
          ;;
          ;;
        rpath | xrpath)
 
          # We need an absolute path.
 
          case $arg in
 
          [\\/]* | [A-Za-z]:[\\/]*) ;;
 
          *)
          *)
            func_fatal_error "only absolute run-paths are allowed"
            eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
            ;;
            ;;
          esac
          esac
          if test "$prev" = rpath; then
          $ECHO >> "$output_objdir/$my_dlsyms" "\
            case "$rpath " in
  {0, (void *) 0}
            *" $arg "*) ;;
};
            *) rpath="$rpath $arg" ;;
 
            esac
/* This works around a problem in FreeBSD linker */
          else
#ifdef FREEBSD_WORKAROUND
            case "$xrpath " in
static const void *lt_preloaded_setup() {
            *" $arg "*) ;;
  return lt_${my_prefix}_LTX_preloaded_symbols;
            *) xrpath="$xrpath $arg" ;;
}
            esac
#endif
 
 
 
#ifdef __cplusplus
 
}
 
#endif\
 
"
 
        } # !$opt_dry_run
 
 
 
        pic_flag_for_symtable=
 
        case "$compile_command " in
 
        *" -static "*) ;;
 
        *)
 
          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
 
          # pic_flag when linking with -static.  The problem exists in
 
          # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
 
          *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
 
            pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
 
          *-*-hpux*)
 
            pic_flag_for_symtable=" $pic_flag"  ;;
 
          *)
 
            if test "X$my_pic_p" != Xno; then
 
              pic_flag_for_symtable=" $pic_flag"
          fi
          fi
          prev=
 
          continue
 
          ;;
 
        shrext)
 
          shrext_cmds="$arg"
 
          prev=
 
          continue
 
          ;;
          ;;
        weak)
          esac
          weak_libs="$weak_libs $arg"
 
          prev=
 
          continue
 
          ;;
          ;;
        xcclinker)
        esac
          linker_flags="$linker_flags $qarg"
        symtab_cflags=
          compiler_flags="$compiler_flags $qarg"
        for arg in $LTCFLAGS; do
          prev=
          case $arg in
          func_append compile_command " $qarg"
          -pie | -fpie | -fPIE) ;;
          func_append finalize_command " $qarg"
          *) symtab_cflags="$symtab_cflags $arg" ;;
          continue
          esac
 
        done
 
 
 
        # Now compile the dynamic symbol file.
 
        func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
 
 
 
        # Clean up the generated files.
 
        func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"'
 
 
 
        # Transform the symbol file into the correct name.
 
        symfileobj="$output_objdir/${my_outputname}S.$objext"
 
        case $host in
 
        *cygwin* | *mingw* | *cegcc* )
 
          if test -f "$output_objdir/$my_outputname.def"; then
 
            compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
 
            finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
 
          else
 
            compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
 
            finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
 
          fi
          ;;
          ;;
        xcompiler)
        *)
          compiler_flags="$compiler_flags $qarg"
          compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
          prev=
          finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
          func_append compile_command " $qarg"
 
          func_append finalize_command " $qarg"
 
          continue
 
          ;;
          ;;
        xlinker)
        esac
          linker_flags="$linker_flags $qarg"
 
          compiler_flags="$compiler_flags $wl$qarg"
 
          prev=
 
          func_append compile_command " $wl$qarg"
 
          func_append finalize_command " $wl$qarg"
 
          continue
 
          ;;
          ;;
        *)
        *)
          eval "$prev=\"\$arg\""
        func_fatal_error "unknown suffix for \`$my_dlsyms'"
          prev=
 
          continue
 
          ;;
          ;;
        esac
        esac
      fi # test -n "$prev"
    else
 
      # We keep going just in case the user didn't refer to
 
      # lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
 
      # really was required.
 
 
      prevarg="$arg"
      # Nullify the symbol file.
 
      compile_command=`$ECHO "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
 
      finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
 
    fi
 
}
 
 
      case $arg in
# func_win32_libid arg
      -all-static)
# return the library type of file 'arg'
        # The effects of -all-static are defined in a previous loop.
#
        continue
# 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 ()
 
{
 
  $opt_debug
 
  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
      -allow-undefined)
    if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |
        # FIXME: remove this flag sometime in the future.
       $EGREP 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then
        func_fatal_error "\`-allow-undefined' must not be used because it is the default"
      win32_nmres=`eval $NM -f posix -A $1 |
 
        $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
        ;;
        ;;
 
  *DLL*)
      -avoid-version)
    win32_libid_type="x86 DLL"
        avoid_version=yes
 
        continue
 
        ;;
        ;;
 
  *executable*) # but shell scripts are "executable" too...
      -dlopen)
    case $win32_fileres in
        prev=dlfiles
    *MS\ Windows\ PE\ Intel*)
        continue
      win32_libid_type="x86 DLL"
        ;;
        ;;
 
    esac
      -dlpreopen)
 
        prev=dlprefiles
 
        continue
 
        ;;
        ;;
 
  esac
 
  $ECHO "$win32_libid_type"
 
}
 
 
      -export-dynamic)
 
        export_dynamic=yes
 
        continue
 
        ;;
 
 
 
      -export-symbols | -export-symbols-regex)
 
        if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
# func_extract_an_archive dir oldlib
          func_fatal_error "more than one -exported-symbols argument is not allowed"
func_extract_an_archive ()
        fi
{
        if test "X$arg" = "X-export-symbols"; then
    $opt_debug
          prev=expsyms
    f_ex_an_ar_dir="$1"; shift
 
    f_ex_an_ar_oldlib="$1"
 
    func_show_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
        else
          prev=expsyms_regex
      func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
        fi
        fi
        continue
}
        ;;
 
 
 
      -framework)
 
        prev=framework
 
        continue
 
        ;;
 
 
 
      -inst-prefix-dir)
 
        prev=inst_prefix
 
        continue
 
        ;;
 
 
 
      # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
# func_extract_archives gentop oldlib ...
      # so, if we see these flags be careful not to treat them like -L
func_extract_archives ()
      -L[A-Z][A-Z]*:*)
{
        case $with_gcc/$host in
    $opt_debug
        no/*-*-irix* | /*-*-irix*)
    my_gentop="$1"; shift
          func_append compile_command " $arg"
    my_oldlibs=${1+"$@"}
          func_append finalize_command " $arg"
    my_oldobjs=""
          ;;
    my_xlib=""
        esac
    my_xabs=""
        continue
    my_xdir=""
        ;;
 
 
 
      -L*)
    for my_xlib in $my_oldlibs; do
        func_stripname '-L' '' "$arg"
      # Extract the objects.
        dir=$func_stripname_result
      case $my_xlib in
        # We need an absolute path.
        [\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
        case $dir in
        *) my_xabs=`pwd`"/$my_xlib" ;;
        [\\/]* | [A-Za-z]:[\\/]*) ;;
 
        *)
 
          absdir=`cd "$dir" && pwd`
 
          test -z "$absdir" && \
 
            func_fatal_error "cannot determine absolute directory name of \`$dir'"
 
          dir="$absdir"
 
          ;;
 
        esac
        esac
        case "$deplibs " in
      func_basename "$my_xlib"
        *" -L$dir "*) ;;
      my_xlib="$func_basename_result"
        *)
      my_xlib_u=$my_xlib
          deplibs="$deplibs -L$dir"
      while :; do
          lib_search_path="$lib_search_path $dir"
        case " $extracted_archives " in
          ;;
        *" $my_xlib_u "*)
 
          func_arith $extracted_serial + 1
 
          extracted_serial=$func_arith_result
 
          my_xlib_u=lt$extracted_serial-$my_xlib ;;
 
        *) break ;;
        esac
        esac
        case $host in
      done
        *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
      extracted_archives="$extracted_archives $my_xlib_u"
          testbindir=`$ECHO "X$dir" | $Xsed -e 's*/lib$*/bin*'`
      my_xdir="$my_gentop/$my_xlib_u"
          case :$dllsearchpath: in
 
          *":$dir:"*) ;;
      func_mkdir_p "$my_xdir"
          *) dllsearchpath="$dllsearchpath:$dir";;
 
          esac
 
          case :$dllsearchpath: in
 
          *":$testbindir:"*) ;;
 
          *) dllsearchpath="$dllsearchpath:$testbindir";;
 
          esac
 
          ;;
 
        esac
 
        continue
 
        ;;
 
 
 
      -l*)
 
        if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
 
          case $host in
          case $host in
          *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos*)
      *-darwin*)
            # These systems don't actually have a C or math library (as such)
        func_verbose "Extracting $my_xabs"
            continue
        # Do not bother doing anything if just a dry run
            ;;
        $opt_dry_run || {
          *-*-os2*)
          darwin_orig_dir=`pwd`
            # These systems don't actually have a C library (as such)
          cd $my_xdir || exit $?
            test "X$arg" = "X-lc" && continue
          darwin_archive=$my_xabs
            ;;
          darwin_curdir=`pwd`
          *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
          darwin_base_archive=`basename "$darwin_archive"`
            # Do not include libc due to us having libc/libc_r.
          darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
            test "X$arg" = "X-lc" && continue
          if test -n "$darwin_arches"; then
            ;;
            darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
          *-*-rhapsody* | *-*-darwin1.[012])
            darwin_arch=
            # Rhapsody C and math libraries are in the System framework
            func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
            deplibs="$deplibs System.ltframework"
            for darwin_arch in  $darwin_arches ; do
            continue
              func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
            ;;
              $LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
          *-*-sco3.2v5* | *-*-sco5v6*)
              cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
            # Causes problems with __ctype
              func_extract_an_archive "`pwd`" "${darwin_base_archive}"
            test "X$arg" = "X-lc" && continue
              cd "$darwin_curdir"
            ;;
              $RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
          *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
            done # $darwin_arches
            # Compiler inserts libc in the correct place for threads to work
            ## Okay now we've a bunch of thin objects, gotta fatten them up :)
            test "X$arg" = "X-lc" && continue
            darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$basename" | sort -u`
 
            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
 
            $RM -rf unfat-$$
 
            cd "$darwin_orig_dir"
 
          else
 
            cd $darwin_orig_dir
 
            func_extract_an_archive "$my_xdir" "$my_xabs"
 
          fi # $darwin_arches
 
        } # !$opt_dry_run
            ;;
            ;;
          esac
      *)
        elif test "X$arg" = "X-lc_r"; then
        func_extract_an_archive "$my_xdir" "$my_xabs"
         case $host in
 
         *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
 
           # Do not include libc_r directly, use -pthread flag.
 
           continue
 
           ;;
           ;;
         esac
         esac
        fi
      my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
        deplibs="$deplibs $arg"
    done
        continue
 
        ;;
 
 
 
      -module)
    func_extract_archives_result="$my_oldobjs"
        module=yes
}
        continue
 
        ;;
 
 
 
      # Tru64 UNIX uses -model [arg] to determine the layout of C++
 
      # classes, name mangling, and exception handling.
 
      # Darwin uses the -arch flag to determine output architecture.
 
      -model|-arch|-isysroot)
 
        compiler_flags="$compiler_flags $arg"
 
        func_append compile_command " $arg"
 
        func_append finalize_command " $arg"
 
        prev=xcompiler
 
        continue
 
        ;;
 
 
 
      -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
 
        compiler_flags="$compiler_flags $arg"
 
        func_append compile_command " $arg"
 
        func_append finalize_command " $arg"
 
        case "$new_inherited_linker_flags " in
 
            *" $arg "*) ;;
 
            * ) new_inherited_linker_flags="$new_inherited_linker_flags $arg" ;;
 
        esac
 
        continue
 
        ;;
 
 
 
      -multi_module)
# func_emit_wrapper_part1 [arg=no]
        single_module="${wl}-multi_module"
#
        continue
# Emit the first part of a libtool wrapper script on stdout.
        ;;
# For more information, see the description associated with
 
# func_emit_wrapper(), below.
 
func_emit_wrapper_part1 ()
 
{
 
        func_emit_wrapper_part1_arg1=no
 
        if test -n "$1" ; then
 
          func_emit_wrapper_part1_arg1=$1
 
        fi
 
 
      -no-fast-install)
        $ECHO "\
        fast_install=no
#! $SHELL
        continue
 
        ;;
 
 
 
      -no-install)
# $output - temporary wrapper script for $objdir/$outputname
        case $host in
# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
        *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
#
          # The PATH hackery in wrapper scripts is required on Windows
# The $output program cannot be directly executed until all the libtool
          # in order for the loader to find any dlls it needs.
# libraries that it depends on are installed.
          func_warning "\`-no-install' is ignored for $host"
#
          func_warning "assuming \`-no-fast-install' instead"
# This wrapper script should never be moved out of the build directory.
          fast_install=no
# If it is, it will not operate correctly.
          ;;
 
        *) no_install=yes ;;
 
        esac
 
        continue
 
        ;;
 
 
 
      -no-undefined)
# Sed substitution that helps us do robust quoting.  It backslashifies
        allow_undefined=no
# metacharacters that are still active within double-quoted strings.
        continue
Xsed='${SED} -e 1s/^X//'
        ;;
sed_quote_subst='$sed_quote_subst'
 
 
      -objectlist)
# Be Bourne compatible
        prev=objectlist
if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
        continue
  emulate sh
        ;;
  NULLCMD=:
 
  # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
 
  # is contrary to our usage.  Disable this feature.
 
  alias -g '\${1+\"\$@\"}'='\"\$@\"'
 
  setopt NO_GLOB_SUBST
 
else
 
  case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
 
fi
 
BIN_SH=xpg4; export BIN_SH # for Tru64
 
DUALCASE=1; export DUALCASE # for MKS sh
 
 
      -o) prev=output ;;
# The HP-UX ksh and POSIX shell print the target directory to stdout
 
# if CDPATH is set.
 
(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
 
 
      -precious-files-regex)
relink_command=\"$relink_command\"
        prev=precious_regex
 
        continue
 
        ;;
 
 
 
      -release)
# This environment variable determines our operation mode.
        prev=release
if test \"\$libtool_install_magic\" = \"$magic\"; then
        continue
  # install mode needs the following variables:
        ;;
  generated_by_libtool_version='$macro_version'
 
  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
 
    ECHO=\"$qecho\"
 
    file=\"\$0\"
 
    # Make sure echo works.
 
    if test \"X\$1\" = X--no-reexec; then
 
      # Discard the --no-reexec flag, and continue.
 
      shift
 
    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
 
  fi\
 
"
 
        $ECHO "\
 
 
      -rpath)
  # Find the directory that this script lives in.
        prev=rpath
  thisdir=\`\$ECHO \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
        continue
  test \"x\$thisdir\" = \"x\$file\" && thisdir=.
        ;;
 
 
 
      -R)
  # Follow symbolic links until we get to the real thisdir.
        prev=xrpath
  file=\`ls -ld \"\$file\" | ${SED} -n 's/.*-> //p'\`
        continue
  while test -n \"\$file\"; do
        ;;
    destdir=\`\$ECHO \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
 
 
      -R*)
    # If there was a directory component, then change thisdir.
        func_stripname '-R' '' "$arg"
    if test \"x\$destdir\" != \"x\$file\"; then
        dir=$func_stripname_result
      case \"\$destdir\" in
        # We need an absolute path.
      [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
        case $dir in
      *) thisdir=\"\$thisdir/\$destdir\" ;;
        [\\/]* | [A-Za-z]:[\\/]*) ;;
 
        *)
 
          func_fatal_error "only absolute run-paths are allowed"
 
          ;;
 
        esac
 
        case "$xrpath " in
 
        *" $dir "*) ;;
 
        *) xrpath="$xrpath $dir" ;;
 
        esac
        esac
        continue
    fi
        ;;
 
 
 
      -shared)
    file=\`\$ECHO \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
        # The effects of -shared are defined in a previous loop.
    file=\`ls -ld \"\$thisdir/\$file\" | ${SED} -n 's/.*-> //p'\`
        continue
  done
        ;;
"
 
}
 
# end: func_emit_wrapper_part1
 
 
      -shrext)
# func_emit_wrapper_part2 [arg=no]
        prev=shrext
#
        continue
# Emit the second part of a libtool wrapper script on stdout.
        ;;
# For more information, see the description associated with
 
# func_emit_wrapper(), below.
      -static | -static-libtool-libs)
func_emit_wrapper_part2 ()
        # The effects of -static are defined in a previous loop.
{
        # We used to do the same as -all-static on platforms that
        func_emit_wrapper_part2_arg1=no
        # didn't have a PIC flag, but the assumption that the effects
        if test -n "$1" ; then
        # would be equivalent was wrong.  It would break on at least
          func_emit_wrapper_part2_arg1=$1
        # Digital Unix and AIX.
        fi
        continue
 
        ;;
 
 
 
      -thread-safe)
 
        thread_safe=yes
 
        continue
 
        ;;
 
 
 
      -version-info)
        $ECHO "\
        prev=vinfo
 
        continue
 
        ;;
 
 
 
      -version-number)
  # Usually 'no', except on cygwin/mingw when embedded into
        prev=vinfo
  # the cwrapper.
        vinfo_number=yes
  WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_part2_arg1
        continue
  if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
        ;;
    # special case for '.'
 
    if test \"\$thisdir\" = \".\"; then
 
      thisdir=\`pwd\`
 
    fi
 
    # remove .libs from thisdir
 
    case \"\$thisdir\" in
 
    *[\\\\/]$objdir ) thisdir=\`\$ECHO \"X\$thisdir\" | \$Xsed -e 's%[\\\\/][^\\\\/]*$%%'\` ;;
 
    $objdir )   thisdir=. ;;
 
    esac
 
  fi
 
 
      -weak)
  # Try to get the absolute directory name.
        prev=weak
  absdir=\`cd \"\$thisdir\" && pwd\`
        continue
  test -n \"\$absdir\" && thisdir=\"\$absdir\"
        ;;
"
 
 
      -Wc,*)
        if test "$fast_install" = yes; then
        func_stripname '-Wc,' '' "$arg"
          $ECHO "\
        args=$func_stripname_result
  program=lt-'$outputname'$exeext
        arg=
  progdir=\"\$thisdir/$objdir\"
        save_ifs="$IFS"; IFS=','
 
        for flag in $args; do
 
          IFS="$save_ifs"
 
          func_quote_for_eval "$flag"
 
          arg="$arg $wl$func_quote_for_eval_result"
 
          compiler_flags="$compiler_flags $func_quote_for_eval_result"
 
        done
 
        IFS="$save_ifs"
 
        func_stripname ' ' '' "$arg"
 
        arg=$func_stripname_result
 
        ;;
 
 
 
      -Wl,*)
  if test ! -f \"\$progdir/\$program\" ||
        func_stripname '-Wl,' '' "$arg"
     { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
        args=$func_stripname_result
       test \"X\$file\" != \"X\$progdir/\$program\"; }; then
        arg=
 
        save_ifs="$IFS"; IFS=','
 
        for flag in $args; do
 
          IFS="$save_ifs"
 
          func_quote_for_eval "$flag"
 
          arg="$arg $wl$func_quote_for_eval_result"
 
          compiler_flags="$compiler_flags $wl$func_quote_for_eval_result"
 
          linker_flags="$linker_flags $func_quote_for_eval_result"
 
        done
 
        IFS="$save_ifs"
 
        func_stripname ' ' '' "$arg"
 
        arg=$func_stripname_result
 
        ;;
 
 
 
      -Xcompiler)
    file=\"\$\$-\$program\"
        prev=xcompiler
 
        continue
 
        ;;
 
 
 
      -Xlinker)
    if test ! -d \"\$progdir\"; then
        prev=xlinker
      $MKDIR \"\$progdir\"
        continue
    else
        ;;
      $RM \"\$progdir/\$file\"
 
    fi"
 
 
      -XCClinker)
          $ECHO "\
        prev=xcclinker
 
        continue
 
        ;;
 
 
 
      # -64, -mips[0-9] enable 64-bit mode on the SGI compiler
    # relink executable if necessary
      # -r[0-9][0-9]* specifies the processor on the SGI compiler
    if test -n \"\$relink_command\"; then
      # -xarch=*, -xtarget=* enable 64-bit mode on the Sun compiler
      if relink_command_output=\`eval \$relink_command 2>&1\`; then :
      # +DA*, +DD* enable 64-bit mode on the HP compiler
      else
      # -q* pass through compiler args for the IBM compiler
        $ECHO \"\$relink_command_output\" >&2
      # -m*, -t[45]*, -txscale* pass through architecture-specific
        $RM \"\$progdir/\$file\"
      # compiler args for GCC
        exit 1
      # -F/path gives path to uninstalled frameworks, gcc on darwin
      fi
      # -p, -pg, --coverage, -fprofile-* pass through profiling flag for GCC
    fi
      # @file GCC response files
 
      -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
 
      -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*)
 
        func_quote_for_eval "$arg"
 
        arg="$func_quote_for_eval_result"
 
        func_append compile_command " $arg"
 
        func_append finalize_command " $arg"
 
        compiler_flags="$compiler_flags $arg"
 
        continue
 
        ;;
 
 
 
      # Some other compiler flag.
    $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
      -* | +*)
    { $RM \"\$progdir/\$program\";
        func_quote_for_eval "$arg"
      $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
        arg="$func_quote_for_eval_result"
    $RM \"\$progdir/\$file\"
        ;;
  fi"
 
        else
 
          $ECHO "\
 
  program='$outputname'
 
  progdir=\"\$thisdir/$objdir\"
 
"
 
        fi
 
 
      *.$objext)
        $ECHO "\
        # A standard object.
 
        objs="$objs $arg"
 
        ;;
 
 
 
      *.lo)
  if test -f \"\$progdir/\$program\"; then"
        # A libtool-controlled object.
 
 
 
        # Check to see that this really is a libtool object.
        # Export our shlibpath_var if we have one.
        if func_lalib_unsafe_p "$arg"; then
        if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
          pic_object=
          $ECHO "\
          non_pic_object=
    # Add our own library path to $shlibpath_var
 
    $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
 
 
          # Read the .lo file
    # Some systems cannot cope with colon-terminated $shlibpath_var
          func_source "$arg"
    # The second colon is a workaround for a bug in BeOS R4 sed
 
    $shlibpath_var=\`\$ECHO \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`
 
 
          if test -z "$pic_object" ||
    export $shlibpath_var
             test -z "$non_pic_object" ||
"
             test "$pic_object" = none &&
 
             test "$non_pic_object" = none; then
 
            func_fatal_error "cannot find name of object for \`$arg'"
 
          fi
          fi
 
 
          # Extract subdirectory from the argument.
        # fixup the dll searchpath if we need to.
          func_dirname "$arg" "/" ""
        if test -n "$dllsearchpath"; then
          xdir="$func_dirname_result"
          $ECHO "\
 
    # Add the dll search path components to the executable PATH
 
    PATH=$dllsearchpath:\$PATH
 
"
 
        fi
 
 
          if test "$pic_object" != none; then
        $ECHO "\
            # Prepend the subdirectory the object is found in.
    if test \"\$libtool_execute_magic\" != \"$magic\"; then
            pic_object="$xdir$pic_object"
      # Run the actual program with our arguments.
 
"
 
        case $host in
 
        # Backslashes separate directories on plain windows
 
        *-*-mingw | *-*-os2* | *-cegcc*)
 
          $ECHO "\
 
      exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
 
"
 
          ;;
 
 
            if test "$prev" = dlfiles; then
        *)
              if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
          $ECHO "\
                dlfiles="$dlfiles $pic_object"
      exec \"\$progdir/\$program\" \${1+\"\$@\"}
                prev=
"
                continue
          ;;
              else
        esac
                # If libtool objects are unsupported, then we need to preload.
        $ECHO "\
                prev=dlprefiles
      \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
 
      exit 1
              fi
              fi
 
  else
 
    # The program doesn't exist.
 
    \$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
 
    \$ECHO \"This script is just a wrapper for \$program.\" 1>&2
 
    $ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
 
    exit 1
            fi
            fi
 
fi\
 
"
 
}
 
# end: func_emit_wrapper_part2
 
 
            # 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.
# func_emit_wrapper [arg=no]
            func_append libobjs " $pic_object"
#
            arg="$pic_object"
# Emit a libtool wrapper script on stdout.
 
# Don't directly open a file because we may want to
 
# incorporate the script contents within a cygwin/mingw
 
# wrapper executable.  Must ONLY be called from within
 
# func_mode_link because it depends on a number of variables
 
# set therein.
 
#
 
# ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
 
# variable will take.  If 'yes', then the emitted script
 
# will assume that the directory in which it is stored is
 
# the $objdir directory.  This is a cygwin/mingw-specific
 
# behavior.
 
func_emit_wrapper ()
 
{
 
        func_emit_wrapper_arg1=no
 
        if test -n "$1" ; then
 
          func_emit_wrapper_arg1=$1
          fi
          fi
 
 
          # Non-PIC object.
        # split this up so that func_emit_cwrapperexe_src
          if test "$non_pic_object" != none; then
        # can call each part independently.
            # Prepend the subdirectory the object is found in.
        func_emit_wrapper_part1 "${func_emit_wrapper_arg1}"
            non_pic_object="$xdir$non_pic_object"
        func_emit_wrapper_part2 "${func_emit_wrapper_arg1}"
 
}
 
 
            # A standard non-PIC object
 
            func_append non_pic_objects " $non_pic_object"
# func_to_host_path arg
            if test -z "$pic_object" || test "$pic_object" = none ; then
#
              arg="$non_pic_object"
# Convert paths to host format when used with build tools.
            fi
# Intended for use with "native" mingw (where libtool itself
 
# is running under the msys shell), or in the following cross-
 
# build environments:
 
#    $build          $host
 
#    mingw (msys)    mingw  [e.g. native]
 
#    cygwin          mingw
 
#    *nix + wine     mingw
 
# where wine is equipped with the `winepath' executable.
 
# In the native mingw case, the (msys) shell automatically
 
# converts paths for any non-msys applications it launches,
 
# but that facility isn't available from inside the cwrapper.
 
# Similar accommodations are necessary for $host mingw and
 
# $build cygwin.  Calling this function does no harm for other
 
# $host/$build combinations not listed above.
 
#
 
# ARG is the path (on $build) that should be converted to
 
# the proper representation for $host. The result is stored
 
# in $func_to_host_path_result.
 
func_to_host_path ()
 
{
 
  func_to_host_path_result="$1"
 
  if test -n "$1" ; then
 
    case $host in
 
      *mingw* )
 
        lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
 
        case $build in
 
          *mingw* ) # actually, msys
 
            # awkward: cmd appends spaces to result
 
            lt_sed_strip_trailing_spaces="s/[ ]*\$//"
 
            func_to_host_path_tmp1=`( cmd //c echo "$1" |\
 
              $SED -e "$lt_sed_strip_trailing_spaces" ) 2>/dev/null || echo ""`
 
            func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\
 
              $SED -e "$lt_sed_naive_backslashify"`
 
            ;;
 
          *cygwin* )
 
            func_to_host_path_tmp1=`cygpath -w "$1"`
 
            func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\
 
              $SED -e "$lt_sed_naive_backslashify"`
 
            ;;
 
          * )
 
            # Unfortunately, winepath does not exit with a non-zero
 
            # error code, so we are forced to check the contents of
 
            # stdout. On the other hand, if the command is not
 
            # found, the shell will set an exit code of 127 and print
 
            # *an error message* to stdout. So we must check for both
 
            # error code of zero AND non-empty stdout, which explains
 
            # the odd construction:
 
            func_to_host_path_tmp1=`winepath -w "$1" 2>/dev/null`
 
            if test "$?" -eq 0 && test -n "${func_to_host_path_tmp1}"; then
 
              func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\
 
                $SED -e "$lt_sed_naive_backslashify"`
          else
          else
            # If the PIC object exists, use it instead.
              # Allow warning below.
            # $xdir was prepended to $pic_object above.
              func_to_host_path_result=""
            non_pic_object="$pic_object"
 
            func_append non_pic_objects " $non_pic_object"
 
          fi
          fi
        else
            ;;
          # Only an error if not doing a dry-run.
        esac
          if $opt_dry_run; then
        if test -z "$func_to_host_path_result" ; then
            # Extract subdirectory from the argument.
          func_error "Could not determine host path corresponding to"
            func_dirname "$arg" "/" ""
          func_error "  '$1'"
            xdir="$func_dirname_result"
          func_error "Continuing, but uninstalled executables may not work."
 
          # Fallback:
 
          func_to_host_path_result="$1"
 
        fi
 
        ;;
 
    esac
 
  fi
 
}
 
# end: func_to_host_path
 
 
            func_lo2o "$arg"
# func_to_host_pathlist arg
            pic_object=$xdir$objdir/$func_lo2o_result
#
            non_pic_object=$xdir$func_lo2o_result
# Convert pathlists to host format when used with build tools.
            func_append libobjs " $pic_object"
# See func_to_host_path(), above. This function supports the
            func_append non_pic_objects " $non_pic_object"
# following $build/$host combinations (but does no harm for
 
# combinations not listed here):
 
#    $build          $host
 
#    mingw (msys)    mingw  [e.g. native]
 
#    cygwin          mingw
 
#    *nix + wine     mingw
 
#
 
# Path separators are also converted from $build format to
 
# $host format. If ARG begins or ends with a path separator
 
# character, it is preserved (but converted to $host format)
 
# on output.
 
#
 
# ARG is a pathlist (on $build) that should be converted to
 
# the proper representation on $host. The result is stored
 
# in $func_to_host_pathlist_result.
 
func_to_host_pathlist ()
 
{
 
  func_to_host_pathlist_result="$1"
 
  if test -n "$1" ; then
 
    case $host in
 
      *mingw* )
 
        lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
 
        # Remove leading and trailing path separator characters from
 
        # ARG. msys behavior is inconsistent here, cygpath turns them
 
        # into '.;' and ';.', and winepath ignores them completely.
 
        func_to_host_pathlist_tmp2="$1"
 
        # Once set for this call, this variable should not be
 
        # reassigned. It is used in tha fallback case.
 
        func_to_host_pathlist_tmp1=`echo "$func_to_host_pathlist_tmp2" |\
 
          $SED -e 's|^:*||' -e 's|:*$||'`
 
        case $build in
 
          *mingw* ) # Actually, msys.
 
            # Awkward: cmd appends spaces to result.
 
            lt_sed_strip_trailing_spaces="s/[ ]*\$//"
 
            func_to_host_pathlist_tmp2=`( cmd //c echo "$func_to_host_pathlist_tmp1" |\
 
              $SED -e "$lt_sed_strip_trailing_spaces" ) 2>/dev/null || echo ""`
 
            func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp2" |\
 
              $SED -e "$lt_sed_naive_backslashify"`
 
            ;;
 
          *cygwin* )
 
            func_to_host_pathlist_tmp2=`cygpath -w -p "$func_to_host_pathlist_tmp1"`
 
            func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp2" |\
 
              $SED -e "$lt_sed_naive_backslashify"`
 
            ;;
 
          * )
 
            # unfortunately, winepath doesn't convert pathlists
 
            func_to_host_pathlist_result=""
 
            func_to_host_pathlist_oldIFS=$IFS
 
            IFS=:
 
            for func_to_host_pathlist_f in $func_to_host_pathlist_tmp1 ; do
 
              IFS=$func_to_host_pathlist_oldIFS
 
              if test -n "$func_to_host_pathlist_f" ; then
 
                func_to_host_path "$func_to_host_pathlist_f"
 
                if test -n "$func_to_host_path_result" ; then
 
                  if test -z "$func_to_host_pathlist_result" ; then
 
                    func_to_host_pathlist_result="$func_to_host_path_result"
          else
          else
            func_fatal_error "\`$arg' is not a valid libtool object"
                    func_to_host_pathlist_result="$func_to_host_pathlist_result;$func_to_host_path_result"
          fi
          fi
        fi
        fi
 
              fi
 
              IFS=:
 
            done
 
            IFS=$func_to_host_pathlist_oldIFS
        ;;
        ;;
 
        esac
      *.$libext)
        if test -z "$func_to_host_pathlist_result" ; then
        # An archive.
          func_error "Could not determine the host path(s) corresponding to"
        deplibs="$deplibs $arg"
          func_error "  '$1'"
        old_deplibs="$old_deplibs $arg"
          func_error "Continuing, but uninstalled executables may not work."
        continue
          # Fallback. This may break if $1 contains DOS-style drive
 
          # specifications. The fix is not to complicate the expression
 
          # below, but for the user to provide a working wine installation
 
          # with winepath so that path translation in the cross-to-mingw
 
          # case works properly.
 
          lt_replace_pathsep_nix_to_dos="s|:|;|g"
 
          func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp1" |\
 
            $SED -e "$lt_replace_pathsep_nix_to_dos"`
 
        fi
 
        # Now, add the leading and trailing path separators back
 
        case "$1" in
 
          :* ) func_to_host_pathlist_result=";$func_to_host_pathlist_result"
 
            ;;
 
        esac
 
        case "$1" in
 
          *: ) func_to_host_pathlist_result="$func_to_host_pathlist_result;"
 
            ;;
 
        esac
        ;;
        ;;
 
    esac
 
  fi
 
}
 
# end: func_to_host_pathlist
 
 
      *.la)
# func_emit_cwrapperexe_src
        # A libtool-controlled library.
# emit the source code for a wrapper executable on stdout
 
# Must ONLY be called from within func_mode_link because
 
# it depends on a number of variable set therein.
 
func_emit_cwrapperexe_src ()
 
{
 
        cat <<EOF
 
 
        if test "$prev" = dlfiles; then
/* $cwrappersource - temporary wrapper executable for $objdir/$outputname
          # This library was specified with -dlopen.
   Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
          dlfiles="$dlfiles $arg"
 
          prev=
 
        elif test "$prev" = dlprefiles; then
 
          # The library was specified with -dlpreopen.
 
          dlprefiles="$dlprefiles $arg"
 
          prev=
 
        else
 
          deplibs="$deplibs $arg"
 
        fi
 
        continue
 
        ;;
 
 
 
      # Some other compiler argument.
   The $output program cannot be directly executed until all the libtool
      *)
   libraries that it depends on are installed.
        # Unknown arguments in both finalize_command and compile_command need
 
        # to be aesthetically quoted because they are evaled later.
 
        func_quote_for_eval "$arg"
 
        arg="$func_quote_for_eval_result"
 
        ;;
 
      esac # arg
 
 
 
      # Now actually substitute the argument into the commands.
   This wrapper executable should never be moved out of the build directory.
      if test -n "$arg"; then
   If it is, it will not operate correctly.
        func_append compile_command " $arg"
 
        func_append finalize_command " $arg"
 
      fi
 
    done # argument parsing loop
 
 
 
    test -n "$prev" && \
   Currently, it simply execs the wrapper *script* "$SHELL $output",
      func_fatal_help "the \`$prevarg' option requires an argument"
   but could eventually absorb all of the scripts functionality and
 
   exec $objdir/$outputname directly.
 
*/
 
EOF
 
            cat <<"EOF"
 
#include <stdio.h>
 
#include <stdlib.h>
 
#ifdef _MSC_VER
 
# include <direct.h>
 
# include <process.h>
 
# include <io.h>
 
# define setmode _setmode
 
#else
 
# include <unistd.h>
 
# include <stdint.h>
 
# ifdef __CYGWIN__
 
#  include <io.h>
 
#  define HAVE_SETENV
 
#  ifdef __STRICT_ANSI__
 
char *realpath (const char *, char *);
 
int putenv (char *);
 
int setenv (const char *, const char *, int);
 
#  endif
 
# endif
 
#endif
 
#include <malloc.h>
 
#include <stdarg.h>
 
#include <assert.h>
 
#include <string.h>
 
#include <ctype.h>
 
#include <errno.h>
 
#include <fcntl.h>
 
#include <sys/stat.h>
 
 
    if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
#if defined(PATH_MAX)
      eval arg=\"$export_dynamic_flag_spec\"
# define LT_PATHMAX PATH_MAX
      func_append compile_command " $arg"
#elif defined(MAXPATHLEN)
      func_append finalize_command " $arg"
# define LT_PATHMAX MAXPATHLEN
    fi
#else
 
# define LT_PATHMAX 1024
 
#endif
 
 
    oldlibs=
#ifndef S_IXOTH
    # calculate the name of the file, without its directory
# define S_IXOTH 0
    func_basename "$output"
#endif
    outputname="$func_basename_result"
#ifndef S_IXGRP
    libobjs_save="$libobjs"
# define S_IXGRP 0
 
#endif
 
 
    if test -n "$shlibpath_var"; then
#ifdef _MSC_VER
      # get the directories listed in $shlibpath_var
# define S_IXUSR _S_IEXEC
      eval shlib_search_path=\`\$ECHO \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
# define stat _stat
    else
# ifndef _INTPTR_T_DEFINED
      shlib_search_path=
#  define intptr_t int
    fi
# endif
    eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
#endif
    eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
 
 
 
    func_dirname "$output" "/" ""
#ifndef DIR_SEPARATOR
    output_objdir="$func_dirname_result$objdir"
# define DIR_SEPARATOR '/'
    # Create the object directory.
# define PATH_SEPARATOR ':'
    func_mkdir_p "$output_objdir"
#endif
 
 
    # Determine the type of output
#if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
    case $output in
  defined (__OS2__)
    "")
# define HAVE_DOS_BASED_FILE_SYSTEM
      func_fatal_help "you must specify an output file"
# define FOPEN_WB "wb"
      ;;
# ifndef DIR_SEPARATOR_2
    *.$libext) linkmode=oldlib ;;
#  define DIR_SEPARATOR_2 '\\'
    *.lo | *.$objext) linkmode=obj ;;
# endif
    *.la) linkmode=lib ;;
# ifndef PATH_SEPARATOR_2
    *) linkmode=prog ;; # Anything else should be a program.
#  define PATH_SEPARATOR_2 ';'
    esac
# endif
 
#endif
 
 
    specialdeplibs=
#ifndef DIR_SEPARATOR_2
 
# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
 
#else /* DIR_SEPARATOR_2 */
 
# define IS_DIR_SEPARATOR(ch) \
 
        (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
 
#endif /* DIR_SEPARATOR_2 */
 
 
    libs=
#ifndef PATH_SEPARATOR_2
    # Find all interdependent deplibs by searching for libraries
# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
    # that are linked more than once (e.g. -la -lb -la)
#else /* PATH_SEPARATOR_2 */
    for deplib in $deplibs; do
# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
      if $opt_duplicate_deps ; then
#endif /* PATH_SEPARATOR_2 */
        case "$libs " in
 
        *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
 
        esac
 
      fi
 
      libs="$libs $deplib"
 
    done
 
 
 
    if test "$linkmode" = lib; then
#ifdef __CYGWIN__
      libs="$predeps $libs $compiler_lib_search_path $postdeps"
# define FOPEN_WB "wb"
 
#endif
 
 
      # Compute libraries that are listed more than once in $predeps
#ifndef FOPEN_WB
      # $postdeps and mark them as special (i.e., whose duplicates are
# define FOPEN_WB "w"
      # not to be eliminated).
#endif
      pre_post_deps=
#ifndef _O_BINARY
      if $opt_duplicate_compiler_generated_deps; then
# define _O_BINARY 0
        for pre_post_dep in $predeps $postdeps; do
#endif
          case "$pre_post_deps " in
 
          *" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
 
          esac
 
          pre_post_deps="$pre_post_deps $pre_post_dep"
 
        done
 
      fi
 
      pre_post_deps=
 
    fi
 
 
 
    deplibs=
#define XMALLOC(type, num)      ((type *) xmalloc ((num) * sizeof(type)))
    newdependency_libs=
#define XFREE(stale) do { \
    newlib_search_path=
  if (stale) { free ((void *) stale); stale = 0; } \
    need_relink=no # whether we're linking any uninstalled libtool libraries
} while (0)
    notinst_deplibs= # not-installed libtool libraries
 
    notinst_path= # paths that contain not-installed libtool libraries
 
 
 
    case $linkmode in
#undef LTWRAPPER_DEBUGPRINTF
    lib)
#if defined DEBUGWRAPPER
        passes="conv dlpreopen link"
# define LTWRAPPER_DEBUGPRINTF(args) ltwrapper_debugprintf args
        for file in $dlfiles $dlprefiles; do
static void
          case $file in
ltwrapper_debugprintf (const char *fmt, ...)
          *.la) ;;
{
          *)
    va_list args;
            func_fatal_help "libraries can \`-dlopen' only libtool libraries: $file"
    va_start (args, fmt);
            ;;
    (void) vfprintf (stderr, fmt, args);
          esac
    va_end (args);
        done
}
        ;;
#else
    prog)
# define LTWRAPPER_DEBUGPRINTF(args)
        compile_deplibs=
#endif
        finalize_deplibs=
 
        alldeplibs=no
 
        newdlfiles=
 
        newdlprefiles=
 
        passes="conv scan dlopen dlpreopen link"
 
        ;;
 
    *)  passes="conv"
 
        ;;
 
    esac
 
 
 
    for pass in $passes; do
const char *program_name = NULL;
      # The preopen pass in lib mode reverses $deplibs; put it back here
 
      # so that -L comes before libs that need it for instance...
 
      if test "$linkmode,$pass" = "lib,link"; then
 
        ## FIXME: Find the place where the list is rebuilt in the wrong
 
        ##        order, and fix it there properly
 
        tmp_deplibs=
 
        for deplib in $deplibs; do
 
          tmp_deplibs="$deplib $tmp_deplibs"
 
        done
 
        deplibs="$tmp_deplibs"
 
      fi
 
 
 
      if test "$linkmode,$pass" = "lib,link" ||
void *xmalloc (size_t num);
         test "$linkmode,$pass" = "prog,scan"; then
char *xstrdup (const char *string);
        libs="$deplibs"
const char *base_name (const char *name);
 
char *find_executable (const char *wrapper);
 
char *chase_symlinks (const char *pathspec);
 
int make_executable (const char *path);
 
int check_executable (const char *path);
 
char *strendzap (char *str, const char *pat);
 
void lt_fatal (const char *message, ...);
 
void lt_setenv (const char *name, const char *value);
 
char *lt_extend_str (const char *orig_value, const char *add, int to_end);
 
void lt_opt_process_env_set (const char *arg);
 
void lt_opt_process_env_prepend (const char *arg);
 
void lt_opt_process_env_append (const char *arg);
 
int lt_split_name_value (const char *arg, char** name, char** value);
 
void lt_update_exe_path (const char *name, const char *value);
 
void lt_update_lib_path (const char *name, const char *value);
 
 
 
static const char *script_text_part1 =
 
EOF
 
 
 
            func_emit_wrapper_part1 yes |
 
                $SED -e 's/\([\\"]\)/\\\1/g' \
 
                     -e 's/^/  "/' -e 's/$/\\n"/'
 
            echo ";"
 
            cat <<EOF
 
 
 
static const char *script_text_part2 =
 
EOF
 
            func_emit_wrapper_part2 yes |
 
                $SED -e 's/\([\\"]\)/\\\1/g' \
 
                     -e 's/^/  "/' -e 's/$/\\n"/'
 
            echo ";"
 
 
 
            cat <<EOF
 
const char * MAGIC_EXE = "$magic_exe";
 
const char * LIB_PATH_VARNAME = "$shlibpath_var";
 
EOF
 
 
 
            if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
 
              func_to_host_pathlist "$temp_rpath"
 
              cat <<EOF
 
const char * LIB_PATH_VALUE   = "$func_to_host_pathlist_result";
 
EOF
 
            else
 
              cat <<"EOF"
 
const char * LIB_PATH_VALUE   = "";
 
EOF
 
            fi
 
 
 
            if test -n "$dllsearchpath"; then
 
              func_to_host_pathlist "$dllsearchpath:"
 
              cat <<EOF
 
const char * EXE_PATH_VARNAME = "PATH";
 
const char * EXE_PATH_VALUE   = "$func_to_host_pathlist_result";
 
EOF
 
            else
 
              cat <<"EOF"
 
const char * EXE_PATH_VARNAME = "";
 
const char * EXE_PATH_VALUE   = "";
 
EOF
 
            fi
 
 
 
            if test "$fast_install" = yes; then
 
              cat <<EOF
 
const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */
 
EOF
 
            else
 
              cat <<EOF
 
const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */
 
EOF
 
            fi
 
 
 
 
 
            cat <<"EOF"
 
 
 
#define LTWRAPPER_OPTION_PREFIX         "--lt-"
 
#define LTWRAPPER_OPTION_PREFIX_LENGTH  5
 
 
 
static const size_t opt_prefix_len         = LTWRAPPER_OPTION_PREFIX_LENGTH;
 
static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
 
 
 
static const char *dumpscript_opt       = LTWRAPPER_OPTION_PREFIX "dump-script";
 
 
 
static const size_t env_set_opt_len     = LTWRAPPER_OPTION_PREFIX_LENGTH + 7;
 
static const char *env_set_opt          = LTWRAPPER_OPTION_PREFIX "env-set";
 
  /* argument is putenv-style "foo=bar", value of foo is set to bar */
 
 
 
static const size_t env_prepend_opt_len = LTWRAPPER_OPTION_PREFIX_LENGTH + 11;
 
static const char *env_prepend_opt      = LTWRAPPER_OPTION_PREFIX "env-prepend";
 
  /* argument is putenv-style "foo=bar", new value of foo is bar${foo} */
 
 
 
static const size_t env_append_opt_len  = LTWRAPPER_OPTION_PREFIX_LENGTH + 10;
 
static const char *env_append_opt       = LTWRAPPER_OPTION_PREFIX "env-append";
 
  /* argument is putenv-style "foo=bar", new value of foo is ${foo}bar */
 
 
 
int
 
main (int argc, char *argv[])
 
{
 
  char **newargz;
 
  int  newargc;
 
  char *tmp_pathspec;
 
  char *actual_cwrapper_path;
 
  char *actual_cwrapper_name;
 
  char *target_name;
 
  char *lt_argv_zero;
 
  intptr_t rval = 127;
 
 
 
  int i;
 
 
 
  program_name = (char *) xstrdup (base_name (argv[0]));
 
  LTWRAPPER_DEBUGPRINTF (("(main) argv[0]      : %s\n", argv[0]));
 
  LTWRAPPER_DEBUGPRINTF (("(main) program_name : %s\n", program_name));
 
 
 
  /* very simple arg parsing; don't want to rely on getopt */
 
  for (i = 1; i < argc; i++)
 
    {
 
      if (strcmp (argv[i], dumpscript_opt) == 0)
 
        {
 
EOF
 
            case "$host" in
 
              *mingw* | *cygwin* )
 
                # make stdout use "unix" line endings
 
                echo "          setmode(1,_O_BINARY);"
 
                ;;
 
              esac
 
 
 
            cat <<"EOF"
 
          printf ("%s", script_text_part1);
 
          printf ("%s", script_text_part2);
 
          return 0;
 
        }
 
    }
 
 
 
  newargz = XMALLOC (char *, argc + 1);
 
  tmp_pathspec = find_executable (argv[0]);
 
  if (tmp_pathspec == NULL)
 
    lt_fatal ("Couldn't find %s", argv[0]);
 
  LTWRAPPER_DEBUGPRINTF (("(main) found exe (before symlink chase) at : %s\n",
 
                          tmp_pathspec));
 
 
 
  actual_cwrapper_path = chase_symlinks (tmp_pathspec);
 
  LTWRAPPER_DEBUGPRINTF (("(main) found exe (after symlink chase) at : %s\n",
 
                          actual_cwrapper_path));
 
  XFREE (tmp_pathspec);
 
 
 
  actual_cwrapper_name = xstrdup( base_name (actual_cwrapper_path));
 
  strendzap (actual_cwrapper_path, actual_cwrapper_name);
 
 
 
  /* wrapper name transforms */
 
  strendzap (actual_cwrapper_name, ".exe");
 
  tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1);
 
  XFREE (actual_cwrapper_name);
 
  actual_cwrapper_name = tmp_pathspec;
 
  tmp_pathspec = 0;
 
 
 
  /* target_name transforms -- use actual target program name; might have lt- prefix */
 
  target_name = xstrdup (base_name (TARGET_PROGRAM_NAME));
 
  strendzap (target_name, ".exe");
 
  tmp_pathspec = lt_extend_str (target_name, ".exe", 1);
 
  XFREE (target_name);
 
  target_name = tmp_pathspec;
 
  tmp_pathspec = 0;
 
 
 
  LTWRAPPER_DEBUGPRINTF (("(main) libtool target name: %s\n",
 
                          target_name));
 
EOF
 
 
 
            cat <<EOF
 
  newargz[0] =
 
    XMALLOC (char, (strlen (actual_cwrapper_path) +
 
                    strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1));
 
  strcpy (newargz[0], actual_cwrapper_path);
 
  strcat (newargz[0], "$objdir");
 
  strcat (newargz[0], "/");
 
EOF
 
 
 
            cat <<"EOF"
 
  /* stop here, and copy so we don't have to do this twice */
 
  tmp_pathspec = xstrdup (newargz[0]);
 
 
 
  /* do NOT want the lt- prefix here, so use actual_cwrapper_name */
 
  strcat (newargz[0], actual_cwrapper_name);
 
 
 
  /* DO want the lt- prefix here if it exists, so use target_name */
 
  lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1);
 
  XFREE (tmp_pathspec);
 
  tmp_pathspec = NULL;
 
EOF
 
 
 
            case $host_os in
 
              mingw*)
 
            cat <<"EOF"
 
  {
 
    char* p;
 
    while ((p = strchr (newargz[0], '\\')) != NULL)
 
      {
 
        *p = '/';
 
      }
 
    while ((p = strchr (lt_argv_zero, '\\')) != NULL)
 
      {
 
        *p = '/';
 
      }
 
  }
 
EOF
 
            ;;
 
            esac
 
 
 
            cat <<"EOF"
 
  XFREE (target_name);
 
  XFREE (actual_cwrapper_path);
 
  XFREE (actual_cwrapper_name);
 
 
 
  lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
 
  lt_setenv ("DUALCASE", "1");  /* for MSK sh */
 
  lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
 
  lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
 
 
 
  newargc=0;
 
  for (i = 1; i < argc; i++)
 
    {
 
      if (strncmp (argv[i], env_set_opt, env_set_opt_len) == 0)
 
        {
 
          if (argv[i][env_set_opt_len] == '=')
 
            {
 
              const char *p = argv[i] + env_set_opt_len + 1;
 
              lt_opt_process_env_set (p);
 
            }
 
          else if (argv[i][env_set_opt_len] == '\0' && i + 1 < argc)
 
            {
 
              lt_opt_process_env_set (argv[++i]); /* don't copy */
 
            }
 
          else
 
            lt_fatal ("%s missing required argument", env_set_opt);
 
          continue;
 
        }
 
      if (strncmp (argv[i], env_prepend_opt, env_prepend_opt_len) == 0)
 
        {
 
          if (argv[i][env_prepend_opt_len] == '=')
 
            {
 
              const char *p = argv[i] + env_prepend_opt_len + 1;
 
              lt_opt_process_env_prepend (p);
 
            }
 
          else if (argv[i][env_prepend_opt_len] == '\0' && i + 1 < argc)
 
            {
 
              lt_opt_process_env_prepend (argv[++i]); /* don't copy */
 
            }
 
          else
 
            lt_fatal ("%s missing required argument", env_prepend_opt);
 
          continue;
 
        }
 
      if (strncmp (argv[i], env_append_opt, env_append_opt_len) == 0)
 
        {
 
          if (argv[i][env_append_opt_len] == '=')
 
            {
 
              const char *p = argv[i] + env_append_opt_len + 1;
 
              lt_opt_process_env_append (p);
 
            }
 
          else if (argv[i][env_append_opt_len] == '\0' && i + 1 < argc)
 
            {
 
              lt_opt_process_env_append (argv[++i]); /* don't copy */
 
            }
 
          else
 
            lt_fatal ("%s missing required argument", env_append_opt);
 
          continue;
 
        }
 
      if (strncmp (argv[i], ltwrapper_option_prefix, opt_prefix_len) == 0)
 
        {
 
          /* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
 
             namespace, but it is not one of the ones we know about and
 
             have already dealt with, above (inluding dump-script), then
 
             report an error. Otherwise, targets might begin to believe
 
             they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
 
             namespace. The first time any user complains about this, we'll
 
             need to make LTWRAPPER_OPTION_PREFIX a configure-time option
 
             or a configure.ac-settable value.
 
           */
 
          lt_fatal ("Unrecognized option in %s namespace: '%s'",
 
                    ltwrapper_option_prefix, argv[i]);
 
        }
 
      /* otherwise ... */
 
      newargz[++newargc] = xstrdup (argv[i]);
 
    }
 
  newargz[++newargc] = NULL;
 
 
 
  LTWRAPPER_DEBUGPRINTF     (("(main) lt_argv_zero : %s\n", (lt_argv_zero ? lt_argv_zero : "<NULL>")));
 
  for (i = 0; i < newargc; i++)
 
    {
 
      LTWRAPPER_DEBUGPRINTF (("(main) newargz[%d]   : %s\n", i, (newargz[i] ? newargz[i] : "<NULL>")));
 
    }
 
 
 
EOF
 
 
 
            case $host_os in
 
              mingw*)
 
                cat <<"EOF"
 
  /* execv doesn't actually work on mingw as expected on unix */
 
  rval = _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
 
  if (rval == -1)
 
    {
 
      /* failed to start process */
 
      LTWRAPPER_DEBUGPRINTF (("(main) failed to launch target \"%s\": errno = %d\n", lt_argv_zero, errno));
 
      return 127;
 
    }
 
  return rval;
 
EOF
 
                ;;
 
              *)
 
                cat <<"EOF"
 
  execv (lt_argv_zero, newargz);
 
  return rval; /* =127, but avoids unused variable warning */
 
EOF
 
                ;;
 
            esac
 
 
 
            cat <<"EOF"
 
}
 
 
 
void *
 
xmalloc (size_t num)
 
{
 
  void *p = (void *) malloc (num);
 
  if (!p)
 
    lt_fatal ("Memory exhausted");
 
 
 
  return p;
 
}
 
 
 
char *
 
xstrdup (const char *string)
 
{
 
  return string ? strcpy ((char *) xmalloc (strlen (string) + 1),
 
                          string) : NULL;
 
}
 
 
 
const char *
 
base_name (const char *name)
 
{
 
  const char *base;
 
 
 
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
 
  /* Skip over the disk name in MSDOS pathnames. */
 
  if (isalpha ((unsigned char) name[0]) && name[1] == ':')
 
    name += 2;
 
#endif
 
 
 
  for (base = name; *name; name++)
 
    if (IS_DIR_SEPARATOR (*name))
 
      base = name + 1;
 
  return base;
 
}
 
 
 
int
 
check_executable (const char *path)
 
{
 
  struct stat st;
 
 
 
  LTWRAPPER_DEBUGPRINTF (("(check_executable)  : %s\n",
 
                          path ? (*path ? path : "EMPTY!") : "NULL!"));
 
  if ((!path) || (!*path))
 
    return 0;
 
 
 
  if ((stat (path, &st) >= 0)
 
      && (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
 
    return 1;
 
  else
 
    return 0;
 
}
 
 
 
int
 
make_executable (const char *path)
 
{
 
  int rval = 0;
 
  struct stat st;
 
 
 
  LTWRAPPER_DEBUGPRINTF (("(make_executable)   : %s\n",
 
                          path ? (*path ? path : "EMPTY!") : "NULL!"));
 
  if ((!path) || (!*path))
 
    return 0;
 
 
 
  if (stat (path, &st) >= 0)
 
    {
 
      rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR);
 
    }
 
  return rval;
 
}
 
 
 
/* Searches for the full path of the wrapper.  Returns
 
   newly allocated full path name if found, NULL otherwise
 
   Does not chase symlinks, even on platforms that support them.
 
*/
 
char *
 
find_executable (const char *wrapper)
 
{
 
  int has_slash = 0;
 
  const char *p;
 
  const char *p_next;
 
  /* static buffer for getcwd */
 
  char tmp[LT_PATHMAX + 1];
 
  int tmp_len;
 
  char *concat_name;
 
 
 
  LTWRAPPER_DEBUGPRINTF (("(find_executable)   : %s\n",
 
                          wrapper ? (*wrapper ? wrapper : "EMPTY!") : "NULL!"));
 
 
 
  if ((wrapper == NULL) || (*wrapper == '\0'))
 
    return NULL;
 
 
 
  /* Absolute path? */
 
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
 
  if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')
 
    {
 
      concat_name = xstrdup (wrapper);
 
      if (check_executable (concat_name))
 
        return concat_name;
 
      XFREE (concat_name);
 
    }
 
  else
 
    {
 
#endif
 
      if (IS_DIR_SEPARATOR (wrapper[0]))
 
        {
 
          concat_name = xstrdup (wrapper);
 
          if (check_executable (concat_name))
 
            return concat_name;
 
          XFREE (concat_name);
 
        }
 
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
 
    }
 
#endif
 
 
 
  for (p = wrapper; *p; p++)
 
    if (*p == '/')
 
      {
 
        has_slash = 1;
 
        break;
 
      }
 
  if (!has_slash)
 
    {
 
      /* no slashes; search PATH */
 
      const char *path = getenv ("PATH");
 
      if (path != NULL)
 
        {
 
          for (p = path; *p; p = p_next)
 
            {
 
              const char *q;
 
              size_t p_len;
 
              for (q = p; *q; q++)
 
                if (IS_PATH_SEPARATOR (*q))
 
                  break;
 
              p_len = q - p;
 
              p_next = (*q == '\0' ? q : q + 1);
 
              if (p_len == 0)
 
                {
 
                  /* empty path: current directory */
 
                  if (getcwd (tmp, LT_PATHMAX) == NULL)
 
                    lt_fatal ("getcwd failed");
 
                  tmp_len = strlen (tmp);
 
                  concat_name =
 
                    XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
 
                  memcpy (concat_name, tmp, tmp_len);
 
                  concat_name[tmp_len] = '/';
 
                  strcpy (concat_name + tmp_len + 1, wrapper);
 
                }
 
              else
 
                {
 
                  concat_name =
 
                    XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);
 
                  memcpy (concat_name, p, p_len);
 
                  concat_name[p_len] = '/';
 
                  strcpy (concat_name + p_len + 1, wrapper);
 
                }
 
              if (check_executable (concat_name))
 
                return concat_name;
 
              XFREE (concat_name);
 
            }
 
        }
 
      /* not found in PATH; assume curdir */
 
    }
 
  /* Relative path | not found in path: prepend cwd */
 
  if (getcwd (tmp, LT_PATHMAX) == NULL)
 
    lt_fatal ("getcwd failed");
 
  tmp_len = strlen (tmp);
 
  concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
 
  memcpy (concat_name, tmp, tmp_len);
 
  concat_name[tmp_len] = '/';
 
  strcpy (concat_name + tmp_len + 1, wrapper);
 
 
 
  if (check_executable (concat_name))
 
    return concat_name;
 
  XFREE (concat_name);
 
  return NULL;
 
}
 
 
 
char *
 
chase_symlinks (const char *pathspec)
 
{
 
#ifndef S_ISLNK
 
  return xstrdup (pathspec);
 
#else
 
  char buf[LT_PATHMAX];
 
  struct stat s;
 
  char *tmp_pathspec = xstrdup (pathspec);
 
  char *p;
 
  int has_symlinks = 0;
 
  while (strlen (tmp_pathspec) && !has_symlinks)
 
    {
 
      LTWRAPPER_DEBUGPRINTF (("checking path component for symlinks: %s\n",
 
                              tmp_pathspec));
 
      if (lstat (tmp_pathspec, &s) == 0)
 
        {
 
          if (S_ISLNK (s.st_mode) != 0)
 
            {
 
              has_symlinks = 1;
 
              break;
 
            }
 
 
 
          /* search backwards for last DIR_SEPARATOR */
 
          p = tmp_pathspec + strlen (tmp_pathspec) - 1;
 
          while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
 
            p--;
 
          if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
 
            {
 
              /* no more DIR_SEPARATORS left */
 
              break;
 
            }
 
          *p = '\0';
 
        }
 
      else
 
        {
 
          char *errstr = strerror (errno);
 
          lt_fatal ("Error accessing file %s (%s)", tmp_pathspec, errstr);
 
        }
 
    }
 
  XFREE (tmp_pathspec);
 
 
 
  if (!has_symlinks)
 
    {
 
      return xstrdup (pathspec);
 
    }
 
 
 
  tmp_pathspec = realpath (pathspec, buf);
 
  if (tmp_pathspec == 0)
 
    {
 
      lt_fatal ("Could not follow symlinks for %s", pathspec);
 
    }
 
  return xstrdup (tmp_pathspec);
 
#endif
 
}
 
 
 
char *
 
strendzap (char *str, const char *pat)
 
{
 
  size_t len, patlen;
 
 
 
  assert (str != NULL);
 
  assert (pat != NULL);
 
 
 
  len = strlen (str);
 
  patlen = strlen (pat);
 
 
 
  if (patlen <= len)
 
    {
 
      str += len - patlen;
 
      if (strcmp (str, pat) == 0)
 
        *str = '\0';
 
    }
 
  return str;
 
}
 
 
 
static void
 
lt_error_core (int exit_status, const char *mode,
 
               const char *message, va_list ap)
 
{
 
  fprintf (stderr, "%s: %s: ", program_name, mode);
 
  vfprintf (stderr, message, ap);
 
  fprintf (stderr, ".\n");
 
 
 
  if (exit_status >= 0)
 
    exit (exit_status);
 
}
 
 
 
void
 
lt_fatal (const char *message, ...)
 
{
 
  va_list ap;
 
  va_start (ap, message);
 
  lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
 
  va_end (ap);
 
}
 
 
 
void
 
lt_setenv (const char *name, const char *value)
 
{
 
  LTWRAPPER_DEBUGPRINTF (("(lt_setenv) setting '%s' to '%s'\n",
 
                          (name ? name : "<NULL>"),
 
                          (value ? value : "<NULL>")));
 
  {
 
#ifdef HAVE_SETENV
 
    /* always make a copy, for consistency with !HAVE_SETENV */
 
    char *str = xstrdup (value);
 
    setenv (name, str, 1);
 
#else
 
    int len = strlen (name) + 1 + strlen (value) + 1;
 
    char *str = XMALLOC (char, len);
 
    sprintf (str, "%s=%s", name, value);
 
    if (putenv (str) != EXIT_SUCCESS)
 
      {
 
        XFREE (str);
 
      }
 
#endif
 
  }
 
}
 
 
 
char *
 
lt_extend_str (const char *orig_value, const char *add, int to_end)
 
{
 
  char *new_value;
 
  if (orig_value && *orig_value)
 
    {
 
      int orig_value_len = strlen (orig_value);
 
      int add_len = strlen (add);
 
      new_value = XMALLOC (char, add_len + orig_value_len + 1);
 
      if (to_end)
 
        {
 
          strcpy (new_value, orig_value);
 
          strcpy (new_value + orig_value_len, add);
 
        }
 
      else
 
        {
 
          strcpy (new_value, add);
 
          strcpy (new_value + add_len, orig_value);
 
        }
 
    }
 
  else
 
    {
 
      new_value = xstrdup (add);
 
    }
 
  return new_value;
 
}
 
 
 
int
 
lt_split_name_value (const char *arg, char** name, char** value)
 
{
 
  const char *p;
 
  int len;
 
  if (!arg || !*arg)
 
    return 1;
 
 
 
  p = strchr (arg, (int)'=');
 
 
 
  if (!p)
 
    return 1;
 
 
 
  *value = xstrdup (++p);
 
 
 
  len = strlen (arg) - strlen (*value);
 
  *name = XMALLOC (char, len);
 
  strncpy (*name, arg, len-1);
 
  (*name)[len - 1] = '\0';
 
 
 
  return 0;
 
}
 
 
 
void
 
lt_opt_process_env_set (const char *arg)
 
{
 
  char *name = NULL;
 
  char *value = NULL;
 
 
 
  if (lt_split_name_value (arg, &name, &value) != 0)
 
    {
 
      XFREE (name);
 
      XFREE (value);
 
      lt_fatal ("bad argument for %s: '%s'", env_set_opt, arg);
 
    }
 
 
 
  lt_setenv (name, value);
 
  XFREE (name);
 
  XFREE (value);
 
}
 
 
 
void
 
lt_opt_process_env_prepend (const char *arg)
 
{
 
  char *name = NULL;
 
  char *value = NULL;
 
  char *new_value = NULL;
 
 
 
  if (lt_split_name_value (arg, &name, &value) != 0)
 
    {
 
      XFREE (name);
 
      XFREE (value);
 
      lt_fatal ("bad argument for %s: '%s'", env_prepend_opt, arg);
 
    }
 
 
 
  new_value = lt_extend_str (getenv (name), value, 0);
 
  lt_setenv (name, new_value);
 
  XFREE (new_value);
 
  XFREE (name);
 
  XFREE (value);
 
}
 
 
 
void
 
lt_opt_process_env_append (const char *arg)
 
{
 
  char *name = NULL;
 
  char *value = NULL;
 
  char *new_value = NULL;
 
 
 
  if (lt_split_name_value (arg, &name, &value) != 0)
 
    {
 
      XFREE (name);
 
      XFREE (value);
 
      lt_fatal ("bad argument for %s: '%s'", env_append_opt, arg);
 
    }
 
 
 
  new_value = lt_extend_str (getenv (name), value, 1);
 
  lt_setenv (name, new_value);
 
  XFREE (new_value);
 
  XFREE (name);
 
  XFREE (value);
 
}
 
 
 
void
 
lt_update_exe_path (const char *name, const char *value)
 
{
 
  LTWRAPPER_DEBUGPRINTF (("(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
 
                          (name ? name : "<NULL>"),
 
                          (value ? value : "<NULL>")));
 
 
 
  if (name && *name && value && *value)
 
    {
 
      char *new_value = lt_extend_str (getenv (name), value, 0);
 
      /* some systems can't cope with a ':'-terminated path #' */
 
      int len = strlen (new_value);
 
      while (((len = strlen (new_value)) > 0) && IS_PATH_SEPARATOR (new_value[len-1]))
 
        {
 
          new_value[len-1] = '\0';
 
        }
 
      lt_setenv (name, new_value);
 
      XFREE (new_value);
 
    }
 
}
 
 
 
void
 
lt_update_lib_path (const char *name, const char *value)
 
{
 
  LTWRAPPER_DEBUGPRINTF (("(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
 
                          (name ? name : "<NULL>"),
 
                          (value ? value : "<NULL>")));
 
 
 
  if (name && *name && value && *value)
 
    {
 
      char *new_value = lt_extend_str (getenv (name), value, 0);
 
      lt_setenv (name, new_value);
 
      XFREE (new_value);
 
    }
 
}
 
 
 
 
 
EOF
 
}
 
# end: func_emit_cwrapperexe_src
 
 
 
# func_mode_link arg...
 
func_mode_link ()
 
{
 
    $opt_debug
 
    case $host in
 
    *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
 
      # 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=
        deplibs=
 
    old_deplibs=
 
    compiler_flags=
 
    linker_flags=
 
    dllsearchpath=
 
    lib_search_path=`pwd`
 
    inst_prefix_dir=
 
    new_inherited_linker_flags=
 
 
 
    avoid_version=no
 
    bindir=
 
    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
 
    weak_libs=
 
    single_module="${wl}-single_module"
 
    func_infer_tag $base_compile
 
 
 
    # We need to know -static, to get the right output filenames.
 
    for arg
 
    do
 
      case $arg in
 
      -shared)
 
        test "$build_libtool_libs" != yes && \
 
          func_fatal_configuration "can not build a shared library"
 
        build_old_libs=no
 
        break
 
        ;;
 
      -all-static | -static | -static-libtool-libs)
 
        case $arg in
 
        -all-static)
 
          if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
 
            func_warning "complete static linking is impossible in this configuration"
 
          fi
 
          if test -n "$link_static_flag"; then
 
            dlopen_self=$dlopen_self_static
 
          fi
 
          prefer_static_libs=yes
 
          ;;
 
        -static)
 
          if test -z "$pic_flag" && test -n "$link_static_flag"; then
 
            dlopen_self=$dlopen_self_static
 
          fi
 
          prefer_static_libs=built
 
          ;;
 
        -static-libtool-libs)
 
          if test -z "$pic_flag" && test -n "$link_static_flag"; then
 
            dlopen_self=$dlopen_self_static
 
          fi
 
          prefer_static_libs=yes
 
          ;;
 
        esac
 
        build_libtool_libs=no
 
        build_old_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
 
      func_quote_for_eval "$arg"
 
      qarg=$func_quote_for_eval_unquoted_result
 
      func_append libtool_args " $func_quote_for_eval_result"
 
 
 
      # If the previous option needs an argument, assign it.
 
      if test -n "$prev"; then
 
        case $prev in
 
        output)
 
          func_append compile_command " @OUTPUT@"
 
          func_append finalize_command " @OUTPUT@"
 
          ;;
 
        esac
 
 
 
        case $prev in
 
        bindir)
 
          bindir="$arg"
 
          prev=
 
          continue
 
          ;;
 
        dlfiles|dlprefiles)
 
          if test "$preload" = no; then
 
            # Add the symbol object into the linking commands.
 
            func_append compile_command " @SYMFILE@"
 
            func_append 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
      fi
      if test "$linkmode" = prog; then
            prev=
        case $pass in
            continue
        dlopen) libs="$dlfiles" ;;
            ;;
        dlpreopen) libs="$dlprefiles" ;;
          self)
        link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
            if test "$prev" = dlprefiles; then
        esac
              dlself=yes
 
            elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
 
              dlself=yes
 
            else
 
              dlself=needless
 
              export_dynamic=yes
      fi
      fi
      if test "$linkmode,$pass" = "lib,dlpreopen"; then
            prev=
        # Collect and forward deplibs of preopened libtool libs
            continue
        for lib in $dlprefiles; do
            ;;
          # Ignore non-libtool-libs
          *)
          dependency_libs=
            if test "$prev" = dlfiles; then
          case $lib in
              dlfiles="$dlfiles $arg"
          *.la) func_source "$lib" ;;
            else
 
              dlprefiles="$dlprefiles $arg"
 
            fi
 
            prev=
 
            continue
 
            ;;
          esac
          esac
 
          ;;
          # Collect preopened libtool deplibs, except any this library
        expsyms)
          # has declared as weak libs
          export_symbols="$arg"
          for deplib in $dependency_libs; do
          test -f "$arg" \
            deplib_base=`$ECHO "X$deplib" | $Xsed -e "$basename"`
            || func_fatal_error "symbol file \`$arg' does not exist"
            case " $weak_libs " in
          prev=
            *" $deplib_base "*) ;;
          continue
            *) deplibs="$deplibs $deplib" ;;
          ;;
 
        expsyms_regex)
 
          export_symbols_regex="$arg"
 
          prev=
 
          continue
 
          ;;
 
        framework)
 
          case $host in
 
            *-*-darwin*)
 
              case "$deplibs " in
 
                *" $qarg.ltframework "*) ;;
 
                *) deplibs="$deplibs $qarg.ltframework" # this is fixed later
 
                   ;;
            esac
            esac
          done
              ;;
        done
          esac
        libs="$dlprefiles"
          prev=
 
          continue
 
          ;;
 
        inst_prefix)
 
          inst_prefix_dir="$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 func_lalib_unsafe_p "$arg"; then
 
                pic_object=
 
                non_pic_object=
 
 
 
                # Read the .lo file
 
                func_source "$arg"
 
 
 
                if test -z "$pic_object" ||
 
                   test -z "$non_pic_object" ||
 
                   test "$pic_object" = none &&
 
                   test "$non_pic_object" = none; then
 
                  func_fatal_error "cannot find name of object for \`$arg'"
 
                fi
 
 
 
                # Extract subdirectory from the argument.
 
                func_dirname "$arg" "/" ""
 
                xdir="$func_dirname_result"
 
 
 
                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
      if test "$pass" = dlopen; then
 
        # Collect dlpreopened libraries
 
        save_deplibs="$deplibs"
 
        deplibs=
 
      fi
      fi
 
 
      for deplib in $libs; do
                  # CHECK ME:  I think I busted this.  -Ossama
        lib=
                  if test "$prev" = dlprefiles; then
        found=no
                    # Preload the old-style object.
        case $deplib in
                    dlprefiles="$dlprefiles $pic_object"
        -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
                    prev=
          if test "$linkmode,$pass" = "prog,link"; then
                  fi
            compile_deplibs="$deplib $compile_deplibs"
 
            finalize_deplibs="$deplib $finalize_deplibs"
                  # A PIC object.
 
                  func_append 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
 
                  func_append non_pic_objects " $non_pic_object"
 
                  if test -z "$pic_object" || test "$pic_object" = none ; then
 
                    arg="$non_pic_object"
 
                  fi
          else
          else
            compiler_flags="$compiler_flags $deplib"
                  # If the PIC object exists, use it instead.
            if test "$linkmode" = lib ; then
                  # $xdir was prepended to $pic_object above.
                case "$new_inherited_linker_flags " in
                  non_pic_object="$pic_object"
                    *" $deplib "*) ;;
                  func_append non_pic_objects " $non_pic_object"
                    * ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
                fi
 
              else
 
                # Only an error if not doing a dry-run.
 
                if $opt_dry_run; then
 
                  # Extract subdirectory from the argument.
 
                  func_dirname "$arg" "/" ""
 
                  xdir="$func_dirname_result"
 
 
 
                  func_lo2o "$arg"
 
                  pic_object=$xdir$objdir/$func_lo2o_result
 
                  non_pic_object=$xdir$func_lo2o_result
 
                  func_append libobjs " $pic_object"
 
                  func_append non_pic_objects " $non_pic_object"
 
                else
 
                  func_fatal_error "\`$arg' is not a valid libtool object"
 
                fi
 
              fi
 
            done
 
          else
 
            func_fatal_error "link input file \`$arg' does not exist"
 
          fi
 
          arg=$save_arg
 
          prev=
 
          continue
 
          ;;
 
        precious_regex)
 
          precious_files_regex="$arg"
 
          prev=
 
          continue
 
          ;;
 
        release)
 
          release="-$arg"
 
          prev=
 
          continue
 
          ;;
 
        rpath | xrpath)
 
          # We need an absolute path.
 
          case $arg in
 
          [\\/]* | [A-Za-z]:[\\/]*) ;;
 
          *)
 
            func_fatal_error "only absolute run-paths are allowed"
 
            ;;
 
          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
 
          ;;
 
        shrext)
 
          shrext_cmds="$arg"
 
          prev=
 
          continue
 
          ;;
 
        weak)
 
          weak_libs="$weak_libs $arg"
 
          prev=
 
          continue
 
          ;;
 
        xcclinker)
 
          linker_flags="$linker_flags $qarg"
 
          compiler_flags="$compiler_flags $qarg"
 
          prev=
 
          func_append compile_command " $qarg"
 
          func_append finalize_command " $qarg"
 
          continue
 
          ;;
 
        xcompiler)
 
          compiler_flags="$compiler_flags $qarg"
 
          prev=
 
          func_append compile_command " $qarg"
 
          func_append finalize_command " $qarg"
 
          continue
 
          ;;
 
        xlinker)
 
          linker_flags="$linker_flags $qarg"
 
          compiler_flags="$compiler_flags $wl$qarg"
 
          prev=
 
          func_append compile_command " $wl$qarg"
 
          func_append finalize_command " $wl$qarg"
 
          continue
 
          ;;
 
        *)
 
          eval "$prev=\"\$arg\""
 
          prev=
 
          continue
 
          ;;
                esac
                esac
            fi
      fi # test -n "$prev"
 
 
 
      prevarg="$arg"
 
 
 
      case $arg in
 
      -all-static)
 
        if test -n "$link_static_flag"; then
 
          # See comment for -static flag below, for more details.
 
          func_append compile_command " $link_static_flag"
 
          func_append finalize_command " $link_static_flag"
          fi
          fi
          continue
          continue
          ;;
          ;;
        -l*)
 
          if test "$linkmode" != lib && test "$linkmode" != prog; then
      -allow-undefined)
            func_warning "\`-l' is ignored for archives/objects"
        # FIXME: remove this flag sometime in the future.
 
        func_fatal_error "\`-allow-undefined' must not be used because it is the default"
 
        ;;
 
 
 
      -avoid-version)
 
        avoid_version=yes
            continue
            continue
          fi
        ;;
          func_stripname '-l' '' "$deplib"
 
          name=$func_stripname_result
      -bindir)
          for searchdir in $newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path; do
        prev=bindir
            for search_ext in .la $std_shrext .so .a; do
 
              # Search the libtool library
 
              lib="$searchdir/lib${name}${search_ext}"
 
              if test -f "$lib"; then
 
                if test "$search_ext" = ".la"; then
 
                  found=yes
 
                else
 
                  found=no
 
                fi
 
                break 2
 
              fi
 
            done
 
          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"
 
            fi
 
            continue
            continue
          else # deplib is a libtool library
        ;;
            # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
 
            # We need to do some special things here, and not later.
      -dlopen)
            if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
        prev=dlfiles
              case " $predeps $postdeps " in
 
              *" $deplib "*)
 
                if func_lalib_p "$lib"; then
 
                  library_names=
 
                  old_library=
 
                  func_source "$lib"
 
                  for l in $old_library $library_names; do
 
                    ll="$l"
 
                  done
 
                  if test "X$ll" = "X$old_library" ; then # only static version available
 
                    found=no
 
                    func_dirname "$lib" "" "."
 
                    ladir="$func_dirname_result"
 
                    lib=$ladir/$old_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"
 
                    fi
 
                    continue
                    continue
                  fi
 
                fi
 
                ;;
                ;;
              *) ;;
 
              esac
      -dlpreopen)
            fi
        prev=dlprefiles
 
        continue
 
        ;;
 
 
 
      -export-dynamic)
 
        export_dynamic=yes
 
        continue
 
        ;;
 
 
 
      -export-symbols | -export-symbols-regex)
 
        if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
 
          func_fatal_error "more than one -exported-symbols argument is not allowed"
          fi
          fi
          ;; # -l
        if test "X$arg" = "X-export-symbols"; then
        *.ltframework)
          prev=expsyms
          if test "$linkmode,$pass" = "prog,link"; then
 
            compile_deplibs="$deplib $compile_deplibs"
 
            finalize_deplibs="$deplib $finalize_deplibs"
 
          else
          else
            deplibs="$deplib $deplibs"
          prev=expsyms_regex
            if test "$linkmode" = lib ; then
 
                case "$new_inherited_linker_flags " in
 
                    *" $deplib "*) ;;
 
                    * ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
 
                esac
 
            fi
 
          fi
          fi
          continue
          continue
          ;;
          ;;
        -L*)
 
          case $linkmode in
      -framework)
          lib)
        prev=framework
            deplibs="$deplib $deplibs"
        continue
            test "$pass" = conv && continue
 
            newdependency_libs="$deplib $newdependency_libs"
 
            func_stripname '-L' '' "$deplib"
 
            newlib_search_path="$newlib_search_path $func_stripname_result"
 
            ;;
            ;;
          prog)
 
            if test "$pass" = conv; then
      -inst-prefix-dir)
              deplibs="$deplib $deplibs"
        prev=inst_prefix
              continue
              continue
            fi
        ;;
            if test "$pass" = scan; then
 
              deplibs="$deplib $deplibs"
      # 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*)
 
          func_append compile_command " $arg"
 
          func_append finalize_command " $arg"
 
          ;;
 
        esac
 
        continue
 
        ;;
 
 
 
      -L*)
 
        func_stripname '-L' '' "$arg"
 
        dir=$func_stripname_result
 
        if test -z "$dir"; then
 
          if test "$#" -gt 0; then
 
            func_fatal_error "require no space between \`-L' and \`$1'"
            else
            else
              compile_deplibs="$deplib $compile_deplibs"
            func_fatal_error "need path for \`-L' option"
              finalize_deplibs="$deplib $finalize_deplibs"
 
            fi
            fi
            func_stripname '-L' '' "$deplib"
        fi
            newlib_search_path="$newlib_search_path $func_stripname_result"
        # We need an absolute path.
 
        case $dir in
 
        [\\/]* | [A-Za-z]:[\\/]*) ;;
 
        *)
 
          absdir=`cd "$dir" && pwd`
 
          test -z "$absdir" && \
 
            func_fatal_error "cannot determine absolute directory name of \`$dir'"
 
          dir="$absdir"
            ;;
            ;;
 
        esac
 
        case "$deplibs " in
 
        *" -L$dir "*) ;;
          *)
          *)
            func_warning "\`-L' is ignored for archives/objects"
          deplibs="$deplibs -L$dir"
 
          lib_search_path="$lib_search_path $dir"
 
          ;;
 
        esac
 
        case $host in
 
        *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
 
          testbindir=`$ECHO "X$dir" | $Xsed -e 's*/lib$*/bin*'`
 
          case :$dllsearchpath: in
 
          *":$dir:"*) ;;
 
          ::) dllsearchpath=$dir;;
 
          *) dllsearchpath="$dllsearchpath:$dir";;
 
          esac
 
          case :$dllsearchpath: in
 
          *":$testbindir:"*) ;;
 
          ::) dllsearchpath=$testbindir;;
 
          *) dllsearchpath="$dllsearchpath:$testbindir";;
 
          esac
            ;;
            ;;
          esac # linkmode
 
          continue
 
          ;; # -L
 
        -R*)
 
          if test "$pass" = link; then
 
            func_stripname '-R' '' "$deplib"
 
            dir=$func_stripname_result
 
            # Make sure the xrpath contains only unique directories.
 
            case "$xrpath " in
 
            *" $dir "*) ;;
 
            *) xrpath="$xrpath $dir" ;;
 
            esac
            esac
          fi
 
          deplibs="$deplib $deplibs"
 
          continue
          continue
          ;;
          ;;
        *.la) lib="$deplib" ;;
 
        *.$libext)
      -l*)
          if test "$pass" = conv; then
        if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
            deplibs="$deplib $deplibs"
          case $host in
 
          *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc*)
 
            # These systems don't actually have a C or math library (as such)
            continue
            continue
          fi
 
          case $linkmode in
 
          lib)
 
            # Linking convenience modules into shared libraries is allowed,
 
            # but linking other static libraries is non-portable.
 
            case " $dlpreconveniencelibs " in
 
            *" $deplib "*) ;;
 
            *)
 
              valid_a_lib=no
 
              case $deplibs_check_method in
 
                match_pattern*)
 
                  set dummy $deplibs_check_method; shift
 
                  match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
 
                  if eval "\$ECHO \"X$deplib\"" 2>/dev/null | $Xsed -e 10q \
 
                    | $EGREP "$match_pattern_regex" > /dev/null; then
 
                    valid_a_lib=yes
 
                  fi
 
                ;;
                ;;
                pass_all)
          *-*-os2*)
                  valid_a_lib=yes
            # These systems don't actually have a C library (as such)
 
            test "X$arg" = "X-lc" && continue
                ;;
                ;;
              esac
          *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
              if test "$valid_a_lib" != yes; then
            # Do not include libc due to us having libc/libc_r.
                $ECHO
            test "X$arg" = "X-lc" && continue
                $ECHO "*** Warning: Trying to link with static lib archive $deplib."
            ;;
                $ECHO "*** I have the capability to make that library automatically link in when"
          *-*-rhapsody* | *-*-darwin1.[012])
                $ECHO "*** you link to this library.  But I can only do this if you have a"
            # Rhapsody C and math libraries are in the System framework
                $ECHO "*** shared version of the library, which you do not appear to have"
            deplibs="$deplibs System.ltframework"
                $ECHO "*** because the file extensions .$libext of this argument makes me believe"
            continue
                $ECHO "*** that it is just a static archive that I should not use here."
            ;;
              else
          *-*-sco3.2v5* | *-*-sco5v6*)
                $ECHO
            # Causes problems with __ctype
                $ECHO "*** Warning: Linking the shared library $output against the"
            test "X$arg" = "X-lc" && continue
                $ECHO "*** static library $deplib is not portable!"
            ;;
                deplibs="$deplib $deplibs"
          *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
              fi
            # Compiler inserts libc in the correct place for threads to work
 
            test "X$arg" = "X-lc" && continue
              ;;
              ;;
            esac
            esac
 
        elif test "X$arg" = "X-lc_r"; then
 
         case $host in
 
         *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
 
           # Do not include libc_r directly, use -pthread flag.
            continue
            continue
            ;;
            ;;
          prog)
         esac
            if test "$pass" != link; then
 
              deplibs="$deplib $deplibs"
 
            else
 
              compile_deplibs="$deplib $compile_deplibs"
 
              finalize_deplibs="$deplib $finalize_deplibs"
 
            fi
            fi
 
        deplibs="$deplibs $arg"
            continue
            continue
            ;;
            ;;
          esac # linkmode
 
          ;; # *.$libext
      -module)
        *.lo | *.$objext)
        module=yes
          if test "$pass" = conv; 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"
 
              compile_deplibs="$deplib $compile_deplibs"
 
              finalize_deplibs="$deplib $finalize_deplibs"
 
            else
 
              newdlfiles="$newdlfiles $deplib"
 
            fi
 
          fi
 
          continue
          continue
          ;;
          ;;
        %DEPLIBS%)
 
          alldeplibs=yes
      # Tru64 UNIX uses -model [arg] to determine the layout of C++
 
      # classes, name mangling, and exception handling.
 
      # Darwin uses the -arch flag to determine output architecture.
 
      -model|-arch|-isysroot)
 
        compiler_flags="$compiler_flags $arg"
 
        func_append compile_command " $arg"
 
        func_append finalize_command " $arg"
 
        prev=xcompiler
          continue
          continue
          ;;
          ;;
        esac # case $deplib
 
 
 
        if test "$found" = yes || test -f "$lib"; then :
 
        else
 
          func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'"
 
        fi
 
 
 
        # Check to see that this really is a libtool archive.
 
        func_lalib_unsafe_p "$lib" \
 
          || func_fatal_error "\`$lib' is not a valid libtool archive"
 
 
 
        func_dirname "$lib" "" "."
 
        ladir="$func_dirname_result"
 
 
 
        dlname=
 
        dlopen=
 
        dlpreopen=
 
        libdir=
 
        library_names=
 
        old_library=
 
        inherited_linker_flags=
 
        # If the library was installed with an old release of libtool,
 
        # it will not redefine variables installed, or shouldnotlink
 
        installed=yes
 
        shouldnotlink=no
 
        avoidtemprpath=
 
 
 
 
 
        # Read the .la file
 
        func_source "$lib"
 
 
 
        # Convert "-framework foo" to "foo.ltframework"
      -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
        if test -n "$inherited_linker_flags"; then
        compiler_flags="$compiler_flags $arg"
          tmp_inherited_linker_flags=`$ECHO "X$inherited_linker_flags" | $Xsed -e 's/-framework \([^ $]*\)/\1.ltframework/g'`
        func_append compile_command " $arg"
          for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
        func_append finalize_command " $arg"
            case " $new_inherited_linker_flags " in
            case " $new_inherited_linker_flags " in
              *" $tmp_inherited_linker_flag "*) ;;
            *" $arg "*) ;;
              *) new_inherited_linker_flags="$new_inherited_linker_flags $tmp_inherited_linker_flag";;
            * ) new_inherited_linker_flags="$new_inherited_linker_flags $arg" ;;
            esac
 
          done
 
        fi
 
        dependency_libs=`$ECHO "X $dependency_libs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
 
        if test "$linkmode,$pass" = "prog,link"; then
 
          compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
 
          finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
 
        else
 
          compiler_flags="$compiler_flags $inherited_linker_flags"
 
        fi
 
        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"
 
        fi
 
 
 
        if test "$pass" = conv; then
 
          # Only check for convenience libraries
 
          deplibs="$lib $deplibs"
 
          if test -z "$libdir"; then
 
            if test -z "$old_library"; then
 
              func_fatal_error "cannot find name of link library for \`$lib'"
 
            fi
 
            # 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"
 
          elif test "$linkmode" != prog && test "$linkmode" != lib; then
 
            func_fatal_error "\`$lib' is not a convenience library"
 
          fi
 
          tmp_libs=
 
          for deplib in $dependency_libs; do
 
            deplibs="$deplib $deplibs"
 
            if $opt_duplicate_deps ; then
 
              case "$tmp_libs " in
 
              *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
 
              esac
              esac
            fi
 
            tmp_libs="$tmp_libs $deplib"
 
          done
 
          continue
          continue
        fi # $pass = conv
        ;;
 
 
 
 
        # Get the name of the library we link against.
      -multi_module)
        linklib=
        single_module="${wl}-multi_module"
        for l in $old_library $library_names; do
        continue
          linklib="$l"
        ;;
        done
 
        if test -z "$linklib"; then
 
          func_fatal_error "cannot find name of link library for \`$lib'"
 
        fi
 
 
 
        # This library was specified with -dlopen.
      -no-fast-install)
        if test "$pass" = dlopen; then
        fast_install=no
          if test -z "$libdir"; then
 
            func_fatal_error "cannot -dlopen a convenience library: \`$lib'"
 
          fi
 
          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, we need to preload.  We also need to preload any
 
            # 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"
 
          fi
 
          continue
          continue
        fi # $pass = dlopen
        ;;
 
 
        # We need an absolute path.
      -no-install)
        case $ladir in
        case $host in
        [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
        *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*)
        *)
          # The PATH hackery in wrapper scripts is required on Windows
          abs_ladir=`cd "$ladir" && pwd`
          # and Darwin in order for the loader to find any dlls it needs.
          if test -z "$abs_ladir"; then
          func_warning "\`-no-install' is ignored for $host"
            func_warning "cannot determine absolute directory name of \`$ladir'"
          func_warning "assuming \`-no-fast-install' instead"
            func_warning "passing it literally to the linker, although it might fail"
          fast_install=no
            abs_ladir="$ladir"
 
          fi
 
          ;;
          ;;
 
        *) no_install=yes ;;
        esac
        esac
        func_basename "$lib"
        continue
        laname="$func_basename_result"
        ;;
 
 
        # Find the relevant object directory and library name.
      -no-undefined)
        if test "X$installed" = Xyes; then
        allow_undefined=no
          if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
        continue
            func_warning "library \`$lib' was moved."
        ;;
            dir="$ladir"
 
            absdir="$abs_ladir"
 
            libdir="$abs_ladir"
 
          else
 
            dir="$libdir"
 
            absdir="$libdir"
 
          fi
 
          test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
 
        else
 
          if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
 
            dir="$ladir"
 
            absdir="$abs_ladir"
 
            # Remove this search path later
 
            notinst_path="$notinst_path $abs_ladir"
 
          else
 
            dir="$ladir/$objdir"
 
            absdir="$abs_ladir/$objdir"
 
            # Remove this search path later
 
            notinst_path="$notinst_path $abs_ladir"
 
          fi
 
        fi # $installed = yes
 
        func_stripname 'lib' '.la' "$laname"
 
        name=$func_stripname_result
 
 
 
        # This library was specified with -dlpreopen.
      -objectlist)
        if test "$pass" = dlpreopen; then
        prev=objectlist
          if test -z "$libdir" && test "$linkmode" = prog; then
        continue
            func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"
        ;;
          fi
 
          # 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"
 
            # Keep a list of preopened convenience libraries to check
 
            # that they are being used correctly in the link pass.
 
            test -z "$libdir" && \
 
                dlpreconveniencelibs="$dlpreconveniencelibs $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
 
        fi # $pass = dlpreopen
 
 
 
        if test -z "$libdir"; then
      -o) prev=output ;;
          # Link the convenience library
 
          if test "$linkmode" = lib; then
      -precious-files-regex)
            deplibs="$dir/$old_library $deplibs"
        prev=precious_regex
          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
 
          fi
 
          continue
          continue
        fi
        ;;
 
 
 
      -release)
 
        prev=release
 
        continue
 
        ;;
 
 
        if test "$linkmode" = prog && test "$pass" != link; then
      -rpath)
          newlib_search_path="$newlib_search_path $ladir"
        prev=rpath
          deplibs="$lib $deplibs"
        continue
 
        ;;
 
 
          linkalldeplibs=no
      -R)
          if test "$link_all_deplibs" != no || test -z "$library_names" ||
        prev=xrpath
             test "$build_libtool_libs" = no; then
        continue
            linkalldeplibs=yes
        ;;
          fi
 
 
 
          tmp_libs=
      -R*)
          for deplib in $dependency_libs; do
        func_stripname '-R' '' "$arg"
            case $deplib in
        dir=$func_stripname_result
            -L*) func_stripname '-L' '' "$deplib"
        # We need an absolute path.
                 newlib_search_path="$newlib_search_path $func_stripname_result"
        case $dir in
 
        [\\/]* | [A-Za-z]:[\\/]*) ;;
 
        *)
 
          func_fatal_error "only absolute run-paths are allowed"
                 ;;
                 ;;
            esac
            esac
            # Need to link against all dependency_libs?
        case "$xrpath " in
            if test "$linkalldeplibs" = yes; then
        *" $dir "*) ;;
              deplibs="$deplib $deplibs"
        *) xrpath="$xrpath $dir" ;;
            else
 
              # Need to hardcode shared library paths
 
              # or/and link against static libraries
 
              newdependency_libs="$deplib $newdependency_libs"
 
            fi
 
            if $opt_duplicate_deps ; then
 
              case "$tmp_libs " in
 
              *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
 
              esac
              esac
            fi
 
            tmp_libs="$tmp_libs $deplib"
 
          done # for deplib
 
          continue
          continue
        fi # $linkmode = prog...
        ;;
 
 
        if test "$linkmode,$pass" = "prog,link"; then
      -shared)
          if test -n "$library_names" &&
        # The effects of -shared are defined in a previous loop.
             { { test "$prefer_static_libs" = no ||
        continue
                 test "$prefer_static_libs,$installed" = "built,yes"; } ||
        ;;
               test -z "$old_library"; }; then
 
            # We need to hardcode the library path
 
            if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
 
              # Make sure the rpath contains only unique directories.
 
              case "$temp_rpath:" in
 
              *"$absdir:"*) ;;
 
              *) temp_rpath="$temp_rpath$absdir:" ;;
 
              esac
 
            fi
 
 
 
            # Hardcode the library path.
      -shrext)
            # Skip directories that are in the system default run-time
        prev=shrext
            # search path.
        continue
            case " $sys_lib_dlsearch_path " in
 
            *" $absdir "*) ;;
 
            *)
 
              case "$compile_rpath " in
 
              *" $absdir "*) ;;
 
              *) compile_rpath="$compile_rpath $absdir"
 
              esac
 
              ;;
              ;;
            esac
 
            case " $sys_lib_dlsearch_path " in
      -static | -static-libtool-libs)
            *" $libdir "*) ;;
        # The effects of -static are defined in a previous loop.
            *)
        # We used to do the same as -all-static on platforms that
              case "$finalize_rpath " in
        # didn't have a PIC flag, but the assumption that the effects
              *" $libdir "*) ;;
        # would be equivalent was wrong.  It would break on at least
              *) finalize_rpath="$finalize_rpath $libdir"
        # Digital Unix and AIX.
              esac
        continue
              ;;
              ;;
            esac
 
          fi # $linkmode,$pass = prog,link...
 
 
 
          if test "$alldeplibs" = yes &&
      -thread-safe)
             { test "$deplibs_check_method" = pass_all ||
        thread_safe=yes
               { test "$build_libtool_libs" = yes &&
 
                 test -n "$library_names"; }; }; then
 
            # We only need to search for static libraries
 
            continue
            continue
          fi
        ;;
        fi
 
 
 
        link_static=no # Whether the deplib will be linked statically
      -version-info)
        use_static_libs=$prefer_static_libs
        prev=vinfo
        if test "$use_static_libs" = built && test "$installed" = yes; then
        continue
          use_static_libs=no
 
        fi
 
        if test -n "$library_names" &&
 
           { test "$use_static_libs" = no || test -z "$old_library"; }; then
 
          case $host in
 
          *cygwin* | *mingw*)
 
              # No point in relinking DLLs because paths are not encoded
 
              notinst_deplibs="$notinst_deplibs $lib"
 
              need_relink=no
 
            ;;
            ;;
          *)
 
            if test "$installed" = no; then
      -version-number)
              notinst_deplibs="$notinst_deplibs $lib"
        prev=vinfo
              need_relink=yes
        vinfo_number=yes
            fi
        continue
            ;;
            ;;
          esac
 
          # This is a shared library
 
 
 
          # Warn about portability, can't link against -module's on some
      -weak)
          # systems (darwin).  Don't bleat about dlopened modules though!
        prev=weak
          dlopenmodule=""
        continue
          for dlpremoduletest in $dlprefiles; do
        ;;
            if test "X$dlpremoduletest" = "X$lib"; then
 
              dlopenmodule="$dlpremoduletest"
      -Wc,*)
              break
        func_stripname '-Wc,' '' "$arg"
            fi
        args=$func_stripname_result
 
        arg=
 
        save_ifs="$IFS"; IFS=','
 
        for flag in $args; do
 
          IFS="$save_ifs"
 
          func_quote_for_eval "$flag"
 
          arg="$arg $wl$func_quote_for_eval_result"
 
          compiler_flags="$compiler_flags $func_quote_for_eval_result"
          done
          done
          if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then
        IFS="$save_ifs"
            $ECHO
        func_stripname ' ' '' "$arg"
            if test "$linkmode" = prog; then
        arg=$func_stripname_result
              $ECHO "*** Warning: Linking the executable $output against the loadable module"
 
            else
 
              $ECHO "*** Warning: Linking the shared library $output against the loadable module"
 
            fi
 
            $ECHO "*** $linklib is not portable!"
 
          fi
 
          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.
 
            case " $sys_lib_dlsearch_path " in
 
            *" $absdir "*) ;;
 
            *)
 
              case "$compile_rpath " in
 
              *" $absdir "*) ;;
 
              *) compile_rpath="$compile_rpath $absdir"
 
              esac
 
              ;;
              ;;
            esac
 
            case " $sys_lib_dlsearch_path " in
      -Wl,*)
            *" $libdir "*) ;;
        func_stripname '-Wl,' '' "$arg"
            *)
        args=$func_stripname_result
              case "$finalize_rpath " in
        arg=
              *" $libdir "*) ;;
        save_ifs="$IFS"; IFS=','
              *) finalize_rpath="$finalize_rpath $libdir"
        for flag in $args; do
              esac
          IFS="$save_ifs"
 
          func_quote_for_eval "$flag"
 
          arg="$arg $wl$func_quote_for_eval_result"
 
          compiler_flags="$compiler_flags $wl$func_quote_for_eval_result"
 
          linker_flags="$linker_flags $func_quote_for_eval_result"
 
        done
 
        IFS="$save_ifs"
 
        func_stripname ' ' '' "$arg"
 
        arg=$func_stripname_result
 
        ;;
 
 
 
      -Xcompiler)
 
        prev=xcompiler
 
        continue
 
        ;;
 
 
 
      -Xlinker)
 
        prev=xlinker
 
        continue
 
        ;;
 
 
 
      -XCClinker)
 
        prev=xcclinker
 
        continue
 
        ;;
 
 
 
      # -msg_* for osf cc
 
      -msg_*)
 
        func_quote_for_eval "$arg"
 
        arg="$func_quote_for_eval_result"
 
        ;;
 
 
 
      # -64, -mips[0-9] enable 64-bit mode on the SGI compiler
 
      # -r[0-9][0-9]* specifies the processor on the SGI compiler
 
      # -xarch=*, -xtarget=* enable 64-bit mode on the Sun compiler
 
      # +DA*, +DD* enable 64-bit mode on the HP compiler
 
      # -q* pass through compiler args for the IBM compiler
 
      # -m*, -t[45]*, -txscale* pass through architecture-specific
 
      # compiler args for GCC
 
      # -F/path gives path to uninstalled frameworks, gcc on darwin
 
      # -p, -pg, --coverage, -fprofile-* pass through profiling flag for GCC
 
      # @file GCC response files
 
      -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
 
      -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*)
 
        func_quote_for_eval "$arg"
 
        arg="$func_quote_for_eval_result"
 
        func_append compile_command " $arg"
 
        func_append finalize_command " $arg"
 
        compiler_flags="$compiler_flags $arg"
 
        continue
 
        ;;
 
 
 
      # Some other compiler flag.
 
      -* | +*)
 
        func_quote_for_eval "$arg"
 
        arg="$func_quote_for_eval_result"
 
        ;;
 
 
 
      *.$objext)
 
        # A standard object.
 
        objs="$objs $arg"
              ;;
              ;;
            esac
 
          fi
 
 
 
          if test -n "$old_archive_from_expsyms_cmds"; then
      *.lo)
            # figure out the soname
        # A libtool-controlled object.
            set dummy $library_names
 
            shift
 
            realname="$1"
 
            shift
 
            libname=`eval "\\$ECHO \"$libname_spec\""`
 
            # 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* | mingw*)
 
                major=`expr $current - $age`
 
                versuffix="-$major"
 
                ;;
 
              esac
 
              eval soname=\"$soname_spec\"
 
            else
 
              soname="$realname"
 
            fi
 
 
 
            # Make a new name for the extract_expsyms_cmds to use
        # Check to see that this really is a libtool object.
            soroot="$soname"
        if func_lalib_unsafe_p "$arg"; then
            func_basename "$soroot"
          pic_object=
            soname="$func_basename_result"
          non_pic_object=
            func_stripname 'lib' '.dll' "$soname"
 
            newlib=libimp-$func_stripname_result.a
 
 
 
            # If the library has no export list, then create one now
          # Read the .lo file
            if test -f "$output_objdir/$soname-def"; then :
          func_source "$arg"
            else
 
              func_echo "extracting exported symbol list from \`$soname'"
 
              func_execute_cmds "$extract_expsyms_cmds" 'exit $?'
 
            fi
 
 
 
            # Create $newlib
          if test -z "$pic_object" ||
            if test -f "$output_objdir/$newlib"; then :; else
             test -z "$non_pic_object" ||
              func_echo "generating import library for \`$soname'"
             test "$pic_object" = none &&
              func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'
             test "$non_pic_object" = none; then
 
            func_fatal_error "cannot find name of object for \`$arg'"
            fi
            fi
            # 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
          # Extract subdirectory from the argument.
            add_shlibpath=
          func_dirname "$arg" "/" ""
            add_dir=
          xdir="$func_dirname_result"
            add=
 
            lib_linked=yes
 
            case $hardcode_action in
 
            immediate | unsupported)
 
              if test "$hardcode_direct" = no; then
 
                add="$dir/$linklib"
 
                case $host in
 
                  *-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;
 
                  *-*-sysv4*uw2*) add_dir="-L$dir" ;;
 
                  *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
 
                    *-*-unixware7*) add_dir="-L$dir" ;;
 
                  *-*-darwin* )
 
                    # if the lib is a (non-dlopened) module then we can not
 
                    # link against it, someone is ignoring the earlier warnings
 
                    if /usr/bin/file -L $add 2> /dev/null |
 
                         $GREP ": [^:]* bundle" >/dev/null ; then
 
                      if test "X$dlopenmodule" != "X$lib"; then
 
                        $ECHO "*** Warning: lib $linklib is a module, not a shared library"
 
                        if test -z "$old_library" ; then
 
                          $ECHO
 
                          $ECHO "*** And there doesn't seem to be a static archive available"
 
                          $ECHO "*** The link will probably fail, sorry"
 
                        else
 
                          add="$dir/$old_library"
 
                        fi
 
                      elif test -n "$old_library"; then
 
                        add="$dir/$old_library"
 
                      fi
 
                    fi
 
                esac
 
              elif test "$hardcode_minus_L" = no; then
 
                case $host in
 
                *-*-sunos*) add_shlibpath="$dir" ;;
 
                esac
 
                add_dir="-L$dir"
 
                add="-l$name"
 
              elif test "$hardcode_shlibpath_var" = no; then
 
                add_shlibpath="$dir"
 
                add="-l$name"
 
              else
 
                lib_linked=no
 
              fi
 
              ;;
 
            relink)
 
              if test "$hardcode_direct" = yes &&
 
                 test "$hardcode_direct_absolute" = no; then
 
                add="$dir/$linklib"
 
              elif test "$hardcode_minus_L" = yes; then
 
                add_dir="-L$dir"
 
                # Try looking first in the location we're being installed to.
 
                if test -n "$inst_prefix_dir"; then
 
                  case $libdir in
 
                    [\\/]*)
 
                      add_dir="$add_dir -L$inst_prefix_dir$libdir"
 
                      ;;
 
                  esac
 
                fi
 
                add="-l$name"
 
              elif test "$hardcode_shlibpath_var" = yes; then
 
                add_shlibpath="$dir"
 
                add="-l$name"
 
              else
 
                lib_linked=no
 
              fi
 
              ;;
 
            *) lib_linked=no ;;
 
            esac
 
 
 
            if test "$lib_linked" != yes; then
          if test "$pic_object" != none; then
              func_fatal_configuration "unsupported hardcode properties"
            # Prepend the subdirectory the object is found in.
            fi
            pic_object="$xdir$pic_object"
 
 
            if test -n "$add_shlibpath"; then
            if test "$prev" = dlfiles; then
              case :$compile_shlibpath: in
              if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
              *":$add_shlibpath:"*) ;;
                dlfiles="$dlfiles $pic_object"
              *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
                prev=
              esac
                continue
            fi
 
            if test "$linkmode" = prog; then
 
              test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
 
              test -n "$add" && compile_deplibs="$add $compile_deplibs"
 
            else
            else
              test -n "$add_dir" && deplibs="$add_dir $deplibs"
                # If libtool objects are unsupported, then we need to preload.
              test -n "$add" && deplibs="$add $deplibs"
                prev=dlprefiles
              if test "$hardcode_direct" != yes &&
 
                 test "$hardcode_minus_L" != yes &&
 
                 test "$hardcode_shlibpath_var" = yes; then
 
                case :$finalize_shlibpath: in
 
                *":$libdir:"*) ;;
 
                *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
 
                esac
 
              fi
 
            fi
            fi
          fi
          fi
 
 
          if test "$linkmode" = prog || test "$mode" = relink; then
            # CHECK ME:  I think I busted this.  -Ossama
            add_shlibpath=
            if test "$prev" = dlprefiles; then
            add_dir=
              # Preload the old-style object.
            add=
              dlprefiles="$dlprefiles $pic_object"
            # Finalize command for both is simple: just hardcode it.
              prev=
            if test "$hardcode_direct" = yes &&
 
               test "$hardcode_direct_absolute" = no; then
 
              add="$libdir/$linklib"
 
            elif test "$hardcode_minus_L" = yes; then
 
              add_dir="-L$libdir"
 
              add="-l$name"
 
            elif test "$hardcode_shlibpath_var" = yes; then
 
              case :$finalize_shlibpath: in
 
              *":$libdir:"*) ;;
 
              *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
 
              esac
 
              add="-l$name"
 
            elif test "$hardcode_automatic" = yes; then
 
              if test -n "$inst_prefix_dir" &&
 
                 test -f "$inst_prefix_dir$libdir/$linklib" ; then
 
                add="$inst_prefix_dir$libdir/$linklib"
 
              else
 
                add="$libdir/$linklib"
 
              fi
 
            else
 
              # We cannot seem to hardcode it, guess we'll fake it.
 
              add_dir="-L$libdir"
 
              # Try looking first in the location we're being installed to.
 
              if test -n "$inst_prefix_dir"; then
 
                case $libdir in
 
                  [\\/]*)
 
                    add_dir="$add_dir -L$inst_prefix_dir$libdir"
 
                    ;;
 
                esac
 
              fi
 
              add="-l$name"
 
            fi
            fi
 
 
            if test "$linkmode" = prog; then
            # A PIC object.
              test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
            func_append libobjs " $pic_object"
              test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
            arg="$pic_object"
            else
 
              test -n "$add_dir" && deplibs="$add_dir $deplibs"
 
              test -n "$add" && deplibs="$add $deplibs"
 
            fi
 
          fi
 
        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.
 
          if test "$hardcode_direct" != unsupported; then
 
            test -n "$old_library" && linklib="$old_library"
 
            compile_deplibs="$dir/$linklib $compile_deplibs"
 
            finalize_deplibs="$dir/$linklib $finalize_deplibs"
 
          else
 
            compile_deplibs="-l$name -L$dir $compile_deplibs"
 
            finalize_deplibs="-l$name -L$dir $finalize_deplibs"
 
          fi
          fi
        elif test "$build_libtool_libs" = yes; then
 
          # Not a shared library
 
          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
          # Non-PIC object.
            # that the program can be linked against the static library.
          if test "$non_pic_object" != none; then
            $ECHO
            # Prepend the subdirectory the object is found in.
            $ECHO "*** Warning: This system can not link to static lib archive $lib."
            non_pic_object="$xdir$non_pic_object"
            $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"
            # A standard non-PIC object
            $ECHO "*** shared version of the library, which you do not appear to have."
            func_append non_pic_objects " $non_pic_object"
            if test "$module" = yes; then
            if test -z "$pic_object" || test "$pic_object" = none ; then
              $ECHO "*** But as you try to build a module library, libtool will still create "
              arg="$non_pic_object"
              $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."
 
              fi
 
              if test "$build_old_libs" = no; then
 
                build_libtool_libs=module
 
                build_old_libs=yes
 
              else
 
                build_libtool_libs=no
 
              fi
 
            fi
            fi
          else
          else
            deplibs="$dir/$old_library $deplibs"
            # If the PIC object exists, use it instead.
            link_static=yes
            # $xdir was prepended to $pic_object above.
 
            non_pic_object="$pic_object"
 
            func_append non_pic_objects " $non_pic_object"
          fi
          fi
        fi # link shared/static library?
        else
 
          # Only an error if not doing a dry-run.
 
          if $opt_dry_run; then
 
            # Extract subdirectory from the argument.
 
            func_dirname "$arg" "/" ""
 
            xdir="$func_dirname_result"
 
 
        if test "$linkmode" = lib; then
            func_lo2o "$arg"
          if test -n "$dependency_libs" &&
            pic_object=$xdir$objdir/$func_lo2o_result
             { test "$hardcode_into_libs" != yes ||
            non_pic_object=$xdir$func_lo2o_result
               test "$build_old_libs" = yes ||
            func_append libobjs " $pic_object"
               test "$link_static" = yes; }; then
            func_append non_pic_objects " $non_pic_object"
            # Extract -R from dependency_libs
          else
            temp_deplibs=
            func_fatal_error "\`$arg' is not a valid libtool object"
            for libdir in $dependency_libs; do
 
              case $libdir in
 
              -R*) func_stripname '-R' '' "$libdir"
 
                   temp_xrpath=$func_stripname_result
 
                   case " $xrpath " in
 
                   *" $temp_xrpath "*) ;;
 
                   *) xrpath="$xrpath $temp_xrpath";;
 
                   esac;;
 
              *) temp_deplibs="$temp_deplibs $libdir";;
 
              esac
 
            done
 
            dependency_libs="$temp_deplibs"
 
          fi
          fi
 
 
          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
 
          tmp_libs=
 
          for deplib in $dependency_libs; do
 
            newdependency_libs="$deplib $newdependency_libs"
 
            if $opt_duplicate_deps ; then
 
              case "$tmp_libs " in
 
              *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
 
              esac
 
            fi
            fi
            tmp_libs="$tmp_libs $deplib"
        ;;
          done
 
 
 
          if test "$link_all_deplibs" != no; then
      *.$libext)
            # Add the search paths of all dependency libraries
        # An archive.
            for deplib in $dependency_libs; do
        deplibs="$deplibs $arg"
              case $deplib in
        old_deplibs="$old_deplibs $arg"
              -L*) path="$deplib" ;;
        continue
              *.la)
 
                func_dirname "$deplib" "" "."
 
                dir="$func_dirname_result"
 
                # We need an absolute path.
 
                case $dir in
 
                [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
 
                *)
 
                  absdir=`cd "$dir" && pwd`
 
                  if test -z "$absdir"; then
 
                    func_warning "cannot determine absolute directory name of \`$dir'"
 
                    absdir="$dir"
 
                  fi
 
                  ;;
                  ;;
                esac
 
                if $GREP "^installed=no" $deplib > /dev/null; then
      *.la)
                case $host in
        # A libtool-controlled library.
                *-*-darwin*)
 
                  depdepl=
        if test "$prev" = dlfiles; then
                  eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
          # This library was specified with -dlopen.
                  if test -n "$deplibrary_names" ; then
          dlfiles="$dlfiles $arg"
                    for tmp in $deplibrary_names ; do
          prev=
                      depdepl=$tmp
        elif test "$prev" = dlprefiles; then
                    done
          # The library was specified with -dlpreopen.
                    if test -f "$absdir/$objdir/$depdepl" ; then
          dlprefiles="$dlprefiles $arg"
                      depdepl="$absdir/$objdir/$depdepl"
          prev=
                      darwin_install_name=`otool -L $depdepl | $SED -n -e '3q;2,2p' | $SED -e 's/(.*//'`
        else
                      darwin_install_name=`$ECHO $darwin_install_name`
          deplibs="$deplibs $arg"
                      if test -z "$darwin_install_name"; then
 
                          darwin_install_name=`otool64 -L $depdepl | $SED -n -e '3q;2,2p' | $SED -e 's/(.*//'`
 
                          darwin_install_name=`$ECHO $darwin_install_name`
 
                      fi
 
                      compiler_flags="$compiler_flags ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
 
                      linker_flags="$linker_flags -dylib_file ${darwin_install_name}:${depdepl}"
 
                      path=
 
                    fi
 
                  fi
                  fi
 
        continue
                  ;;
                  ;;
 
 
 
      # Some other compiler argument.
                *)
                *)
                  path="-L$absdir/$objdir"
        # Unknown arguments in both finalize_command and compile_command need
 
        # to be aesthetically quoted because they are evaled later.
 
        func_quote_for_eval "$arg"
 
        arg="$func_quote_for_eval_result"
                  ;;
                  ;;
                esac
      esac # arg
                else
 
                  eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
 
                  test -z "$libdir" && \
 
                    func_fatal_error "\`$deplib' is not a valid libtool archive"
 
                  test "$absdir" != "$libdir" && \
 
                    func_warning "\`$deplib' seems to be moved"
 
 
 
                  path="-L$absdir"
      # Now actually substitute the argument into the commands.
 
      if test -n "$arg"; then
 
        func_append compile_command " $arg"
 
        func_append finalize_command " $arg"
 
      fi
 
    done # argument parsing loop
 
 
 
    test -n "$prev" && \
 
      func_fatal_help "the \`$prevarg' option requires an argument"
 
 
 
    if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
 
      eval arg=\"$export_dynamic_flag_spec\"
 
      func_append compile_command " $arg"
 
      func_append finalize_command " $arg"
 
    fi
 
 
 
    oldlibs=
 
    # calculate the name of the file, without its directory
 
    func_basename "$output"
 
    outputname="$func_basename_result"
 
    libobjs_save="$libobjs"
 
 
 
    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\'\`
 
    else
 
      shlib_search_path=
                fi
                fi
 
    eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
 
    eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
 
 
 
    func_dirname "$output" "/" ""
 
    output_objdir="$func_dirname_result$objdir"
 
    # Create the object directory.
 
    func_mkdir_p "$output_objdir"
 
 
 
    # Determine the type of output
 
    case $output in
 
    "")
 
      func_fatal_help "you must specify an output file"
                ;;
                ;;
 
    *.$libext) linkmode=oldlib ;;
 
    *.lo | *.$objext) linkmode=obj ;;
 
    *.la) linkmode=lib ;;
 
    *) linkmode=prog ;; # Anything else should be a program.
              esac
              esac
              case " $deplibs " in
 
              *" $path "*) ;;
    specialdeplibs=
              *) deplibs="$path $deplibs" ;;
 
 
    libs=
 
    # Find all interdependent deplibs by searching for libraries
 
    # that are linked more than once (e.g. -la -lb -la)
 
    for deplib in $deplibs; do
 
      if $opt_duplicate_deps ; then
 
        case "$libs " in
 
        *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
              esac
              esac
            done
 
          fi # link_all_deplibs != no
 
        fi # linkmode = lib
 
      done # for deplib in $libs
 
      dependency_libs="$newdependency_libs"
 
      if test "$pass" = dlpreopen; then
 
        # Link the dlpreopened libraries before other libraries
 
        for deplib in $save_deplibs; do
 
          deplibs="$deplib $deplibs"
 
        done
 
      fi
      fi
      if test "$pass" != dlopen; then
      libs="$libs $deplib"
        if test "$pass" != conv; then
    done
          # Make sure lib_search_path contains only unique directories.
 
          lib_search_path=
    if test "$linkmode" = lib; then
          for dir in $newlib_search_path; do
      libs="$predeps $libs $compiler_lib_search_path $postdeps"
            case "$lib_search_path " in
 
            *" $dir "*) ;;
      # Compute libraries that are listed more than once in $predeps
            *) lib_search_path="$lib_search_path $dir" ;;
      # $postdeps and mark them as special (i.e., whose duplicates are
 
      # not to be eliminated).
 
      pre_post_deps=
 
      if $opt_duplicate_compiler_generated_deps; then
 
        for pre_post_dep in $predeps $postdeps; do
 
          case "$pre_post_deps " in
 
          *" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
            esac
            esac
 
          pre_post_deps="$pre_post_deps $pre_post_dep"
          done
          done
          newlib_search_path=
 
        fi
        fi
 
      pre_post_deps=
        if test "$linkmode,$pass" != "prog,link"; then
 
          vars="deplibs"
 
        else
 
          vars="compile_deplibs finalize_deplibs"
 
        fi
        fi
        for var in $vars dependency_libs; do
 
          # Add libraries to $var in reverse order
    deplibs=
          eval tmp_libs=\"\$$var\"
    newdependency_libs=
          new_libs=
    newlib_search_path=
          for deplib in $tmp_libs; do
    need_relink=no # whether we're linking any uninstalled libtool libraries
            # FIXME: Pedantically, this is the right thing to do, so
    notinst_deplibs= # not-installed libtool libraries
            #        that some nasty dependency loop isn't accidentally
    notinst_path= # paths that contain not-installed libtool libraries
            #        broken:
 
            #new_libs="$deplib $new_libs"
    case $linkmode in
            # Pragmatically, this seems to cause very few problems in
    lib)
            # practice:
        passes="conv dlpreopen link"
            case $deplib in
        for file in $dlfiles $dlprefiles; do
            -L*) new_libs="$deplib $new_libs" ;;
          case $file in
            -R*) ;;
          *.la) ;;
            *)
 
              # 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" ;;
 
              *)
              *)
                case " $new_libs " in
            func_fatal_help "libraries can \`-dlopen' only libtool libraries: $file"
                *" $deplib "*) ;;
 
                *) new_libs="$deplib $new_libs" ;;
 
                esac
 
                ;;
 
              esac
 
              ;;
              ;;
            esac
            esac
          done
          done
          tmp_libs=
 
          for deplib in $new_libs; do
 
            case $deplib in
 
            -L*)
 
              case " $tmp_libs " in
 
              *" $deplib "*) ;;
 
              *) tmp_libs="$tmp_libs $deplib" ;;
 
              esac
 
              ;;
              ;;
            *) tmp_libs="$tmp_libs $deplib" ;;
    prog)
 
        compile_deplibs=
 
        finalize_deplibs=
 
        alldeplibs=no
 
        newdlfiles=
 
        newdlprefiles=
 
        passes="conv scan dlopen dlpreopen link"
 
        ;;
 
    *)  passes="conv"
 
        ;;
            esac
            esac
 
 
 
    for pass in $passes; do
 
      # The preopen pass in lib mode reverses $deplibs; put it back here
 
      # so that -L comes before libs that need it for instance...
 
      if test "$linkmode,$pass" = "lib,link"; then
 
        ## FIXME: Find the place where the list is rebuilt in the wrong
 
        ##        order, and fix it there properly
 
        tmp_deplibs=
 
        for deplib in $deplibs; do
 
          tmp_deplibs="$deplib $tmp_deplibs"
          done
          done
          eval $var=\"$tmp_libs\"
        deplibs="$tmp_deplibs"
        done # for var
 
      fi
      fi
      # Last step: remove runtime libs from dependency_libs
 
      # (they stay in deplibs)
      if test "$linkmode,$pass" = "lib,link" ||
      tmp_libs=
         test "$linkmode,$pass" = "prog,scan"; then
      for i in $dependency_libs ; do
        libs="$deplibs"
        case " $predeps $postdeps $compiler_lib_search_path " in
        deplibs=
        *" $i "*)
      fi
          i=""
      if test "$linkmode" = prog; then
          ;;
        case $pass in
 
        dlopen) libs="$dlfiles" ;;
 
        dlpreopen) libs="$dlprefiles" ;;
 
        link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
        esac
        esac
        if test -n "$i" ; then
 
          tmp_libs="$tmp_libs $i"
 
        fi
        fi
 
      if test "$linkmode,$pass" = "lib,dlpreopen"; then
 
        # Collect and forward deplibs of preopened libtool libs
 
        for lib in $dlprefiles; do
 
          # Ignore non-libtool-libs
 
          dependency_libs=
 
          case $lib in
 
          *.la) func_source "$lib" ;;
 
          esac
 
 
 
          # Collect preopened libtool deplibs, except any this library
 
          # has declared as weak libs
 
          for deplib in $dependency_libs; do
 
            deplib_base=`$ECHO "X$deplib" | $Xsed -e "$basename"`
 
            case " $weak_libs " in
 
            *" $deplib_base "*) ;;
 
            *) deplibs="$deplibs $deplib" ;;
 
            esac
      done
      done
      dependency_libs=$tmp_libs
        done
    done # for pass
        libs="$dlprefiles"
    if test "$linkmode" = prog; then
 
      dlfiles="$newdlfiles"
 
    fi
    fi
    if test "$linkmode" = prog || test "$linkmode" = lib; then
      if test "$pass" = dlopen; then
      dlprefiles="$newdlprefiles"
        # Collect dlpreopened libraries
 
        save_deplibs="$deplibs"
 
        deplibs=
    fi
    fi
 
 
    case $linkmode in
      for deplib in $libs; do
    oldlib)
        lib=
      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
        found=no
        func_warning "\`-dlopen' is ignored for archives"
        case $deplib in
 
        -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
 
          if test "$linkmode,$pass" = "prog,link"; then
 
            compile_deplibs="$deplib $compile_deplibs"
 
            finalize_deplibs="$deplib $finalize_deplibs"
 
          else
 
            compiler_flags="$compiler_flags $deplib"
 
            if test "$linkmode" = lib ; then
 
                case "$new_inherited_linker_flags " in
 
                    *" $deplib "*) ;;
 
                    * ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
 
                esac
      fi
      fi
 
          fi
      test -n "$deplibs" && \
          continue
        func_warning "\`-l' and \`-L' are ignored for archives"
 
 
 
 
 
      test -n "$rpath" && \
 
        func_warning "\`-rpath' is ignored for archives"
 
 
 
      test -n "$xrpath" && \
 
        func_warning "\`-R' is ignored for archives"
 
 
 
      test -n "$vinfo" && \
 
        func_warning "\`-version-info/-version-number' is ignored for archives"
 
 
 
      test -n "$release" && \
 
        func_warning "\`-release' is ignored for archives"
 
 
 
      test -n "$export_symbols$export_symbols_regex" && \
 
        func_warning "\`-export-symbols' is ignored for archives"
 
 
 
      # Now set the variables for building old libraries.
 
      build_libtool_libs=no
 
      oldlibs="$output"
 
      objs="$objs$old_deplibs"
 
      ;;
 
 
 
    lib)
 
      # Make sure we only generate libraries of the form `libNAME.la'.
 
      case $outputname in
 
      lib*)
 
        func_stripname 'lib' '.la' "$outputname"
 
        name=$func_stripname_result
 
        eval shared_ext=\"$shrext_cmds\"
 
        eval libname=\"$libname_spec\"
 
        ;;
        ;;
      *)
        -l*)
        test "$module" = no && \
          if test "$linkmode" != lib && test "$linkmode" != prog; then
          func_fatal_help "libtool library \`$output' must begin with \`lib'"
            func_warning "\`-l' is ignored for archives/objects"
 
            continue
        if test "$need_lib_prefix" != no; then
          fi
          # Add the "lib" prefix for modules if required
          func_stripname '-l' '' "$deplib"
          func_stripname '' '.la' "$outputname"
 
          name=$func_stripname_result
          name=$func_stripname_result
          eval shared_ext=\"$shrext_cmds\"
          if test "$linkmode" = lib; then
          eval libname=\"$libname_spec\"
            searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
        else
        else
          func_stripname '' '.la' "$outputname"
            searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"
          libname=$func_stripname_result
 
        fi
        fi
        ;;
          for searchdir in $searchdirs; do
      esac
            for search_ext in .la $std_shrext .so .a; do
 
              # Search the libtool library
      if test -n "$objs"; then
              lib="$searchdir/lib${name}${search_ext}"
        if test "$deplibs_check_method" != pass_all; then
              if test -f "$lib"; then
          func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"
                if test "$search_ext" = ".la"; then
 
                  found=yes
        else
        else
          $ECHO
                  found=no
          $ECHO "*** Warning: Linking the shared library $output against the non-libtool"
 
          $ECHO "*** objects $objs is not portable!"
 
          libobjs="$libobjs $objs"
 
        fi
        fi
 
                break 2
 
              fi
 
            done
 
          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"
 
            fi
 
            continue
 
          else # deplib is a libtool library
 
            # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
 
            # We need to do some special things here, and not later.
 
            if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
 
              case " $predeps $postdeps " in
 
              *" $deplib "*)
 
                if func_lalib_p "$lib"; then
 
                  library_names=
 
                  old_library=
 
                  func_source "$lib"
 
                  for l in $old_library $library_names; do
 
                    ll="$l"
 
                  done
 
                  if test "X$ll" = "X$old_library" ; then # only static version available
 
                    found=no
 
                    func_dirname "$lib" "" "."
 
                    ladir="$func_dirname_result"
 
                    lib=$ladir/$old_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"
 
                    fi
 
                    continue
 
                  fi
 
                fi
 
                ;;
 
              *) ;;
 
              esac
      fi
      fi
 
 
      test "$dlself" != no && \
 
        func_warning "\`-dlopen self' is ignored for libtool libraries"
 
 
 
      set dummy $rpath
 
      shift
 
      test "$#" -gt 1 && \
 
        func_warning "ignoring multiple \`-rpath's for a libtool library"
 
 
 
      install_libdir="$1"
 
 
 
      oldlibs=
 
      if test -z "$rpath"; then
 
        if test "$build_libtool_libs" = yes; then
 
          # Building a libtool convenience library.
 
          # 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
 
        fi
        fi
 
          ;; # -l
        test -n "$vinfo" && \
        *.ltframework)
          func_warning "\`-version-info/-version-number' is ignored for convenience libraries"
          if test "$linkmode,$pass" = "prog,link"; then
 
            compile_deplibs="$deplib $compile_deplibs"
        test -n "$release" && \
            finalize_deplibs="$deplib $finalize_deplibs"
          func_warning "\`-release' is ignored for convenience libraries"
 
      else
      else
 
            deplibs="$deplib $deplibs"
        # Parse the version information argument.
            if test "$linkmode" = lib ; then
        save_ifs="$IFS"; IFS=':'
                case "$new_inherited_linker_flags " in
        set dummy $vinfo 0 0 0
                    *" $deplib "*) ;;
        shift
                    * ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
        IFS="$save_ifs"
 
 
 
        test -n "$7" && \
 
          func_fatal_help "too many parameters to \`-version-info'"
 
 
 
        # convert absolute version numbers to libtool ages
 
        # this retains compatibility with .la files and attempts
 
        # to make the code below a bit more comprehensible
 
 
 
        case $vinfo_number in
 
        yes)
 
          number_major="$1"
 
          number_minor="$2"
 
          number_revision="$3"
 
          #
 
          # There are really only two kinds -- those that
 
          # use the current revision as the major version
 
          # and those that subtract age and use age as
 
          # a minor version.  But, then there is irix
 
          # which has an extra 1 added just for fun
 
          #
 
          case $version_type in
 
          darwin|linux|osf|windows|none)
 
            current=`expr $number_major + $number_minor`
 
            age="$number_minor"
 
            revision="$number_revision"
 
            ;;
 
          freebsd-aout|freebsd-elf|sunos)
 
            current="$number_major"
 
            revision="$number_minor"
 
            age="0"
 
            ;;
 
          irix|nonstopux)
 
            current=`expr $number_major + $number_minor - 1`
 
            age="$number_minor"
 
            revision="$number_minor"
 
            ;;
 
          esac
          esac
 
            fi
 
          fi
 
          continue
          ;;
          ;;
        no)
        -L*)
          current="$1"
          case $linkmode in
          revision="$2"
          lib)
          age="$3"
            deplibs="$deplib $deplibs"
 
            test "$pass" = conv && continue
 
            newdependency_libs="$deplib $newdependency_libs"
 
            func_stripname '-L' '' "$deplib"
 
            newlib_search_path="$newlib_search_path $func_stripname_result"
 
            ;;
 
          prog)
 
            if test "$pass" = conv; then
 
              deplibs="$deplib $deplibs"
 
              continue
 
            fi
 
            if test "$pass" = scan; then
 
              deplibs="$deplib $deplibs"
 
            else
 
              compile_deplibs="$deplib $compile_deplibs"
 
              finalize_deplibs="$deplib $finalize_deplibs"
 
            fi
 
            func_stripname '-L' '' "$deplib"
 
            newlib_search_path="$newlib_search_path $func_stripname_result"
          ;;
          ;;
        esac
 
 
 
        # Check that each of the things are valid numbers.
 
        case $current in
 
        0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
 
        *)
        *)
          func_error "CURRENT \`$current' must be a nonnegative integer"
            func_warning "\`-L' is ignored for archives/objects"
          func_fatal_error "\`$vinfo' is not valid version information"
 
          ;;
          ;;
 
          esac # linkmode
 
          continue
 
          ;; # -L
 
        -R*)
 
          if test "$pass" = link; then
 
            func_stripname '-R' '' "$deplib"
 
            dir=$func_stripname_result
 
            # Make sure the xrpath contains only unique directories.
 
            case "$xrpath " in
 
            *" $dir "*) ;;
 
            *) xrpath="$xrpath $dir" ;;
        esac
        esac
 
          fi
        case $revision in
          deplibs="$deplib $deplibs"
        0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
          continue
 
          ;;
 
        *.la) lib="$deplib" ;;
 
        *.$libext)
 
          if test "$pass" = conv; then
 
            deplibs="$deplib $deplibs"
 
            continue
 
          fi
 
          case $linkmode in
 
          lib)
 
            # Linking convenience modules into shared libraries is allowed,
 
            # but linking other static libraries is non-portable.
 
            case " $dlpreconveniencelibs " in
 
            *" $deplib "*) ;;
        *)
        *)
          func_error "REVISION \`$revision' must be a nonnegative integer"
              valid_a_lib=no
          func_fatal_error "\`$vinfo' is not valid version information"
              case $deplibs_check_method in
 
                match_pattern*)
 
                  set dummy $deplibs_check_method; shift
 
                  match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
 
                  if eval "\$ECHO \"X$deplib\"" 2>/dev/null | $Xsed -e 10q \
 
                    | $EGREP "$match_pattern_regex" > /dev/null; then
 
                    valid_a_lib=yes
 
                  fi
 
                ;;
 
                pass_all)
 
                  valid_a_lib=yes
          ;;
          ;;
        esac
        esac
 
              if test "$valid_a_lib" != yes; then
        case $age in
                $ECHO
        0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
                $ECHO "*** Warning: Trying to link with static lib archive $deplib."
        *)
                $ECHO "*** I have the capability to make that library automatically link in when"
          func_error "AGE \`$age' must be a nonnegative integer"
                $ECHO "*** you link to this library.  But I can only do this if you have a"
          func_fatal_error "\`$vinfo' is not valid version information"
                $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 use here."
 
              else
 
                $ECHO
 
                $ECHO "*** Warning: Linking the shared library $output against the"
 
                $ECHO "*** static library $deplib is not portable!"
 
                deplibs="$deplib $deplibs"
 
              fi
          ;;
          ;;
        esac
        esac
 
            continue
        if test "$age" -gt "$current"; then
            ;;
          func_error "AGE \`$age' is greater than the current interface number \`$current'"
          prog)
          func_fatal_error "\`$vinfo' is not valid version information"
            if test "$pass" != link; then
 
              deplibs="$deplib $deplibs"
 
            else
 
              compile_deplibs="$deplib $compile_deplibs"
 
              finalize_deplibs="$deplib $finalize_deplibs"
        fi
        fi
 
            continue
        # Calculate the version variables.
 
        major=
 
        versuffix=
 
        verstring=
 
        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"
 
          ;;
          ;;
 
          esac # linkmode
        freebsd-aout)
          ;; # *.$libext
          major=".$current"
        *.lo | *.$objext)
          versuffix=".$current.$revision";
          if test "$pass" = conv; 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"
 
              compile_deplibs="$deplib $compile_deplibs"
 
              finalize_deplibs="$deplib $finalize_deplibs"
 
            else
 
              newdlfiles="$newdlfiles $deplib"
 
            fi
 
          fi
 
          continue
          ;;
          ;;
 
        %DEPLIBS%)
        freebsd-elf)
          alldeplibs=yes
          major=".$current"
          continue
          versuffix=".$current"
 
          ;;
          ;;
 
        esac # case $deplib
 
 
        irix | nonstopux)
        if test "$found" = yes || test -f "$lib"; then :
          major=`expr $current - $age + 1`
        else
 
          func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'"
          case $version_type in
        fi
            nonstopux) verstring_prefix=nonstopux ;;
 
            *)         verstring_prefix=sgi ;;
 
          esac
 
          verstring="$verstring_prefix$major.$revision"
 
 
 
          # Add in all the interfaces that we are compatible with.
        # Check to see that this really is a libtool archive.
          loop=$revision
        func_lalib_unsafe_p "$lib" \
          while test "$loop" -ne 0; do
          || func_fatal_error "\`$lib' is not a valid libtool archive"
            iface=`expr $revision - $loop`
 
            loop=`expr $loop - 1`
 
            verstring="$verstring_prefix$major.$iface:$verstring"
 
          done
 
 
 
          # Before this point, $major must not contain `.'.
        func_dirname "$lib" "" "."
          major=.$major
        ladir="$func_dirname_result"
          versuffix="$major.$revision"
 
          ;;
 
 
 
        linux)
        dlname=
          major=.`expr $current - $age`
        dlopen=
          versuffix="$major.$age.$revision"
        dlpreopen=
          ;;
        libdir=
 
        library_names=
 
        old_library=
 
        inherited_linker_flags=
 
        # If the library was installed with an old release of libtool,
 
        # it will not redefine variables installed, or shouldnotlink
 
        installed=yes
 
        shouldnotlink=no
 
        avoidtemprpath=
 
 
        osf)
 
          major=.`expr $current - $age`
 
          versuffix=".$current.$age.$revision"
 
          verstring="$current.$age.$revision"
 
 
 
          # Add in all the interfaces that we are compatible with.
        # Read the .la file
          loop=$age
        func_source "$lib"
          while test "$loop" -ne 0; do
 
            iface=`expr $current - $loop`
        # Convert "-framework foo" to "foo.ltframework"
            loop=`expr $loop - 1`
        if test -n "$inherited_linker_flags"; then
            verstring="$verstring:${iface}.0"
          tmp_inherited_linker_flags=`$ECHO "X$inherited_linker_flags" | $Xsed -e 's/-framework \([^ $]*\)/\1.ltframework/g'`
 
          for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
 
            case " $new_inherited_linker_flags " in
 
              *" $tmp_inherited_linker_flag "*) ;;
 
              *) new_inherited_linker_flags="$new_inherited_linker_flags $tmp_inherited_linker_flag";;
 
            esac
          done
          done
 
        fi
 
        dependency_libs=`$ECHO "X $dependency_libs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
 
        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"
 
        fi
 
 
          # Make executables depend on our current version.
        if test "$pass" = conv; then
          verstring="$verstring:${current}.0"
          # Only check for convenience libraries
          ;;
          deplibs="$lib $deplibs"
 
          if test -z "$libdir"; then
 
            if test -z "$old_library"; then
 
              func_fatal_error "cannot find name of link library for \`$lib'"
 
            fi
 
            # 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"
 
          elif test "$linkmode" != prog && test "$linkmode" != lib; then
 
            func_fatal_error "\`$lib' is not a convenience library"
 
          fi
 
          tmp_libs=
 
          for deplib in $dependency_libs; do
 
            deplibs="$deplib $deplibs"
 
            if $opt_duplicate_deps ; then
 
              case "$tmp_libs " in
 
              *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
 
              esac
 
            fi
 
            tmp_libs="$tmp_libs $deplib"
 
          done
 
          continue
 
        fi # $pass = conv
 
 
        qnx)
 
          major=".$current"
 
          versuffix=".$current"
 
          ;;
 
 
 
        sunos)
        # Get the name of the library we link against.
          major=".$current"
        linklib=
          versuffix=".$current.$revision"
        for l in $old_library $library_names; do
          ;;
          linklib="$l"
 
        done
 
        if test -z "$linklib"; then
 
          func_fatal_error "cannot find name of link library for \`$lib'"
 
        fi
 
 
        windows)
        # This library was specified with -dlopen.
          # Use '-' rather than '.', since we only want one
        if test "$pass" = dlopen; then
          # extension on DOS 8.3 filesystems.
          if test -z "$libdir"; then
          major=`expr $current - $age`
            func_fatal_error "cannot -dlopen a convenience library: \`$lib'"
          versuffix="-$major"
          fi
          ;;
          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, we need to preload.  We also need to preload any
 
            # 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"
 
          fi
 
          continue
 
        fi # $pass = dlopen
 
 
 
        # We need an absolute path.
 
        case $ladir in
 
        [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
        *)
        *)
          func_fatal_configuration "unknown library version type \`$version_type'"
          abs_ladir=`cd "$ladir" && pwd`
 
          if test -z "$abs_ladir"; then
 
            func_warning "cannot determine absolute directory name of \`$ladir'"
 
            func_warning "passing it literally to the linker, although it might fail"
 
            abs_ladir="$ladir"
 
          fi
          ;;
          ;;
        esac
        esac
 
        func_basename "$lib"
 
        laname="$func_basename_result"
 
 
        # Clear the version info if we defaulted, and they specified a release.
        # Find the relevant object directory and library name.
        if test -z "$vinfo" && test -n "$release"; then
        if test "X$installed" = Xyes; then
          major=
          if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
          case $version_type in
            func_warning "library \`$lib' was moved."
          darwin)
            dir="$ladir"
            # we can't check for "0.0" in archive_cmds due to quoting
            absdir="$abs_ladir"
            # problems, so we reset it completely
            libdir="$abs_ladir"
            verstring=
 
            ;;
 
          *)
 
            verstring="0.0"
 
            ;;
 
          esac
 
          if test "$need_version" = no; then
 
            versuffix=
 
          else
          else
            versuffix=".0.0"
            dir="$libdir"
          fi
            absdir="$libdir"
        fi
        fi
 
          test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
        # Remove version info from name if versioning should be avoided
        else
        if test "$avoid_version" = yes && test "$need_version" = no; then
          if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
          major=
            dir="$ladir"
          versuffix=
            absdir="$abs_ladir"
          verstring=""
            # Remove this search path later
 
            notinst_path="$notinst_path $abs_ladir"
 
          else
 
            dir="$ladir/$objdir"
 
            absdir="$abs_ladir/$objdir"
 
            # Remove this search path later
 
            notinst_path="$notinst_path $abs_ladir"
        fi
        fi
 
        fi # $installed = yes
 
        func_stripname 'lib' '.la' "$laname"
 
        name=$func_stripname_result
 
 
        # Check to see if the archive will have undefined symbols.
        # This library was specified with -dlpreopen.
        if test "$allow_undefined" = yes; then
        if test "$pass" = dlpreopen; then
          if test "$allow_undefined_flag" = unsupported; then
          if test -z "$libdir" && test "$linkmode" = prog; then
            func_warning "undefined symbols not allowed in $host shared libraries"
            func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"
            build_libtool_libs=no
 
            build_old_libs=yes
 
          fi
          fi
 
          # 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"
 
            # Keep a list of preopened convenience libraries to check
 
            # that they are being used correctly in the link pass.
 
            test -z "$libdir" && \
 
                dlpreconveniencelibs="$dlpreconveniencelibs $dir/$old_library"
 
          # Otherwise, use the dlname, so that lt_dlopen finds it.
 
          elif test -n "$dlname"; then
 
            newdlprefiles="$newdlprefiles $dir/$dlname"
        else
        else
          # Don't allow undefined symbols.
            newdlprefiles="$newdlprefiles $dir/$linklib"
          allow_undefined_flag="$no_undefined_flag"
 
        fi
        fi
 
        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
      fi
      fi
 
 
      func_generate_dlsyms "$libname" "$libname" "yes"
 
      libobjs="$libobjs $symfileobj"
 
      test "X$libobjs" = "X " && libobjs=
 
 
 
      if test "$mode" != relink; then
 
        # Remove our outputs, but don't remove object files since they
 
        # may have been created when compiling PIC objects.
 
        removelist=
 
        tempremovelist=`$ECHO "$output_objdir/*"`
 
        for p in $tempremovelist; do
 
          case $p in
 
            *.$objext)
 
               ;;
 
            $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
 
               if test "X$precious_files_regex" != "X"; then
 
                 if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
 
                 then
 
                   continue
                   continue
                 fi
                 fi
 
 
 
 
 
        if test "$linkmode" = prog && test "$pass" != link; then
 
          newlib_search_path="$newlib_search_path $ladir"
 
          deplibs="$lib $deplibs"
 
 
 
          linkalldeplibs=no
 
          if test "$link_all_deplibs" != no || test -z "$library_names" ||
 
             test "$build_libtool_libs" = no; then
 
            linkalldeplibs=yes
               fi
               fi
               removelist="$removelist $p"
 
 
          tmp_libs=
 
          for deplib in $dependency_libs; do
 
            case $deplib in
 
            -L*) func_stripname '-L' '' "$deplib"
 
                 newlib_search_path="$newlib_search_path $func_stripname_result"
               ;;
               ;;
            *) ;;
 
          esac
          esac
        done
            # Need to link against all dependency_libs?
        test -n "$removelist" && \
            if test "$linkalldeplibs" = yes; then
          func_show_eval "${RM}r \$removelist"
              deplibs="$deplib $deplibs"
 
            else
 
              # Need to hardcode shared library paths
 
              # or/and link against static libraries
 
              newdependency_libs="$deplib $newdependency_libs"
      fi
      fi
 
            if $opt_duplicate_deps ; then
 
              case "$tmp_libs " in
 
              *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
 
              esac
 
            fi
 
            tmp_libs="$tmp_libs $deplib"
 
          done # for deplib
 
          continue
 
        fi # $linkmode = prog...
 
 
      # Now set the variables for building old libraries.
        if test "$linkmode,$pass" = "prog,link"; then
      if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
          if test -n "$library_names" &&
        oldlibs="$oldlibs $output_objdir/$libname.$libext"
             { { test "$prefer_static_libs" = no ||
 
                 test "$prefer_static_libs,$installed" = "built,yes"; } ||
        # Transform .lo files to .o files.
               test -z "$old_library"; }; then
        oldobjs="$objs "`$ECHO "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
            # We need to hardcode the library path
 
            if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
 
              # Make sure the rpath contains only unique directories.
 
              case "$temp_rpath:" in
 
              *"$absdir:"*) ;;
 
              *) temp_rpath="$temp_rpath$absdir:" ;;
 
              esac
      fi
      fi
 
 
      # Eliminate all temporary directories.
            # Hardcode the library path.
      #for path in $notinst_path; do
            # Skip directories that are in the system default run-time
      # lib_search_path=`$ECHO "X$lib_search_path " | $Xsed -e "s% $path % %g"`
            # search path.
      # deplibs=`$ECHO "X$deplibs " | $Xsed -e "s% -L$path % %g"`
            case " $sys_lib_dlsearch_path " in
      # dependency_libs=`$ECHO "X$dependency_libs " | $Xsed -e "s% -L$path % %g"`
            *" $absdir "*) ;;
      #done
            *)
 
              case "$compile_rpath " in
      if test -n "$xrpath"; then
              *" $absdir "*) ;;
        # If the user specified any rpath flags, then add them.
              *) compile_rpath="$compile_rpath $absdir"
        temp_xrpath=
              esac
        for libdir in $xrpath; do
              ;;
          temp_xrpath="$temp_xrpath -R$libdir"
            esac
 
            case " $sys_lib_dlsearch_path " in
 
            *" $libdir "*) ;;
 
            *)
          case "$finalize_rpath " in
          case "$finalize_rpath " in
          *" $libdir "*) ;;
          *" $libdir "*) ;;
          *) finalize_rpath="$finalize_rpath $libdir" ;;
              *) finalize_rpath="$finalize_rpath $libdir"
          esac
          esac
        done
              ;;
        if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
 
          dependency_libs="$temp_xrpath $dependency_libs"
 
        fi
 
      fi
 
 
 
      # Make sure dlfiles contains only unique files that won't be dlpreopened
 
      old_dlfiles="$dlfiles"
 
      dlfiles=
 
      for lib in $old_dlfiles; do
 
        case " $dlprefiles $dlfiles " in
 
        *" $lib "*) ;;
 
        *) dlfiles="$dlfiles $lib" ;;
 
        esac
        esac
      done
          fi # $linkmode,$pass = prog,link...
 
 
      # Make sure dlprefiles contains only unique files
          if test "$alldeplibs" = yes &&
      old_dlprefiles="$dlprefiles"
             { test "$deplibs_check_method" = pass_all ||
      dlprefiles=
               { test "$build_libtool_libs" = yes &&
      for lib in $old_dlprefiles; do
                 test -n "$library_names"; }; }; then
        case "$dlprefiles " in
            # We only need to search for static libraries
        *" $lib "*) ;;
            continue
        *) dlprefiles="$dlprefiles $lib" ;;
          fi
        esac
        fi
      done
 
 
 
      if test "$build_libtool_libs" = yes; then
        link_static=no # Whether the deplib will be linked statically
        if test -n "$rpath"; then
        use_static_libs=$prefer_static_libs
 
        if test "$use_static_libs" = built && test "$installed" = yes; then
 
          use_static_libs=no
 
        fi
 
        if test -n "$library_names" &&
 
           { test "$use_static_libs" = no || test -z "$old_library"; }; then
          case $host in
          case $host in
          *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos*)
          *cygwin* | *mingw* | *cegcc*)
            # these systems don't actually have a c library (as such)!
              # No point in relinking DLLs because paths are not encoded
            ;;
              notinst_deplibs="$notinst_deplibs $lib"
          *-*-rhapsody* | *-*-darwin1.[012])
              need_relink=no
            # Rhapsody C library is in the System framework
 
            deplibs="$deplibs System.ltframework"
 
            ;;
 
          *-*-netbsd*)
 
            # Don't link with libc until the a.out ld.so is fixed.
 
            ;;
 
          *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
 
            # Do not include libc due to us having libc/libc_r.
 
            ;;
 
          *-*-sco3.2v5* | *-*-sco5v6*)
 
            # Causes problems with __ctype
 
            ;;
 
          *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
 
            # Compiler inserts libc in the correct place for threads to work
 
            ;;
            ;;
          *)
          *)
            # Add libc to deplibs on all other systems if necessary.
            if test "$installed" = no; then
            if test "$build_libtool_need_lc" = "yes"; then
              notinst_deplibs="$notinst_deplibs $lib"
              deplibs="$deplibs -lc"
              need_relink=yes
            fi
            fi
            ;;
            ;;
          esac
          esac
        fi
          # This is a shared library
 
 
        # Transform deplibs into only deplibs that can be linked in shared.
          # Warn about portability, can't link against -module's on some
        name_save=$name
          # systems (darwin).  Don't bleat about dlopened modules though!
        libname_save=$libname
          dlopenmodule=""
        release_save=$release
          for dlpremoduletest in $dlprefiles; do
        versuffix_save=$versuffix
            if test "X$dlpremoduletest" = "X$lib"; then
        major_save=$major
              dlopenmodule="$dlpremoduletest"
        # I'm not sure if I'm treating the release correctly.  I think
              break
        # release should show up in the -l (ie -lgmp5) so we don't want to
            fi
        # add it in twice.  Is that correct?
          done
        release=""
          if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then
        versuffix=""
            $ECHO
        major=""
            if test "$linkmode" = prog; then
        newdeplibs=
              $ECHO "*** Warning: Linking the executable $output against the loadable module"
        droppeddeps=no
            else
        case $deplibs_check_method in
              $ECHO "*** Warning: Linking the shared library $output against the loadable module"
        pass_all)
            fi
          # Don't check for shared/static.  Everything works.
            $ECHO "*** $linklib is not portable!"
          # This might be a little naive.  We might want to check
          fi
          # whether the library exists or not.  But this is on
          if test "$linkmode" = lib &&
          # osf3 & osf4 and I'm not really sure... Just
             test "$hardcode_into_libs" = yes; then
          # implementing what was already the behavior.
            # Hardcode the library path.
          newdeplibs=$deplibs
            # Skip directories that are in the system default run-time
 
            # search path.
 
            case " $sys_lib_dlsearch_path " in
 
            *" $absdir "*) ;;
 
            *)
 
              case "$compile_rpath " in
 
              *" $absdir "*) ;;
 
              *) compile_rpath="$compile_rpath $absdir"
 
              esac
          ;;
          ;;
        test_compile)
            esac
          # This code stresses the "libraries are programs" paradigm to its
            case " $sys_lib_dlsearch_path " in
          # limits. Maybe even breaks it.  We compile a program, linking it
            *" $libdir "*) ;;
          # against the deplibs as a proxy for the library.  Then we can check
            *)
          # whether they linked in statically or dynamically with ldd.
              case "$finalize_rpath " in
          $opt_dry_run || $RM conftest.c
              *" $libdir "*) ;;
          cat > conftest.c <<EOF
              *) finalize_rpath="$finalize_rpath $libdir"
          int main() { return 0; }
              esac
EOF
 
          $opt_dry_run || $RM conftest
 
          if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; 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" != "" && test "$name" != "0"; then
 
                if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
 
                  case " $predeps $postdeps " in
 
                  *" $i "*)
 
                    newdeplibs="$newdeplibs $i"
 
                    i=""
 
                    ;;
                    ;;
                  esac
                  esac
                fi
                fi
                if test -n "$i" ; then
 
 
          if test -n "$old_archive_from_expsyms_cmds"; then
 
            # figure out the soname
 
            set dummy $library_names
 
            shift
 
            realname="$1"
 
            shift
                  libname=`eval "\\$ECHO \"$libname_spec\""`
                  libname=`eval "\\$ECHO \"$libname_spec\""`
                  deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
            # use dlname if we got it. it's perfectly good, no?
                  set dummy $deplib_matches; shift
            if test -n "$dlname"; then
                  deplib_match=$1
              soname="$dlname"
                  if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
            elif test -n "$soname_spec"; then
                    newdeplibs="$newdeplibs $i"
              # bleh windows
 
              case $host in
 
              *cygwin* | mingw* | *cegcc*)
 
                func_arith $current - $age
 
                major=$func_arith_result
 
                versuffix="-$major"
 
                ;;
 
              esac
 
              eval soname=\"$soname_spec\"
                  else
                  else
                    droppeddeps=yes
              soname="$realname"
                    $ECHO
 
                    $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 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."
 
                  fi
 
                fi
                fi
 
 
 
            # Make a new name for the extract_expsyms_cmds to use
 
            soroot="$soname"
 
            func_basename "$soroot"
 
            soname="$func_basename_result"
 
            func_stripname 'lib' '.dll' "$soname"
 
            newlib=libimp-$func_stripname_result.a
 
 
 
            # If the library has no export list, then create one now
 
            if test -f "$output_objdir/$soname-def"; then :
              else
              else
                newdeplibs="$newdeplibs $i"
              func_verbose "extracting exported symbol list from \`$soname'"
 
              func_execute_cmds "$extract_expsyms_cmds" 'exit $?'
              fi
              fi
            done
 
          else
            # Create $newlib
            # Error occurred in the first compile.  Let's try to salvage
            if test -f "$output_objdir/$newlib"; then :; else
            # the situation: Compile a separate program for each library.
              func_verbose "generating import library for \`$soname'"
            for i in $deplibs; do
              func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'
              name=`expr $i : '-l\(.*\)'`
 
              # If $name is empty we are operating on a -L argument.
 
              if test "$name" != "" && test "$name" != "0"; then
 
                $opt_dry_run || $RM conftest
 
                if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
 
                  ldd_output=`ldd conftest`
 
                  if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
 
                    case " $predeps $postdeps " in
 
                    *" $i "*)
 
                      newdeplibs="$newdeplibs $i"
 
                      i=""
 
                      ;;
 
                    esac
 
                  fi
                  fi
                  if test -n "$i" ; then
            # make sure the library variables are pointing to the new library
                    libname=`eval "\\$ECHO \"$libname_spec\""`
            dir=$output_objdir
                    deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
            linklib=$newlib
                    set dummy $deplib_matches; shift
          fi # test -n "$old_archive_from_expsyms_cmds"
                    deplib_match=$1
 
                    if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
          if test "$linkmode" = prog || test "$mode" != relink; then
                      newdeplibs="$newdeplibs $i"
            add_shlibpath=
                    else
            add_dir=
                      droppeddeps=yes
            add=
 
            lib_linked=yes
 
            case $hardcode_action in
 
            immediate | unsupported)
 
              if test "$hardcode_direct" = no; then
 
                add="$dir/$linklib"
 
                case $host in
 
                  *-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;
 
                  *-*-sysv4*uw2*) add_dir="-L$dir" ;;
 
                  *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
 
                    *-*-unixware7*) add_dir="-L$dir" ;;
 
                  *-*-darwin* )
 
                    # if the lib is a (non-dlopened) module then we can not
 
                    # link against it, someone is ignoring the earlier warnings
 
                    if /usr/bin/file -L $add 2> /dev/null |
 
                         $GREP ": [^:]* bundle" >/dev/null ; then
 
                      if test "X$dlopenmodule" != "X$lib"; then
 
                        $ECHO "*** Warning: lib $linklib is a module, not a shared library"
 
                        if test -z "$old_library" ; then
                      $ECHO
                      $ECHO
                      $ECHO "*** Warning: dynamic linker does not accept needed library $i."
                          $ECHO "*** And there doesn't seem to be a static archive available"
                      $ECHO "*** I have the capability to make that library automatically link in when"
                          $ECHO "*** The link will probably fail, sorry"
                      $ECHO "*** you link to this library.  But I can only do this if you have a"
                        else
                      $ECHO "*** shared version of the library, which you do not appear to have"
                          add="$dir/$old_library"
                      $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."
 
                    fi
                    fi
 
                      elif test -n "$old_library"; then
 
                        add="$dir/$old_library"
                  fi
                  fi
                else
 
                  droppeddeps=yes
 
                  $ECHO
 
                  $ECHO "*** Warning!  Library $i is needed by this library but I was not able to"
 
                  $ECHO "*** make it link in!  You will probably need to install it or some"
 
                  $ECHO "*** library that it depends on before this library will be fully"
 
                  $ECHO "*** functional.  Installing it before continuing would be even better."
 
                fi
                fi
 
                esac
 
              elif test "$hardcode_minus_L" = no; then
 
                case $host in
 
                *-*-sunos*) add_shlibpath="$dir" ;;
 
                esac
 
                add_dir="-L$dir"
 
                add="-l$name"
 
              elif test "$hardcode_shlibpath_var" = no; then
 
                add_shlibpath="$dir"
 
                add="-l$name"
              else
              else
                newdeplibs="$newdeplibs $i"
                lib_linked=no
              fi
 
            done
 
          fi
          fi
          ;;
          ;;
        file_magic*)
            relink)
          set dummy $deplibs_check_method; shift
              if test "$hardcode_direct" = yes &&
          file_magic_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
                 test "$hardcode_direct_absolute" = no; then
          for a_deplib in $deplibs; do
                add="$dir/$linklib"
            name=`expr $a_deplib : '-l\(.*\)'`
              elif test "$hardcode_minus_L" = yes; then
            # If $name is empty we are operating on a -L argument.
                add_dir="-L$dir"
            if test "$name" != "" && test  "$name" != "0"; then
                # Try looking first in the location we're being installed to.
              if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
                if test -n "$inst_prefix_dir"; then
                case " $predeps $postdeps " in
                  case $libdir in
                *" $a_deplib "*)
                    [\\/]*)
                  newdeplibs="$newdeplibs $a_deplib"
                      add_dir="$add_dir -L$inst_prefix_dir$libdir"
                  a_deplib=""
 
                  ;;
                  ;;
                esac
                esac
              fi
              fi
              if test -n "$a_deplib" ; then
                add="-l$name"
                libname=`eval "\\$ECHO \"$libname_spec\""`
              elif test "$hardcode_shlibpath_var" = yes; then
                for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
                add_shlibpath="$dir"
                  potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
                add="-l$name"
                  for potent_lib in $potential_libs; do
              else
                      # Follow soft links.
                lib_linked=no
                      if ls -lLd "$potent_lib" 2>/dev/null |
 
                         $GREP " -> " >/dev/null; then
 
                        continue
 
                      fi
                      fi
                      # The statement above tries to avoid entering an
              ;;
                      # endless loop below, in case of cyclic links.
            *) lib_linked=no ;;
                      # We might still enter an endless loop, since a link
 
                      # loop can be closed while we follow links,
 
                      # but so what?
 
                      potlib="$potent_lib"
 
                      while test -h "$potlib" 2>/dev/null; do
 
                        potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
 
                        case $potliblink in
 
                        [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
 
                        *) potlib=`$ECHO "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
 
                        esac
                        esac
                      done
 
                      if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |
            if test "$lib_linked" != yes; then
                         $SED -e 10q |
              func_fatal_configuration "unsupported hardcode properties"
                         $EGREP "$file_magic_regex" > /dev/null; then
 
                        newdeplibs="$newdeplibs $a_deplib"
 
                        a_deplib=""
 
                        break 2
 
                      fi
                      fi
                  done
 
                done
            if test -n "$add_shlibpath"; then
 
              case :$compile_shlibpath: in
 
              *":$add_shlibpath:"*) ;;
 
              *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
 
              esac
              fi
              fi
              if test -n "$a_deplib" ; then
            if test "$linkmode" = prog; then
                droppeddeps=yes
              test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
                $ECHO
              test -n "$add" && compile_deplibs="$add $compile_deplibs"
                $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 file magic test)"
 
                else
                else
                  $ECHO "*** with $libname and none of the candidates passed a file format test"
              test -n "$add_dir" && deplibs="$add_dir $deplibs"
                  $ECHO "*** using a file magic. Last file checked: $potlib"
              test -n "$add" && deplibs="$add $deplibs"
 
              if test "$hardcode_direct" != yes &&
 
                 test "$hardcode_minus_L" != yes &&
 
                 test "$hardcode_shlibpath_var" = yes; then
 
                case :$finalize_shlibpath: in
 
                *":$libdir:"*) ;;
 
                *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
 
                esac
                fi
                fi
              fi
              fi
            else
 
              # Add a -L argument.
 
              newdeplibs="$newdeplibs $a_deplib"
 
            fi
            fi
          done # Gone through all deplibs.
 
          ;;
          if test "$linkmode" = prog || test "$mode" = relink; then
        match_pattern*)
            add_shlibpath=
          set dummy $deplibs_check_method; shift
            add_dir=
          match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
            add=
          for a_deplib in $deplibs; do
            # Finalize command for both is simple: just hardcode it.
            name=`expr $a_deplib : '-l\(.*\)'`
            if test "$hardcode_direct" = yes &&
            # If $name is empty we are operating on a -L argument.
               test "$hardcode_direct_absolute" = no; then
            if test -n "$name" && test "$name" != "0"; then
              add="$libdir/$linklib"
              if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
            elif test "$hardcode_minus_L" = yes; then
                case " $predeps $postdeps " in
              add_dir="-L$libdir"
                *" $a_deplib "*)
              add="-l$name"
                  newdeplibs="$newdeplibs $a_deplib"
            elif test "$hardcode_shlibpath_var" = yes; then
                  a_deplib=""
              case :$finalize_shlibpath: in
                  ;;
              *":$libdir:"*) ;;
 
              *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
                esac
                esac
 
              add="-l$name"
 
            elif test "$hardcode_automatic" = yes; then
 
              if test -n "$inst_prefix_dir" &&
 
                 test -f "$inst_prefix_dir$libdir/$linklib" ; then
 
                add="$inst_prefix_dir$libdir/$linklib"
 
              else
 
                add="$libdir/$linklib"
              fi
              fi
              if test -n "$a_deplib" ; 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 \"X$potent_lib\"" 2>/dev/null | $Xsed -e 10q | \
 
                       $EGREP "$match_pattern_regex" > /dev/null; then
 
                      newdeplibs="$newdeplibs $a_deplib"
 
                      a_deplib=""
 
                      break 2
 
                    fi
 
                  done
 
                done
 
              fi
 
              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
                else
                  $ECHO "*** with $libname and none of the candidates passed a file format test"
              # We cannot seem to hardcode it, guess we'll fake it.
                  $ECHO "*** using a regex pattern. Last file checked: $potlib"
              add_dir="-L$libdir"
 
              # Try looking first in the location we're being installed to.
 
              if test -n "$inst_prefix_dir"; then
 
                case $libdir in
 
                  [\\/]*)
 
                    add_dir="$add_dir -L$inst_prefix_dir$libdir"
 
                    ;;
 
                esac
                fi
                fi
 
              add="-l$name"
              fi
              fi
 
 
 
            if test "$linkmode" = prog; then
 
              test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
 
              test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
            else
            else
              # Add a -L argument.
              test -n "$add_dir" && deplibs="$add_dir $deplibs"
              newdeplibs="$newdeplibs $a_deplib"
              test -n "$add" && deplibs="$add $deplibs"
            fi
            fi
          done # Gone through all deplibs.
 
          ;;
 
        none | unknown | *)
 
          newdeplibs=""
 
          tmp_deplibs=`$ECHO "X $deplibs" | $Xsed \
 
              -e 's/ -lc$//' -e 's/ -[LR][^ ]*//g'`
 
          if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
 
            for i in $predeps $postdeps ; do
 
              # can't use Xsed below, because $i might contain '/'
 
              tmp_deplibs=`$ECHO "X $tmp_deplibs" | $Xsed -e "s,$i,,"`
 
            done
 
          fi
          fi
          if $ECHO "X $tmp_deplibs" | $Xsed -e 's/[     ]//g' |
        elif test "$linkmode" = prog; then
             $GREP . >/dev/null; then
          # Here we assume that one of hardcode_direct or hardcode_minus_L
            $ECHO
          # is not unsupported.  This is valid on all known static and
            if test "X$deplibs_check_method" = "Xnone"; then
          # shared platforms.
              $ECHO "*** Warning: inter-library dependencies are not supported in this platform."
          if test "$hardcode_direct" != unsupported; then
 
            test -n "$old_library" && linklib="$old_library"
 
            compile_deplibs="$dir/$linklib $compile_deplibs"
 
            finalize_deplibs="$dir/$linklib $finalize_deplibs"
            else
            else
              $ECHO "*** Warning: inter-library dependencies are not known to be supported."
            compile_deplibs="-l$name -L$dir $compile_deplibs"
            fi
            finalize_deplibs="-l$name -L$dir $finalize_deplibs"
            $ECHO "*** All declared inter-library dependencies are being dropped."
 
            droppeddeps=yes
 
          fi
          fi
          ;;
        elif test "$build_libtool_libs" = yes; then
        esac
          # Not a shared library
        versuffix=$versuffix_save
          if test "$deplibs_check_method" != pass_all; then
        major=$major_save
            # We're trying link a shared library against a static one
        release=$release_save
            # but the system doesn't support it.
        libname=$libname_save
 
        name=$name_save
 
 
 
        case $host in
 
        *-*-rhapsody* | *-*-darwin1.[012])
 
          # On Rhapsody replace the C library with the System framework
 
          newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
 
          ;;
 
        esac
 
 
 
        if test "$droppeddeps" = yes; then
            # Just print a warning and add the library to dependency_libs so
          if test "$module" = yes; then
            # that the program can be linked against the static library.
            $ECHO
            $ECHO
            $ECHO "*** Warning: libtool could not satisfy all declared inter-library"
            $ECHO "*** Warning: This system can not link to static lib archive $lib."
            $ECHO "*** dependencies of module $libname.  Therefore, libtool will create"
            $ECHO "*** I have the capability to make that library automatically link in when"
            $ECHO "*** a static module, that should work as long as the dlopening"
            $ECHO "*** you link to this library.  But I can only do this if you have a"
            $ECHO "*** application is linked with the -dlopen flag."
            $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
            if test -z "$global_symbol_pipe"; then
              $ECHO
              $ECHO
              $ECHO "*** However, this would only work if libtool was able to extract symbol"
              $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 "*** lists from a program, using \`nm' or equivalent, but libtool could"
              $ECHO "*** not find such a program.  So, this module is probably useless."
              $ECHO "*** not find such a program.  So, this module is probably useless."
              $ECHO "*** \`nm' from GNU binutils and a full rebuild may help."
              $ECHO "*** \`nm' from GNU binutils and a full rebuild may help."
            fi
            fi
            if test "$build_old_libs" = no; then
            if test "$build_old_libs" = no; then
              oldlibs="$output_objdir/$libname.$libext"
 
              build_libtool_libs=module
              build_libtool_libs=module
              build_old_libs=yes
              build_old_libs=yes
            else
            else
              build_libtool_libs=no
              build_libtool_libs=no
            fi
            fi
          else
 
            $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
 
              fi
              fi
 
          else
 
            deplibs="$dir/$old_library $deplibs"
 
            link_static=yes
            fi
            fi
 
        fi # link shared/static library?
 
 
 
        if test "$linkmode" = lib; then
 
          if test -n "$dependency_libs" &&
 
             { test "$hardcode_into_libs" != yes ||
 
               test "$build_old_libs" = yes ||
 
               test "$link_static" = yes; }; then
 
            # Extract -R from dependency_libs
 
            temp_deplibs=
 
            for libdir in $dependency_libs; do
 
              case $libdir in
 
              -R*) func_stripname '-R' '' "$libdir"
 
                   temp_xrpath=$func_stripname_result
 
                   case " $xrpath " in
 
                   *" $temp_xrpath "*) ;;
 
                   *) xrpath="$xrpath $temp_xrpath";;
 
                   esac;;
 
              *) temp_deplibs="$temp_deplibs $libdir";;
 
              esac
 
            done
 
            dependency_libs="$temp_deplibs"
          fi
          fi
 
 
 
          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
 
          tmp_libs=
 
          for deplib in $dependency_libs; do
 
            newdependency_libs="$deplib $newdependency_libs"
 
            if $opt_duplicate_deps ; then
 
              case "$tmp_libs " in
 
              *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
 
              esac
        fi
        fi
        # Done checking deplibs!
            tmp_libs="$tmp_libs $deplib"
        deplibs=$newdeplibs
          done
 
 
 
          if test "$link_all_deplibs" != no; then
 
            # Add the search paths of all dependency libraries
 
            for deplib in $dependency_libs; do
 
              case $deplib in
 
              -L*) path="$deplib" ;;
 
              *.la)
 
                func_dirname "$deplib" "" "."
 
                dir="$func_dirname_result"
 
                # We need an absolute path.
 
                case $dir in
 
                [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
 
                *)
 
                  absdir=`cd "$dir" && pwd`
 
                  if test -z "$absdir"; then
 
                    func_warning "cannot determine absolute directory name of \`$dir'"
 
                    absdir="$dir"
      fi
      fi
      # Time to change all our "foo.ltframework" stuff back to "-framework foo"
                  ;;
 
                esac
 
                if $GREP "^installed=no" $deplib > /dev/null; then
      case $host in
      case $host in
        *-*-darwin*)
        *-*-darwin*)
          newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
                  depdepl=
          new_inherited_linker_flags=`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
                  eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
          deplibs=`$ECHO "X $deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
                  if test -n "$deplibrary_names" ; then
 
                    for tmp in $deplibrary_names ; do
 
                      depdepl=$tmp
 
                    done
 
                    if test -f "$absdir/$objdir/$depdepl" ; then
 
                      depdepl="$absdir/$objdir/$depdepl"
 
                      darwin_install_name=`${OTOOL} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
 
                      if test -z "$darwin_install_name"; then
 
                          darwin_install_name=`${OTOOL64} -L $depdepl  | awk '{if (NR == 2) {print $1;exit}}'`
 
                      fi
 
                      compiler_flags="$compiler_flags ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
 
                      linker_flags="$linker_flags -dylib_file ${darwin_install_name}:${depdepl}"
 
                      path=
 
                    fi
 
                  fi
 
                  ;;
 
                *)
 
                  path="-L$absdir/$objdir"
          ;;
          ;;
      esac
      esac
 
                else
 
                  eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
 
                  test -z "$libdir" && \
 
                    func_fatal_error "\`$deplib' is not a valid libtool archive"
 
                  test "$absdir" != "$libdir" && \
 
                    func_warning "\`$deplib' seems to be moved"
 
 
      # move library search paths that coincide with paths to not yet
                  path="-L$absdir"
      # installed libraries to the beginning of the library search list
                fi
      new_libs=
                ;;
      for path in $notinst_path; do
              esac
        case " $new_libs " in
 
        *" -L$path/$objdir "*) ;;
 
        *)
 
          case " $deplibs " in
          case " $deplibs " in
          *" -L$path/$objdir "*)
              *" $path "*) ;;
            new_libs="$new_libs -L$path/$objdir" ;;
              *) deplibs="$path $deplibs" ;;
          esac
          esac
          ;;
            done
 
          fi # link_all_deplibs != no
 
        fi # linkmode = lib
 
      done # for deplib in $libs
 
      if test "$pass" = link; then
 
        if test "$linkmode" = "prog"; then
 
          compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
 
          finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
 
        else
 
          compiler_flags="$compiler_flags "`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
 
        fi
 
      fi
 
      dependency_libs="$newdependency_libs"
 
      if test "$pass" = dlpreopen; then
 
        # Link the dlpreopened libraries before other libraries
 
        for deplib in $save_deplibs; do
 
          deplibs="$deplib $deplibs"
 
        done
 
      fi
 
      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
        esac
      done
      done
      for deplib in $deplibs; do
          newlib_search_path=
 
        fi
 
 
 
        if test "$linkmode,$pass" != "prog,link"; then
 
          vars="deplibs"
 
        else
 
          vars="compile_deplibs finalize_deplibs"
 
        fi
 
        for var in $vars dependency_libs; do
 
          # Add libraries to $var in reverse order
 
          eval tmp_libs=\"\$$var\"
 
          new_libs=
 
          for deplib in $tmp_libs; do
 
            # 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
        case $deplib in
        -L*)
            -L*) new_libs="$deplib $new_libs" ;;
 
            -R*) ;;
 
            *)
 
              # 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" ;;
 
              *)
          case " $new_libs " in
          case " $new_libs " in
          *" $deplib "*) ;;
          *" $deplib "*) ;;
          *) new_libs="$new_libs $deplib" ;;
                *) new_libs="$deplib $new_libs" ;;
          esac
 
          ;;
 
        *) new_libs="$new_libs $deplib" ;;
 
        esac
        esac
      done
 
      deplibs="$new_libs"
 
 
 
      # All the library-specific variables (install_libdir is set above).
 
      library_names=
 
      old_library=
 
      dlname=
 
 
 
      # Test again, we may have decided not to build it any more
 
      if test "$build_libtool_libs" = yes; then
 
        if test "$hardcode_into_libs" = yes; then
 
          # Hardcode the library paths
 
          hardcode_libdirs=
 
          dep_rpath=
 
          rpath="$finalize_rpath"
 
          test "$mode" != relink && rpath="$compile_rpath$rpath"
 
          for libdir in $rpath; do
 
            if test -n "$hardcode_libdir_flag_spec"; then
 
              if test -n "$hardcode_libdir_separator"; then
 
                if test -z "$hardcode_libdirs"; then
 
                  hardcode_libdirs="$libdir"
 
                else
 
                  # Just accumulate the unique libdirs.
 
                  case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
 
                  *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
 
                    ;;
                    ;;
                  *)
              esac
                    hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
 
                    ;;
                    ;;
                  esac
                  esac
                fi
          done
              else
          tmp_libs=
                eval flag=\"$hardcode_libdir_flag_spec\"
          for deplib in $new_libs; do
                dep_rpath="$dep_rpath $flag"
            case $deplib in
              fi
            -L*)
            elif test -n "$runpath_var"; then
              case " $tmp_libs " in
              case "$perm_rpath " in
              *" $deplib "*) ;;
              *" $libdir "*) ;;
              *) tmp_libs="$tmp_libs $deplib" ;;
              *) perm_rpath="$perm_rpath $libdir" ;;
              esac
 
              ;;
 
            *) tmp_libs="$tmp_libs $deplib" ;;
              esac
              esac
            fi
 
          done
          done
          # Substitute the hardcoded libdirs into the rpath.
          eval $var=\"$tmp_libs\"
          if test -n "$hardcode_libdir_separator" &&
        done # for var
             test -n "$hardcode_libdirs"; then
 
            libdir="$hardcode_libdirs"
 
            if test -n "$hardcode_libdir_flag_spec_ld"; then
 
              eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\"
 
            else
 
              eval dep_rpath=\"$hardcode_libdir_flag_spec\"
 
            fi
            fi
 
      # Last step: remove runtime libs from dependency_libs
 
      # (they stay in deplibs)
 
      tmp_libs=
 
      for i in $dependency_libs ; do
 
        case " $predeps $postdeps $compiler_lib_search_path " in
 
        *" $i "*)
 
          i=""
 
          ;;
 
        esac
 
        if test -n "$i" ; then
 
          tmp_libs="$tmp_libs $i"
          fi
          fi
          if test -n "$runpath_var" && test -n "$perm_rpath"; then
 
            # We should set the runpath_var.
 
            rpath=
 
            for dir in $perm_rpath; do
 
              rpath="$rpath$dir:"
 
            done
            done
            eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
      dependency_libs=$tmp_libs
 
    done # for pass
 
    if test "$linkmode" = prog; then
 
      dlfiles="$newdlfiles"
          fi
          fi
          test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
    if test "$linkmode" = prog || test "$linkmode" = lib; then
 
      dlprefiles="$newdlprefiles"
        fi
        fi
 
 
        shlibpath="$finalize_shlibpath"
    case $linkmode in
        test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
    oldlib)
        if test -n "$shlibpath"; then
      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
          eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
        func_warning "\`-dlopen' is ignored for archives"
        fi
        fi
 
 
        # Get the real and link names of the library.
      case " $deplibs" in
        eval shared_ext=\"$shrext_cmds\"
      *\ -l* | *\ -L*)
        eval library_names=\"$library_names_spec\"
        func_warning "\`-l' and \`-L' are ignored for archives" ;;
        set dummy $library_names
      esac
        shift
 
        realname="$1"
 
        shift
 
 
 
        if test -n "$soname_spec"; then
      test -n "$rpath" && \
          eval soname=\"$soname_spec\"
        func_warning "\`-rpath' is ignored for archives"
        else
 
          soname="$realname"
 
        fi
 
        if test -z "$dlname"; then
 
          dlname=$soname
 
        fi
 
 
 
        lib="$output_objdir/$realname"
      test -n "$xrpath" && \
        linknames=
        func_warning "\`-R' is ignored for archives"
        for link
 
        do
 
          linknames="$linknames $link"
 
        done
 
 
 
        # Use standard objects if they are pic
      test -n "$vinfo" && \
        test -z "$pic_flag" && libobjs=`$ECHO "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
        func_warning "\`-version-info/-version-number' is ignored for archives"
        test "X$libobjs" = "X " && libobjs=
 
 
 
        delfiles=
      test -n "$release" && \
        if test -n "$export_symbols" && test -n "$include_expsyms"; then
        func_warning "\`-release' is ignored for archives"
          $opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"
 
          export_symbols="$output_objdir/$libname.uexp"
 
          delfiles="$delfiles $export_symbols"
 
        fi
 
 
 
        orig_export_symbols=
      test -n "$export_symbols$export_symbols_regex" && \
        case $host_os in
        func_warning "\`-export-symbols' is ignored for archives"
        cygwin* | mingw*)
 
          if test -n "$export_symbols" && test -z "$export_symbols_regex"; then
      # Now set the variables for building old libraries.
            # exporting using user supplied symfile
      build_libtool_libs=no
            if test "x`$SED 1q $export_symbols`" != xEXPORTS; then
      oldlibs="$output"
              # and it's NOT already a .def file. Must figure out
      objs="$objs$old_deplibs"
              # which of the given symbols are data symbols and tag
      ;;
              # them as such. So, trigger use of export_symbols_cmds.
 
              # export_symbols gets reassigned inside the "prepare
    lib)
              # the list of exported symbols" if statement, so the
      # Make sure we only generate libraries of the form `libNAME.la'.
              # include_expsyms logic still works.
      case $outputname in
              orig_export_symbols="$export_symbols"
      lib*)
              export_symbols=
        func_stripname 'lib' '.la' "$outputname"
              always_export_symbols=yes
        name=$func_stripname_result
            fi
        eval shared_ext=\"$shrext_cmds\"
 
        eval libname=\"$libname_spec\"
 
        ;;
 
      *)
 
        test "$module" = no && \
 
          func_fatal_help "libtool library \`$output' must begin with \`lib'"
 
 
 
        if test "$need_lib_prefix" != no; then
 
          # Add the "lib" prefix for modules if required
 
          func_stripname '' '.la' "$outputname"
 
          name=$func_stripname_result
 
          eval shared_ext=\"$shrext_cmds\"
 
          eval libname=\"$libname_spec\"
 
        else
 
          func_stripname '' '.la' "$outputname"
 
          libname=$func_stripname_result
          fi
          fi
          ;;
          ;;
        esac
        esac
 
 
        # Prepare the list of exported symbols
      if test -n "$objs"; then
        if test -z "$export_symbols"; then
        if test "$deplibs_check_method" != pass_all; then
          if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
          func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"
            func_echo "generating symbol list for \`$libname.la'"
 
            export_symbols="$output_objdir/$libname.exp"
 
            $opt_dry_run || $RM $export_symbols
 
            cmds=$export_symbols_cmds
 
            save_ifs="$IFS"; IFS='~'
 
            for cmd in $cmds; do
 
              IFS="$save_ifs"
 
              eval cmd=\"$cmd\"
 
              if len=`expr "X$cmd" : ".*"` &&
 
               test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
 
                func_show_eval "$cmd" 'exit $?'
 
                skipped_export=false
 
              else
              else
                # The command line is too long to execute in one step.
          $ECHO
                func_echo "using reloadable object file for export list..."
          $ECHO "*** Warning: Linking the shared library $output against the non-libtool"
                skipped_export=:
          $ECHO "*** objects $objs is not portable!"
                # Break out early, otherwise skipped_export may be
          libobjs="$libobjs $objs"
                # set to false by a later but shorter cmd.
 
                break
 
              fi
 
            done
 
            IFS="$save_ifs"
 
            if test -n "$export_symbols_regex" && test "X$skipped_export" != "X:"; then
 
              func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
 
              func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
 
            fi
            fi
          fi
          fi
 
 
 
      test "$dlself" != no && \
 
        func_warning "\`-dlopen self' is ignored for libtool libraries"
 
 
 
      set dummy $rpath
 
      shift
 
      test "$#" -gt 1 && \
 
        func_warning "ignoring multiple \`-rpath's for a libtool library"
 
 
 
      install_libdir="$1"
 
 
 
      oldlibs=
 
      if test -z "$rpath"; then
 
        if test "$build_libtool_libs" = yes; then
 
          # Building a libtool convenience library.
 
          # 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
        fi
        fi
 
 
        if test -n "$export_symbols" && test -n "$include_expsyms"; then
        test -n "$vinfo" && \
          tmp_export_symbols="$export_symbols"
          func_warning "\`-version-info/-version-number' is ignored for convenience libraries"
          test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
 
          $opt_dry_run || eval '$ECHO "X$include_expsyms" | $Xsed | $SP2NL >> "$tmp_export_symbols"'
        test -n "$release" && \
        fi
          func_warning "\`-release' is ignored for convenience libraries"
 
      else
 
 
 
        # Parse the version information argument.
 
        save_ifs="$IFS"; IFS=':'
 
        set dummy $vinfo 0 0 0
 
        shift
 
        IFS="$save_ifs"
 
 
 
        test -n "$7" && \
 
          func_fatal_help "too many parameters to \`-version-info'"
 
 
 
        # convert absolute version numbers to libtool ages
 
        # this retains compatibility with .la files and attempts
 
        # to make the code below a bit more comprehensible
 
 
 
        case $vinfo_number in
 
        yes)
 
          number_major="$1"
 
          number_minor="$2"
 
          number_revision="$3"
 
          #
 
          # There are really only two kinds -- those that
 
          # use the current revision as the major version
 
          # and those that subtract age and use age as
 
          # a minor version.  But, then there is irix
 
          # which has an extra 1 added just for fun
 
          #
 
          case $version_type in
 
          darwin|linux|osf|windows|none)
 
            func_arith $number_major + $number_minor
 
            current=$func_arith_result
 
            age="$number_minor"
 
            revision="$number_revision"
 
            ;;
 
          freebsd-aout|freebsd-elf|sunos)
 
            current="$number_major"
 
            revision="$number_minor"
 
            age="0"
 
            ;;
 
          irix|nonstopux)
 
            func_arith $number_major + $number_minor
 
            current=$func_arith_result
 
            age="$number_minor"
 
            revision="$number_minor"
 
            lt_irix_increment=no
 
            ;;
 
          esac
 
          ;;
 
        no)
 
          current="$1"
 
          revision="$2"
 
          age="$3"
 
          ;;
 
        esac
 
 
 
        # Check that each of the things are valid numbers.
 
        case $current in
 
        0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
 
        *)
 
          func_error "CURRENT \`$current' must be a nonnegative integer"
 
          func_fatal_error "\`$vinfo' is not valid version information"
 
          ;;
 
        esac
 
 
        if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then
        case $revision in
          # The given exports_symbols file has to be filtered, so filter it.
        0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
          func_echo "filter symbol list for \`$libname.la' to tag DATA exports"
        *)
          # FIXME: $output_objdir/$libname.filter potentially contains lots of
          func_error "REVISION \`$revision' must be a nonnegative integer"
          # 's' commands which not all seds can handle. GNU sed should be fine
          func_fatal_error "\`$vinfo' is not valid version information"
          # though. Also, the filter scales superlinearly with the number of
          ;;
          # global variables. join(1) would be nice here, but unfortunately
        esac
          # isn't a blessed tool.
 
          $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
 
          delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"
 
          export_symbols=$output_objdir/$libname.def
 
          $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
 
        fi
 
 
 
        tmp_deplibs=
        case $age in
        for test_deplib in $deplibs; do
        0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
          case " $convenience " in
 
          *" $test_deplib "*) ;;
 
          *)
          *)
            tmp_deplibs="$tmp_deplibs $test_deplib"
          func_error "AGE \`$age' must be a nonnegative integer"
 
          func_fatal_error "\`$vinfo' is not valid version information"
            ;;
            ;;
          esac
          esac
        done
 
        deplibs="$tmp_deplibs"
 
 
 
        if test -n "$convenience"; then
        if test "$age" -gt "$current"; then
          if test -n "$whole_archive_flag_spec" &&
          func_error "AGE \`$age' is greater than the current interface number \`$current'"
            test "$compiler_needs_object" = yes &&
          func_fatal_error "\`$vinfo' is not valid version information"
            test -z "$libobjs"; then
 
            # extract the archives, so we have objects to list.
 
            # TODO: could optimize this to just extract one archive.
 
            whole_archive_flag_spec=
 
          fi
          fi
          if test -n "$whole_archive_flag_spec"; then
 
            save_libobjs=$libobjs
 
            eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
 
            test "X$libobjs" = "X " && libobjs=
 
          else
 
            gentop="$output_objdir/${outputname}x"
 
            generated="$generated $gentop"
 
 
 
            func_extract_archives $gentop $convenience
        # Calculate the version variables.
            libobjs="$libobjs $func_extract_archives_result"
        major=
            test "X$libobjs" = "X " && libobjs=
        versuffix=
          fi
        verstring=
        fi
        case $version_type in
 
        none) ;;
 
 
        if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
        darwin)
          eval flag=\"$thread_safe_flag_spec\"
          # Like Linux, but with the current version available in
          linker_flags="$linker_flags $flag"
          # verstring for coding it into the library header
        fi
          func_arith $current - $age
 
          major=.$func_arith_result
 
          versuffix="$major.$age.$revision"
 
          # Darwin ld doesn't like 0 for these options...
 
          func_arith $current + 1
 
          minor_current=$func_arith_result
 
          xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
 
          verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
 
          ;;
 
 
        # Make a backup of the uninstalled library when relinking
        freebsd-aout)
        if test "$mode" = relink; then
          major=".$current"
          $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?
          versuffix=".$current.$revision";
        fi
          ;;
 
 
        # Do each of the archive commands.
        freebsd-elf)
        if test "$module" = yes && test -n "$module_cmds" ; then
          major=".$current"
          if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
          versuffix=".$current"
            eval test_cmds=\"$module_expsym_cmds\"
          ;;
            cmds=$module_expsym_cmds
 
          else
 
            eval test_cmds=\"$module_cmds\"
 
            cmds=$module_cmds
 
          fi
 
        else
 
          if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
 
            eval test_cmds=\"$archive_expsym_cmds\"
 
            cmds=$archive_expsym_cmds
 
          else
 
            eval test_cmds=\"$archive_cmds\"
 
            cmds=$archive_cmds
 
          fi
 
        fi
 
 
 
        if test "X$skipped_export" != "X:" &&
        irix | nonstopux)
           len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
          if test "X$lt_irix_increment" = "Xno"; then
           test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
            func_arith $current - $age
          :
 
        else
        else
          # The command line is too long to link in one step, link piecewise
            func_arith $current - $age + 1
          # or, if using GNU ld and skipped_export is not :, use a linker
 
          # script.
 
 
 
          # 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
 
          fi
          fi
          save_output=$output
          major=$func_arith_result
          output_la=`$ECHO "X$output" | $Xsed -e "$basename"`
 
 
 
          # Clear the reloadable object creation command queue and
          case $version_type in
          # initialize k to one.
            nonstopux) verstring_prefix=nonstopux ;;
          test_cmds=
            *)         verstring_prefix=sgi ;;
          concat_cmds=
          esac
          objlist=
          verstring="$verstring_prefix$major.$revision"
          last_robj=
 
          k=1
 
 
 
          if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then
          # Add in all the interfaces that we are compatible with.
            output=${output_objdir}/${output_la}.lnkscript
          loop=$revision
            func_echo "creating GNU ld script: $output"
          while test "$loop" -ne 0; do
            $ECHO 'INPUT (' > $output
            func_arith $revision - $loop
            for obj in $save_libobjs
            iface=$func_arith_result
            do
            func_arith $loop - 1
              $ECHO "$obj" >> $output
            loop=$func_arith_result
            done
            verstring="$verstring_prefix$major.$iface:$verstring"
            $ECHO ')' >> $output
 
            delfiles="$delfiles $output"
 
          elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then
 
            output=${output_objdir}/${output_la}.lnk
 
            func_echo "creating linker input file list: $output"
 
            : > $output
 
            set x $save_libobjs
 
            shift
 
            firstobj=
 
            if test "$compiler_needs_object" = yes; then
 
              firstobj="$1 "
 
              shift
 
            fi
 
            for obj
 
            do
 
              $ECHO "$obj" >> $output
 
            done
 
            delfiles="$delfiles $output"
 
            output=$firstobj\"$file_list_spec$output\"
 
          else
 
            if test -n "$save_libobjs"; then
 
              func_echo "creating reloadable object files..."
 
              output=$output_objdir/$output_la-${k}.$objext
 
              # Loop over the list of objects to be linked.
 
              for obj in $save_libobjs
 
              do
 
                eval test_cmds=\"$reload_cmds $objlist $last_robj\"
 
                if test "X$objlist" = X ||
 
                   { len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
 
                     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\"
 
                  fi
 
                  last_robj=$output_objdir/$output_la-${k}.$objext
 
                  k=`expr $k + 1`
 
                  output=$output_objdir/$output_la-${k}.$objext
 
                  objlist=$obj
 
                  len=1
 
                fi
 
              done
              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 reloadable object files
          # Before this point, $major must not contain `.'.
              # after they are used.
          major=.$major
              i=0
          versuffix="$major.$revision"
              while test "$i" -lt "$k"
          ;;
              do
 
                i=`expr $i + 1`
        linux)
                delfiles="$delfiles $output_objdir/$output_la-${i}.$objext"
          func_arith $current - $age
 
          major=.$func_arith_result
 
          versuffix="$major.$age.$revision"
 
          ;;
 
 
 
        osf)
 
          func_arith $current - $age
 
          major=.$func_arith_result
 
          versuffix=".$current.$age.$revision"
 
          verstring="$current.$age.$revision"
 
 
 
          # Add in all the interfaces that we are compatible with.
 
          loop=$age
 
          while test "$loop" -ne 0; do
 
            func_arith $current - $loop
 
            iface=$func_arith_result
 
            func_arith $loop - 1
 
            loop=$func_arith_result
 
            verstring="$verstring:${iface}.0"
              done
              done
 
 
 
          # Make executables depend on our current version.
 
          verstring="$verstring:${current}.0"
 
          ;;
 
 
 
        qnx)
 
          major=".$current"
 
          versuffix=".$current"
 
          ;;
 
 
 
        sunos)
 
          major=".$current"
 
          versuffix=".$current.$revision"
 
          ;;
 
 
 
        windows)
 
          # Use '-' rather than '.', since we only want one
 
          # extension on DOS 8.3 filesystems.
 
          func_arith $current - $age
 
          major=$func_arith_result
 
          versuffix="-$major"
 
          ;;
 
 
 
        *)
 
          func_fatal_configuration "unknown library version type \`$version_type'"
 
          ;;
 
        esac
 
 
 
        # Clear the version info if we defaulted, and they specified a release.
 
        if test -z "$vinfo" && test -n "$release"; then
 
          major=
 
          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
            else
              output=
            versuffix=".0.0"
            fi
            fi
 
 
            if ${skipped_export-false}; then
 
              func_echo "generating symbol list for \`$libname.la'"
 
              export_symbols="$output_objdir/$libname.exp"
 
              $opt_dry_run || $RM $export_symbols
 
              libobjs=$output
 
              # Append the command to create the export file.
 
              test -z "$concat_cmds" || concat_cmds=$concat_cmds~
 
              eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\"
 
            fi
            fi
 
 
            test -n "$save_libobjs" &&
        # Remove version info from name if versioning should be avoided
              func_echo "creating a temporary reloadable object file: $output"
        if test "$avoid_version" = yes && test "$need_version" = no; then
 
          major=
 
          versuffix=
 
          verstring=""
 
        fi
 
 
            # Loop through the commands generated above and execute them.
        # Check to see if the archive will have undefined symbols.
            save_ifs="$IFS"; IFS='~'
        if test "$allow_undefined" = yes; then
            for cmd in $concat_cmds; do
          if test "$allow_undefined_flag" = unsupported; then
              IFS="$save_ifs"
            func_warning "undefined symbols not allowed in $host shared libraries"
              $opt_silent || {
            build_libtool_libs=no
                  func_quote_for_expand "$cmd"
            build_old_libs=yes
                  eval "func_echo $func_quote_for_expand_result"
          fi
              }
        else
              $opt_dry_run || eval "$cmd" || {
          # Don't allow undefined symbols.
                lt_exit=$?
          allow_undefined_flag="$no_undefined_flag"
 
        fi
 
 
                # Restore the uninstalled library and exit
 
                if test "$mode" = relink; then
 
                  ( cd "$output_objdir" && \
 
                    $RM "${realname}T" && \
 
                    $MV "${realname}U" "$realname" )
 
                fi
                fi
 
 
                exit $lt_exit
      func_generate_dlsyms "$libname" "$libname" "yes"
              }
      libobjs="$libobjs $symfileobj"
            done
      test "X$libobjs" = "X " && libobjs=
            IFS="$save_ifs"
 
 
 
            if test -n "$export_symbols_regex" && ${skipped_export-false}; then
      if test "$mode" != relink; then
              func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
        # Remove our outputs, but don't remove object files since they
              func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
        # may have been created when compiling PIC objects.
 
        removelist=
 
        tempremovelist=`$ECHO "$output_objdir/*"`
 
        for p in $tempremovelist; do
 
          case $p in
 
            *.$objext | *.gcno)
 
               ;;
 
            $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
 
               if test "X$precious_files_regex" != "X"; then
 
                 if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
 
                 then
 
                   continue
 
                 fi
            fi
            fi
 
               removelist="$removelist $p"
 
               ;;
 
            *) ;;
 
          esac
 
        done
 
        test -n "$removelist" && \
 
          func_show_eval "${RM}r \$removelist"
          fi
          fi
 
 
          if ${skipped_export-false}; then
      # Now set the variables for building old libraries.
            if test -n "$export_symbols" && test -n "$include_expsyms"; then
      if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
              tmp_export_symbols="$export_symbols"
        oldlibs="$oldlibs $output_objdir/$libname.$libext"
              test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
 
              $opt_dry_run || eval '$ECHO "X$include_expsyms" | $Xsed | $SP2NL >> "$tmp_export_symbols"'
        # Transform .lo files to .o files.
 
        oldobjs="$objs "`$ECHO "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
            fi
            fi
 
 
            if test -n "$orig_export_symbols"; then
      # Eliminate all temporary directories.
              # The given exports_symbols file has to be filtered, so filter it.
      #for path in $notinst_path; do
              func_echo "filter symbol list for \`$libname.la' to tag DATA exports"
      # lib_search_path=`$ECHO "X$lib_search_path " | $Xsed -e "s% $path % %g"`
              # FIXME: $output_objdir/$libname.filter potentially contains lots of
      # deplibs=`$ECHO "X$deplibs " | $Xsed -e "s% -L$path % %g"`
              # 's' commands which not all seds can handle. GNU sed should be fine
      # dependency_libs=`$ECHO "X$dependency_libs " | $Xsed -e "s% -L$path % %g"`
              # though. Also, the filter scales superlinearly with the number of
      #done
              # global variables. join(1) would be nice here, but unfortunately
 
              # isn't a blessed tool.
      if test -n "$xrpath"; then
              $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
        # If the user specified any rpath flags, then add them.
              delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"
        temp_xrpath=
              export_symbols=$output_objdir/$libname.def
        for libdir in $xrpath; do
              $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
          temp_xrpath="$temp_xrpath -R$libdir"
 
          case "$finalize_rpath " in
 
          *" $libdir "*) ;;
 
          *) finalize_rpath="$finalize_rpath $libdir" ;;
 
          esac
 
        done
 
        if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
 
          dependency_libs="$temp_xrpath $dependency_libs"
            fi
            fi
          fi
          fi
 
 
          libobjs=$output
      # Make sure dlfiles contains only unique files that won't be dlpreopened
          # Restore the value of output.
      old_dlfiles="$dlfiles"
          output=$save_output
      dlfiles=
 
      for lib in $old_dlfiles; do
 
        case " $dlprefiles $dlfiles " in
 
        *" $lib "*) ;;
 
        *) dlfiles="$dlfiles $lib" ;;
 
        esac
 
      done
 
 
          if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
      # Make sure dlprefiles contains only unique files
            eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
      old_dlprefiles="$dlprefiles"
            test "X$libobjs" = "X " && libobjs=
      dlprefiles=
 
      for lib in $old_dlprefiles; do
 
        case "$dlprefiles " in
 
        *" $lib "*) ;;
 
        *) dlprefiles="$dlprefiles $lib" ;;
 
        esac
 
      done
 
 
 
      if test "$build_libtool_libs" = yes; then
 
        if test -n "$rpath"; then
 
          case $host in
 
          *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc*)
 
            # these systems don't actually have a c library (as such)!
 
            ;;
 
          *-*-rhapsody* | *-*-darwin1.[012])
 
            # Rhapsody C library is in the System framework
 
            deplibs="$deplibs System.ltframework"
 
            ;;
 
          *-*-netbsd*)
 
            # Don't link with libc until the a.out ld.so is fixed.
 
            ;;
 
          *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
 
            # Do not include libc due to us having libc/libc_r.
 
            ;;
 
          *-*-sco3.2v5* | *-*-sco5v6*)
 
            # Causes problems with __ctype
 
            ;;
 
          *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
 
            # Compiler inserts libc in the correct place for threads to work
 
            ;;
 
          *)
 
            # Add libc to deplibs on all other systems if necessary.
 
            if test "$build_libtool_need_lc" = "yes"; then
 
              deplibs="$deplibs -lc"
 
            fi
 
            ;;
 
          esac
          fi
          fi
          # Expand the library linking commands again to reset the
 
          # value of $libobjs for piecewise linking.
 
 
 
          # Do each of the archive commands.
        # Transform deplibs into only deplibs that can be linked in shared.
          if test "$module" = yes && test -n "$module_cmds" ; then
        name_save=$name
            if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
        libname_save=$libname
              cmds=$module_expsym_cmds
        release_save=$release
 
        versuffix_save=$versuffix
 
        major_save=$major
 
        # I'm not sure if I'm treating the release correctly.  I think
 
        # release should show up in the -l (ie -lgmp5) so we don't want to
 
        # add it in twice.  Is that correct?
 
        release=""
 
        versuffix=""
 
        major=""
 
        newdeplibs=
 
        droppeddeps=no
 
        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
 
          # whether the library exists or not.  But this is on
 
          # osf3 & osf4 and I'm not really sure... Just
 
          # implementing what was already the behavior.
 
          newdeplibs=$deplibs
 
          ;;
 
        test_compile)
 
          # This code stresses the "libraries are programs" paradigm to its
 
          # limits. Maybe even breaks it.  We compile a program, linking it
 
          # against the deplibs as a proxy for the library.  Then we can check
 
          # whether they linked in statically or dynamically with ldd.
 
          $opt_dry_run || $RM conftest.c
 
          cat > conftest.c <<EOF
 
          int main() { return 0; }
 
EOF
 
          $opt_dry_run || $RM conftest
 
          if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then
 
            ldd_output=`ldd conftest`
 
            for i in $deplibs; do
 
              case $i in
 
              -l*)
 
                func_stripname -l '' "$i"
 
                name=$func_stripname_result
 
                if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
 
                  case " $predeps $postdeps " in
 
                  *" $i "*)
 
                    newdeplibs="$newdeplibs $i"
 
                    i=""
 
                    ;;
 
                  esac
 
                fi
 
                if test -n "$i" ; then
 
                  libname=`eval "\\$ECHO \"$libname_spec\""`
 
                  deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
 
                  set dummy $deplib_matches; shift
 
                  deplib_match=$1
 
                  if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
 
                    newdeplibs="$newdeplibs $i"
            else
            else
              cmds=$module_cmds
                    droppeddeps=yes
 
                    $ECHO
 
                    $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 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."
 
                  fi
 
                fi
 
                ;;
 
              *)
 
                newdeplibs="$newdeplibs $i"
 
                ;;
 
              esac
 
            done
 
          else
 
            # Error occurred in the first compile.  Let's try to salvage
 
            # the situation: Compile a separate program for each library.
 
            for i in $deplibs; do
 
              case $i in
 
              -l*)
 
                func_stripname -l '' "$i"
 
                name=$func_stripname_result
 
                $opt_dry_run || $RM conftest
 
                if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
 
                  ldd_output=`ldd conftest`
 
                  if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
 
                    case " $predeps $postdeps " in
 
                    *" $i "*)
 
                      newdeplibs="$newdeplibs $i"
 
                      i=""
 
                      ;;
 
                    esac
            fi
            fi
 
                  if test -n "$i" ; then
 
                    libname=`eval "\\$ECHO \"$libname_spec\""`
 
                    deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
 
                    set dummy $deplib_matches; shift
 
                    deplib_match=$1
 
                    if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
 
                      newdeplibs="$newdeplibs $i"
          else
          else
            if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
                      droppeddeps=yes
              cmds=$archive_expsym_cmds
                      $ECHO
            else
                      $ECHO "*** Warning: dynamic linker does not accept needed library $i."
              cmds=$archive_cmds
                      $ECHO "*** I have the capability to make that library automatically link in when"
            fi
                      $ECHO "*** you link to this library.  But I can only do this if you have a"
          fi
                      $ECHO "*** shared version of the library, which you do not appear to have"
        fi
                      $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."
        if test -n "$delfiles"; then
 
          # Append the command to remove temporary files to $cmds.
 
          eval cmds=\"\$cmds~\$RM $delfiles\"
 
        fi
        fi
 
 
        # Add any objects from preloaded convenience libraries
 
        if test -n "$dlprefiles"; then
 
          gentop="$output_objdir/${outputname}x"
 
          generated="$generated $gentop"
 
 
 
          func_extract_archives $gentop $dlprefiles
 
          libobjs="$libobjs $func_extract_archives_result"
 
          test "X$libobjs" = "X " && libobjs=
 
        fi
        fi
 
                else
        save_ifs="$IFS"; IFS='~'
                  droppeddeps=yes
        for cmd in $cmds; do
                  $ECHO
          IFS="$save_ifs"
                  $ECHO "*** Warning!  Library $i is needed by this library but I was not able to"
          eval cmd=\"$cmd\"
                  $ECHO "*** make it link in!  You will probably need to install it or some"
          $opt_silent || {
                  $ECHO "*** library that it depends on before this library will be fully"
            func_quote_for_expand "$cmd"
                  $ECHO "*** functional.  Installing it before continuing would be even better."
            eval "func_echo $func_quote_for_expand_result"
 
          }
 
          $opt_dry_run || eval "$cmd" || {
 
            lt_exit=$?
 
 
 
            # Restore the uninstalled library and exit
 
            if test "$mode" = relink; then
 
              ( cd "$output_objdir" && \
 
                $RM "${realname}T" && \
 
                $MV "${realname}U" "$realname" )
 
            fi
            fi
 
                ;;
            exit $lt_exit
              *)
          }
                newdeplibs="$newdeplibs $i"
 
                ;;
 
              esac
        done
        done
        IFS="$save_ifs"
 
 
 
        # Restore the uninstalled library and exit
 
        if test "$mode" = relink; then
 
          $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?
 
 
 
          if test -n "$convenience"; then
 
            if test -z "$whole_archive_flag_spec"; then
 
              func_show_eval '${RM}r "$gentop"'
 
            fi
            fi
 
          ;;
 
        file_magic*)
 
          set dummy $deplibs_check_method; shift
 
          file_magic_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
 
          for a_deplib in $deplibs; do
 
            case $a_deplib in
 
            -l*)
 
              func_stripname -l '' "$a_deplib"
 
              name=$func_stripname_result
 
              if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
 
                case " $predeps $postdeps " in
 
                *" $a_deplib "*)
 
                  newdeplibs="$newdeplibs $a_deplib"
 
                  a_deplib=""
 
                  ;;
 
                esac
          fi
          fi
 
              if test -n "$a_deplib" ; then
          exit $EXIT_SUCCESS
                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
 
                      # Follow soft links.
 
                      if ls -lLd "$potent_lib" 2>/dev/null |
 
                         $GREP " -> " >/dev/null; then
 
                        continue
        fi
        fi
 
                      # The statement above tries to avoid entering an
        # Create links to the real library.
                      # endless loop below, in case of cyclic links.
        for linkname in $linknames; do
                      # We might still enter an endless loop, since a link
          if test "$realname" != "$linkname"; then
                      # loop can be closed while we follow links,
            func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?'
                      # but so what?
 
                      potlib="$potent_lib"
 
                      while test -h "$potlib" 2>/dev/null; do
 
                        potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
 
                        case $potliblink in
 
                        [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
 
                        *) potlib=`$ECHO "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
 
                        esac
 
                      done
 
                      if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |
 
                         $SED -e 10q |
 
                         $EGREP "$file_magic_regex" > /dev/null; then
 
                        newdeplibs="$newdeplibs $a_deplib"
 
                        a_deplib=""
 
                        break 2
          fi
          fi
        done
        done
 
                done
        # If -module or -export-dynamic was specified, set the dlname.
 
        if test "$module" = yes || test "$export_dynamic" = yes; then
 
          # On all known operating systems, these are identical.
 
          dlname="$soname"
 
        fi
        fi
 
              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 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"
      fi
      fi
      ;;
 
 
 
    obj)
 
      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
 
        func_warning "\`-dlopen' is ignored for objects"
 
      fi
      fi
 
 
      test -n "$deplibs" && \
 
        func_warning "\`-l' and \`-L' are ignored for objects"
 
 
 
      test -n "$rpath" && \
 
        func_warning "\`-rpath' is ignored for objects"
 
 
 
      test -n "$xrpath" && \
 
        func_warning "\`-R' is ignored for objects"
 
 
 
      test -n "$vinfo" && \
 
        func_warning "\`-version-info' is ignored for objects"
 
 
 
      test -n "$release" && \
 
        func_warning "\`-release' is ignored for objects"
 
 
 
      case $output in
 
      *.lo)
 
        test -n "$objs$old_deplibs" && \
 
          func_fatal_error "cannot build library object \`$output' from non-libtool objects"
 
 
 
        libobj=$output
 
        func_lo2o "$libobj"
 
        obj=$func_lo2o_result
 
        ;;
        ;;
      *)
      *)
        libobj=
              # Add a -L argument.
        obj="$output"
              newdeplibs="$newdeplibs $a_deplib"
 
              ;;
 
            esac
 
          done # Gone through all deplibs.
 
          ;;
 
        match_pattern*)
 
          set dummy $deplibs_check_method; shift
 
          match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
 
          for a_deplib in $deplibs; do
 
            case $a_deplib in
 
            -l*)
 
              func_stripname -l '' "$a_deplib"
 
              name=$func_stripname_result
 
              if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
 
                case " $predeps $postdeps " in
 
                *" $a_deplib "*)
 
                  newdeplibs="$newdeplibs $a_deplib"
 
                  a_deplib=""
        ;;
        ;;
      esac
      esac
 
 
      # Delete the old objects.
 
      $opt_dry_run || $RM $obj $libobj
 
 
 
      # Objects from convenience libraries.  This assumes
 
      # single-version convenience libraries.  Whenever we create
 
      # different ones for PIC/non-PIC, this we'll have to duplicate
 
      # the extraction.
 
      reload_conv_objs=
 
      gentop=
 
      # reload_cmds runs $LD directly, so let us get rid of
 
      # -Wl from whole_archive_flag_spec and hope we can get by with
 
      # turning comma into space..
 
      wl=
 
 
 
      if test -n "$convenience"; then
 
        if test -n "$whole_archive_flag_spec"; then
 
          eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
 
          reload_conv_objs=$reload_objs\ `$ECHO "X$tmp_whole_archive_flags" | $Xsed -e 's|,| |g'`
 
        else
 
          gentop="$output_objdir/${obj}x"
 
          generated="$generated $gentop"
 
 
 
          func_extract_archives $gentop $convenience
 
          reload_conv_objs="$reload_objs $func_extract_archives_result"
 
        fi
        fi
 
              if test -n "$a_deplib" ; 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 \"X$potent_lib\"" 2>/dev/null | $Xsed -e 10q | \
 
                       $EGREP "$match_pattern_regex" > /dev/null; then
 
                      newdeplibs="$newdeplibs $a_deplib"
 
                      a_deplib=""
 
                      break 2
      fi
      fi
 
                  done
      # Create the old-style object.
                done
      reload_objs="$objs$old_deplibs "`$ECHO "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}$'/d' -e '/\.lib$/d' -e "$lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test
 
 
 
      output="$obj"
 
      func_execute_cmds "$reload_cmds" 'exit $?'
 
 
 
      # Exit if we aren't doing a library object file.
 
      if test -z "$libobj"; then
 
        if test -n "$gentop"; then
 
          func_show_eval '${RM}r "$gentop"'
 
        fi
        fi
 
              if test -n "$a_deplib" ; then
        exit $EXIT_SUCCESS
                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"
      fi
      fi
 
 
      if test "$build_libtool_libs" != yes; then
 
        if test -n "$gentop"; then
 
          func_show_eval '${RM}r "$gentop"'
 
        fi
        fi
 
              ;;
        # Create an invalid libtool object if no PIC, so that we don't
            *)
        # accidentally link it into a program.
              # Add a -L argument.
        # $show "echo timestamp > $libobj"
              newdeplibs="$newdeplibs $a_deplib"
        # $opt_dry_run || eval "echo timestamp > $libobj" || exit $?
              ;;
        exit $EXIT_SUCCESS
            esac
 
          done # Gone through all deplibs.
 
          ;;
 
        none | unknown | *)
 
          newdeplibs=""
 
          tmp_deplibs=`$ECHO "X $deplibs" | $Xsed \
 
              -e 's/ -lc$//' -e 's/ -[LR][^ ]*//g'`
 
          if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
 
            for i in $predeps $postdeps ; do
 
              # can't use Xsed below, because $i might contain '/'
 
              tmp_deplibs=`$ECHO "X $tmp_deplibs" | $Xsed -e "s,$i,,"`
 
            done
      fi
      fi
 
          if $ECHO "X $tmp_deplibs" | $Xsed -e 's/[      ]//g' |
      if test -n "$pic_flag" || test "$pic_mode" != default; then
             $GREP . >/dev/null; then
        # Only do commands if we really have different PIC objects.
            $ECHO
        reload_objs="$libobjs $reload_conv_objs"
            if test "X$deplibs_check_method" = "Xnone"; then
        output="$libobj"
              $ECHO "*** Warning: inter-library dependencies are not supported in this platform."
        func_execute_cmds "$reload_cmds" 'exit $?'
            else
 
              $ECHO "*** Warning: inter-library dependencies are not known to be supported."
      fi
      fi
 
            $ECHO "*** All declared inter-library dependencies are being dropped."
      if test -n "$gentop"; then
            droppeddeps=yes
        func_show_eval '${RM}r "$gentop"'
 
      fi
      fi
 
 
      exit $EXIT_SUCCESS
 
      ;;
      ;;
 
 
    prog)
 
      case $host in
 
        *cygwin*) func_stripname '' '.exe' "$output"
 
                  output=$func_stripname_result.exe;;
 
      esac
      esac
      test -n "$vinfo" && \
        versuffix=$versuffix_save
        func_warning "\`-version-info' is ignored for programs"
        major=$major_save
 
        release=$release_save
      test -n "$release" && \
        libname=$libname_save
        func_warning "\`-release' is ignored for programs"
        name=$name_save
 
 
      test "$preload" = yes \
 
        && test "$dlopen_support" = unknown \
 
        && test "$dlopen_self" = unknown \
 
        && test "$dlopen_self_static" = unknown && \
 
          func_warning "\`LT_INIT([dlopen])' not used. Assuming no dlopen support."
 
 
 
      case $host in
      case $host in
      *-*-rhapsody* | *-*-darwin1.[012])
      *-*-rhapsody* | *-*-darwin1.[012])
        # On Rhapsody replace the C library is the System framework
          # On Rhapsody replace the C library with the System framework
        compile_deplibs=`$ECHO "X $compile_deplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
          newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
        finalize_deplibs=`$ECHO "X $finalize_deplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
 
        ;;
        ;;
      esac
      esac
 
 
      case $host in
        if test "$droppeddeps" = yes; then
      *-*-darwin*)
          if test "$module" = yes; then
        # Don't allow lazy linking, it breaks C++ global constructors
            $ECHO
        # But is supposedly fixed on 10.4 or later (yay!).
            $ECHO "*** Warning: libtool could not satisfy all declared inter-library"
        if test "$tagname" = CXX ; then
            $ECHO "*** dependencies of module $libname.  Therefore, libtool will create"
          case ${MACOSX_DEPLOYMENT_TARGET-10.0} in
            $ECHO "*** a static module, that should work as long as the dlopening"
            10.[0123])
            $ECHO "*** application is linked with the -dlopen flag."
              compile_command="$compile_command ${wl}-bind_at_load"
            if test -z "$global_symbol_pipe"; then
              finalize_command="$finalize_command ${wl}-bind_at_load"
              $ECHO
            ;;
              $ECHO "*** However, this would only work if libtool was able to extract symbol"
          esac
              $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."
 
            fi
 
            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
 
            fi
 
          else
 
            $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
 
              fi
 
            fi
 
          fi
 
        fi
 
        # Done checking deplibs!
 
        deplibs=$newdeplibs
        fi
        fi
        # Time to change all our "foo.ltframework" stuff back to "-framework foo"
        # Time to change all our "foo.ltframework" stuff back to "-framework foo"
        compile_deplibs=`$ECHO "X $compile_deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
      case $host in
        finalize_deplibs=`$ECHO "X $finalize_deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
        *-*-darwin*)
 
          newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
 
          new_inherited_linker_flags=`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
 
          deplibs=`$ECHO "X $deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
        ;;
        ;;
      esac
      esac
 
 
 
 
      # move library search paths that coincide with paths to not yet
      # move library search paths that coincide with paths to not yet
      # installed libraries to the beginning of the library search list
      # installed libraries to the beginning of the library search list
      new_libs=
      new_libs=
      for path in $notinst_path; do
      for path in $notinst_path; do
        case " $new_libs " in
        case " $new_libs " in
        *" -L$path/$objdir "*) ;;
        *" -L$path/$objdir "*) ;;
        *)
        *)
          case " $compile_deplibs " in
          case " $deplibs " in
          *" -L$path/$objdir "*)
          *" -L$path/$objdir "*)
            new_libs="$new_libs -L$path/$objdir" ;;
            new_libs="$new_libs -L$path/$objdir" ;;
          esac
          esac
          ;;
          ;;
        esac
        esac
      done
      done
      for deplib in $compile_deplibs; do
      for deplib in $deplibs; do
        case $deplib in
        case $deplib in
        -L*)
        -L*)
          case " $new_libs " in
          case " $new_libs " in
          *" $deplib "*) ;;
          *" $deplib "*) ;;
          *) new_libs="$new_libs $deplib" ;;
          *) new_libs="$new_libs $deplib" ;;
          esac
          esac
          ;;
          ;;
        *) new_libs="$new_libs $deplib" ;;
        *) new_libs="$new_libs $deplib" ;;
        esac
        esac
      done
      done
      compile_deplibs="$new_libs"
      deplibs="$new_libs"
 
 
 
 
      compile_command="$compile_command $compile_deplibs"
 
      finalize_command="$finalize_command $finalize_deplibs"
 
 
 
      if test -n "$rpath$xrpath"; then
      # All the library-specific variables (install_libdir is set above).
        # If the user specified any rpath flags, then add them.
      library_names=
        for libdir in $rpath $xrpath; do
      old_library=
          # This is the magic to use -rpath.
      dlname=
          case "$finalize_rpath " in
 
          *" $libdir "*) ;;
 
          *) finalize_rpath="$finalize_rpath $libdir" ;;
 
          esac
 
        done
 
      fi
 
 
 
      # Now hardcode the library paths
      # Test again, we may have decided not to build it any more
      rpath=
      if test "$build_libtool_libs" = yes; then
 
        if test "$hardcode_into_libs" = yes; then
 
          # Hardcode the library paths
      hardcode_libdirs=
      hardcode_libdirs=
      for libdir in $compile_rpath $finalize_rpath; do
          dep_rpath=
 
          rpath="$finalize_rpath"
 
          test "$mode" != relink && rpath="$compile_rpath$rpath"
 
          for libdir in $rpath; do
        if test -n "$hardcode_libdir_flag_spec"; then
        if test -n "$hardcode_libdir_flag_spec"; then
          if test -n "$hardcode_libdir_separator"; then
          if test -n "$hardcode_libdir_separator"; then
            if test -z "$hardcode_libdirs"; then
            if test -z "$hardcode_libdirs"; then
              hardcode_libdirs="$libdir"
              hardcode_libdirs="$libdir"
            else
            else
Line 6085... Line 7058...
                ;;
                ;;
              esac
              esac
            fi
            fi
          else
          else
            eval flag=\"$hardcode_libdir_flag_spec\"
            eval flag=\"$hardcode_libdir_flag_spec\"
            rpath="$rpath $flag"
                dep_rpath="$dep_rpath $flag"
 
              fi
 
            elif test -n "$runpath_var"; then
 
              case "$perm_rpath " in
 
              *" $libdir "*) ;;
 
              *) perm_rpath="$perm_rpath $libdir" ;;
 
              esac
 
            fi
 
          done
 
          # Substitute the hardcoded libdirs into the rpath.
 
          if test -n "$hardcode_libdir_separator" &&
 
             test -n "$hardcode_libdirs"; then
 
            libdir="$hardcode_libdirs"
 
            if test -n "$hardcode_libdir_flag_spec_ld"; then
 
              eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\"
 
            else
 
              eval dep_rpath=\"$hardcode_libdir_flag_spec\"
 
            fi
 
          fi
 
          if test -n "$runpath_var" && test -n "$perm_rpath"; then
 
            # We should set the runpath_var.
 
            rpath=
 
            for dir in $perm_rpath; do
 
              rpath="$rpath$dir:"
 
            done
 
            eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
 
          fi
 
          test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
 
        fi
 
 
 
        shlibpath="$finalize_shlibpath"
 
        test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
 
        if test -n "$shlibpath"; then
 
          eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
 
        fi
 
 
 
        # Get the real and link names of the library.
 
        eval shared_ext=\"$shrext_cmds\"
 
        eval library_names=\"$library_names_spec\"
 
        set dummy $library_names
 
        shift
 
        realname="$1"
 
        shift
 
 
 
        if test -n "$soname_spec"; then
 
          eval soname=\"$soname_spec\"
 
        else
 
          soname="$realname"
 
        fi
 
        if test -z "$dlname"; then
 
          dlname=$soname
 
        fi
 
 
 
        lib="$output_objdir/$realname"
 
        linknames=
 
        for link
 
        do
 
          linknames="$linknames $link"
 
        done
 
 
 
        # Use standard objects if they are pic
 
        test -z "$pic_flag" && libobjs=`$ECHO "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
 
        test "X$libobjs" = "X " && libobjs=
 
 
 
        delfiles=
 
        if test -n "$export_symbols" && test -n "$include_expsyms"; then
 
          $opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"
 
          export_symbols="$output_objdir/$libname.uexp"
 
          delfiles="$delfiles $export_symbols"
 
        fi
 
 
 
        orig_export_symbols=
 
        case $host_os in
 
        cygwin* | mingw* | cegcc*)
 
          if test -n "$export_symbols" && test -z "$export_symbols_regex"; then
 
            # exporting using user supplied symfile
 
            if test "x`$SED 1q $export_symbols`" != xEXPORTS; then
 
              # and it's NOT already a .def file. Must figure out
 
              # which of the given symbols are data symbols and tag
 
              # them as such. So, trigger use of export_symbols_cmds.
 
              # export_symbols gets reassigned inside the "prepare
 
              # the list of exported symbols" if statement, so the
 
              # include_expsyms logic still works.
 
              orig_export_symbols="$export_symbols"
 
              export_symbols=
 
              always_export_symbols=yes
          fi
          fi
        elif test -n "$runpath_var"; then
 
          case "$perm_rpath " in
 
          *" $libdir "*) ;;
 
          *) perm_rpath="$perm_rpath $libdir" ;;
 
          esac
 
        fi
        fi
        case $host in
 
        *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
 
          testbindir=`${ECHO} "$libdir" | ${SED} -e 's*/lib$*/bin*'`
 
          case :$dllsearchpath: in
 
          *":$libdir:"*) ;;
 
          *) dllsearchpath="$dllsearchpath:$libdir";;
 
          esac
 
          case :$dllsearchpath: in
 
          *":$testbindir:"*) ;;
 
          *) dllsearchpath="$dllsearchpath:$testbindir";;
 
          esac
 
          ;;
          ;;
        esac
        esac
      done
 
      # Substitute the hardcoded libdirs into the rpath.
 
      if test -n "$hardcode_libdir_separator" &&
 
         test -n "$hardcode_libdirs"; then
 
        libdir="$hardcode_libdirs"
 
        eval rpath=\" $hardcode_libdir_flag_spec\"
 
      fi
 
      compile_rpath="$rpath"
 
 
 
      rpath=
        # Prepare the list of exported symbols
      hardcode_libdirs=
        if test -z "$export_symbols"; then
      for libdir in $finalize_rpath; do
          if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
        if test -n "$hardcode_libdir_flag_spec"; then
            func_verbose "generating symbol list for \`$libname.la'"
          if test -n "$hardcode_libdir_separator"; then
            export_symbols="$output_objdir/$libname.exp"
            if test -z "$hardcode_libdirs"; then
            $opt_dry_run || $RM $export_symbols
              hardcode_libdirs="$libdir"
            cmds=$export_symbols_cmds
 
            save_ifs="$IFS"; IFS='~'
 
            for cmd in $cmds; do
 
              IFS="$save_ifs"
 
              eval cmd=\"$cmd\"
 
              func_len " $cmd"
 
              len=$func_len_result
 
              if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
 
                func_show_eval "$cmd" 'exit $?'
 
                skipped_export=false
            else
            else
              # Just accumulate the unique libdirs.
                # The command line is too long to execute in one step.
              case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
                func_verbose "using reloadable object file for export list..."
              *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
                skipped_export=:
                ;;
                # Break out early, otherwise skipped_export may be
              *)
                # set to false by a later but shorter cmd.
                hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
                break
                ;;
 
              esac
 
            fi
            fi
          else
            done
            eval flag=\"$hardcode_libdir_flag_spec\"
            IFS="$save_ifs"
            rpath="$rpath $flag"
            if test -n "$export_symbols_regex" && test "X$skipped_export" != "X:"; then
 
              func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
 
              func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
          fi
          fi
        elif test -n "$runpath_var"; then
 
          case "$finalize_perm_rpath " in
 
          *" $libdir "*) ;;
 
          *) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
 
          esac
 
        fi
        fi
      done
 
      # Substitute the hardcoded libdirs into the rpath.
 
      if test -n "$hardcode_libdir_separator" &&
 
         test -n "$hardcode_libdirs"; then
 
        libdir="$hardcode_libdirs"
 
        eval rpath=\" $hardcode_libdir_flag_spec\"
 
      fi
      fi
      finalize_rpath="$rpath"
 
 
 
      if test -n "$libobjs" && test "$build_old_libs" = yes; then
        if test -n "$export_symbols" && test -n "$include_expsyms"; then
        # Transform all the library objects into standard objects.
          tmp_export_symbols="$export_symbols"
        compile_command=`$ECHO "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
          test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
        finalize_command=`$ECHO "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
          $opt_dry_run || eval '$ECHO "X$include_expsyms" | $Xsed | $SP2NL >> "$tmp_export_symbols"'
      fi
      fi
 
 
      func_generate_dlsyms "$outputname" "@PROGRAM@" "no"
        if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then
 
          # The given exports_symbols file has to be filtered, so filter it.
      # template prelinking step
          func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
      if test -n "$prelink_cmds"; then
          # FIXME: $output_objdir/$libname.filter potentially contains lots of
        func_execute_cmds "$prelink_cmds" 'exit $?'
          # 's' commands which not all seds can handle. GNU sed should be fine
 
          # though. Also, the filter scales superlinearly with the number of
 
          # global variables. join(1) would be nice here, but unfortunately
 
          # isn't a blessed tool.
 
          $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
 
          delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"
 
          export_symbols=$output_objdir/$libname.def
 
          $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
      fi
      fi
 
 
      wrappers_required=yes
        tmp_deplibs=
      case $host in
        for test_deplib in $deplibs; do
      *cygwin* | *mingw* )
          case " $convenience " in
        if test "$build_libtool_libs" != yes; then
          *" $test_deplib "*) ;;
          wrappers_required=no
 
        fi
 
        ;;
 
      *)
      *)
        if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
            tmp_deplibs="$tmp_deplibs $test_deplib"
          wrappers_required=no
 
        fi
 
        ;;
        ;;
      esac
      esac
      if test "$wrappers_required" = no; then
        done
        # Replace the output file specification.
        deplibs="$tmp_deplibs"
        compile_command=`$ECHO "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
 
        link_command="$compile_command$compile_rpath"
 
 
 
        # We have no uninstalled library dependencies, so finalize right now.
        if test -n "$convenience"; then
        exit_status=0
          if test -n "$whole_archive_flag_spec" &&
        func_show_eval "$link_command" 'exit_status=$?'
            test "$compiler_needs_object" = yes &&
 
            test -z "$libobjs"; then
 
            # extract the archives, so we have objects to list.
 
            # TODO: could optimize this to just extract one archive.
 
            whole_archive_flag_spec=
 
          fi
 
          if test -n "$whole_archive_flag_spec"; then
 
            save_libobjs=$libobjs
 
            eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
 
            test "X$libobjs" = "X " && libobjs=
 
          else
 
            gentop="$output_objdir/${outputname}x"
 
            generated="$generated $gentop"
 
 
        # Delete the generated files.
            func_extract_archives $gentop $convenience
        if test -f "$output_objdir/${outputname}S.${objext}"; then
            libobjs="$libobjs $func_extract_archives_result"
          func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"'
            test "X$libobjs" = "X " && libobjs=
 
          fi
        fi
        fi
 
 
        exit $exit_status
        if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
 
          eval flag=\"$thread_safe_flag_spec\"
 
          linker_flags="$linker_flags $flag"
      fi
      fi
 
 
      if test -n "$compile_shlibpath$finalize_shlibpath"; then
        # Make a backup of the uninstalled library when relinking
        compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
        if test "$mode" = relink; then
 
          $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?
 
        fi
 
 
 
        # Do each of the archive commands.
 
        if test "$module" = yes && test -n "$module_cmds" ; then
 
          if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
 
            eval test_cmds=\"$module_expsym_cmds\"
 
            cmds=$module_expsym_cmds
 
          else
 
            eval test_cmds=\"$module_cmds\"
 
            cmds=$module_cmds
 
          fi
 
        else
 
          if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
 
            eval test_cmds=\"$archive_expsym_cmds\"
 
            cmds=$archive_expsym_cmds
 
          else
 
            eval test_cmds=\"$archive_cmds\"
 
            cmds=$archive_cmds
      fi
      fi
      if test -n "$finalize_shlibpath"; then
 
        finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
 
      fi
      fi
 
 
      compile_var=
        if test "X$skipped_export" != "X:" &&
      finalize_var=
           func_len " $test_cmds" &&
      if test -n "$runpath_var"; then
           len=$func_len_result &&
        if test -n "$perm_rpath"; then
           test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
          # We should set the runpath_var.
          :
          rpath=
        else
          for dir in $perm_rpath; do
          # The command line is too long to link in one step, link piecewise
            rpath="$rpath$dir:"
          # or, if using GNU ld and skipped_export is not :, use a linker
 
          # script.
 
 
 
          # 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
 
          fi
 
          save_output=$output
 
          output_la=`$ECHO "X$output" | $Xsed -e "$basename"`
 
 
 
          # Clear the reloadable object creation command queue and
 
          # initialize k to one.
 
          test_cmds=
 
          concat_cmds=
 
          objlist=
 
          last_robj=
 
          k=1
 
 
 
          if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then
 
            output=${output_objdir}/${output_la}.lnkscript
 
            func_verbose "creating GNU ld script: $output"
 
            $ECHO 'INPUT (' > $output
 
            for obj in $save_libobjs
 
            do
 
              $ECHO "$obj" >> $output
          done
          done
          compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
            $ECHO ')' >> $output
 
            delfiles="$delfiles $output"
 
          elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then
 
            output=${output_objdir}/${output_la}.lnk
 
            func_verbose "creating linker input file list: $output"
 
            : > $output
 
            set x $save_libobjs
 
            shift
 
            firstobj=
 
            if test "$compiler_needs_object" = yes; then
 
              firstobj="$1 "
 
              shift
        fi
        fi
        if test -n "$finalize_perm_rpath"; then
            for obj
          # We should set the runpath_var.
            do
          rpath=
              $ECHO "$obj" >> $output
          for dir in $finalize_perm_rpath; do
 
            rpath="$rpath$dir:"
 
          done
          done
          finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
            delfiles="$delfiles $output"
 
            output=$firstobj\"$file_list_spec$output\"
 
          else
 
            if test -n "$save_libobjs"; then
 
              func_verbose "creating reloadable object files..."
 
              output=$output_objdir/$output_la-${k}.$objext
 
              eval test_cmds=\"$reload_cmds\"
 
              func_len " $test_cmds"
 
              len0=$func_len_result
 
              len=$len0
 
 
 
              # Loop over the list of objects to be linked.
 
              for obj in $save_libobjs
 
              do
 
                func_len " $obj"
 
                func_arith $len + $func_len_result
 
                len=$func_arith_result
 
                if test "X$objlist" = X ||
 
                   test "$len" -lt "$max_cmd_len"; then
 
                  func_append 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~\$RM $last_robj\"
        fi
        fi
 
                  last_robj=$output_objdir/$output_la-${k}.$objext
 
                  func_arith $k + 1
 
                  k=$func_arith_result
 
                  output=$output_objdir/$output_la-${k}.$objext
 
                  objlist=$obj
 
                  func_len " $last_robj"
 
                  func_arith $len0 + $func_len_result
 
                  len=$func_arith_result
      fi
      fi
 
              done
      if test "$no_install" = yes; then
              # Handle the remaining objects by creating one last
        # We don't need to create a wrapper script.
              # reloadable object file.  All subsequent reloadable object
        link_command="$compile_var$compile_command$compile_rpath"
              # files will link in the last one created.
        # Replace the output file specification.
              test -z "$concat_cmds" || concat_cmds=$concat_cmds~
        link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
              eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"
        # Delete the old output file.
              if test -n "$last_robj"; then
        $opt_dry_run || $RM $output
                eval concat_cmds=\"\${concat_cmds}~\$RM $last_robj\"
        # Link the executable and exit
 
        func_show_eval "$link_command" 'exit $?'
 
        exit $EXIT_SUCCESS
 
      fi
      fi
 
              delfiles="$delfiles $output"
 
 
      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"
 
 
 
        func_warning "this platform does not like uninstalled shared libraries"
 
        func_warning "\`$output' will be relinked during installation"
 
      else
 
        if test "$fast_install" != no; then
 
          link_command="$finalize_var$compile_command$finalize_rpath"
 
          if test "$fast_install" = yes; then
 
            relink_command=`$ECHO "X$compile_var$compile_command$compile_rpath" | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g'`
 
          else
          else
            # fast_install is set to needless
              output=
            relink_command=
 
          fi
          fi
        else
 
          link_command="$compile_var$compile_command$compile_rpath"
            if ${skipped_export-false}; then
          relink_command="$finalize_var$finalize_command$finalize_rpath"
              func_verbose "generating symbol list for \`$libname.la'"
 
              export_symbols="$output_objdir/$libname.exp"
 
              $opt_dry_run || $RM $export_symbols
 
              libobjs=$output
 
              # Append the command to create the export file.
 
              test -z "$concat_cmds" || concat_cmds=$concat_cmds~
 
              eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\"
 
              if test -n "$last_robj"; then
 
                eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"
        fi
        fi
      fi
      fi
 
 
      # Replace the output file specification.
            test -n "$save_libobjs" &&
      link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
              func_verbose "creating a temporary reloadable object file: $output"
 
 
      # Delete the old output files.
            # Loop through the commands generated above and execute them.
      $opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname
            save_ifs="$IFS"; IFS='~'
 
            for cmd in $concat_cmds; do
 
              IFS="$save_ifs"
 
              $opt_silent || {
 
                  func_quote_for_expand "$cmd"
 
                  eval "func_echo $func_quote_for_expand_result"
 
              }
 
              $opt_dry_run || eval "$cmd" || {
 
                lt_exit=$?
 
 
      func_show_eval "$link_command" 'exit $?'
                # Restore the uninstalled library and exit
 
                if test "$mode" = relink; then
 
                  ( cd "$output_objdir" && \
 
                    $RM "${realname}T" && \
 
                    $MV "${realname}U" "$realname" )
 
                fi
 
 
      # Now create the wrapper script.
                exit $lt_exit
      func_echo "creating $output"
              }
 
            done
 
            IFS="$save_ifs"
 
 
      # Quote the relink command for shipping.
            if test -n "$export_symbols_regex" && ${skipped_export-false}; then
      if test -n "$relink_command"; then
              func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
        # Preserve any variables that may affect compiler behavior
              func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
        for var in $variables_saved_for_relink; do
 
          if eval test -z \"\${$var+set}\"; then
 
            relink_command="{ test -z \"\${$var+set}\" || $lt_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
 
            func_quote_for_eval "$var_value"
 
            relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
 
          fi
          fi
        done
 
        relink_command="(cd `pwd`; $relink_command)"
 
        relink_command=`$ECHO "X$relink_command" | $Xsed -e "$sed_quote_subst"`
 
      fi
      fi
 
 
      # Quote $ECHO for shipping.
          if ${skipped_export-false}; then
      if test "X$ECHO" = "X$SHELL $progpath --fallback-echo"; then
            if test -n "$export_symbols" && test -n "$include_expsyms"; then
        case $progpath in
              tmp_export_symbols="$export_symbols"
        [\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $progpath --fallback-echo";;
              test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
        *) qecho="$SHELL `pwd`/$progpath --fallback-echo";;
              $opt_dry_run || eval '$ECHO "X$include_expsyms" | $Xsed | $SP2NL >> "$tmp_export_symbols"'
        esac
 
        qecho=`$ECHO "X$qecho" | $Xsed -e "$sed_quote_subst"`
 
      else
 
        qecho=`$ECHO "X$ECHO" | $Xsed -e "$sed_quote_subst"`
 
      fi
      fi
 
 
      # Only actually do things if not in dry run mode.
            if test -n "$orig_export_symbols"; then
      $opt_dry_run || {
              # The given exports_symbols file has to be filtered, so filter it.
        # win32 will think the script is a binary if it has
              func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
        # a .exe suffix, so we strip it off here.
              # FIXME: $output_objdir/$libname.filter potentially contains lots of
        case $output in
              # 's' commands which not all seds can handle. GNU sed should be fine
          *.exe) func_stripname '' '.exe' "$output"
              # though. Also, the filter scales superlinearly with the number of
                 output=$func_stripname_result ;;
              # global variables. join(1) would be nice here, but unfortunately
        esac
              # isn't a blessed tool.
        # test for cygwin because mv fails w/o .exe extensions
              $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
        case $host in
              delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"
          *cygwin*)
              export_symbols=$output_objdir/$libname.def
            exeext=.exe
              $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
            func_stripname '' '.exe' "$outputname"
            fi
            outputname=$func_stripname_result ;;
          fi
          *) exeext= ;;
 
        esac
 
        case $host in
 
          *cygwin* | *mingw* )
 
            output_name=`basename $output`
 
            output_path=`dirname $output`
 
            cwrappersource="$output_path/$objdir/lt-$output_name.c"
 
            cwrapper="$output_path/$output_name.exe"
 
            $RM $cwrappersource $cwrapper
 
            trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
 
 
 
            cat > $cwrappersource <<EOF
          libobjs=$output
 
          # Restore the value of output.
 
          output=$save_output
 
 
/* $cwrappersource - temporary wrapper executable for $objdir/$outputname
          if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
   Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
            eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
 
            test "X$libobjs" = "X " && libobjs=
 
          fi
 
          # Expand the library linking commands again to reset the
 
          # value of $libobjs for piecewise linking.
 
 
   The $output program cannot be directly executed until all the libtool
          # Do each of the archive commands.
   libraries that it depends on are installed.
          if test "$module" = yes && test -n "$module_cmds" ; then
 
            if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
 
              cmds=$module_expsym_cmds
 
            else
 
              cmds=$module_cmds
 
            fi
 
          else
 
            if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
 
              cmds=$archive_expsym_cmds
 
            else
 
              cmds=$archive_cmds
 
            fi
 
          fi
 
        fi
 
 
   This wrapper executable should never be moved out of the build directory.
        if test -n "$delfiles"; then
   If it is, it will not operate correctly.
          # Append the command to remove temporary files to $cmds.
 
          eval cmds=\"\$cmds~\$RM $delfiles\"
 
        fi
 
 
   Currently, it simply execs the wrapper *script* "/bin/sh $output",
        # Add any objects from preloaded convenience libraries
   but could eventually absorb all of the scripts functionality and
        if test -n "$dlprefiles"; then
   exec $objdir/$outputname directly.
          gentop="$output_objdir/${outputname}x"
*/
          generated="$generated $gentop"
EOF
 
            cat >> $cwrappersource<<"EOF"
 
#include <stdio.h>
 
#include <stdlib.h>
 
#include <unistd.h>
 
#include <malloc.h>
 
#include <stdarg.h>
 
#include <assert.h>
 
#include <string.h>
 
#include <ctype.h>
 
#include <sys/stat.h>
 
 
 
#if defined(PATH_MAX)
          func_extract_archives $gentop $dlprefiles
# define LT_PATHMAX PATH_MAX
          libobjs="$libobjs $func_extract_archives_result"
#elif defined(MAXPATHLEN)
          test "X$libobjs" = "X " && libobjs=
# define LT_PATHMAX MAXPATHLEN
        fi
#else
 
# define LT_PATHMAX 1024
 
#endif
 
 
 
#ifndef DIR_SEPARATOR
        save_ifs="$IFS"; IFS='~'
# define DIR_SEPARATOR '/'
        for cmd in $cmds; do
# define PATH_SEPARATOR ':'
          IFS="$save_ifs"
#endif
          eval cmd=\"$cmd\"
 
          $opt_silent || {
 
            func_quote_for_expand "$cmd"
 
            eval "func_echo $func_quote_for_expand_result"
 
          }
 
          $opt_dry_run || eval "$cmd" || {
 
            lt_exit=$?
 
 
#if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
            # Restore the uninstalled library and exit
  defined (__OS2__)
            if test "$mode" = relink; then
# define HAVE_DOS_BASED_FILE_SYSTEM
              ( cd "$output_objdir" && \
# ifndef DIR_SEPARATOR_2
                $RM "${realname}T" && \
#  define DIR_SEPARATOR_2 '\\'
                $MV "${realname}U" "$realname" )
# endif
            fi
# ifndef PATH_SEPARATOR_2
 
#  define PATH_SEPARATOR_2 ';'
 
# endif
 
#endif
 
 
 
#ifndef DIR_SEPARATOR_2
            exit $lt_exit
# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
          }
#else /* DIR_SEPARATOR_2 */
        done
# define IS_DIR_SEPARATOR(ch) \
        IFS="$save_ifs"
        (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
 
#endif /* DIR_SEPARATOR_2 */
 
 
 
#ifndef PATH_SEPARATOR_2
        # Restore the uninstalled library and exit
# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
        if test "$mode" = relink; then
#else /* PATH_SEPARATOR_2 */
          $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?
# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
 
#endif /* PATH_SEPARATOR_2 */
          if test -n "$convenience"; then
 
            if test -z "$whole_archive_flag_spec"; then
 
              func_show_eval '${RM}r "$gentop"'
 
            fi
 
          fi
 
 
#define XMALLOC(type, num)      ((type *) xmalloc ((num) * sizeof(type)))
          exit $EXIT_SUCCESS
#define XFREE(stale) do { \
        fi
  if (stale) { free ((void *) stale); stale = 0; } \
 
} while (0)
 
 
 
/* -DDEBUG is fairly common in CFLAGS.  */
        # Create links to the real library.
#undef DEBUG
        for linkname in $linknames; do
#if defined DEBUGWRAPPER
          if test "$realname" != "$linkname"; then
# define DEBUG(format, ...) fprintf(stderr, format, __VA_ARGS__)
            func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?'
#else
          fi
# define DEBUG(format, ...)
        done
#endif
 
 
 
const char *program_name = NULL;
        # If -module or -export-dynamic was specified, set the dlname.
 
        if test "$module" = yes || test "$export_dynamic" = yes; then
 
          # On all known operating systems, these are identical.
 
          dlname="$soname"
 
        fi
 
      fi
 
      ;;
 
 
void * xmalloc (size_t num);
    obj)
char * xstrdup (const char *string);
      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
const char * base_name (const char *name);
        func_warning "\`-dlopen' is ignored for objects"
char * find_executable(const char *wrapper);
      fi
int    check_executable(const char *path);
 
char * strendzap(char *str, const char *pat);
 
void lt_fatal (const char *message, ...);
 
 
 
int
      case " $deplibs" in
main (int argc, char *argv[])
      *\ -l* | *\ -L*)
{
        func_warning "\`-l' and \`-L' are ignored for objects" ;;
  char **newargz;
      esac
  int i;
 
 
 
  program_name = (char *) xstrdup (base_name (argv[0]));
      test -n "$rpath" && \
  DEBUG("(main) argv[0]      : %s\n",argv[0]);
        func_warning "\`-rpath' is ignored for objects"
  DEBUG("(main) program_name : %s\n",program_name);
 
  newargz = XMALLOC(char *, argc+2);
 
EOF
 
 
 
            cat >> $cwrappersource <<EOF
      test -n "$xrpath" && \
  newargz[0] = (char *) xstrdup("$SHELL");
        func_warning "\`-R' is ignored for objects"
EOF
 
 
 
            cat >> $cwrappersource <<"EOF"
      test -n "$vinfo" && \
  newargz[1] = find_executable(argv[0]);
        func_warning "\`-version-info' is ignored for objects"
  if (newargz[1] == NULL)
 
    lt_fatal("Couldn't find %s", argv[0]);
 
  DEBUG("(main) found exe at : %s\n",newargz[1]);
 
  /* we know the script has the same name, without the .exe */
 
  /* so make sure newargz[1] doesn't end in .exe */
 
  strendzap(newargz[1],".exe");
 
  for (i = 1; i < argc; i++)
 
    newargz[i+1] = xstrdup(argv[i]);
 
  newargz[argc+1] = NULL;
 
 
 
  for (i=0; i<argc+1; i++)
      test -n "$release" && \
  {
        func_warning "\`-release' is ignored for objects"
    DEBUG("(main) newargz[%d]   : %s\n",i,newargz[i]);
 
    ;
 
  }
 
 
 
EOF
      case $output in
 
      *.lo)
 
        test -n "$objs$old_deplibs" && \
 
          func_fatal_error "cannot build library object \`$output' from non-libtool objects"
 
 
            case $host_os in
        libobj=$output
              mingw*)
        func_lo2o "$libobj"
                cat >> $cwrappersource <<EOF
        obj=$func_lo2o_result
  execv("$SHELL",(char const **)newargz);
 
EOF
 
              ;;
              ;;
              *)
              *)
                cat >> $cwrappersource <<EOF
        libobj=
  execv("$SHELL",newargz);
        obj="$output"
EOF
 
              ;;
              ;;
            esac
            esac
 
 
            cat >> $cwrappersource <<"EOF"
      # Delete the old objects.
  return 127;
      $opt_dry_run || $RM $obj $libobj
}
 
 
 
void *
 
xmalloc (size_t num)
 
{
 
  void * p = (void *) malloc (num);
 
  if (!p)
 
    lt_fatal ("Memory exhausted");
 
 
 
  return p;
 
}
 
 
 
char *
 
xstrdup (const char *string)
 
{
 
  return string ? strcpy ((char *) xmalloc (strlen (string) + 1), string) : NULL
 
;
 
}
 
 
 
const char *
 
base_name (const char *name)
 
{
 
  const char *base;
 
 
 
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
      # Objects from convenience libraries.  This assumes
  /* Skip over the disk name in MSDOS pathnames. */
      # single-version convenience libraries.  Whenever we create
  if (isalpha ((unsigned char)name[0]) && name[1] == ':')
      # different ones for PIC/non-PIC, this we'll have to duplicate
    name += 2;
      # the extraction.
#endif
      reload_conv_objs=
 
      gentop=
 
      # reload_cmds runs $LD directly, so let us get rid of
 
      # -Wl from whole_archive_flag_spec and hope we can get by with
 
      # turning comma into space..
 
      wl=
 
 
  for (base = name; *name; name++)
      if test -n "$convenience"; then
    if (IS_DIR_SEPARATOR (*name))
        if test -n "$whole_archive_flag_spec"; then
      base = name + 1;
          eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
  return base;
          reload_conv_objs=$reload_objs\ `$ECHO "X$tmp_whole_archive_flags" | $Xsed -e 's|,| |g'`
}
        else
 
          gentop="$output_objdir/${obj}x"
 
          generated="$generated $gentop"
 
 
int
          func_extract_archives $gentop $convenience
check_executable(const char * path)
          reload_conv_objs="$reload_objs $func_extract_archives_result"
{
        fi
  struct stat st;
      fi
 
 
  DEBUG("(check_executable)  : %s\n", path ? (*path ? path : "EMPTY!") : "NULL!");
      # Create the old-style object.
  if ((!path) || (!*path))
      reload_objs="$objs$old_deplibs "`$ECHO "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}$'/d' -e '/\.lib$/d' -e "$lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test
    return 0;
 
 
 
  if ((stat (path, &st) >= 0) &&
      output="$obj"
      (
      func_execute_cmds "$reload_cmds" 'exit $?'
        /* MinGW & native WIN32 do not support S_IXOTH or S_IXGRP */
 
#if defined (S_IXOTH)
 
       ((st.st_mode & S_IXOTH) == S_IXOTH) ||
 
#endif
 
#if defined (S_IXGRP)
 
       ((st.st_mode & S_IXGRP) == S_IXGRP) ||
 
#endif
 
       ((st.st_mode & S_IXUSR) == S_IXUSR))
 
      )
 
    return 1;
 
  else
 
    return 0;
 
}
 
 
 
/* Searches for the full path of the wrapper.  Returns
      # Exit if we aren't doing a library object file.
   newly allocated full path name if found, NULL otherwise */
      if test -z "$libobj"; then
char *
        if test -n "$gentop"; then
find_executable (const char* wrapper)
          func_show_eval '${RM}r "$gentop"'
{
        fi
  int has_slash = 0;
 
  const char* p;
 
  const char* p_next;
 
  /* static buffer for getcwd */
 
  char tmp[LT_PATHMAX + 1];
 
  int tmp_len;
 
  char* concat_name;
 
 
 
  DEBUG("(find_executable)  : %s\n", wrapper ? (*wrapper ? wrapper : "EMPTY!") : "NULL!");
        exit $EXIT_SUCCESS
 
      fi
 
 
  if ((wrapper == NULL) || (*wrapper == '\0'))
      if test "$build_libtool_libs" != yes; then
    return NULL;
        if test -n "$gentop"; then
 
          func_show_eval '${RM}r "$gentop"'
 
        fi
 
 
  /* Absolute path? */
        # Create an invalid libtool object if no PIC, so that we don't
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
        # accidentally link it into a program.
  if (isalpha ((unsigned char)wrapper[0]) && wrapper[1] == ':')
        # $show "echo timestamp > $libobj"
  {
        # $opt_dry_run || eval "echo timestamp > $libobj" || exit $?
    concat_name = xstrdup (wrapper);
        exit $EXIT_SUCCESS
    if (check_executable(concat_name))
      fi
      return concat_name;
 
    XFREE(concat_name);
 
  }
 
  else
 
  {
 
#endif
 
    if (IS_DIR_SEPARATOR (wrapper[0]))
 
    {
 
      concat_name = xstrdup (wrapper);
 
      if (check_executable(concat_name))
 
        return concat_name;
 
      XFREE(concat_name);
 
    }
 
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
 
  }
 
#endif
 
 
 
  for (p = wrapper; *p; p++)
      if test -n "$pic_flag" || test "$pic_mode" != default; then
    if (*p == '/')
        # Only do commands if we really have different PIC objects.
    {
        reload_objs="$libobjs $reload_conv_objs"
      has_slash = 1;
        output="$libobj"
      break;
        func_execute_cmds "$reload_cmds" 'exit $?'
    }
      fi
  if (!has_slash)
 
  {
 
    /* no slashes; search PATH */
 
    const char* path = getenv ("PATH");
 
    if (path != NULL)
 
    {
 
      for (p = path; *p; p = p_next)
 
      {
 
        const char* q;
 
        size_t p_len;
 
        for (q = p; *q; q++)
 
          if (IS_PATH_SEPARATOR(*q))
 
            break;
 
        p_len = q - p;
 
        p_next = (*q == '\0' ? q : q + 1);
 
        if (p_len == 0)
 
        {
 
          /* empty path: current directory */
 
          if (getcwd (tmp, LT_PATHMAX) == NULL)
 
            lt_fatal ("getcwd failed");
 
          tmp_len = strlen(tmp);
 
          concat_name = XMALLOC(char, tmp_len + 1 + strlen(wrapper) + 1);
 
          memcpy (concat_name, tmp, tmp_len);
 
          concat_name[tmp_len] = '/';
 
          strcpy (concat_name + tmp_len + 1, wrapper);
 
        }
 
        else
 
        {
 
          concat_name = XMALLOC(char, p_len + 1 + strlen(wrapper) + 1);
 
          memcpy (concat_name, p, p_len);
 
          concat_name[p_len] = '/';
 
          strcpy (concat_name + p_len + 1, wrapper);
 
        }
 
        if (check_executable(concat_name))
 
          return concat_name;
 
        XFREE(concat_name);
 
      }
 
    }
 
    /* not found in PATH; assume curdir */
 
  }
 
  /* Relative path | not found in path: prepend cwd */
 
  if (getcwd (tmp, LT_PATHMAX) == NULL)
 
    lt_fatal ("getcwd failed");
 
  tmp_len = strlen(tmp);
 
  concat_name = XMALLOC(char, tmp_len + 1 + strlen(wrapper) + 1);
 
  memcpy (concat_name, tmp, tmp_len);
 
  concat_name[tmp_len] = '/';
 
  strcpy (concat_name + tmp_len + 1, wrapper);
 
 
 
  if (check_executable(concat_name))
      if test -n "$gentop"; then
    return concat_name;
        func_show_eval '${RM}r "$gentop"'
  XFREE(concat_name);
      fi
  return NULL;
 
}
 
 
 
char *
      exit $EXIT_SUCCESS
strendzap(char *str, const char *pat)
      ;;
{
 
  size_t len, patlen;
 
 
 
  assert(str != NULL);
    prog)
  assert(pat != NULL);
      case $host in
 
        *cygwin*) func_stripname '' '.exe' "$output"
 
                  output=$func_stripname_result.exe;;
 
      esac
 
      test -n "$vinfo" && \
 
        func_warning "\`-version-info' is ignored for programs"
 
 
  len = strlen(str);
      test -n "$release" && \
  patlen = strlen(pat);
        func_warning "\`-release' is ignored for programs"
 
 
  if (patlen <= len)
      test "$preload" = yes \
  {
        && test "$dlopen_support" = unknown \
    str += len - patlen;
        && test "$dlopen_self" = unknown \
    if (strcmp(str, pat) == 0)
        && test "$dlopen_self_static" = unknown && \
      *str = '\0';
          func_warning "\`LT_INIT([dlopen])' not used. Assuming no dlopen support."
  }
 
  return str;
 
}
 
 
 
static void
      case $host in
lt_error_core (int exit_status, const char * mode,
      *-*-rhapsody* | *-*-darwin1.[012])
          const char * message, va_list ap)
        # On Rhapsody replace the C library is the System framework
{
        compile_deplibs=`$ECHO "X $compile_deplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
  fprintf (stderr, "%s: %s: ", program_name, mode);
        finalize_deplibs=`$ECHO "X $finalize_deplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
  vfprintf (stderr, message, ap);
        ;;
  fprintf (stderr, ".\n");
      esac
 
 
  if (exit_status >= 0)
      case $host in
    exit (exit_status);
      *-*-darwin*)
}
        # Don't allow lazy linking, it breaks C++ global constructors
 
        # But is supposedly fixed on 10.4 or later (yay!).
 
        if test "$tagname" = CXX ; then
 
          case ${MACOSX_DEPLOYMENT_TARGET-10.0} in
 
            10.[0123])
 
              compile_command="$compile_command ${wl}-bind_at_load"
 
              finalize_command="$finalize_command ${wl}-bind_at_load"
 
            ;;
 
          esac
 
        fi
 
        # Time to change all our "foo.ltframework" stuff back to "-framework foo"
 
        compile_deplibs=`$ECHO "X $compile_deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
 
        finalize_deplibs=`$ECHO "X $finalize_deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
 
        ;;
 
      esac
 
 
void
 
lt_fatal (const char *message, ...)
      # move library search paths that coincide with paths to not yet
{
      # installed libraries to the beginning of the library search list
  va_list ap;
      new_libs=
  va_start (ap, message);
      for path in $notinst_path; do
  lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
        case " $new_libs " in
  va_end (ap);
        *" -L$path/$objdir "*) ;;
}
        *)
EOF
          case " $compile_deplibs " in
          # we should really use a build-platform specific compiler
          *" -L$path/$objdir "*)
          # here, but OTOH, the wrappers (shell script and this C one)
            new_libs="$new_libs -L$path/$objdir" ;;
          # are only useful if you want to execute the "real" binary.
          esac
          # Since the "real" binary is built for $host, then this
 
          # wrapper might as well be built for $host, too.
 
          $opt_dry_run || $LTCC $LTCFLAGS -s -o $cwrapper $cwrappersource
 
          ;;
          ;;
        esac
        esac
        $RM $output
      done
        trap "$RM $output; exit $EXIT_FAILURE" 1 2 15
      for deplib in $compile_deplibs; do
 
        case $deplib in
 
        -L*)
 
          case " $new_libs " in
 
          *" $deplib "*) ;;
 
          *) new_libs="$new_libs $deplib" ;;
 
          esac
 
          ;;
 
        *) new_libs="$new_libs $deplib" ;;
 
        esac
 
      done
 
      compile_deplibs="$new_libs"
 
 
        $ECHO > $output "\
 
#! $SHELL
 
 
 
# $output - temporary wrapper script for $objdir/$outputname
      compile_command="$compile_command $compile_deplibs"
# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
      finalize_command="$finalize_command $finalize_deplibs"
#
 
# The $output program cannot be directly executed until all the libtool
 
# libraries that it depends on are installed.
 
#
 
# This wrapper script should never be moved out of the build directory.
 
# If it is, it will not operate correctly.
 
 
 
# Sed substitution that helps us do robust quoting.  It backslashifies
      if test -n "$rpath$xrpath"; then
# metacharacters that are still active within double-quoted strings.
        # If the user specified any rpath flags, then add them.
Xsed='${SED} -e 1s/^X//'
        for libdir in $rpath $xrpath; do
sed_quote_subst='$sed_quote_subst'
          # This is the magic to use -rpath.
 
          case "$finalize_rpath " in
 
          *" $libdir "*) ;;
 
          *) finalize_rpath="$finalize_rpath $libdir" ;;
 
          esac
 
        done
 
      fi
 
 
# Be Bourne compatible
      # Now hardcode the library paths
if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
      rpath=
  emulate sh
      hardcode_libdirs=
  NULLCMD=:
      for libdir in $compile_rpath $finalize_rpath; do
  # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
        if test -n "$hardcode_libdir_flag_spec"; then
  # is contrary to our usage.  Disable this feature.
          if test -n "$hardcode_libdir_separator"; then
  alias -g '\${1+\"\$@\"}'='\"\$@\"'
            if test -z "$hardcode_libdirs"; then
  setopt NO_GLOB_SUBST
              hardcode_libdirs="$libdir"
else
else
  case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
              # Just accumulate the unique libdirs.
 
              case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
 
              *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
 
                ;;
 
              *)
 
                hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
 
                ;;
 
              esac
fi
fi
BIN_SH=xpg4; export BIN_SH # for Tru64
          else
DUALCASE=1; export DUALCASE # for MKS sh
            eval flag=\"$hardcode_libdir_flag_spec\"
 
            rpath="$rpath $flag"
# The HP-UX ksh and POSIX shell print the target directory to stdout
          fi
# if CDPATH is set.
        elif test -n "$runpath_var"; then
(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
          case "$perm_rpath " in
 
          *" $libdir "*) ;;
relink_command=\"$relink_command\"
          *) perm_rpath="$perm_rpath $libdir" ;;
 
          esac
 
        fi
 
        case $host in
 
        *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
 
          testbindir=`${ECHO} "$libdir" | ${SED} -e 's*/lib$*/bin*'`
 
          case :$dllsearchpath: in
 
          *":$libdir:"*) ;;
 
          ::) dllsearchpath=$libdir;;
 
          *) dllsearchpath="$dllsearchpath:$libdir";;
 
          esac
 
          case :$dllsearchpath: in
 
          *":$testbindir:"*) ;;
 
          ::) dllsearchpath=$testbindir;;
 
          *) dllsearchpath="$dllsearchpath:$testbindir";;
 
          esac
 
          ;;
 
        esac
 
      done
 
      # Substitute the hardcoded libdirs into the rpath.
 
      if test -n "$hardcode_libdir_separator" &&
 
         test -n "$hardcode_libdirs"; then
 
        libdir="$hardcode_libdirs"
 
        eval rpath=\" $hardcode_libdir_flag_spec\"
 
      fi
 
      compile_rpath="$rpath"
 
 
# This environment variable determines our operation mode.
      rpath=
if test \"\$libtool_install_magic\" = \"$magic\"; then
      hardcode_libdirs=
  # install mode needs the following variables:
      for libdir in $finalize_rpath; do
  generated_by_libtool_version='$macro_version'
        if test -n "$hardcode_libdir_flag_spec"; then
  notinst_deplibs='$notinst_deplibs'
          if test -n "$hardcode_libdir_separator"; then
 
            if test -z "$hardcode_libdirs"; then
 
              hardcode_libdirs="$libdir"
else
else
  # When we are sourced in execute mode, \$file and \$ECHO are already set.
              # Just accumulate the unique libdirs.
  if test \"\$libtool_execute_magic\" != \"$magic\"; then
              case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
    ECHO=\"$qecho\"
              *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
    file=\"\$0\"
                ;;
    # Make sure echo works.
              *)
    if test \"X\$1\" = X--no-reexec; then
                hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
      # Discard the --no-reexec flag, and continue.
                ;;
      shift
              esac
    elif test \"X\`{ \$ECHO '\t'; } 2>/dev/null\`\" = 'X\t'; then
            fi
      # Yippee, \$ECHO works!
 
      :
 
    else
    else
      # Restart under the correct shell, and then maybe \$ECHO will work.
            eval flag=\"$hardcode_libdir_flag_spec\"
      exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}
            rpath="$rpath $flag"
 
          fi
 
        elif test -n "$runpath_var"; then
 
          case "$finalize_perm_rpath " in
 
          *" $libdir "*) ;;
 
          *) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
 
          esac
 
        fi
 
      done
 
      # Substitute the hardcoded libdirs into the rpath.
 
      if test -n "$hardcode_libdir_separator" &&
 
         test -n "$hardcode_libdirs"; then
 
        libdir="$hardcode_libdirs"
 
        eval rpath=\" $hardcode_libdir_flag_spec\"
 
      fi
 
      finalize_rpath="$rpath"
 
 
 
      if test -n "$libobjs" && test "$build_old_libs" = yes; then
 
        # Transform all the library objects into standard objects.
 
        compile_command=`$ECHO "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
 
        finalize_command=`$ECHO "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
    fi
    fi
  fi\
 
"
 
        $ECHO >> $output "\
 
 
 
  # Find the directory that this script lives in.
      func_generate_dlsyms "$outputname" "@PROGRAM@" "no"
  thisdir=\`\$ECHO \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
 
  test \"x\$thisdir\" = \"x\$file\" && thisdir=.
 
 
 
  # Follow symbolic links until we get to the real thisdir.
      # template prelinking step
  file=\`ls -ld \"\$file\" | ${SED} -n 's/.*-> //p'\`
      if test -n "$prelink_cmds"; then
  while test -n \"\$file\"; do
        func_execute_cmds "$prelink_cmds" 'exit $?'
    destdir=\`\$ECHO \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
      fi
 
 
    # If there was a directory component, then change thisdir.
      wrappers_required=yes
    if test \"x\$destdir\" != \"x\$file\"; then
      case $host in
      case \"\$destdir\" in
      *cygwin* | *mingw* )
      [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
        if test "$build_libtool_libs" != yes; then
      *) thisdir=\"\$thisdir/\$destdir\" ;;
          wrappers_required=no
      esac
        fi
 
        ;;
 
      *cegcc)
 
        # Disable wrappers for cegcc, we are cross compiling anyway.
 
        wrappers_required=no
 
        ;;
 
      *)
 
        if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
 
          wrappers_required=no
    fi
    fi
 
        ;;
 
      esac
 
      if test "$wrappers_required" = no; then
 
        # Replace the output file specification.
 
        compile_command=`$ECHO "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
 
        link_command="$compile_command$compile_rpath"
 
 
    file=\`\$ECHO \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
        # We have no uninstalled library dependencies, so finalize right now.
    file=\`ls -ld \"\$thisdir/\$file\" | ${SED} -n 's/.*-> //p'\`
        exit_status=0
  done
        func_show_eval "$link_command" 'exit_status=$?'
 
 
  # Try to get the absolute directory name.
        # Delete the generated files.
  absdir=\`cd \"\$thisdir\" && pwd\`
        if test -f "$output_objdir/${outputname}S.${objext}"; then
  test -n \"\$absdir\" && thisdir=\"\$absdir\"
          func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"'
"
        fi
 
 
        if test "$fast_install" = yes; then
        exit $exit_status
          $ECHO >> $output "\
      fi
  program=lt-'$outputname'$exeext
 
  progdir=\"\$thisdir/$objdir\"
 
 
 
  if test ! -f \"\$progdir/\$program\" ||
      if test -n "$compile_shlibpath$finalize_shlibpath"; then
     { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
        compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
       test \"X\$file\" != \"X\$progdir/\$program\"; }; then
      fi
 
      if test -n "$finalize_shlibpath"; then
 
        finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
 
      fi
 
 
    file=\"\$\$-\$program\"
      compile_var=
 
      finalize_var=
 
      if test -n "$runpath_var"; then
 
        if test -n "$perm_rpath"; then
 
          # We should set the runpath_var.
 
          rpath=
 
          for dir in $perm_rpath; do
 
            rpath="$rpath$dir:"
 
          done
 
          compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
 
        fi
 
        if test -n "$finalize_perm_rpath"; then
 
          # We should set the runpath_var.
 
          rpath=
 
          for dir in $finalize_perm_rpath; do
 
            rpath="$rpath$dir:"
 
          done
 
          finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
 
        fi
 
      fi
 
 
    if test ! -d \"\$progdir\"; then
      if test "$no_install" = yes; then
      $MKDIR \"\$progdir\"
        # We don't need to create a wrapper script.
    else
        link_command="$compile_var$compile_command$compile_rpath"
      $RM \"\$progdir/\$file\"
        # Replace the output file specification.
    fi"
        link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
 
        # Delete the old output file.
 
        $opt_dry_run || $RM $output
 
        # Link the executable and exit
 
        func_show_eval "$link_command" 'exit $?'
 
        exit $EXIT_SUCCESS
 
      fi
 
 
          $ECHO >> $output "\
      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"
 
 
    # relink executable if necessary
        func_warning "this platform does not like uninstalled shared libraries"
    if test -n \"\$relink_command\"; then
        func_warning "\`$output' will be relinked during installation"
      if relink_command_output=\`eval \$relink_command 2>&1\`; then :
 
      else
      else
        $ECHO \"\$relink_command_output\" >&2
        if test "$fast_install" != no; then
        $RM \"\$progdir/\$file\"
          link_command="$finalize_var$compile_command$finalize_rpath"
        exit 1
          if test "$fast_install" = yes; then
      fi
            relink_command=`$ECHO "X$compile_var$compile_command$compile_rpath" | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g'`
 
          else
 
            # fast_install is set to needless
 
            relink_command=
    fi
    fi
 
 
    $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
 
    { $RM \"\$progdir/\$program\";
 
      $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
 
    $RM \"\$progdir/\$file\"
 
  fi"
 
        else
        else
          $ECHO >> $output "\
          link_command="$compile_var$compile_command$compile_rpath"
  program='$outputname'
          relink_command="$finalize_var$finalize_command$finalize_rpath"
  progdir=\"\$thisdir/$objdir\"
        fi
"
 
        fi
        fi
 
 
        $ECHO >> $output "\
      # Replace the output file specification.
 
      link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
 
 
  if test -f \"\$progdir/\$program\"; then"
      # Delete the old output files.
 
      $opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname
 
 
        # Export our shlibpath_var if we have one.
      func_show_eval "$link_command" 'exit $?'
        if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
 
          $ECHO >> $output "\
 
    # Add our own library path to $shlibpath_var
 
    $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
 
 
 
    # Some systems cannot cope with colon-terminated $shlibpath_var
      # Now create the wrapper script.
    # The second colon is a workaround for a bug in BeOS R4 sed
      func_verbose "creating $output"
    $shlibpath_var=\`\$ECHO \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`
 
 
 
    export $shlibpath_var
      # 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}\" || $lt_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
 
            func_quote_for_eval "$var_value"
 
            relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
 
          fi
 
        done
 
        relink_command="(cd `pwd`; $relink_command)"
 
        relink_command=`$ECHO "X$relink_command" | $Xsed -e "$sed_quote_subst"`
        fi
        fi
 
 
        # fixup the dll searchpath if we need to.
      # Quote $ECHO for shipping.
        if test -n "$dllsearchpath"; then
      if test "X$ECHO" = "X$SHELL $progpath --fallback-echo"; then
          $ECHO >> $output "\
        case $progpath in
    # Add the dll search path components to the executable PATH
        [\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $progpath --fallback-echo";;
    PATH=$dllsearchpath:\$PATH
        *) qecho="$SHELL `pwd`/$progpath --fallback-echo";;
"
        esac
 
        qecho=`$ECHO "X$qecho" | $Xsed -e "$sed_quote_subst"`
 
      else
 
        qecho=`$ECHO "X$ECHO" | $Xsed -e "$sed_quote_subst"`
        fi
        fi
 
 
        $ECHO >> $output "\
      # Only actually do things if not in dry run mode.
    if test \"\$libtool_execute_magic\" != \"$magic\"; then
      $opt_dry_run || {
      # Run the actual program with our arguments.
        # win32 will think the script is a binary if it has
"
        # a .exe suffix, so we strip it off here.
 
        case $output in
 
          *.exe) func_stripname '' '.exe' "$output"
 
                 output=$func_stripname_result ;;
 
        esac
 
        # test for cygwin because mv fails w/o .exe extensions
        case $host in
        case $host in
        # Backslashes separate directories on plain windows
          *cygwin*)
        *-*-mingw | *-*-os2*)
            exeext=.exe
          $ECHO >> $output "\
            func_stripname '' '.exe' "$outputname"
      exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
            outputname=$func_stripname_result ;;
"
          *) exeext= ;;
          ;;
 
 
 
        *)
 
          $ECHO >> $output "\
 
      exec \"\$progdir/\$program\" \${1+\"\$@\"}
 
"
 
          ;;
 
        esac
        esac
        $ECHO >> $output "\
        case $host in
      \$ECHO \"\$0: cannot exec \$program \$*\"
          *cygwin* | *mingw* )
      exit 1
            func_dirname_and_basename "$output" "" "."
    fi
            output_name=$func_basename_result
 
            output_path=$func_dirname_result
 
            cwrappersource="$output_path/$objdir/lt-$output_name.c"
 
            cwrapper="$output_path/$output_name.exe"
 
            $RM $cwrappersource $cwrapper
 
            trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
 
 
 
            func_emit_cwrapperexe_src > $cwrappersource
 
 
 
            # The wrapper executable is built using the $host compiler,
 
            # because it contains $host paths and files. If cross-
 
            # compiling, it, like the target executable, must be
 
            # executed on the $host or under an emulation environment.
 
            $opt_dry_run || {
 
              $LTCC $LTCFLAGS -o $cwrapper $cwrappersource
 
              $STRIP $cwrapper
 
            }
 
 
 
            # Now, create the wrapper script for func_source use:
 
            func_ltwrapper_scriptname $cwrapper
 
            $RM $func_ltwrapper_scriptname_result
 
            trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15
 
            $opt_dry_run || {
 
              # note: this script will not be executed, so do not chmod.
 
              if test "x$build" = "x$host" ; then
 
                $cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result
  else
  else
    # The program doesn't exist.
                func_emit_wrapper no > $func_ltwrapper_scriptname_result
    \$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
 
    \$ECHO \"This script is just a wrapper for \$program.\" 1>&2
 
    $ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
 
    exit 1
 
  fi
  fi
fi\
            }
"
          ;;
 
          * )
 
            $RM $output
 
            trap "$RM $output; exit $EXIT_FAILURE" 1 2 15
 
 
 
            func_emit_wrapper no > $output
        chmod +x $output
        chmod +x $output
 
          ;;
 
        esac
      }
      }
      exit $EXIT_SUCCESS
      exit $EXIT_SUCCESS
      ;;
      ;;
    esac
    esac
 
 
Line 6938... Line 8099...
            *[\ /]"$objbase "*)
            *[\ /]"$objbase "*)
              while :; do
              while :; do
                # Make sure we don't pick an alternate name that also
                # Make sure we don't pick an alternate name that also
                # overlaps.
                # overlaps.
                newobj=lt$counter-$objbase
                newobj=lt$counter-$objbase
                counter=`expr $counter + 1`
                func_arith $counter + 1
 
                counter=$func_arith_result
                case " $oldobjs " in
                case " $oldobjs " in
                *[\ /]"$newobj "*) ;;
                *[\ /]"$newobj "*) ;;
                *) if test ! -f "$gentop/$newobj"; then break; fi ;;
                *) if test ! -f "$gentop/$newobj"; then break; fi ;;
                esac
                esac
              done
              done
Line 6953... Line 8115...
            esac
            esac
          done
          done
        fi
        fi
        eval cmds=\"$old_archive_cmds\"
        eval cmds=\"$old_archive_cmds\"
 
 
        if len=`expr "X$cmds" : ".*" 2>/dev/null` &&
        func_len " $cmds"
           test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
        len=$func_len_result
 
        if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
          cmds=$old_archive_cmds
          cmds=$old_archive_cmds
        else
        else
          # the command line is too long to link in one step, link in parts
          # the command line is too long to link in one step, link in parts
          func_echo "using piecewise archive linking..."
          func_verbose "using piecewise archive linking..."
          save_RANLIB=$RANLIB
          save_RANLIB=$RANLIB
          RANLIB=:
          RANLIB=:
          objlist=
          objlist=
          concat_cmds=
          concat_cmds=
          save_oldobjs=$oldobjs
          save_oldobjs=$oldobjs
 
          oldobjs=
          # Is there a better way of finding the last object in the list?
          # Is there a better way of finding the last object in the list?
          for obj in $save_oldobjs
          for obj in $save_oldobjs
          do
          do
            last_oldobj=$obj
            last_oldobj=$obj
          done
          done
 
          eval test_cmds=\"$old_archive_cmds\"
 
          func_len " $test_cmds"
 
          len0=$func_len_result
 
          len=$len0
          for obj in $save_oldobjs
          for obj in $save_oldobjs
          do
          do
            oldobjs="$objlist $obj"
            func_len " $obj"
            objlist="$objlist $obj"
            func_arith $len + $func_len_result
            eval test_cmds=\"$old_archive_cmds\"
            len=$func_arith_result
            if len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
            func_append objlist " $obj"
               test "$len" -le "$max_cmd_len"; then
            if test "$len" -lt "$max_cmd_len"; then
              :
              :
            else
            else
              # the above command should be used before it gets too long
              # the above command should be used before it gets too long
              oldobjs=$objlist
              oldobjs=$objlist
              if test "$obj" = "$last_oldobj" ; then
              if test "$obj" = "$last_oldobj" ; then
                RANLIB=$save_RANLIB
                RANLIB=$save_RANLIB
              fi
              fi
              test -z "$concat_cmds" || concat_cmds=$concat_cmds~
              test -z "$concat_cmds" || concat_cmds=$concat_cmds~
              eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
              eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
              objlist=
              objlist=
 
              len=$len0
            fi
            fi
          done
          done
          RANLIB=$save_RANLIB
          RANLIB=$save_RANLIB
          oldobjs=$objlist
          oldobjs=$objlist
          if test "X$oldobjs" = "X" ; then
          if test "X$oldobjs" = "X" ; then
Line 7008... Line 8177...
    # Now create the libtool archive.
    # Now create the libtool archive.
    case $output in
    case $output in
    *.la)
    *.la)
      old_library=
      old_library=
      test "$build_old_libs" = yes && old_library="$libname.$libext"
      test "$build_old_libs" = yes && old_library="$libname.$libext"
      func_echo "creating $output"
      func_verbose "creating $output"
 
 
      # Preserve any variables that may affect compiler behavior
      # Preserve any variables that may affect compiler behavior
      for var in $variables_saved_for_relink; do
      for var in $variables_saved_for_relink; do
        if eval test -z \"\${$var+set}\"; then
        if eval test -z \"\${$var+set}\"; then
          relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
          relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
Line 7108... Line 8277...
            done
            done
            dlprefiles="$newdlprefiles"
            dlprefiles="$newdlprefiles"
          fi
          fi
          $RM $output
          $RM $output
          # place dlname in correct position for cygwin
          # place dlname in correct position for cygwin
 
          # In fact, it would be nice if we could use this code for all target
 
          # systems that can't hard-code library paths into their executables
 
          # and that have no shared library path variable independent of PATH,
 
          # but it turns out we can't easily determine that from inspecting
 
          # libtool variables, so we have to hard-code the OSs to which it
 
          # applies here; at the moment, that means platforms that use the PE
 
          # object format with DLL files.  See the long comment at the top of
 
          # tests/bindir.at for full details.
          tdlname=$dlname
          tdlname=$dlname
          case $host,$output,$installed,$module,$dlname in
          case $host,$output,$installed,$module,$dlname in
            *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll) tdlname=../bin/$dlname ;;
            *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll)
 
              # If a -bindir argument was supplied, place the dll there.
 
              if test "x$bindir" != x ;
 
              then
 
                func_relative_path "$install_libdir" "$bindir"
 
                tdlname=$func_relative_path_result$dlname
 
              else
 
                # Otherwise fall back on heuristic.
 
                tdlname=../bin/$dlname
 
              fi
 
              ;;
          esac
          esac
          $ECHO > $output "\
          $ECHO > $output "\
# $outputname - a libtool library file
# $outputname - a libtool library file
# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
#
#
Line 7309... Line 8496...
            rmfiles="$rmfiles $file"
            rmfiles="$rmfiles $file"
            ;;
            ;;
          esac
          esac
          # Do a test to see if this is a libtool program.
          # Do a test to see if this is a libtool program.
          if func_ltwrapper_p "$file"; then
          if func_ltwrapper_p "$file"; then
 
            if func_ltwrapper_executable_p "$file"; then
 
              func_ltwrapper_scriptname "$file"
 
              relink_command=
 
              func_source $func_ltwrapper_scriptname_result
 
              rmfiles="$rmfiles $func_ltwrapper_scriptname_result"
 
            else
            relink_command=
            relink_command=
            func_source $dir/$noexename
            func_source $dir/$noexename
 
            fi
 
 
            # note $name still contains .exe if it was in $file originally
            # note $name still contains .exe if it was in $file originally
            # as does the version of $file that was added into $rmfiles
            # as does the version of $file that was added into $rmfiles
            rmfiles="$rmfiles $objdir/$name $objdir/${name}S.${objext}"
            rmfiles="$rmfiles $objdir/$name $objdir/${name}S.${objext}"
            if test "$fast_install" = yes && test -n "$relink_command"; then
            if test "$fast_install" = yes && test -n "$relink_command"; then

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.