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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [newlib-1.10.0/] [ltmain.sh] - Diff between revs 1005 and 1765

Only display areas with differences | Details | Blame | View Log

Rev 1005 Rev 1765
# ltmain.sh - Provide generalized library-building support services.
# ltmain.sh - Provide generalized library-building support services.
# NOTE: Changing this file will not affect anything until you rerun ltconfig.
# NOTE: Changing this file will not affect anything until you rerun ltconfig.
#
#
# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001
# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001
# Free Software Foundation, Inc.
# Free Software Foundation, Inc.
# Originally by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
# Originally by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
#
#
# This program is free software; you can redistribute it and/or modify
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# 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
# This program 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 this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#
#
# As a special exception to the GNU General Public License, if you
# As a special exception to the GNU General Public License, if you
# distribute this file as part of a program that contains a
# distribute this file as part of a program that contains a
# configuration script generated by Autoconf, you may include it under
# configuration script generated by Autoconf, you may include it under
# the same distribution terms that you use for the rest of that program.
# the same distribution terms that you use for the rest of that program.
 
 
# Check that we have a working $echo.
# Check that we have a working $echo.
if test "X$1" = X--no-reexec; then
if test "X$1" = X--no-reexec; then
  # Discard the --no-reexec flag, and continue.
  # Discard the --no-reexec flag, and continue.
  shift
  shift
elif test "X$1" = X--fallback-echo; then
elif test "X$1" = X--fallback-echo; then
  # Avoid inline document here, it may be left over
  # Avoid inline document here, it may be left over
  :
  :
elif test "X`($echo '\t') 2>/dev/null`" = 'X\t'; then
elif test "X`($echo '\t') 2>/dev/null`" = 'X\t'; then
  # Yippee, $echo works!
  # Yippee, $echo works!
  :
  :
else
else
  # Restart under the correct shell, and then maybe $echo will work.
  # Restart under the correct shell, and then maybe $echo will work.
  exec $SHELL "$0" --no-reexec ${1+"$@"}
  exec $SHELL "$0" --no-reexec ${1+"$@"}
fi
fi
 
 
if test "X$1" = X--fallback-echo; then
if test "X$1" = X--fallback-echo; then
  # used as fallback echo
  # used as fallback echo
  shift
  shift
  cat <<EOF
  cat <<EOF
$*
$*
EOF
EOF
  exit 0
  exit 0
fi
fi
 
 
# The name of this program.
# The name of this program.
progname=`$echo "$0" | sed 's%^.*/%%'`
progname=`$echo "$0" | sed 's%^.*/%%'`
modename="$progname"
modename="$progname"
 
 
# Constants.
# Constants.
PROGRAM=ltmain.sh
PROGRAM=ltmain.sh
PACKAGE=libtool
PACKAGE=libtool
VERSION=1.4a-GCC3.0
VERSION=1.4a-GCC3.0
TIMESTAMP=" (1.641.2.256 2001/05/28 20:09:07 with GCC-local changes)"
TIMESTAMP=" (1.641.2.256 2001/05/28 20:09:07 with GCC-local changes)"
 
 
default_mode=
default_mode=
help="Try \`$progname --help' for more information."
help="Try \`$progname --help' for more information."
magic="%%%MAGIC variable%%%"
magic="%%%MAGIC variable%%%"
mkdir="mkdir"
mkdir="mkdir"
mv="mv -f"
mv="mv -f"
rm="rm -f"
rm="rm -f"
 
 
# Sed substitution that helps us do robust quoting.  It backslashifies
# Sed substitution that helps us do robust quoting.  It backslashifies
# metacharacters that are still active within double-quoted strings.
# metacharacters that are still active within double-quoted strings.
Xsed='sed -e 1s/^X//'
Xsed='sed -e 1s/^X//'
sed_quote_subst='s/\([\\`\\"$\\\\]\)/\\\1/g'
sed_quote_subst='s/\([\\`\\"$\\\\]\)/\\\1/g'
SP2NL='tr \040 \012'
SP2NL='tr \040 \012'
NL2SP='tr \015\012 \040\040'
NL2SP='tr \015\012 \040\040'
 
 
# NLS nuisances.
# NLS nuisances.
# 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).
# We save the old values to restore during execute mode.
# We save the old values to restore during execute mode.
if test "${LC_ALL+set}" = set; then
if test "${LC_ALL+set}" = set; then
  save_LC_ALL="$LC_ALL"; LC_ALL=C; export LC_ALL
  save_LC_ALL="$LC_ALL"; LC_ALL=C; export LC_ALL
fi
fi
if test "${LANG+set}" = set; then
if test "${LANG+set}" = set; then
  save_LANG="$LANG"; LANG=C; export LANG
  save_LANG="$LANG"; LANG=C; export LANG
fi
fi
 
 
if test "$LTCONFIG_VERSION" != "$VERSION"; then
if test "$LTCONFIG_VERSION" != "$VERSION"; then
  echo "$modename: ltconfig version \`$LTCONFIG_VERSION' does not match $PROGRAM version \`$VERSION'" 1>&2
  echo "$modename: ltconfig version \`$LTCONFIG_VERSION' does not match $PROGRAM version \`$VERSION'" 1>&2
  echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
  echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
  exit 1
  exit 1
fi
fi
 
 
if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
  echo "$modename: not configured to build any kind of library" 1>&2
  echo "$modename: not configured to build any kind of library" 1>&2
  echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
  echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
  exit 1
  exit 1
fi
fi
 
 
# Global variables.
# Global variables.
mode=$default_mode
mode=$default_mode
nonopt=
nonopt=
prev=
prev=
prevopt=
prevopt=
run=
run=
show="$echo"
show="$echo"
show_help=
show_help=
execute_dlfiles=
execute_dlfiles=
lo2o="s/\\.lo\$/.${objext}/"
lo2o="s/\\.lo\$/.${objext}/"
o2lo="s/\\.${objext}\$/.lo/"
o2lo="s/\\.${objext}\$/.lo/"
 
 
# Parse our command line options once, thoroughly.
# Parse our command line options once, thoroughly.
while test $# -gt 0
while test $# -gt 0
do
do
  arg="$1"
  arg="$1"
  shift
  shift
 
 
  case $arg in
  case $arg in
  -*=*) optarg=`$echo "X$arg" | $Xsed -e 's/[-_a-zA-Z0-9]*=//'` ;;
  -*=*) optarg=`$echo "X$arg" | $Xsed -e 's/[-_a-zA-Z0-9]*=//'` ;;
  *) optarg= ;;
  *) optarg= ;;
  esac
  esac
 
 
  # If the previous option needs an argument, assign it.
  # If the previous option needs an argument, assign it.
  if test -n "$prev"; then
  if test -n "$prev"; then
    case $prev in
    case $prev in
    execute_dlfiles)
    execute_dlfiles)
      execute_dlfiles="$execute_dlfiles $arg"
      execute_dlfiles="$execute_dlfiles $arg"
      ;;
      ;;
    tag)
    tag)
      tagname="$arg"
      tagname="$arg"
 
 
      # Check whether tagname contains only valid characters
      # Check whether tagname contains only valid characters
      case $tagname in
      case $tagname in
      *[!-_A-Za-z0-9,/]*)
      *[!-_A-Za-z0-9,/]*)
        echo "$progname: invalid tag name: $tagname" 1>&2
        echo "$progname: invalid tag name: $tagname" 1>&2
        exit 1
        exit 1
        ;;
        ;;
      esac
      esac
 
 
      case $tagname in
      case $tagname in
      CC)
      CC)
        # Don't test for the "default" C tag, as we know, it's there, but
        # Don't test for the "default" C tag, as we know, it's there, but
        # not specially marked.
        # not specially marked.
        ;;
        ;;
      *)
      *)
        if grep "^### BEGIN LIBTOOL TAG CONFIG: $tagname$" < "$0" > /dev/null; then
        if grep "^### BEGIN LIBTOOL TAG CONFIG: $tagname$" < "$0" > /dev/null; then
          taglist="$taglist $tagname"
          taglist="$taglist $tagname"
          # Evaluate the configuration.
          # Evaluate the configuration.
          eval "`sed -n -e '/^### BEGIN LIBTOOL TAG CONFIG: '$tagname'$/,/^### END LIBTOOL TAG CONFIG: '$tagname'$/p' < $0`"
          eval "`sed -n -e '/^### BEGIN LIBTOOL TAG CONFIG: '$tagname'$/,/^### END LIBTOOL TAG CONFIG: '$tagname'$/p' < $0`"
        else
        else
          echo "$progname: ignoring unknown tag $tagname" 1>&2
          echo "$progname: ignoring unknown tag $tagname" 1>&2
        fi
        fi
        ;;
        ;;
      esac
      esac
      ;;
      ;;
    *)
    *)
      eval "$prev=\$arg"
      eval "$prev=\$arg"
      ;;
      ;;
    esac
    esac
 
 
    prev=
    prev=
    prevopt=
    prevopt=
    continue
    continue
  fi
  fi
 
 
  # Have we seen a non-optional argument yet?
  # Have we seen a non-optional argument yet?
  case $arg in
  case $arg in
  --help)
  --help)
    show_help=yes
    show_help=yes
    ;;
    ;;
 
 
  --version)
  --version)
    echo "$PROGRAM (GNU $PACKAGE) $VERSION$TIMESTAMP"
    echo "$PROGRAM (GNU $PACKAGE) $VERSION$TIMESTAMP"
    exit 0
    exit 0
    ;;
    ;;
 
 
  --config)
  --config)
    sed -n -e '/^### BEGIN LIBTOOL CONFIG/,/^### END LIBTOOL CONFIG/p' < "$0"
    sed -n -e '/^### BEGIN LIBTOOL CONFIG/,/^### END LIBTOOL CONFIG/p' < "$0"
    # Now print the configurations for the tags.
    # Now print the configurations for the tags.
    for tagname in $taglist; do
    for tagname in $taglist; do
      sed -n -e "/^### BEGIN LIBTOOL TAG CONFIG: $tagname$/,/^### END LIBTOOL TAG CONFIG: $tagname$/p" < "$0"
      sed -n -e "/^### BEGIN LIBTOOL TAG CONFIG: $tagname$/,/^### END LIBTOOL TAG CONFIG: $tagname$/p" < "$0"
    done
    done
    exit 0
    exit 0
    ;;
    ;;
 
 
  --debug)
  --debug)
    echo "$progname: enabling shell trace mode"
    echo "$progname: enabling shell trace mode"
    set -x
    set -x
    ;;
    ;;
 
 
  --dry-run | -n)
  --dry-run | -n)
    run=:
    run=:
    ;;
    ;;
 
 
  --features)
  --features)
    echo "host: $host"
    echo "host: $host"
    if test "$build_libtool_libs" = yes; then
    if test "$build_libtool_libs" = yes; then
      echo "enable shared libraries"
      echo "enable shared libraries"
    else
    else
      echo "disable shared libraries"
      echo "disable shared libraries"
    fi
    fi
    if test "$build_old_libs" = yes; then
    if test "$build_old_libs" = yes; then
      echo "enable static libraries"
      echo "enable static libraries"
    else
    else
      echo "disable static libraries"
      echo "disable static libraries"
    fi
    fi
    exit 0
    exit 0
    ;;
    ;;
 
 
  --finish) mode="finish" ;;
  --finish) mode="finish" ;;
 
 
  --mode) prevopt="--mode" prev=mode ;;
  --mode) prevopt="--mode" prev=mode ;;
  --mode=*) mode="$optarg" ;;
  --mode=*) mode="$optarg" ;;
 
 
  --quiet | --silent)
  --quiet | --silent)
    show=:
    show=:
    ;;
    ;;
 
 
  --tag) prevopt="--tag" prev=tag ;;
  --tag) prevopt="--tag" prev=tag ;;
  --tag=*)
  --tag=*)
    set tag "$optarg" ${1+"$@"}
    set tag "$optarg" ${1+"$@"}
    shift
    shift
    prev=tag
    prev=tag
    ;;
    ;;
 
 
  -dlopen)
  -dlopen)
    prevopt="-dlopen"
    prevopt="-dlopen"
    prev=execute_dlfiles
    prev=execute_dlfiles
    ;;
    ;;
 
 
  -*)
  -*)
    $echo "$modename: unrecognized option \`$arg'" 1>&2
    $echo "$modename: unrecognized option \`$arg'" 1>&2
    $echo "$help" 1>&2
    $echo "$help" 1>&2
    exit 1
    exit 1
    ;;
    ;;
 
 
  *)
  *)
    nonopt="$arg"
    nonopt="$arg"
    break
    break
    ;;
    ;;
  esac
  esac
done
done
 
 
if test -n "$prevopt"; then
if test -n "$prevopt"; then
  $echo "$modename: option \`$prevopt' requires an argument" 1>&2
  $echo "$modename: option \`$prevopt' requires an argument" 1>&2
  $echo "$help" 1>&2
  $echo "$help" 1>&2
  exit 1
  exit 1
fi
fi
 
 
# If this variable is set in any of the actions, the command in it
# If this variable is set in any of the actions, the command in it
# will be execed at the end.  This prevents here-documents from being
# will be execed at the end.  This prevents here-documents from being
# left over by shells.
# left over by shells.
exec_cmd=
exec_cmd=
 
 
if test -z "$show_help"; then
if test -z "$show_help"; then
 
 
  # Infer the operation mode.
  # Infer the operation mode.
  if test -z "$mode"; then
  if test -z "$mode"; then
    case $nonopt in
    case $nonopt in
    *cc | *++ | gcc* | *-gcc*)
    *cc | *++ | gcc* | *-gcc*)
      mode=link
      mode=link
      for arg
      for arg
      do
      do
        case $arg in
        case $arg in
        -c)
        -c)
           mode=compile
           mode=compile
           break
           break
           ;;
           ;;
        esac
        esac
      done
      done
      ;;
      ;;
    *db | *dbx | *strace | *truss)
    *db | *dbx | *strace | *truss)
      mode=execute
      mode=execute
      ;;
      ;;
    *install*|cp|mv)
    *install*|cp|mv)
      mode=install
      mode=install
      ;;
      ;;
    *rm)
    *rm)
      mode=uninstall
      mode=uninstall
      ;;
      ;;
    *)
    *)
      # If we have no mode, but dlfiles were specified, then do execute mode.
      # If we have no mode, but dlfiles were specified, then do execute mode.
      test -n "$execute_dlfiles" && mode=execute
      test -n "$execute_dlfiles" && mode=execute
 
 
      # Just use the default operation mode.
      # Just use the default operation mode.
      if test -z "$mode"; then
      if test -z "$mode"; then
        if test -n "$nonopt"; then
        if test -n "$nonopt"; then
          $echo "$modename: warning: cannot infer operation mode from \`$nonopt'" 1>&2
          $echo "$modename: warning: cannot infer operation mode from \`$nonopt'" 1>&2
        else
        else
          $echo "$modename: warning: cannot infer operation mode without MODE-ARGS" 1>&2
          $echo "$modename: warning: cannot infer operation mode without MODE-ARGS" 1>&2
        fi
        fi
      fi
      fi
      ;;
      ;;
    esac
    esac
  fi
  fi
 
 
  # Only execute mode is allowed to have -dlopen flags.
  # Only execute mode is allowed to have -dlopen flags.
  if test -n "$execute_dlfiles" && test "$mode" != execute; then
  if test -n "$execute_dlfiles" && test "$mode" != execute; then
    $echo "$modename: unrecognized option \`-dlopen'" 1>&2
    $echo "$modename: unrecognized option \`-dlopen'" 1>&2
    $echo "$help" 1>&2
    $echo "$help" 1>&2
    exit 1
    exit 1
  fi
  fi
 
 
  # Change the help message to a mode-specific one.
  # Change the help message to a mode-specific one.
  generic_help="$help"
  generic_help="$help"
  help="Try \`$modename --help --mode=$mode' for more information."
  help="Try \`$modename --help --mode=$mode' for more information."
 
 
  # These modes are in order of execution frequency so that they run quickly.
  # These modes are in order of execution frequency so that they run quickly.
  case $mode in
  case $mode in
  # libtool compile mode
  # libtool compile mode
  compile)
  compile)
    modename="$modename: compile"
    modename="$modename: compile"
    # Get the compilation command and the source file.
    # Get the compilation command and the source file.
    base_compile=
    base_compile=
    prev=
    prev=
    lastarg=
    lastarg=
    srcfile="$nonopt"
    srcfile="$nonopt"
    suppress_output=
    suppress_output=
 
 
    user_target=no
    user_target=no
    for arg
    for arg
    do
    do
      case $prev in
      case $prev in
      "") ;;
      "") ;;
      xcompiler)
      xcompiler)
        # Aesthetically quote the previous argument.
        # Aesthetically quote the previous argument.
        prev=
        prev=
        lastarg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
        lastarg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
 
 
        case $arg in
        case $arg in
        # Double-quote args containing other shell metacharacters.
        # Double-quote args containing other shell metacharacters.
        # Many Bourne shells cannot handle close brackets correctly
        # Many Bourne shells cannot handle close brackets correctly
        # in scan sets, so we specify it separately.
        # in scan sets, so we specify it separately.
        *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
        *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
          arg="\"$arg\""
          arg="\"$arg\""
          ;;
          ;;
        esac
        esac
 
 
        # Add the previous argument to base_compile.
        # Add the previous argument to base_compile.
        if test -z "$base_compile"; then
        if test -z "$base_compile"; then
          base_compile="$lastarg"
          base_compile="$lastarg"
        else
        else
          base_compile="$base_compile $lastarg"
          base_compile="$base_compile $lastarg"
        fi
        fi
        continue
        continue
        ;;
        ;;
      esac
      esac
 
 
      # Accept any command-line options.
      # Accept any command-line options.
      case $arg in
      case $arg in
      -o)
      -o)
        if test "$user_target" != "no"; then
        if test "$user_target" != "no"; then
          $echo "$modename: you cannot specify \`-o' more than once" 1>&2
          $echo "$modename: you cannot specify \`-o' more than once" 1>&2
          exit 1
          exit 1
        fi
        fi
        user_target=next
        user_target=next
        ;;
        ;;
 
 
      -static)
      -static)
        build_old_libs=yes
        build_old_libs=yes
        continue
        continue
        ;;
        ;;
 
 
      -prefer-pic)
      -prefer-pic)
        pic_mode=yes
        pic_mode=yes
        continue
        continue
        ;;
        ;;
 
 
      -prefer-non-pic)
      -prefer-non-pic)
        pic_mode=no
        pic_mode=no
        continue
        continue
        ;;
        ;;
 
 
      -Xcompiler)
      -Xcompiler)
        prev=xcompiler
        prev=xcompiler
        continue
        continue
        ;;
        ;;
 
 
      -Wc,*)
      -Wc,*)
        args=`$echo "X$arg" | $Xsed -e "s/^-Wc,//"`
        args=`$echo "X$arg" | $Xsed -e "s/^-Wc,//"`
        lastarg=
        lastarg=
        IFS="${IFS=     }"; save_ifs="$IFS"; IFS=','
        IFS="${IFS=     }"; save_ifs="$IFS"; IFS=','
        for arg in $args; do
        for arg in $args; do
          IFS="$save_ifs"
          IFS="$save_ifs"
 
 
          # Double-quote args containing other shell metacharacters.
          # Double-quote args containing other shell metacharacters.
          # Many Bourne shells cannot handle close brackets correctly
          # Many Bourne shells cannot handle close brackets correctly
          # in scan sets, so we specify it separately.
          # in scan sets, so we specify it separately.
          case $arg in
          case $arg in
            *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
            *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
            arg="\"$arg\""
            arg="\"$arg\""
            ;;
            ;;
          esac
          esac
          lastarg="$lastarg $arg"
          lastarg="$lastarg $arg"
        done
        done
        IFS="$save_ifs"
        IFS="$save_ifs"
        lastarg=`$echo "X$lastarg" | $Xsed -e "s/^ //"`
        lastarg=`$echo "X$lastarg" | $Xsed -e "s/^ //"`
 
 
        # Add the arguments to base_compile.
        # Add the arguments to base_compile.
        if test -z "$base_compile"; then
        if test -z "$base_compile"; then
          base_compile="$lastarg"
          base_compile="$lastarg"
        else
        else
          base_compile="$base_compile $lastarg"
          base_compile="$base_compile $lastarg"
        fi
        fi
        continue
        continue
        ;;
        ;;
      esac
      esac
 
 
      case $user_target in
      case $user_target in
      next)
      next)
        # The next one is the -o target name
        # The next one is the -o target name
        user_target=yes
        user_target=yes
        continue
        continue
        ;;
        ;;
      yes)
      yes)
        # We got the output file
        # We got the output file
        user_target=set
        user_target=set
        libobj="$arg"
        libobj="$arg"
        continue
        continue
        ;;
        ;;
      esac
      esac
 
 
      # Accept the current argument as the source file.
      # Accept the current argument as the source file.
      lastarg="$srcfile"
      lastarg="$srcfile"
      srcfile="$arg"
      srcfile="$arg"
 
 
      # Aesthetically quote the previous argument.
      # Aesthetically quote the previous argument.
 
 
      # Backslashify any backslashes, double quotes, and dollar signs.
      # Backslashify any backslashes, double quotes, and dollar signs.
      # These are the only characters that are still specially
      # These are the only characters that are still specially
      # interpreted inside of double-quoted scrings.
      # interpreted inside of double-quoted scrings.
      lastarg=`$echo "X$lastarg" | $Xsed -e "$sed_quote_subst"`
      lastarg=`$echo "X$lastarg" | $Xsed -e "$sed_quote_subst"`
 
 
      # Double-quote args containing other shell metacharacters.
      # Double-quote args containing other shell metacharacters.
      # Many Bourne shells cannot handle close brackets correctly
      # Many Bourne shells cannot handle close brackets correctly
      # in scan sets, so we specify it separately.
      # in scan sets, so we specify it separately.
      case $lastarg in
      case $lastarg in
      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
        lastarg="\"$lastarg\""
        lastarg="\"$lastarg\""
        ;;
        ;;
      esac
      esac
 
 
      # Add the previous argument to base_compile.
      # Add the previous argument to base_compile.
      if test -z "$base_compile"; then
      if test -z "$base_compile"; then
        base_compile="$lastarg"
        base_compile="$lastarg"
      else
      else
        base_compile="$base_compile $lastarg"
        base_compile="$base_compile $lastarg"
      fi
      fi
    done
    done
 
 
    case $user_target in
    case $user_target in
    set)
    set)
      ;;
      ;;
    no)
    no)
      # Get the name of the library object.
      # Get the name of the library object.
      libobj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%'`
      libobj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%'`
      ;;
      ;;
    *)
    *)
      $echo "$modename: you must specify a target with \`-o'" 1>&2
      $echo "$modename: you must specify a target with \`-o'" 1>&2
      exit 1
      exit 1
      ;;
      ;;
    esac
    esac
 
 
    # Recognize several different file suffixes.
    # Recognize several different file suffixes.
    # If the user specifies -o file.o, it is replaced with file.lo
    # If the user specifies -o file.o, it is replaced with file.lo
    xform='[cCFSfmso]'
    xform='[cCFSfmso]'
    case $libobj in
    case $libobj in
    *.ada) xform=ada ;;
    *.ada) xform=ada ;;
    *.adb) xform=adb ;;
    *.adb) xform=adb ;;
    *.ads) xform=ads ;;
    *.ads) xform=ads ;;
    *.asm) xform=asm ;;
    *.asm) xform=asm ;;
    *.c++) xform=c++ ;;
    *.c++) xform=c++ ;;
    *.cc) xform=cc ;;
    *.cc) xform=cc ;;
    *.class) xform=class ;;
    *.class) xform=class ;;
    *.cpp) xform=cpp ;;
    *.cpp) xform=cpp ;;
    *.cxx) xform=cxx ;;
    *.cxx) xform=cxx ;;
    *.f90) xform=f90 ;;
    *.f90) xform=f90 ;;
    *.for) xform=for ;;
    *.for) xform=for ;;
    *.java) xform=java ;;
    *.java) xform=java ;;
    esac
    esac
 
 
    libobj=`$echo "X$libobj" | $Xsed -e "s/\.$xform$/.lo/"`
    libobj=`$echo "X$libobj" | $Xsed -e "s/\.$xform$/.lo/"`
 
 
    case $libobj in
    case $libobj in
    *.lo) obj=`$echo "X$libobj" | $Xsed -e "$lo2o"` ;;
    *.lo) obj=`$echo "X$libobj" | $Xsed -e "$lo2o"` ;;
    *)
    *)
      $echo "$modename: cannot determine name of library object from \`$libobj'" 1>&2
      $echo "$modename: cannot determine name of library object from \`$libobj'" 1>&2
      exit 1
      exit 1
      ;;
      ;;
    esac
    esac
 
 
    # 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.
    if test -n "$available_tags" && test -z "$tagname"; then
    if test -n "$available_tags" && test -z "$tagname"; then
      case $base_compile in
      case $base_compile in
      "$CC "*) ;;
      "$CC "*) ;;
      # Blanks in the command may have been stripped by the calling shell,
      # Blanks in the command may have been stripped by the calling shell,
      # but not from the CC environment variable when ltconfig was run.
      # but not from the CC environment variable when ltconfig was run.
      "`$echo $CC` "*) ;;
      "`$echo $CC` "*) ;;
      *)
      *)
        for z in $available_tags; do
        for z in $available_tags; do
          if grep "^### BEGIN LIBTOOL TAG CONFIG: $z$" < "$0" > /dev/null; then
          if grep "^### BEGIN LIBTOOL TAG CONFIG: $z$" < "$0" > /dev/null; then
            # Evaluate the configuration.
            # Evaluate the configuration.
            eval "`sed -n -e '/^### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^### END LIBTOOL TAG CONFIG: '$z'$/p' < $0`"
            eval "`sed -n -e '/^### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^### END LIBTOOL TAG CONFIG: '$z'$/p' < $0`"
            case $base_compile in
            case $base_compile in
            "$CC "*)
            "$CC "*)
              # The compiler in the base compile command matches
              # The compiler in the base compile command matches
              # the one in the tagged configuration.
              # the one in the tagged configuration.
              # Assume this is the tagged configuration we want.
              # Assume this is the tagged configuration we want.
              tagname=$z
              tagname=$z
              break
              break
              ;;
              ;;
            "`$echo $CC` "*)
            "`$echo $CC` "*)
              tagname=$z
              tagname=$z
              break
              break
              ;;
              ;;
            esac
            esac
          fi
          fi
        done
        done
        # If $tagname still isn't set, then no tagged configuration
        # If $tagname still isn't set, then no tagged configuration
        # was found and let the user know that the "--tag" command
        # was found and let the user know that the "--tag" command
        # line option must be used.
        # line option must be used.
        if test -z "$tagname"; then
        if test -z "$tagname"; then
          echo "$modename: unable to infer tagged configuration"
          echo "$modename: unable to infer tagged configuration"
          echo "$modename: specify a tag with \`--tag'" 1>&2
          echo "$modename: specify a tag with \`--tag'" 1>&2
          exit 1
          exit 1
#        else
#        else
#          echo "$modename: using $tagname tagged configuration"
#          echo "$modename: using $tagname tagged configuration"
        fi
        fi
        ;;
        ;;
      esac
      esac
    fi
    fi
 
 
    objname=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
    objname=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
    xdir=`$echo "X$obj" | $Xsed -e 's%/[^/]*$%%'`
    xdir=`$echo "X$obj" | $Xsed -e 's%/[^/]*$%%'`
    if test "X$xdir" = "X$obj"; then
    if test "X$xdir" = "X$obj"; then
      xdir=
      xdir=
    else
    else
      xdir=$xdir/
      xdir=$xdir/
    fi
    fi
    lobj=${xdir}$objdir/$objname
    lobj=${xdir}$objdir/$objname
 
 
    if test -z "$base_compile"; then
    if test -z "$base_compile"; then
      $echo "$modename: you must specify a compilation command" 1>&2
      $echo "$modename: you must specify a compilation command" 1>&2
      $echo "$help" 1>&2
      $echo "$help" 1>&2
      exit 1
      exit 1
    fi
    fi
 
 
    # Delete any leftover library objects.
    # Delete any leftover library objects.
    if test "$build_old_libs" = yes; then
    if test "$build_old_libs" = yes; then
      removelist="$obj $lobj $libobj ${libobj}T"
      removelist="$obj $lobj $libobj ${libobj}T"
    else
    else
      removelist="$lobj $libobj ${libobj}T"
      removelist="$lobj $libobj ${libobj}T"
    fi
    fi
 
 
    $run $rm $removelist
    $run $rm $removelist
    trap "$run $rm $removelist; exit 1" 1 2 15
    trap "$run $rm $removelist; exit 1" 1 2 15
 
 
    # On Cygwin there's no "real" PIC flag so we must build both object types
    # On Cygwin there's no "real" PIC flag so we must build both object types
    case $host_os in
    case $host_os in
    cygwin* | mingw* | pw32* | os2*)
    cygwin* | mingw* | pw32* | os2*)
      pic_mode=default
      pic_mode=default
      ;;
      ;;
    esac
    esac
    if test $pic_mode = no && test "$deplibs_check_method" != pass_all; then
    if test $pic_mode = no && test "$deplibs_check_method" != pass_all; then
      # non-PIC code in shared libraries is not supported
      # non-PIC code in shared libraries is not supported
      pic_mode=default
      pic_mode=default
    fi
    fi
 
 
    # Calculate the filename of the output object if compiler does
    # Calculate the filename of the output object if compiler does
    # not support -o with -c
    # not support -o with -c
    if test "$compiler_c_o" = no; then
    if test "$compiler_c_o" = no; then
      output_obj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}
      output_obj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}
      lockfile="$output_obj.lock"
      lockfile="$output_obj.lock"
      removelist="$removelist $output_obj $lockfile"
      removelist="$removelist $output_obj $lockfile"
      trap "$run $rm $removelist; exit 1" 1 2 15
      trap "$run $rm $removelist; exit 1" 1 2 15
    else
    else
      output_obj=
      output_obj=
      need_locks=no
      need_locks=no
      lockfile=
      lockfile=
    fi
    fi
 
 
    # Lock this critical section if it is needed
    # Lock this critical section if it is needed
    # We use this script file to make the link, it avoids creating a new file
    # We use this script file to make the link, it avoids creating a new file
    if test "$need_locks" = yes; then
    if test "$need_locks" = yes; then
      until $run ln "$0" "$lockfile" 2>/dev/null; do
      until $run ln "$0" "$lockfile" 2>/dev/null; do
        $show "Waiting for $lockfile to be removed"
        $show "Waiting for $lockfile to be removed"
        sleep 2
        sleep 2
      done
      done
    elif test "$need_locks" = warn; then
    elif test "$need_locks" = warn; then
      if test -f "$lockfile"; then
      if test -f "$lockfile"; then
        echo "\
        echo "\
*** ERROR, $lockfile exists and contains:
*** ERROR, $lockfile exists and contains:
`cat $lockfile 2>/dev/null`
`cat $lockfile 2>/dev/null`
 
 
This indicates that another process is trying to use the same
This indicates that another process is trying to use the same
temporary object file, and libtool could not work around it because
temporary object file, and libtool could not work around it because
your compiler does not support \`-c' and \`-o' together.  If you
your compiler does not support \`-c' and \`-o' together.  If you
repeat this compilation, it may succeed, by chance, but you had better
repeat this compilation, it may succeed, by chance, but you had better
avoid parallel builds (make -j) in this platform, or get a better
avoid parallel builds (make -j) in this platform, or get a better
compiler."
compiler."
 
 
        $run $rm $removelist
        $run $rm $removelist
        exit 1
        exit 1
      fi
      fi
      echo $srcfile > "$lockfile"
      echo $srcfile > "$lockfile"
    fi
    fi
 
 
    if test -n "$fix_srcfile_path"; then
    if test -n "$fix_srcfile_path"; then
      eval srcfile=\"$fix_srcfile_path\"
      eval srcfile=\"$fix_srcfile_path\"
    fi
    fi
 
 
    $run $rm "$libobj" "${libobj}T"
    $run $rm "$libobj" "${libobj}T"
 
 
    # Create a libtool object file (analogous to a ".la" file),
    # Create a libtool object file (analogous to a ".la" file),
    # but don't create it if we're doing a dry run.
    # but don't create it if we're doing a dry run.
    test -z "$run" && cat > ${libobj}T <<EOF
    test -z "$run" && cat > ${libobj}T <<EOF
# $libobj - a libtool object file
# $libobj - a libtool object file
# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
#
#
# Please DO NOT delete this file!
# Please DO NOT delete this file!
# It is necessary for linking the library.
# It is necessary for linking the library.
 
 
# Name of the PIC object.
# Name of the PIC object.
EOF
EOF
 
 
    # Only build a PIC object if we are building libtool libraries.
    # Only build a PIC object if we are building libtool libraries.
    if test "$build_libtool_libs" = yes; then
    if test "$build_libtool_libs" = yes; then
      # Without this assignment, base_compile gets emptied.
      # Without this assignment, base_compile gets emptied.
      fbsd_hideous_sh_bug=$base_compile
      fbsd_hideous_sh_bug=$base_compile
 
 
      if test "$pic_mode" != no; then
      if test "$pic_mode" != no; then
        command="$base_compile $srcfile $pic_flag"
        command="$base_compile $srcfile $pic_flag"
      else
      else
        # Don't build PIC code
        # Don't build PIC code
        command="$base_compile $srcfile"
        command="$base_compile $srcfile"
      fi
      fi
 
 
      if test ! -d ${xdir}$objdir; then
      if test ! -d ${xdir}$objdir; then
        $show "$mkdir ${xdir}$objdir"
        $show "$mkdir ${xdir}$objdir"
        $run $mkdir ${xdir}$objdir
        $run $mkdir ${xdir}$objdir
        status=$?
        status=$?
        if test $status -ne 0 && test ! -d ${xdir}$objdir; then
        if test $status -ne 0 && test ! -d ${xdir}$objdir; then
          exit $status
          exit $status
        fi
        fi
      fi
      fi
 
 
      if test -z "$output_obj"; then
      if test -z "$output_obj"; then
        # Place PIC objects in $objdir
        # Place PIC objects in $objdir
        command="$command -o $lobj"
        command="$command -o $lobj"
      fi
      fi
 
 
      $run $rm "$lobj" "$output_obj"
      $run $rm "$lobj" "$output_obj"
 
 
      $show "$command"
      $show "$command"
      if $run eval "$command"; then :
      if $run eval "$command"; then :
      else
      else
        test -n "$output_obj" && $run $rm $removelist
        test -n "$output_obj" && $run $rm $removelist
        exit 1
        exit 1
      fi
      fi
 
 
      if test "$need_locks" = warn &&
      if test "$need_locks" = warn &&
         test x"`cat $lockfile 2>/dev/null`" != x"$srcfile"; then
         test x"`cat $lockfile 2>/dev/null`" != x"$srcfile"; then
        echo "\
        echo "\
*** ERROR, $lockfile contains:
*** ERROR, $lockfile contains:
`cat $lockfile 2>/dev/null`
`cat $lockfile 2>/dev/null`
 
 
but it should contain:
but it should contain:
$srcfile
$srcfile
 
 
This indicates that another process is trying to use the same
This indicates that another process is trying to use the same
temporary object file, and libtool could not work around it because
temporary object file, and libtool could not work around it because
your compiler does not support \`-c' and \`-o' together.  If you
your compiler does not support \`-c' and \`-o' together.  If you
repeat this compilation, it may succeed, by chance, but you had better
repeat this compilation, it may succeed, by chance, but you had better
avoid parallel builds (make -j) in this platform, or get a better
avoid parallel builds (make -j) in this platform, or get a better
compiler."
compiler."
 
 
        $run $rm $removelist
        $run $rm $removelist
        exit 1
        exit 1
      fi
      fi
 
 
      # Just move the object if needed, then go on to compile the next one
      # 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
      if test -n "$output_obj" && test "x$output_obj" != "x$lobj"; then
        $show "$mv $output_obj $lobj"
        $show "$mv $output_obj $lobj"
        if $run $mv $output_obj $lobj; then :
        if $run $mv $output_obj $lobj; then :
        else
        else
          error=$?
          error=$?
          $run $rm $removelist
          $run $rm $removelist
          exit $error
          exit $error
        fi
        fi
      fi
      fi
 
 
      # Append the name of the PIC object to the libtool object file.
      # Append the name of the PIC object to the libtool object file.
      test -z "$run" && cat >> ${libobj}T <<EOF
      test -z "$run" && cat >> ${libobj}T <<EOF
pic_object='$objdir/$objname'
pic_object='$objdir/$objname'
 
 
EOF
EOF
 
 
      # Allow error messages only from the first compilation.
      # Allow error messages only from the first compilation.
      suppress_output=' >/dev/null 2>&1'
      suppress_output=' >/dev/null 2>&1'
    else
    else
      # No PIC object so indicate it doesn't exist in the libtool
      # No PIC object so indicate it doesn't exist in the libtool
      # object file.
      # object file.
      test -z "$run" && cat >> ${libobj}T <<EOF
      test -z "$run" && cat >> ${libobj}T <<EOF
pic_object=none
pic_object=none
 
 
EOF
EOF
    fi
    fi
 
 
    # Only build a position-dependent object if we build old libraries.
    # 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
      if test "$pic_mode" != yes; then
      if test "$pic_mode" != yes; then
        # Don't build PIC code
        # Don't build PIC code
        command="$base_compile $srcfile"
        command="$base_compile $srcfile"
      else
      else
        command="$base_compile $srcfile $pic_flag"
        command="$base_compile $srcfile $pic_flag"
      fi
      fi
      if test "$compiler_c_o" = yes; then
      if test "$compiler_c_o" = yes; then
        command="$command -o $obj"
        command="$command -o $obj"
      fi
      fi
 
 
      # Suppress compiler output if we already did a PIC compilation.
      # Suppress compiler output if we already did a PIC compilation.
      command="$command$suppress_output"
      command="$command$suppress_output"
      $run $rm "$obj" "$output_obj"
      $run $rm "$obj" "$output_obj"
      $show "$command"
      $show "$command"
      if $run eval "$command"; then :
      if $run eval "$command"; then :
      else
      else
        $run $rm $removelist
        $run $rm $removelist
        exit 1
        exit 1
      fi
      fi
 
 
      if test "$need_locks" = warn &&
      if test "$need_locks" = warn &&
         test x"`cat $lockfile 2>/dev/null`" != x"$srcfile"; then
         test x"`cat $lockfile 2>/dev/null`" != x"$srcfile"; then
        echo "\
        echo "\
*** ERROR, $lockfile contains:
*** ERROR, $lockfile contains:
`cat $lockfile 2>/dev/null`
`cat $lockfile 2>/dev/null`
 
 
but it should contain:
but it should contain:
$srcfile
$srcfile
 
 
This indicates that another process is trying to use the same
This indicates that another process is trying to use the same
temporary object file, and libtool could not work around it because
temporary object file, and libtool could not work around it because
your compiler does not support \`-c' and \`-o' together.  If you
your compiler does not support \`-c' and \`-o' together.  If you
repeat this compilation, it may succeed, by chance, but you had better
repeat this compilation, it may succeed, by chance, but you had better
avoid parallel builds (make -j) in this platform, or get a better
avoid parallel builds (make -j) in this platform, or get a better
compiler."
compiler."
 
 
        $run $rm $removelist
        $run $rm $removelist
        exit 1
        exit 1
      fi
      fi
 
 
      # Just move the object if needed
      # Just move the object if needed
      if test -n "$output_obj" && test "x$output_obj" != "x$obj"; then
      if test -n "$output_obj" && test "x$output_obj" != "x$obj"; then
        $show "$mv $output_obj $obj"
        $show "$mv $output_obj $obj"
        if $run $mv $output_obj $obj; then :
        if $run $mv $output_obj $obj; then :
        else
        else
          error=$?
          error=$?
          $run $rm $removelist
          $run $rm $removelist
          exit $error
          exit $error
        fi
        fi
      fi
      fi
 
 
      # Append the name of the non-PIC object the libtool object file.
      # Append the name of the non-PIC object the libtool object file.
      # Only append if the libtool object file exists.
      # Only append if the libtool object file exists.
      test -z "$run" && cat >> ${libobj}T <<EOF
      test -z "$run" && cat >> ${libobj}T <<EOF
# Name of the non-PIC object.
# Name of the non-PIC object.
non_pic_object='$objname'
non_pic_object='$objname'
 
 
EOF
EOF
    else
    else
      # Append the name of the non-PIC object the libtool object file.
      # Append the name of the non-PIC object the libtool object file.
      # Only append if the libtool object file exists.
      # Only append if the libtool object file exists.
      test -z "$run" && cat >> ${libobj}T <<EOF
      test -z "$run" && cat >> ${libobj}T <<EOF
# Name of the non-PIC object.
# Name of the non-PIC object.
non_pic_object=none
non_pic_object=none
 
 
EOF
EOF
    fi
    fi
 
 
    $run $mv "${libobj}T" "${libobj}"
    $run $mv "${libobj}T" "${libobj}"
 
 
    # Unlock the critical section if it was locked
    # Unlock the critical section if it was locked
    if test "$need_locks" != no; then
    if test "$need_locks" != no; then
      $run $rm "$lockfile"
      $run $rm "$lockfile"
    fi
    fi
 
 
    exit 0
    exit 0
    ;;
    ;;
 
 
  # libtool link mode
  # libtool link mode
  link | relink)
  link | relink)
    modename="$modename: link"
    modename="$modename: link"
    case $host in
    case $host in
    *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
    *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
      # It is impossible to link a dll without this setting, and
      # It is impossible to link a dll without this setting, and
      # we shouldn't force the makefile maintainer to figure out
      # we shouldn't force the makefile maintainer to figure out
      # which system we are compiling for in order to pass an extra
      # which system we are compiling for in order to pass an extra
      # flag for every libtool invokation.
      # flag for every libtool invokation.
      # allow_undefined=no
      # allow_undefined=no
 
 
      # FIXME: Unfortunately, there are problems with the above when trying
      # FIXME: Unfortunately, there are problems with the above when trying
      # to make a dll which has undefined symbols, in which case not
      # to make a dll which has undefined symbols, in which case not
      # even a static library is built.  For now, we need to specify
      # even a static library is built.  For now, we need to specify
      # -no-undefined on the libtool link line when we can be certain
      # -no-undefined on the libtool link line when we can be certain
      # that all symbols are satisfied, otherwise we get a static library.
      # that all symbols are satisfied, otherwise we get a static library.
      allow_undefined=yes
      allow_undefined=yes
      ;;
      ;;
    *)
    *)
      allow_undefined=yes
      allow_undefined=yes
      ;;
      ;;
    esac
    esac
    libtool_args="$nonopt"
    libtool_args="$nonopt"
    base_compile="$nonopt"
    base_compile="$nonopt"
    compile_command="$nonopt"
    compile_command="$nonopt"
    finalize_command="$nonopt"
    finalize_command="$nonopt"
 
 
    compile_rpath=
    compile_rpath=
    finalize_rpath=
    finalize_rpath=
    compile_shlibpath=
    compile_shlibpath=
    finalize_shlibpath=
    finalize_shlibpath=
    convenience=
    convenience=
    old_convenience=
    old_convenience=
    deplibs=
    deplibs=
    old_deplibs=
    old_deplibs=
    compiler_flags=
    compiler_flags=
    linker_flags=
    linker_flags=
    dllsearchpath=
    dllsearchpath=
    lib_search_path=`pwd`
    lib_search_path=`pwd`
 
 
    avoid_version=no
    avoid_version=no
    dlfiles=
    dlfiles=
    dlprefiles=
    dlprefiles=
    dlself=no
    dlself=no
    export_dynamic=no
    export_dynamic=no
    export_symbols=
    export_symbols=
    export_symbols_regex=
    export_symbols_regex=
    generated=
    generated=
    libobjs=
    libobjs=
    ltlibs=
    ltlibs=
    module=no
    module=no
    no_install=no
    no_install=no
    objs=
    objs=
    non_pic_objects=
    non_pic_objects=
    prefer_static_libs=no
    prefer_static_libs=no
    preload=no
    preload=no
    prev=
    prev=
    prevarg=
    prevarg=
    release=
    release=
    rpath=
    rpath=
    xrpath=
    xrpath=
    perm_rpath=
    perm_rpath=
    temp_rpath=
    temp_rpath=
    thread_safe=no
    thread_safe=no
    vinfo=
    vinfo=
 
 
    # We need to know -static, to get the right output filenames.
    # We need to know -static, to get the right output filenames.
    for arg
    for arg
    do
    do
      case $arg in
      case $arg in
      -all-static | -static)
      -all-static | -static)
        if test "X$arg" = "X-all-static"; then
        if test "X$arg" = "X-all-static"; then
          if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
          if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
            $echo "$modename: warning: complete static linking is impossible in this configuration" 1>&2
            $echo "$modename: warning: complete static linking is impossible in this configuration" 1>&2
          fi
          fi
          if test -n "$link_static_flag"; then
          if test -n "$link_static_flag"; then
            dlopen_self=$dlopen_self_static
            dlopen_self=$dlopen_self_static
          fi
          fi
        else
        else
          if test -z "$pic_flag" && test -n "$link_static_flag"; then
          if test -z "$pic_flag" && test -n "$link_static_flag"; then
            dlopen_self=$dlopen_self_static
            dlopen_self=$dlopen_self_static
          fi
          fi
        fi
        fi
        build_libtool_libs=no
        build_libtool_libs=no
        build_old_libs=yes
        build_old_libs=yes
        prefer_static_libs=yes
        prefer_static_libs=yes
        break
        break
        ;;
        ;;
      esac
      esac
    done
    done
 
 
    # See if our shared archives depend on static archives.
    # See if our shared archives depend on static archives.
    test -n "$old_archive_from_new_cmds" && build_old_libs=yes
    test -n "$old_archive_from_new_cmds" && build_old_libs=yes
 
 
    # Go through the arguments, transforming them on the way.
    # Go through the arguments, transforming them on the way.
    while test $# -gt 0; do
    while test $# -gt 0; do
      arg="$1"
      arg="$1"
      base_compile="$base_compile $arg"
      base_compile="$base_compile $arg"
      shift
      shift
      case $arg in
      case $arg in
      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
        qarg=\"`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`\" ### testsuite: skip nested quoting test
        qarg=\"`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`\" ### testsuite: skip nested quoting test
        ;;
        ;;
      *) qarg=$arg ;;
      *) qarg=$arg ;;
      esac
      esac
      libtool_args="$libtool_args $qarg"
      libtool_args="$libtool_args $qarg"
 
 
      # If the previous option needs an argument, assign it.
      # If the previous option needs an argument, assign it.
      if test -n "$prev"; then
      if test -n "$prev"; then
        case $prev in
        case $prev in
        output)
        output)
          compile_command="$compile_command @OUTPUT@"
          compile_command="$compile_command @OUTPUT@"
          finalize_command="$finalize_command @OUTPUT@"
          finalize_command="$finalize_command @OUTPUT@"
          ;;
          ;;
        esac
        esac
 
 
        case $prev in
        case $prev in
        dlfiles|dlprefiles)
        dlfiles|dlprefiles)
          if test "$preload" = no; then
          if test "$preload" = no; then
            # Add the symbol object into the linking commands.
            # Add the symbol object into the linking commands.
            compile_command="$compile_command @SYMFILE@"
            compile_command="$compile_command @SYMFILE@"
            finalize_command="$finalize_command @SYMFILE@"
            finalize_command="$finalize_command @SYMFILE@"
            preload=yes
            preload=yes
          fi
          fi
          case $arg in
          case $arg in
          *.la | *.lo) ;;  # We handle these cases below.
          *.la | *.lo) ;;  # We handle these cases below.
          force)
          force)
            if test "$dlself" = no; then
            if test "$dlself" = no; then
              dlself=needless
              dlself=needless
              export_dynamic=yes
              export_dynamic=yes
            fi
            fi
            prev=
            prev=
            continue
            continue
            ;;
            ;;
          self)
          self)
            if test "$prev" = dlprefiles; then
            if test "$prev" = dlprefiles; then
              dlself=yes
              dlself=yes
            elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
            elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
              dlself=yes
              dlself=yes
            else
            else
              dlself=needless
              dlself=needless
              export_dynamic=yes
              export_dynamic=yes
            fi
            fi
            prev=
            prev=
            continue
            continue
            ;;
            ;;
          *)
          *)
            if test "$prev" = dlfiles; then
            if test "$prev" = dlfiles; then
              dlfiles="$dlfiles $arg"
              dlfiles="$dlfiles $arg"
            else
            else
              dlprefiles="$dlprefiles $arg"
              dlprefiles="$dlprefiles $arg"
            fi
            fi
            prev=
            prev=
            continue
            continue
            ;;
            ;;
          esac
          esac
          ;;
          ;;
        expsyms)
        expsyms)
          export_symbols="$arg"
          export_symbols="$arg"
          if test ! -f "$arg"; then
          if test ! -f "$arg"; then
            $echo "$modename: symbol file \`$arg' does not exist"
            $echo "$modename: symbol file \`$arg' does not exist"
            exit 1
            exit 1
          fi
          fi
          prev=
          prev=
          continue
          continue
          ;;
          ;;
        expsyms_regex)
        expsyms_regex)
          export_symbols_regex="$arg"
          export_symbols_regex="$arg"
          prev=
          prev=
          continue
          continue
          ;;
          ;;
        release)
        release)
          release="-$arg"
          release="-$arg"
          prev=
          prev=
          continue
          continue
          ;;
          ;;
        objectlist)
        objectlist)
          if test -f "$arg"; then
          if test -f "$arg"; then
            save_arg=$arg
            save_arg=$arg
            moreargs=
            moreargs=
            for fil in `cat $save_arg`
            for fil in `cat $save_arg`
            do
            do
#             moreargs="$moreargs $fil"
#             moreargs="$moreargs $fil"
              arg=$fil
              arg=$fil
              # A libtool-controlled object.
              # A libtool-controlled object.
 
 
              # Check to see that this really is a libtool object.
              # Check to see that this really is a libtool object.
              if (sed -e '2q' $arg | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
              if (sed -e '2q' $arg | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
                pic_object=
                pic_object=
                non_pic_object=
                non_pic_object=
 
 
                # Read the .lo file
                # Read the .lo file
                # If there is no directory component, then add one.
                # If there is no directory component, then add one.
                case $arg in
                case $arg in
                */* | *\\*) . $arg ;;
                */* | *\\*) . $arg ;;
                *) . ./$arg ;;
                *) . ./$arg ;;
                esac
                esac
 
 
                if test -z "$pic_object" || \
                if test -z "$pic_object" || \
                   test -z "$non_pic_object" ||
                   test -z "$non_pic_object" ||
                   test "$pic_object" = none && \
                   test "$pic_object" = none && \
                   test "$non_pic_object" = none; then
                   test "$non_pic_object" = none; then
                  $echo "$modename: cannot find name of object for \`$arg'" 1>&2
                  $echo "$modename: cannot find name of object for \`$arg'" 1>&2
                  exit 1
                  exit 1
                fi
                fi
 
 
                # Extract subdirectory from the argument.
                # Extract subdirectory from the argument.
                xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
                xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
                if test "X$xdir" = "X$arg"; then
                if test "X$xdir" = "X$arg"; then
                  xdir=
                  xdir=
                else
                else
                  xdir="$xdir/"
                  xdir="$xdir/"
                fi
                fi
 
 
                if test "$pic_object" != none; then
                if test "$pic_object" != none; then
                  # Prepend the subdirectory the object is found in.
                  # Prepend the subdirectory the object is found in.
                  pic_object="$xdir$pic_object"
                  pic_object="$xdir$pic_object"
 
 
                  if test "$prev" = dlfiles; then
                  if test "$prev" = dlfiles; then
                    if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
                    if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
                      dlfiles="$dlfiles $pic_object"
                      dlfiles="$dlfiles $pic_object"
                      prev=
                      prev=
                      continue
                      continue
                    else
                    else
                      # If libtool objects are unsupported, then we need to preload.
                      # If libtool objects are unsupported, then we need to preload.
                      prev=dlprefiles
                      prev=dlprefiles
                    fi
                    fi
                  fi
                  fi
 
 
                  # CHECK ME:  I think I busted this.  -Ossama
                  # CHECK ME:  I think I busted this.  -Ossama
                  if test "$prev" = dlprefiles; then
                  if test "$prev" = dlprefiles; then
                    # Preload the old-style object.
                    # Preload the old-style object.
                    dlprefiles="$dlprefiles $pic_object"
                    dlprefiles="$dlprefiles $pic_object"
                    prev=
                    prev=
                  fi
                  fi
 
 
                  # A PIC object.
                  # A PIC object.
                  libobjs="$libobjs $pic_object"
                  libobjs="$libobjs $pic_object"
                  arg="$pic_object"
                  arg="$pic_object"
                fi
                fi
 
 
                # Non-PIC object.
                # Non-PIC object.
                if test "$non_pic_object" != none; then
                if test "$non_pic_object" != none; then
                  # Prepend the subdirectory the object is found in.
                  # Prepend the subdirectory the object is found in.
                  non_pic_object="$xdir$non_pic_object"
                  non_pic_object="$xdir$non_pic_object"
 
 
                  # A standard non-PIC object
                  # A standard non-PIC object
                  non_pic_objects="$non_pic_objects $non_pic_object"
                  non_pic_objects="$non_pic_objects $non_pic_object"
                  if test -z "$pic_object" || test "$pic_object" = none ; then
                  if test -z "$pic_object" || test "$pic_object" = none ; then
                    arg="$non_pic_object"
                    arg="$non_pic_object"
                  fi
                  fi
                fi
                fi
              else
              else
                # Only an error if not doing a dry-run.
                # Only an error if not doing a dry-run.
                if test -z "$run"; then
                if test -z "$run"; then
                  $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
                  $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
                  exit 1
                  exit 1
                else
                else
                  # Dry-run case.
                  # Dry-run case.
 
 
                  # Extract subdirectory from the argument.
                  # Extract subdirectory from the argument.
                  xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
                  xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
                  if test "X$xdir" = "X$arg"; then
                  if test "X$xdir" = "X$arg"; then
                    xdir=
                    xdir=
                  else
                  else
                    xdir="$xdir/"
                    xdir="$xdir/"
                  fi
                  fi
 
 
                  pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
                  pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
                  non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
                  non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
                  libobjs="$libobjs $pic_object"
                  libobjs="$libobjs $pic_object"
                  non_pic_objects="$non_pic_objects $non_pic_object"
                  non_pic_objects="$non_pic_objects $non_pic_object"
                fi
                fi
              fi
              fi
            done
            done
          else
          else
            $echo "$modename: link input file \`$save_arg' does not exist"
            $echo "$modename: link input file \`$save_arg' does not exist"
            exit 1
            exit 1
          fi
          fi
          arg=$save_arg
          arg=$save_arg
          prev=
          prev=
          continue
          continue
          ;;
          ;;
        rpath | xrpath)
        rpath | xrpath)
          # We need an absolute path.
          # We need an absolute path.
          case $arg in
          case $arg in
          [\\/]* | [A-Za-z]:[\\/]*) ;;
          [\\/]* | [A-Za-z]:[\\/]*) ;;
          *)
          *)
            $echo "$modename: only absolute run-paths are allowed" 1>&2
            $echo "$modename: only absolute run-paths are allowed" 1>&2
            exit 1
            exit 1
            ;;
            ;;
          esac
          esac
          if test "$prev" = rpath; then
          if test "$prev" = rpath; then
            case "$rpath " in
            case "$rpath " in
            *" $arg "*) ;;
            *" $arg "*) ;;
            *) rpath="$rpath $arg" ;;
            *) rpath="$rpath $arg" ;;
            esac
            esac
          else
          else
            case "$xrpath " in
            case "$xrpath " in
            *" $arg "*) ;;
            *" $arg "*) ;;
            *) xrpath="$xrpath $arg" ;;
            *) xrpath="$xrpath $arg" ;;
            esac
            esac
          fi
          fi
          prev=
          prev=
          continue
          continue
          ;;
          ;;
        xcompiler)
        xcompiler)
          compiler_flags="$compiler_flags $qarg"
          compiler_flags="$compiler_flags $qarg"
          prev=
          prev=
          compile_command="$compile_command $qarg"
          compile_command="$compile_command $qarg"
          finalize_command="$finalize_command $qarg"
          finalize_command="$finalize_command $qarg"
          continue
          continue
          ;;
          ;;
        xlinker)
        xlinker)
          linker_flags="$linker_flags $qarg"
          linker_flags="$linker_flags $qarg"
          compiler_flags="$compiler_flags $wl$qarg"
          compiler_flags="$compiler_flags $wl$qarg"
          prev=
          prev=
          compile_command="$compile_command $wl$qarg"
          compile_command="$compile_command $wl$qarg"
          finalize_command="$finalize_command $wl$qarg"
          finalize_command="$finalize_command $wl$qarg"
          continue
          continue
          ;;
          ;;
        *)
        *)
          eval "$prev=\"\$arg\""
          eval "$prev=\"\$arg\""
          prev=
          prev=
          continue
          continue
          ;;
          ;;
        esac
        esac
      fi # test -n $prev
      fi # test -n $prev
 
 
      prevarg="$arg"
      prevarg="$arg"
 
 
      case $arg in
      case $arg in
      -all-static)
      -all-static)
        if test -n "$link_static_flag"; then
        if test -n "$link_static_flag"; then
          compile_command="$compile_command $link_static_flag"
          compile_command="$compile_command $link_static_flag"
          finalize_command="$finalize_command $link_static_flag"
          finalize_command="$finalize_command $link_static_flag"
        fi
        fi
        continue
        continue
        ;;
        ;;
 
 
      -allow-undefined)
      -allow-undefined)
        # FIXME: remove this flag sometime in the future.
        # FIXME: remove this flag sometime in the future.
        $echo "$modename: \`-allow-undefined' is deprecated because it is the default" 1>&2
        $echo "$modename: \`-allow-undefined' is deprecated because it is the default" 1>&2
        continue
        continue
        ;;
        ;;
 
 
      -avoid-version)
      -avoid-version)
        avoid_version=yes
        avoid_version=yes
        continue
        continue
        ;;
        ;;
 
 
      -dlopen)
      -dlopen)
        prev=dlfiles
        prev=dlfiles
        continue
        continue
        ;;
        ;;
 
 
      -dlpreopen)
      -dlpreopen)
        prev=dlprefiles
        prev=dlprefiles
        continue
        continue
        ;;
        ;;
 
 
      -export-dynamic)
      -export-dynamic)
        export_dynamic=yes
        export_dynamic=yes
        continue
        continue
        ;;
        ;;
 
 
      -export-symbols | -export-symbols-regex)
      -export-symbols | -export-symbols-regex)
        if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
        if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
          $echo "$modename: more than one -exported-symbols argument is not allowed"
          $echo "$modename: more than one -exported-symbols argument is not allowed"
          exit 1
          exit 1
        fi
        fi
        if test "X$arg" = "X-export-symbols"; then
        if test "X$arg" = "X-export-symbols"; then
          prev=expsyms
          prev=expsyms
        else
        else
          prev=expsyms_regex
          prev=expsyms_regex
        fi
        fi
        continue
        continue
        ;;
        ;;
 
 
      # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
      # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
      # so, if we see these flags be careful not to treat them like -L
      # so, if we see these flags be careful not to treat them like -L
      -L[A-Z][A-Z]*:*)
      -L[A-Z][A-Z]*:*)
        case $with_gcc/$host in
        case $with_gcc/$host in
        no/*-*-irix*)
        no/*-*-irix*)
          compile_command="$compile_command $arg"
          compile_command="$compile_command $arg"
          finalize_command="$finalize_command $arg"
          finalize_command="$finalize_command $arg"
          ;;
          ;;
        esac
        esac
        continue
        continue
        ;;
        ;;
 
 
      -L*)
      -L*)
        dir=`$echo "X$arg" | $Xsed -e 's/^-L//'`
        dir=`$echo "X$arg" | $Xsed -e 's/^-L//'`
        # We need an absolute path.
        # We need an absolute path.
        case $dir in
        case $dir in
        [\\/]* | [A-Za-z]:[\\/]*) ;;
        [\\/]* | [A-Za-z]:[\\/]*) ;;
        *)
        *)
          absdir=`cd "$dir" && pwd`
          absdir=`cd "$dir" && pwd`
          if test -z "$absdir"; then
          if test -z "$absdir"; then
            $echo "$modename: cannot determine absolute directory name of \`$dir'" 1>&2
            $echo "$modename: cannot determine absolute directory name of \`$dir'" 1>&2
            exit 1
            exit 1
          fi
          fi
          dir="$absdir"
          dir="$absdir"
          ;;
          ;;
        esac
        esac
        case "$deplibs " in
        case "$deplibs " in
        *" -L$dir "*) ;;
        *" -L$dir "*) ;;
        *)
        *)
          deplibs="$deplibs -L$dir"
          deplibs="$deplibs -L$dir"
          lib_search_path="$lib_search_path $dir"
          lib_search_path="$lib_search_path $dir"
          ;;
          ;;
        esac
        esac
        case $host in
        case $host in
        *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
        *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
          case :$dllsearchpath: in
          case :$dllsearchpath: in
          *":$dir:"*) ;;
          *":$dir:"*) ;;
          *) dllsearchpath="$dllsearchpath:$dir";;
          *) dllsearchpath="$dllsearchpath:$dir";;
          esac
          esac
          ;;
          ;;
        esac
        esac
        continue
        continue
        ;;
        ;;
 
 
      -l*)
      -l*)
        if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
        if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
          case $host in
          case $host in
          *-*-cygwin* | *-*-pw32* | *-*-beos*)
          *-*-cygwin* | *-*-pw32* | *-*-beos*)
            # These systems don't actually have a C or math library (as such)
            # These systems don't actually have a C or math library (as such)
            continue
            continue
            ;;
            ;;
          *-*-mingw* | *-*-os2*)
          *-*-mingw* | *-*-os2*)
            # These systems don't actually have a C library (as such)
            # These systems don't actually have a C library (as such)
            test "X$arg" = "X-lc" && continue
            test "X$arg" = "X-lc" && continue
            ;;
            ;;
          esac
          esac
        fi
        fi
        deplibs="$deplibs $arg"
        deplibs="$deplibs $arg"
        continue
        continue
        ;;
        ;;
 
 
      -module)
      -module)
        module=yes
        module=yes
        continue
        continue
        ;;
        ;;
 
 
      -no-fast-install)
      -no-fast-install)
        fast_install=no
        fast_install=no
        continue
        continue
        ;;
        ;;
 
 
      -no-install)
      -no-install)
        case $host in
        case $host in
        *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
        *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
          # The PATH hackery in wrapper scripts is required on Windows
          # The PATH hackery in wrapper scripts is required on Windows
          # in order for the loader to find any dlls it needs.
          # in order for the loader to find any dlls it needs.
          $echo "$modename: warning: \`-no-install' is ignored for $host" 1>&2
          $echo "$modename: warning: \`-no-install' is ignored for $host" 1>&2
          $echo "$modename: warning: assuming \`-no-fast-install' instead" 1>&2
          $echo "$modename: warning: assuming \`-no-fast-install' instead" 1>&2
          fast_install=no
          fast_install=no
          ;;
          ;;
        *) no_install=yes ;;
        *) no_install=yes ;;
        esac
        esac
        continue
        continue
        ;;
        ;;
 
 
      -no-undefined)
      -no-undefined)
        allow_undefined=no
        allow_undefined=no
        continue
        continue
        ;;
        ;;
 
 
      -objectlist)
      -objectlist)
        prev=objectlist
        prev=objectlist
        continue
        continue
        ;;
        ;;
 
 
      -o) prev=output ;;
      -o) prev=output ;;
 
 
      -release)
      -release)
        prev=release
        prev=release
        continue
        continue
        ;;
        ;;
 
 
      -rpath)
      -rpath)
        prev=rpath
        prev=rpath
        continue
        continue
        ;;
        ;;
 
 
      -R)
      -R)
        prev=xrpath
        prev=xrpath
        continue
        continue
        ;;
        ;;
 
 
      -R*)
      -R*)
        dir=`$echo "X$arg" | $Xsed -e 's/^-R//'`
        dir=`$echo "X$arg" | $Xsed -e 's/^-R//'`
        # We need an absolute path.
        # We need an absolute path.
        case $dir in
        case $dir in
        [\\/]* | [A-Za-z]:[\\/]*) ;;
        [\\/]* | [A-Za-z]:[\\/]*) ;;
        *)
        *)
          $echo "$modename: only absolute run-paths are allowed" 1>&2
          $echo "$modename: only absolute run-paths are allowed" 1>&2
          exit 1
          exit 1
          ;;
          ;;
        esac
        esac
        case "$xrpath " in
        case "$xrpath " in
        *" $dir "*) ;;
        *" $dir "*) ;;
        *) xrpath="$xrpath $dir" ;;
        *) xrpath="$xrpath $dir" ;;
        esac
        esac
        continue
        continue
        ;;
        ;;
 
 
      -static)
      -static)
        # The effects of -static are defined in a previous loop.
        # The effects of -static are defined in a previous loop.
        # We used to do the same as -all-static on platforms that
        # We used to do the same as -all-static on platforms that
        # didn't have a PIC flag, but the assumption that the effects
        # didn't have a PIC flag, but the assumption that the effects
        # would be equivalent was wrong.  It would break on at least
        # would be equivalent was wrong.  It would break on at least
        # Digital Unix and AIX.
        # Digital Unix and AIX.
        continue
        continue
        ;;
        ;;
 
 
      -thread-safe)
      -thread-safe)
        thread_safe=yes
        thread_safe=yes
        continue
        continue
        ;;
        ;;
 
 
      -version-info)
      -version-info)
        prev=vinfo
        prev=vinfo
        continue
        continue
        ;;
        ;;
 
 
      -Wc,*)
      -Wc,*)
        args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wc,//'`
        args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wc,//'`
        arg=
        arg=
        IFS="${IFS=     }"; save_ifs="$IFS"; IFS=','
        IFS="${IFS=     }"; save_ifs="$IFS"; IFS=','
        for flag in $args; do
        for flag in $args; do
          IFS="$save_ifs"
          IFS="$save_ifs"
          case $flag in
          case $flag in
            *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
            *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
            flag="\"$flag\""
            flag="\"$flag\""
            ;;
            ;;
          esac
          esac
          arg="$arg $wl$flag"
          arg="$arg $wl$flag"
          compiler_flags="$compiler_flags $flag"
          compiler_flags="$compiler_flags $flag"
        done
        done
        IFS="$save_ifs"
        IFS="$save_ifs"
        arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
        arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
        ;;
        ;;
 
 
      -Wl,*)
      -Wl,*)
        args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wl,//'`
        args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wl,//'`
        arg=
        arg=
        IFS="${IFS=     }"; save_ifs="$IFS"; IFS=','
        IFS="${IFS=     }"; save_ifs="$IFS"; IFS=','
        for flag in $args; do
        for flag in $args; do
          IFS="$save_ifs"
          IFS="$save_ifs"
          case $flag in
          case $flag in
            *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
            *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
            flag="\"$flag\""
            flag="\"$flag\""
            ;;
            ;;
          esac
          esac
          arg="$arg $wl$flag"
          arg="$arg $wl$flag"
          compiler_flags="$compiler_flags $wl$flag"
          compiler_flags="$compiler_flags $wl$flag"
          linker_flags="$linker_flags $flag"
          linker_flags="$linker_flags $flag"
        done
        done
        IFS="$save_ifs"
        IFS="$save_ifs"
        arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
        arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
        ;;
        ;;
 
 
      -Xcompiler)
      -Xcompiler)
        prev=xcompiler
        prev=xcompiler
        continue
        continue
        ;;
        ;;
 
 
      -Xlinker)
      -Xlinker)
        prev=xlinker
        prev=xlinker
        continue
        continue
        ;;
        ;;
 
 
      # Some other compiler flag.
      # Some other compiler flag.
      -* | +*)
      -* | +*)
        # Unknown arguments in both finalize_command and compile_command need
        # Unknown arguments in both finalize_command and compile_command need
        # to be aesthetically quoted because they are evaled later.
        # to be aesthetically quoted because they are evaled later.
        arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
        arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
        case $arg in
        case $arg in
        *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
        *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
          arg="\"$arg\""
          arg="\"$arg\""
          ;;
          ;;
        esac
        esac
        ;;
        ;;
 
 
      *.$objext)
      *.$objext)
        # A standard object.
        # A standard object.
        objs="$objs $arg"
        objs="$objs $arg"
        ;;
        ;;
 
 
      *.lo)
      *.lo)
        # A libtool-controlled object.
        # A libtool-controlled object.
 
 
        # Check to see that this really is a libtool object.
        # Check to see that this really is a libtool object.
        if (sed -e '2q' $arg | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
        if (sed -e '2q' $arg | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
          pic_object=
          pic_object=
          non_pic_object=
          non_pic_object=
 
 
          # Read the .lo file
          # Read the .lo file
          # If there is no directory component, then add one.
          # If there is no directory component, then add one.
          case $arg in
          case $arg in
          */* | *\\*) . $arg ;;
          */* | *\\*) . $arg ;;
          *) . ./$arg ;;
          *) . ./$arg ;;
          esac
          esac
 
 
          if test -z "$pic_object" || \
          if test -z "$pic_object" || \
             test -z "$non_pic_object" ||
             test -z "$non_pic_object" ||
             test "$pic_object" = none && \
             test "$pic_object" = none && \
             test "$non_pic_object" = none; then
             test "$non_pic_object" = none; then
            $echo "$modename: cannot find name of object for \`$arg'" 1>&2
            $echo "$modename: cannot find name of object for \`$arg'" 1>&2
            exit 1
            exit 1
          fi
          fi
 
 
          # Extract subdirectory from the argument.
          # Extract subdirectory from the argument.
          xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
          xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
          if test "X$xdir" = "X$arg"; then
          if test "X$xdir" = "X$arg"; then
            xdir=
            xdir=
          else
          else
            xdir="$xdir/"
            xdir="$xdir/"
          fi
          fi
 
 
          if test "$pic_object" != none; then
          if test "$pic_object" != none; then
            # Prepend the subdirectory the object is found in.
            # Prepend the subdirectory the object is found in.
            pic_object="$xdir$pic_object"
            pic_object="$xdir$pic_object"
 
 
            if test "$prev" = dlfiles; then
            if test "$prev" = dlfiles; then
              if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
              if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
                dlfiles="$dlfiles $pic_object"
                dlfiles="$dlfiles $pic_object"
                prev=
                prev=
                continue
                continue
              else
              else
                # If libtool objects are unsupported, then we need to preload.
                # If libtool objects are unsupported, then we need to preload.
                prev=dlprefiles
                prev=dlprefiles
              fi
              fi
            fi
            fi
 
 
            # CHECK ME:  I think I busted this.  -Ossama
            # CHECK ME:  I think I busted this.  -Ossama
            if test "$prev" = dlprefiles; then
            if test "$prev" = dlprefiles; then
              # Preload the old-style object.
              # Preload the old-style object.
              dlprefiles="$dlprefiles $pic_object"
              dlprefiles="$dlprefiles $pic_object"
              prev=
              prev=
            fi
            fi
 
 
            # A PIC object.
            # A PIC object.
            libobjs="$libobjs $pic_object"
            libobjs="$libobjs $pic_object"
            arg="$pic_object"
            arg="$pic_object"
          fi
          fi
 
 
          # Non-PIC object.
          # Non-PIC object.
          if test "$non_pic_object" != none; then
          if test "$non_pic_object" != none; then
            # Prepend the subdirectory the object is found in.
            # Prepend the subdirectory the object is found in.
            non_pic_object="$xdir$non_pic_object"
            non_pic_object="$xdir$non_pic_object"
 
 
            # A standard non-PIC object
            # A standard non-PIC object
            non_pic_objects="$non_pic_objects $non_pic_object"
            non_pic_objects="$non_pic_objects $non_pic_object"
            if test -z "$pic_object" || test "$pic_object" = none ; then
            if test -z "$pic_object" || test "$pic_object" = none ; then
              arg="$non_pic_object"
              arg="$non_pic_object"
            fi
            fi
          fi
          fi
        else
        else
          # Only an error if not doing a dry-run.
          # Only an error if not doing a dry-run.
          if test -z "$run"; then
          if test -z "$run"; then
            $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
            $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
            exit 1
            exit 1
          else
          else
            # Dry-run case.
            # Dry-run case.
 
 
            # Extract subdirectory from the argument.
            # Extract subdirectory from the argument.
            xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
            xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
            if test "X$xdir" = "X$arg"; then
            if test "X$xdir" = "X$arg"; then
              xdir=
              xdir=
            else
            else
              xdir="$xdir/"
              xdir="$xdir/"
            fi
            fi
 
 
            pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
            pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
            non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
            non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
            libobjs="$libobjs $pic_object"
            libobjs="$libobjs $pic_object"
            non_pic_objects="$non_pic_objects $non_pic_object"
            non_pic_objects="$non_pic_objects $non_pic_object"
          fi
          fi
        fi
        fi
        ;;
        ;;
 
 
      *.$libext)
      *.$libext)
        # An archive.
        # An archive.
        deplibs="$deplibs $arg"
        deplibs="$deplibs $arg"
        old_deplibs="$old_deplibs $arg"
        old_deplibs="$old_deplibs $arg"
        continue
        continue
        ;;
        ;;
 
 
      *.la)
      *.la)
        # A libtool-controlled library.
        # A libtool-controlled library.
 
 
        if test "$prev" = dlfiles; then
        if test "$prev" = dlfiles; then
          # This library was specified with -dlopen.
          # This library was specified with -dlopen.
          dlfiles="$dlfiles $arg"
          dlfiles="$dlfiles $arg"
          prev=
          prev=
        elif test "$prev" = dlprefiles; then
        elif test "$prev" = dlprefiles; then
          # The library was specified with -dlpreopen.
          # The library was specified with -dlpreopen.
          dlprefiles="$dlprefiles $arg"
          dlprefiles="$dlprefiles $arg"
          prev=
          prev=
        else
        else
          deplibs="$deplibs $arg"
          deplibs="$deplibs $arg"
        fi
        fi
        continue
        continue
        ;;
        ;;
 
 
      # Some other compiler argument.
      # Some other compiler argument.
      *)
      *)
        # Unknown arguments in both finalize_command and compile_command need
        # Unknown arguments in both finalize_command and compile_command need
        # to be aesthetically quoted because they are evaled later.
        # to be aesthetically quoted because they are evaled later.
        arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
        arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
        case $arg in
        case $arg in
        *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
        *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
          arg="\"$arg\""
          arg="\"$arg\""
          ;;
          ;;
        esac
        esac
        ;;
        ;;
      esac # arg
      esac # arg
 
 
      # Now actually substitute the argument into the commands.
      # Now actually substitute the argument into the commands.
      if test -n "$arg"; then
      if test -n "$arg"; then
        compile_command="$compile_command $arg"
        compile_command="$compile_command $arg"
        finalize_command="$finalize_command $arg"
        finalize_command="$finalize_command $arg"
      fi
      fi
    done # argument parsing loop
    done # argument parsing loop
 
 
    if test -n "$prev"; then
    if test -n "$prev"; then
      $echo "$modename: the \`$prevarg' option requires an argument" 1>&2
      $echo "$modename: the \`$prevarg' option requires an argument" 1>&2
      $echo "$help" 1>&2
      $echo "$help" 1>&2
      exit 1
      exit 1
    fi
    fi
 
 
    # 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 link
    # Only attempt this if the compiler in the base link
    # command doesn't match the default compiler.
    # command doesn't match the default compiler.
    if test -n "$available_tags" && test -z "$tagname"; then
    if test -n "$available_tags" && test -z "$tagname"; then
      case $base_compile in
      case $base_compile in
      "$CC "*) ;;
      "$CC "*) ;;
      # Blanks in the command may have been stripped by the calling shell,
      # Blanks in the command may have been stripped by the calling shell,
      # but not from the CC environment variable when ltconfig was run.
      # but not from the CC environment variable when ltconfig was run.
      "`$echo $CC` "*) ;;
      "`$echo $CC` "*) ;;
      *)
      *)
        for z in $available_tags; do
        for z in $available_tags; do
          if grep "^### BEGIN LIBTOOL TAG CONFIG: $z$" < "$0" > /dev/null; then
          if grep "^### BEGIN LIBTOOL TAG CONFIG: $z$" < "$0" > /dev/null; then
            # Evaluate the configuration.
            # Evaluate the configuration.
            eval "`sed -n -e '/^### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^### END LIBTOOL TAG CONFIG: '$z'$/p' < $0`"
            eval "`sed -n -e '/^### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^### END LIBTOOL TAG CONFIG: '$z'$/p' < $0`"
            case $base_compile in
            case $base_compile in
            "$CC "*)
            "$CC "*)
              # The compiler in $compile_command matches
              # The compiler in $compile_command matches
              # the one in the tagged configuration.
              # the one in the tagged configuration.
              # Assume this is the tagged configuration we want.
              # Assume this is the tagged configuration we want.
              tagname=$z
              tagname=$z
              break
              break
              ;;
              ;;
            "`$echo $CC` "*)
            "`$echo $CC` "*)
              tagname=$z
              tagname=$z
              break
              break
              ;;
              ;;
            esac
            esac
          fi
          fi
        done
        done
        # If $tagname still isn't set, then no tagged configuration
        # If $tagname still isn't set, then no tagged configuration
        # was found and let the user know that the "--tag" command
        # was found and let the user know that the "--tag" command
        # line option must be used.
        # line option must be used.
        if test -z "$tagname"; then
        if test -z "$tagname"; then
          echo "$modename: unable to infer tagged configuration"
          echo "$modename: unable to infer tagged configuration"
          echo "$modename: specify a tag with \`--tag'" 1>&2
          echo "$modename: specify a tag with \`--tag'" 1>&2
          exit 1
          exit 1
#       else
#       else
#         echo "$modename: using $tagname tagged configuration"
#         echo "$modename: using $tagname tagged configuration"
        fi
        fi
        ;;
        ;;
      esac
      esac
    fi
    fi
 
 
    if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
    if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
      eval arg=\"$export_dynamic_flag_spec\"
      eval arg=\"$export_dynamic_flag_spec\"
      compile_command="$compile_command $arg"
      compile_command="$compile_command $arg"
      finalize_command="$finalize_command $arg"
      finalize_command="$finalize_command $arg"
    fi
    fi
 
 
    # calculate the name of the file, without its directory
    # calculate the name of the file, without its directory
    outputname=`$echo "X$output" | $Xsed -e 's%^.*/%%'`
    outputname=`$echo "X$output" | $Xsed -e 's%^.*/%%'`
    libobjs_save="$libobjs"
    libobjs_save="$libobjs"
 
 
    if test -n "$shlibpath_var"; then
    if test -n "$shlibpath_var"; then
      # get the directories listed in $shlibpath_var
      # get the directories listed in $shlibpath_var
      eval shlib_search_path=\`\$echo \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
      eval shlib_search_path=\`\$echo \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
    else
    else
      shlib_search_path=
      shlib_search_path=
    fi
    fi
    eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
    eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
    eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
    eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
 
 
    output_objdir=`$echo "X$output" | $Xsed -e 's%/[^/]*$%%'`
    output_objdir=`$echo "X$output" | $Xsed -e 's%/[^/]*$%%'`
    if test "X$output_objdir" = "X$output"; then
    if test "X$output_objdir" = "X$output"; then
      output_objdir="$objdir"
      output_objdir="$objdir"
    else
    else
      output_objdir="$output_objdir/$objdir"
      output_objdir="$output_objdir/$objdir"
    fi
    fi
    # Create the object directory.
    # Create the object directory.
    if test ! -d $output_objdir; then
    if test ! -d $output_objdir; then
      $show "$mkdir $output_objdir"
      $show "$mkdir $output_objdir"
      $run $mkdir $output_objdir
      $run $mkdir $output_objdir
      status=$?
      status=$?
      if test $status -ne 0 && test ! -d $output_objdir; then
      if test $status -ne 0 && test ! -d $output_objdir; then
        exit $status
        exit $status
      fi
      fi
    fi
    fi
 
 
    # Determine the type of output
    # Determine the type of output
    case $output in
    case $output in
    "")
    "")
      $echo "$modename: you must specify an output file" 1>&2
      $echo "$modename: you must specify an output file" 1>&2
      $echo "$help" 1>&2
      $echo "$help" 1>&2
      exit 1
      exit 1
      ;;
      ;;
    *.$libext) linkmode=oldlib ;;
    *.$libext) linkmode=oldlib ;;
    *.lo | *.$objext) linkmode=obj ;;
    *.lo | *.$objext) linkmode=obj ;;
    *.la) linkmode=lib ;;
    *.la) linkmode=lib ;;
    *) linkmode=prog ;; # Anything else should be a program.
    *) linkmode=prog ;; # Anything else should be a program.
    esac
    esac
 
 
    specialdeplibs=
    specialdeplibs=
    libs=
    libs=
    # Find all interdependent deplibs by searching for libraries
    # Find all interdependent deplibs by searching for libraries
    # that are linked more than once (e.g. -la -lb -la)
    # that are linked more than once (e.g. -la -lb -la)
    for deplib in $deplibs; do
    for deplib in $deplibs; do
      case "$libs " in
      case "$libs " in
      *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
      *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
      esac
      esac
      libs="$libs $deplib"
      libs="$libs $deplib"
    done
    done
 
 
    if test $linkmode = lib; then
    if test $linkmode = lib; then
      libs="$predeps $libs $compiler_lib_search_path $postdeps"
      libs="$predeps $libs $compiler_lib_search_path $postdeps"
 
 
      # Compute libraries that are listed more than once in $predeps
      # Compute libraries that are listed more than once in $predeps
      # $postdeps and mark them as special (i.e., whose duplicates are
      # $postdeps and mark them as special (i.e., whose duplicates are
      # not to be eliminated).
      # not to be eliminated).
      pre_post_deps=
      pre_post_deps=
      for pre_post_dep in $predeps $postdeps; do
      for pre_post_dep in $predeps $postdeps; do
        case "$pre_post_deps " in
        case "$pre_post_deps " in
        *" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
        *" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
        esac
        esac
        pre_post_deps="$pre_post_deps $pre_post_dep"
        pre_post_deps="$pre_post_deps $pre_post_dep"
      done
      done
      pre_post_deps=
      pre_post_deps=
    fi
    fi
 
 
    deplibs=
    deplibs=
    newdependency_libs=
    newdependency_libs=
    newlib_search_path=
    newlib_search_path=
    need_relink=no # whether we're linking any uninstalled libtool libraries
    need_relink=no # whether we're linking any uninstalled libtool libraries
    notinst_deplibs= # not-installed libtool libraries
    notinst_deplibs= # not-installed libtool libraries
    notinst_path= # paths that contain not-installed libtool libraries
    notinst_path= # paths that contain not-installed libtool libraries
    case $linkmode in
    case $linkmode in
    lib)
    lib)
        passes="conv link"
        passes="conv link"
        for file in $dlfiles $dlprefiles; do
        for file in $dlfiles $dlprefiles; do
          case $file in
          case $file in
          *.la) ;;
          *.la) ;;
          *)
          *)
            $echo "$modename: libraries can \`-dlopen' only libtool libraries: $file" 1>&2
            $echo "$modename: libraries can \`-dlopen' only libtool libraries: $file" 1>&2
            exit 1
            exit 1
            ;;
            ;;
          esac
          esac
        done
        done
        ;;
        ;;
    prog)
    prog)
        compile_deplibs=
        compile_deplibs=
        finalize_deplibs=
        finalize_deplibs=
        alldeplibs=no
        alldeplibs=no
        newdlfiles=
        newdlfiles=
        newdlprefiles=
        newdlprefiles=
        passes="conv scan dlopen dlpreopen link"
        passes="conv scan dlopen dlpreopen link"
        ;;
        ;;
    *)  passes="conv"
    *)  passes="conv"
        ;;
        ;;
    esac
    esac
    for pass in $passes; do
    for pass in $passes; do
      if test $linkmode = prog; then
      if test $linkmode = prog; then
        # Determine which files to process
        # Determine which files to process
        case $pass in
        case $pass in
        dlopen)
        dlopen)
          libs="$dlfiles"
          libs="$dlfiles"
          save_deplibs="$deplibs" # Collect dlpreopened libraries
          save_deplibs="$deplibs" # Collect dlpreopened libraries
          deplibs=
          deplibs=
          ;;
          ;;
        dlpreopen) libs="$dlprefiles" ;;
        dlpreopen) libs="$dlprefiles" ;;
        link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
        link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
        esac
        esac
      fi
      fi
      for deplib in $libs; do
      for deplib in $libs; do
        lib=
        lib=
        found=no
        found=no
        case $deplib in
        case $deplib in
        -l*)
        -l*)
          if test $linkmode = oldlib && test $linkmode = obj; then
          if test $linkmode = oldlib && test $linkmode = obj; then
            $echo "$modename: warning: \`-l' is ignored for archives/objects: $deplib" 1>&2
            $echo "$modename: warning: \`-l' is ignored for archives/objects: $deplib" 1>&2
            continue
            continue
          fi
          fi
          if test $pass = conv; then
          if test $pass = conv; then
            deplibs="$deplib $deplibs"
            deplibs="$deplib $deplibs"
            continue
            continue
          fi
          fi
          name=`$echo "X$deplib" | $Xsed -e 's/^-l//'`
          name=`$echo "X$deplib" | $Xsed -e 's/^-l//'`
          for searchdir in $newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path; do
          for searchdir in $newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path; do
            # Search the libtool library
            # Search the libtool library
            lib="$searchdir/lib${name}.la"
            lib="$searchdir/lib${name}.la"
            if test -f "$lib"; then
            if test -f "$lib"; then
              found=yes
              found=yes
              break
              break
            fi
            fi
          done
          done
          if test "$found" != yes; then
          if test "$found" != yes; then
            # deplib doesn't seem to be a libtool library
            # deplib doesn't seem to be a libtool library
            if test "$linkmode,$pass" = "prog,link"; then
            if test "$linkmode,$pass" = "prog,link"; then
              compile_deplibs="$deplib $compile_deplibs"
              compile_deplibs="$deplib $compile_deplibs"
              finalize_deplibs="$deplib $finalize_deplibs"
              finalize_deplibs="$deplib $finalize_deplibs"
            else
            else
              deplibs="$deplib $deplibs"
              deplibs="$deplib $deplibs"
              test $linkmode = lib && newdependency_libs="$deplib $newdependency_libs"
              test $linkmode = lib && newdependency_libs="$deplib $newdependency_libs"
            fi
            fi
            continue
            continue
          fi
          fi
          ;; # -l
          ;; # -l
        -L*)
        -L*)
          case $linkmode in
          case $linkmode in
          lib)
          lib)
            deplibs="$deplib $deplibs"
            deplibs="$deplib $deplibs"
            test $pass = conv && continue
            test $pass = conv && continue
            newdependency_libs="$deplib $newdependency_libs"
            newdependency_libs="$deplib $newdependency_libs"
            newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
            newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
            ;;
            ;;
          prog)
          prog)
            if test $pass = conv; then
            if test $pass = conv; then
              deplibs="$deplib $deplibs"
              deplibs="$deplib $deplibs"
              continue
              continue
            fi
            fi
            if test $pass = scan; then
            if test $pass = scan; then
              deplibs="$deplib $deplibs"
              deplibs="$deplib $deplibs"
              newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
              newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
            else
            else
              compile_deplibs="$deplib $compile_deplibs"
              compile_deplibs="$deplib $compile_deplibs"
              finalize_deplibs="$deplib $finalize_deplibs"
              finalize_deplibs="$deplib $finalize_deplibs"
            fi
            fi
            ;;
            ;;
          *)
          *)
            $echo "$modename: warning: \`-L' is ignored for archives/objects: $deplib" 1>&2
            $echo "$modename: warning: \`-L' is ignored for archives/objects: $deplib" 1>&2
            ;;
            ;;
          esac # linkmode
          esac # linkmode
          continue
          continue
          ;; # -L
          ;; # -L
        -R*)
        -R*)
          if test $pass = link; then
          if test $pass = link; then
            dir=`$echo "X$deplib" | $Xsed -e 's/^-R//'`
            dir=`$echo "X$deplib" | $Xsed -e 's/^-R//'`
            # Make sure the xrpath contains only unique directories.
            # Make sure the xrpath contains only unique directories.
            case "$xrpath " in
            case "$xrpath " in
            *" $dir "*) ;;
            *" $dir "*) ;;
            *) xrpath="$xrpath $dir" ;;
            *) xrpath="$xrpath $dir" ;;
            esac
            esac
          fi
          fi
          deplibs="$deplib $deplibs"
          deplibs="$deplib $deplibs"
          continue
          continue
          ;;
          ;;
        *.la) lib="$deplib" ;;
        *.la) lib="$deplib" ;;
        *.$libext)
        *.$libext)
          if test $pass = conv; then
          if test $pass = conv; then
            deplibs="$deplib $deplibs"
            deplibs="$deplib $deplibs"
            continue
            continue
          fi
          fi
          case $linkmode in
          case $linkmode in
          lib)
          lib)
            if test "$deplibs_check_method" != pass_all; then
            if test "$deplibs_check_method" != pass_all; then
              echo
              echo
              echo "*** Warning: This library needs some functionality provided by $deplib."
              echo "*** Warning: This library needs some functionality provided by $deplib."
              echo "*** I have the capability to make that library automatically link in when"
              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 "*** you link to this library.  But I can only do this if you have a"
              echo "*** shared version of the library, which you do not appear to have."
              echo "*** shared version of the library, which you do not appear to have."
            else
            else
              echo
              echo
              echo "*** Warning: Linking the shared library $output against the"
              echo "*** Warning: Linking the shared library $output against the"
              echo "*** static library $deplib is not portable!"
              echo "*** static library $deplib is not portable!"
              deplibs="$deplib $deplibs"
              deplibs="$deplib $deplibs"
            fi
            fi
            continue
            continue
            ;;
            ;;
          prog)
          prog)
            if test $pass != link; then
            if test $pass != link; then
              deplibs="$deplib $deplibs"
              deplibs="$deplib $deplibs"
            else
            else
              compile_deplibs="$deplib $compile_deplibs"
              compile_deplibs="$deplib $compile_deplibs"
              finalize_deplibs="$deplib $finalize_deplibs"
              finalize_deplibs="$deplib $finalize_deplibs"
            fi
            fi
            continue
            continue
            ;;
            ;;
          esac # linkmode
          esac # linkmode
          ;; # *.$libext
          ;; # *.$libext
        *.lo | *.$objext)
        *.lo | *.$objext)
          if test $pass = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; 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,
            # If there is no dlopen support or we're linking statically,
            # we need to preload.
            # we need to preload.
            newdlprefiles="$newdlprefiles $deplib"
            newdlprefiles="$newdlprefiles $deplib"
            compile_deplibs="$deplib $compile_deplibs"
            compile_deplibs="$deplib $compile_deplibs"
            finalize_deplibs="$deplib $finalize_deplibs"
            finalize_deplibs="$deplib $finalize_deplibs"
          else
          else
            newdlfiles="$newdlfiles $deplib"
            newdlfiles="$newdlfiles $deplib"
          fi
          fi
          continue
          continue
          ;;
          ;;
        %DEPLIBS%)
        %DEPLIBS%)
          alldeplibs=yes
          alldeplibs=yes
          continue
          continue
          ;;
          ;;
        esac # case $deplib
        esac # case $deplib
        if test $found = yes || test -f "$lib"; then :
        if test $found = yes || test -f "$lib"; then :
        else
        else
          $echo "$modename: cannot find the library \`$lib'" 1>&2
          $echo "$modename: cannot find the library \`$lib'" 1>&2
          exit 1
          exit 1
        fi
        fi
 
 
        # Check to see that this really is a libtool archive.
        # Check to see that this really is a libtool archive.
        if (sed -e '2q' $lib | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
        if (sed -e '2q' $lib | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
        else
        else
          $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
          $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
          exit 1
          exit 1
        fi
        fi
 
 
        ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
        ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
        test "X$ladir" = "X$lib" && ladir="."
        test "X$ladir" = "X$lib" && ladir="."
 
 
        dlname=
        dlname=
        dlopen=
        dlopen=
        dlpreopen=
        dlpreopen=
        libdir=
        libdir=
        library_names=
        library_names=
        old_library=
        old_library=
        # If the library was installed with an old release of libtool,
        # If the library was installed with an old release of libtool,
        # it will not redefine variable installed.
        # it will not redefine variable installed.
        installed=yes
        installed=yes
 
 
        # Read the .la file
        # Read the .la file
        case $lib in
        case $lib in
        */* | *\\*) . $lib ;;
        */* | *\\*) . $lib ;;
        *) . ./$lib ;;
        *) . ./$lib ;;
        esac
        esac
 
 
        if test "$linkmode,$pass" = "lib,link" ||
        if test "$linkmode,$pass" = "lib,link" ||
           test "$linkmode,$pass" = "prog,scan" ||
           test "$linkmode,$pass" = "prog,scan" ||
           { test $linkmode = oldlib && test $linkmode = obj; }; then
           { test $linkmode = oldlib && test $linkmode = obj; }; then
           # Add dl[pre]opened files of deplib
           # Add dl[pre]opened files of deplib
          test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
          test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
          test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
          test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
        fi
        fi
 
 
        if test $pass = conv; then
        if test $pass = conv; then
          # Only check for convenience libraries
          # Only check for convenience libraries
          deplibs="$lib $deplibs"
          deplibs="$lib $deplibs"
          if test -z "$libdir"; then
          if test -z "$libdir"; then
            if test -z "$old_library"; then
            if test -z "$old_library"; then
              $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
              $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
              exit 1
              exit 1
            fi
            fi
            # It is a libtool convenience library, so add in its objects.
            # It is a libtool convenience library, so add in its objects.
            convenience="$convenience $ladir/$objdir/$old_library"
            convenience="$convenience $ladir/$objdir/$old_library"
            old_convenience="$old_convenience $ladir/$objdir/$old_library"
            old_convenience="$old_convenience $ladir/$objdir/$old_library"
            tmp_libs=
            tmp_libs=
            for deplib in $dependency_libs; do
            for deplib in $dependency_libs; do
              deplibs="$deplib $deplibs"
              deplibs="$deplib $deplibs"
              case "$tmp_libs " in
              case "$tmp_libs " in
              *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
              *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
              esac
              esac
              tmp_libs="$tmp_libs $deplib"
              tmp_libs="$tmp_libs $deplib"
            done
            done
          elif test $linkmode != prog && test $linkmode != lib; then
          elif test $linkmode != prog && test $linkmode != lib; then
            $echo "$modename: \`$lib' is not a convenience library" 1>&2
            $echo "$modename: \`$lib' is not a convenience library" 1>&2
            exit 1
            exit 1
          fi
          fi
          continue
          continue
        fi # $pass = conv
        fi # $pass = conv
 
 
        # Get the name of the library we link against.
        # Get the name of the library we link against.
        linklib=
        linklib=
        for l in $old_library $library_names; do
        for l in $old_library $library_names; do
          linklib="$l"
          linklib="$l"
        done
        done
        if test -z "$linklib"; then
        if test -z "$linklib"; then
          $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
          $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
          exit 1
          exit 1
        fi
        fi
 
 
        # This library was specified with -dlopen.
        # This library was specified with -dlopen.
        if test $pass = dlopen; then
        if test $pass = dlopen; then
          if test -z "$libdir"; then
          if test -z "$libdir"; then
            $echo "$modename: cannot -dlopen a convenience library: \`$lib'" 1>&2
            $echo "$modename: cannot -dlopen a convenience library: \`$lib'" 1>&2
            exit 1
            exit 1
          fi
          fi
          if test -z "$dlname" || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
          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
            # If there is no dlname, no dlopen support or we're linking
            # statically, we need to preload.
            # statically, we need to preload.
            dlprefiles="$dlprefiles $lib"
            dlprefiles="$dlprefiles $lib"
          else
          else
            newdlfiles="$newdlfiles $lib"
            newdlfiles="$newdlfiles $lib"
          fi
          fi
          continue
          continue
        fi # $pass = dlopen
        fi # $pass = dlopen
 
 
        # We need an absolute path.
        # We need an absolute path.
        case $ladir in
        case $ladir in
        [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
        [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
        *)
        *)
          abs_ladir=`cd "$ladir" && pwd`
          abs_ladir=`cd "$ladir" && pwd`
          if test -z "$abs_ladir"; then
          if test -z "$abs_ladir"; then
            $echo "$modename: warning: cannot determine absolute directory name of \`$ladir'" 1>&2
            $echo "$modename: warning: cannot determine absolute directory name of \`$ladir'" 1>&2
            $echo "$modename: passing it literally to the linker, although it might fail" 1>&2
            $echo "$modename: passing it literally to the linker, although it might fail" 1>&2
            abs_ladir="$ladir"
            abs_ladir="$ladir"
          fi
          fi
          ;;
          ;;
        esac
        esac
        laname=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
        laname=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
 
 
        # Find the relevant object directory and library name.
        # Find the relevant object directory and library name.
        if test "X$installed" = Xyes; then
        if test "X$installed" = Xyes; then
          if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
          if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
            $echo "$modename: warning: library \`$lib' was moved." 1>&2
            $echo "$modename: warning: library \`$lib' was moved." 1>&2
            dir="$ladir"
            dir="$ladir"
            absdir="$abs_ladir"
            absdir="$abs_ladir"
            libdir="$abs_ladir"
            libdir="$abs_ladir"
          else
          else
            dir="$libdir"
            dir="$libdir"
            absdir="$libdir"
            absdir="$libdir"
          fi
          fi
        else
        else
          dir="$ladir/$objdir"
          dir="$ladir/$objdir"
          absdir="$abs_ladir/$objdir"
          absdir="$abs_ladir/$objdir"
          # Remove this search path later
          # Remove this search path later
          notinst_path="$notinst_path $abs_ladir"
          notinst_path="$notinst_path $abs_ladir"
        fi # $installed = yes
        fi # $installed = yes
        name=`$echo "X$laname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
        name=`$echo "X$laname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
 
 
        # This library was specified with -dlpreopen.
        # This library was specified with -dlpreopen.
        if test $pass = dlpreopen; then
        if test $pass = dlpreopen; then
          if test -z "$libdir"; then
          if test -z "$libdir"; then
            $echo "$modename: cannot -dlpreopen a convenience library: \`$lib'" 1>&2
            $echo "$modename: cannot -dlpreopen a convenience library: \`$lib'" 1>&2
            exit 1
            exit 1
          fi
          fi
          # Prefer using a static library (so that no silly _DYNAMIC symbols
          # Prefer using a static library (so that no silly _DYNAMIC symbols
          # are required to link).
          # are required to link).
          if test -n "$old_library"; then
          if test -n "$old_library"; then
            newdlprefiles="$newdlprefiles $dir/$old_library"
            newdlprefiles="$newdlprefiles $dir/$old_library"
          # Otherwise, use the dlname, so that lt_dlopen finds it.
          # Otherwise, use the dlname, so that lt_dlopen finds it.
          elif test -n "$dlname"; then
          elif test -n "$dlname"; then
            newdlprefiles="$newdlprefiles $dir/$dlname"
            newdlprefiles="$newdlprefiles $dir/$dlname"
          else
          else
            newdlprefiles="$newdlprefiles $dir/$linklib"
            newdlprefiles="$newdlprefiles $dir/$linklib"
          fi
          fi
        fi # $pass = dlpreopen
        fi # $pass = dlpreopen
 
 
        if test -z "$libdir"; then
        if test -z "$libdir"; then
          # Link the convenience library
          # Link the convenience library
          if test $linkmode = lib; then
          if test $linkmode = lib; then
            deplibs="$dir/$old_library $deplibs"
            deplibs="$dir/$old_library $deplibs"
          elif test "$linkmode,$pass" = "prog,link"; then
          elif test "$linkmode,$pass" = "prog,link"; then
            compile_deplibs="$dir/$old_library $compile_deplibs"
            compile_deplibs="$dir/$old_library $compile_deplibs"
            finalize_deplibs="$dir/$old_library $finalize_deplibs"
            finalize_deplibs="$dir/$old_library $finalize_deplibs"
          else
          else
            deplibs="$lib $deplibs"
            deplibs="$lib $deplibs"
          fi
          fi
          continue
          continue
        fi
        fi
 
 
        if test $linkmode = prog && test $pass != link; then
        if test $linkmode = prog && test $pass != link; then
          newlib_search_path="$newlib_search_path $ladir"
          newlib_search_path="$newlib_search_path $ladir"
          deplibs="$lib $deplibs"
          deplibs="$lib $deplibs"
 
 
          linkalldeplibs=no
          linkalldeplibs=no
          if test "$link_all_deplibs" != no || test -z "$library_names" ||
          if test "$link_all_deplibs" != no || test -z "$library_names" ||
             test "$build_libtool_libs" = no; then
             test "$build_libtool_libs" = no; then
            linkalldeplibs=yes
            linkalldeplibs=yes
          fi
          fi
 
 
          tmp_libs=
          tmp_libs=
          for deplib in $dependency_libs; do
          for deplib in $dependency_libs; do
            case $deplib in
            case $deplib in
            -L*) newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`;; ### testsuite: skip nested quoting test
            -L*) newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`;; ### testsuite: skip nested quoting test
            esac
            esac
            # Need to link against all dependency_libs?
            # Need to link against all dependency_libs?
            if test $linkalldeplibs = yes; then
            if test $linkalldeplibs = yes; then
              deplibs="$deplib $deplibs"
              deplibs="$deplib $deplibs"
            else
            else
              # Need to hardcode shared library paths
              # Need to hardcode shared library paths
              # or/and link against static libraries
              # or/and link against static libraries
              newdependency_libs="$deplib $newdependency_libs"
              newdependency_libs="$deplib $newdependency_libs"
            fi
            fi
            case "$tmp_libs " in
            case "$tmp_libs " in
            *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
            *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
            esac
            esac
            tmp_libs="$tmp_libs $deplib"
            tmp_libs="$tmp_libs $deplib"
          done # for deplib
          done # for deplib
          continue
          continue
        fi # $linkmode = prog...
        fi # $linkmode = prog...
 
 
        link_static=no # Whether the deplib will be linked statically
        link_static=no # Whether the deplib will be linked statically
        if test -n "$library_names" &&
        if test -n "$library_names" &&
           { test "$prefer_static_libs" = no || test -z "$old_library"; }; then
           { test "$prefer_static_libs" = no || test -z "$old_library"; }; then
          # Link against this shared library
          # Link against this shared library
 
 
          if test "$linkmode,$pass" = "prog,link" ||
          if test "$linkmode,$pass" = "prog,link" ||
           { test $linkmode = lib && test $hardcode_into_libs = yes; }; then
           { test $linkmode = lib && test $hardcode_into_libs = yes; }; then
            # Hardcode the library path.
            # Hardcode the library path.
            # Skip directories that are in the system default run-time
            # Skip directories that are in the system default run-time
            # search path.
            # search path.
            case " $sys_lib_dlsearch_path " in
            case " $sys_lib_dlsearch_path " in
            *" $absdir "*) ;;
            *" $absdir "*) ;;
            *)
            *)
              case "$compile_rpath " in
              case "$compile_rpath " in
              *" $absdir "*) ;;
              *" $absdir "*) ;;
              *) compile_rpath="$compile_rpath $absdir"
              *) compile_rpath="$compile_rpath $absdir"
              esac
              esac
              ;;
              ;;
            esac
            esac
            case " $sys_lib_dlsearch_path " in
            case " $sys_lib_dlsearch_path " in
            *" $libdir "*) ;;
            *" $libdir "*) ;;
            *)
            *)
              case "$finalize_rpath " in
              case "$finalize_rpath " in
              *" $libdir "*) ;;
              *" $libdir "*) ;;
              *) finalize_rpath="$finalize_rpath $libdir"
              *) finalize_rpath="$finalize_rpath $libdir"
              esac
              esac
              ;;
              ;;
            esac
            esac
            if test $linkmode = prog; then
            if test $linkmode = prog; then
              # We need to hardcode the library path
              # We need to hardcode the library path
              if test -n "$shlibpath_var"; then
              if test -n "$shlibpath_var"; then
                # Make sure the rpath contains only unique directories.
                # Make sure the rpath contains only unique directories.
                case "$temp_rpath " in
                case "$temp_rpath " in
                *" $dir "*) ;;
                *" $dir "*) ;;
                *" $absdir "*) ;;
                *" $absdir "*) ;;
                *) temp_rpath="$temp_rpath $dir" ;;
                *) temp_rpath="$temp_rpath $dir" ;;
                esac
                esac
              fi
              fi
            fi
            fi
          fi # $linkmode,$pass = prog,link...
          fi # $linkmode,$pass = prog,link...
 
 
          if test "$alldeplibs" = yes &&
          if test "$alldeplibs" = yes &&
             { test "$deplibs_check_method" = pass_all ||
             { test "$deplibs_check_method" = pass_all ||
               { test "$build_libtool_libs" = yes &&
               { test "$build_libtool_libs" = yes &&
                 test -n "$library_names"; }; }; then
                 test -n "$library_names"; }; }; then
            # We only need to search for static libraries
            # We only need to search for static libraries
            continue
            continue
          fi
          fi
 
 
          if test "$installed" = no; then
          if test "$installed" = no; then
            notinst_deplibs="$notinst_deplibs $lib"
            notinst_deplibs="$notinst_deplibs $lib"
            need_relink=yes
            need_relink=yes
          fi
          fi
 
 
          if test -n "$old_archive_from_expsyms_cmds"; then
          if test -n "$old_archive_from_expsyms_cmds"; then
            # figure out the soname
            # figure out the soname
            set dummy $library_names
            set dummy $library_names
            realname="$2"
            realname="$2"
            shift; shift
            shift; shift
            libname=`eval \\$echo \"$libname_spec\"`
            libname=`eval \\$echo \"$libname_spec\"`
            # use dlname if we got it. it's perfectly good, no?
            # use dlname if we got it. it's perfectly good, no?
            if test -n "$dlname"; then
            if test -n "$dlname"; then
              soname="$dlname"
              soname="$dlname"
            elif test -n "$soname_spec"; then
            elif test -n "$soname_spec"; then
              # bleh windows
              # bleh windows
              case $host in
              case $host in
              *cygwin*)
              *cygwin*)
                major=`expr $current - $age`
                major=`expr $current - $age`
                versuffix="-$major"
                versuffix="-$major"
                ;;
                ;;
              esac
              esac
              eval soname=\"$soname_spec\"
              eval soname=\"$soname_spec\"
            else
            else
              soname="$realname"
              soname="$realname"
            fi
            fi
 
 
            # Make a new name for the extract_expsyms_cmds to use
            # Make a new name for the extract_expsyms_cmds to use
            soroot="$soname"
            soroot="$soname"
            soname=`echo $soroot | sed -e 's/^.*\///'`
            soname=`echo $soroot | sed -e 's/^.*\///'`
            newlib="libimp-`echo $soname | sed 's/^lib//;s/\.dll$//'`.a"
            newlib="libimp-`echo $soname | sed 's/^lib//;s/\.dll$//'`.a"
 
 
            # If the library has no export list, then create one now
            # If the library has no export list, then create one now
            if test -f "$output_objdir/$soname-def"; then :
            if test -f "$output_objdir/$soname-def"; then :
            else
            else
              $show "extracting exported symbol list from \`$soname'"
              $show "extracting exported symbol list from \`$soname'"
              IFS="${IFS=       }"; save_ifs="$IFS"; IFS='~'
              IFS="${IFS=       }"; save_ifs="$IFS"; IFS='~'
              eval cmds=\"$extract_expsyms_cmds\"
              eval cmds=\"$extract_expsyms_cmds\"
              for cmd in $cmds; do
              for cmd in $cmds; do
                IFS="$save_ifs"
                IFS="$save_ifs"
                $show "$cmd"
                $show "$cmd"
                $run eval "$cmd" || exit $?
                $run eval "$cmd" || exit $?
              done
              done
              IFS="$save_ifs"
              IFS="$save_ifs"
            fi
            fi
 
 
            # Create $newlib
            # Create $newlib
            if test -f "$output_objdir/$newlib"; then :; else
            if test -f "$output_objdir/$newlib"; then :; else
              $show "generating import library for \`$soname'"
              $show "generating import library for \`$soname'"
              IFS="${IFS=       }"; save_ifs="$IFS"; IFS='~'
              IFS="${IFS=       }"; save_ifs="$IFS"; IFS='~'
              eval cmds=\"$old_archive_from_expsyms_cmds\"
              eval cmds=\"$old_archive_from_expsyms_cmds\"
              for cmd in $cmds; do
              for cmd in $cmds; do
                IFS="$save_ifs"
                IFS="$save_ifs"
                $show "$cmd"
                $show "$cmd"
                $run eval "$cmd" || exit $?
                $run eval "$cmd" || exit $?
              done
              done
              IFS="$save_ifs"
              IFS="$save_ifs"
            fi
            fi
            # make sure the library variables are pointing to the new library
            # make sure the library variables are pointing to the new library
            dir=$output_objdir
            dir=$output_objdir
            linklib=$newlib
            linklib=$newlib
          fi # test -n $old_archive_from_expsyms_cmds
          fi # test -n $old_archive_from_expsyms_cmds
 
 
          if test $linkmode = prog || test "$mode" != relink; then
          if test $linkmode = prog || test "$mode" != relink; then
            add_shlibpath=
            add_shlibpath=
            add_dir=
            add_dir=
            add=
            add=
            lib_linked=yes
            lib_linked=yes
            case $hardcode_action in
            case $hardcode_action in
            immediate | unsupported)
            immediate | unsupported)
              if test "$hardcode_direct" = no; then
              if test "$hardcode_direct" = no; then
                add="$dir/$linklib"
                add="$dir/$linklib"
              elif test "$hardcode_minus_L" = no; then
              elif test "$hardcode_minus_L" = no; then
                case $host in
                case $host in
                *-*-sunos*) add_shlibpath="$dir" ;;
                *-*-sunos*) add_shlibpath="$dir" ;;
                esac
                esac
                add_dir="-L$dir"
                add_dir="-L$dir"
                add="-l$name"
                add="-l$name"
              elif test "$hardcode_shlibpath_var" = no; then
              elif test "$hardcode_shlibpath_var" = no; then
                add_shlibpath="$dir"
                add_shlibpath="$dir"
                add="-l$name"
                add="-l$name"
              else
              else
                lib_linked=no
                lib_linked=no
              fi
              fi
              ;;
              ;;
            relink)
            relink)
              if test "$hardcode_direct" = yes; then
              if test "$hardcode_direct" = yes; then
                add="$dir/$linklib"
                add="$dir/$linklib"
              elif test "$hardcode_minus_L" = yes; then
              elif test "$hardcode_minus_L" = yes; then
                add_dir="-L$dir"
                add_dir="-L$dir"
                add="-l$name"
                add="-l$name"
              elif test "$hardcode_shlibpath_var" = yes; then
              elif test "$hardcode_shlibpath_var" = yes; then
                add_shlibpath="$dir"
                add_shlibpath="$dir"
                add="-l$name"
                add="-l$name"
              else
              else
                lib_linked=no
                lib_linked=no
              fi
              fi
              ;;
              ;;
            *) lib_linked=no ;;
            *) lib_linked=no ;;
            esac
            esac
 
 
            if test "$lib_linked" != yes; then
            if test "$lib_linked" != yes; then
              $echo "$modename: configuration error: unsupported hardcode properties"
              $echo "$modename: configuration error: unsupported hardcode properties"
              exit 1
              exit 1
            fi
            fi
 
 
            if test -n "$add_shlibpath"; then
            if test -n "$add_shlibpath"; then
              case :$compile_shlibpath: in
              case :$compile_shlibpath: in
              *":$add_shlibpath:"*) ;;
              *":$add_shlibpath:"*) ;;
              *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
              *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
              esac
              esac
            fi
            fi
            if test $linkmode = prog; then
            if test $linkmode = prog; then
              test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
              test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
              test -n "$add" && compile_deplibs="$add $compile_deplibs"
              test -n "$add" && compile_deplibs="$add $compile_deplibs"
            else
            else
              test -n "$add_dir" && deplibs="$add_dir $deplibs"
              test -n "$add_dir" && deplibs="$add_dir $deplibs"
              test -n "$add" && deplibs="$add $deplibs"
              test -n "$add" && deplibs="$add $deplibs"
              if test "$hardcode_direct" != yes && \
              if test "$hardcode_direct" != yes && \
                 test "$hardcode_minus_L" != yes && \
                 test "$hardcode_minus_L" != yes && \
                 test "$hardcode_shlibpath_var" = yes; then
                 test "$hardcode_shlibpath_var" = yes; then
                case :$finalize_shlibpath: in
                case :$finalize_shlibpath: in
                *":$libdir:"*) ;;
                *":$libdir:"*) ;;
                *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
                *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
                esac
                esac
              fi
              fi
            fi
            fi
          fi
          fi
 
 
          if test $linkmode = prog || test "$mode" = relink; then
          if test $linkmode = prog || test "$mode" = relink; then
            add_shlibpath=
            add_shlibpath=
            add_dir=
            add_dir=
            add=
            add=
            # Finalize command for both is simple: just hardcode it.
            # Finalize command for both is simple: just hardcode it.
            if test "$hardcode_direct" = yes; then
            if test "$hardcode_direct" = yes; then
              add="$libdir/$linklib"
              add="$libdir/$linklib"
            elif test "$hardcode_minus_L" = yes; then
            elif test "$hardcode_minus_L" = yes; then
              add_dir="-L$libdir"
              add_dir="-L$libdir"
              add="-l$name"
              add="-l$name"
            elif test "$hardcode_shlibpath_var" = yes; then
            elif test "$hardcode_shlibpath_var" = yes; then
              case :$finalize_shlibpath: in
              case :$finalize_shlibpath: in
              *":$libdir:"*) ;;
              *":$libdir:"*) ;;
              *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
              *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
              esac
              esac
              add="-l$name"
              add="-l$name"
            else
            else
              # We cannot seem to hardcode it, guess we'll fake it.
              # We cannot seem to hardcode it, guess we'll fake it.
              add_dir="-L$libdir"
              add_dir="-L$libdir"
              add="-l$name"
              add="-l$name"
            fi
            fi
 
 
            if test $linkmode = prog; then
            if test $linkmode = prog; then
              test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
              test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
              test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
              test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
            else
            else
              test -n "$add_dir" && deplibs="$add_dir $deplibs"
              test -n "$add_dir" && deplibs="$add_dir $deplibs"
              test -n "$add" && deplibs="$add $deplibs"
              test -n "$add" && deplibs="$add $deplibs"
            fi
            fi
          fi
          fi
        elif test $linkmode = prog; then
        elif test $linkmode = prog; then
          if test "$alldeplibs" = yes &&
          if test "$alldeplibs" = yes &&
             { test "$deplibs_check_method" = pass_all ||
             { test "$deplibs_check_method" = pass_all ||
               { test "$build_libtool_libs" = yes &&
               { test "$build_libtool_libs" = yes &&
                 test -n "$library_names"; }; }; then
                 test -n "$library_names"; }; }; then
            # We only need to search for static libraries
            # We only need to search for static libraries
            continue
            continue
          fi
          fi
 
 
          # Try to link the static library
          # Try to link the static library
          # Here we assume that one of hardcode_direct or hardcode_minus_L
          # Here we assume that one of hardcode_direct or hardcode_minus_L
          # is not unsupported.  This is valid on all known static and
          # is not unsupported.  This is valid on all known static and
          # shared platforms.
          # shared platforms.
          if test "$hardcode_direct" != unsupported; then
          if test "$hardcode_direct" != unsupported; then
            test -n "$old_library" && linklib="$old_library"
            test -n "$old_library" && linklib="$old_library"
            compile_deplibs="$dir/$linklib $compile_deplibs"
            compile_deplibs="$dir/$linklib $compile_deplibs"
            finalize_deplibs="$dir/$linklib $finalize_deplibs"
            finalize_deplibs="$dir/$linklib $finalize_deplibs"
          else
          else
            compile_deplibs="-l$name -L$dir $compile_deplibs"
            compile_deplibs="-l$name -L$dir $compile_deplibs"
            finalize_deplibs="-l$name -L$dir $finalize_deplibs"
            finalize_deplibs="-l$name -L$dir $finalize_deplibs"
          fi
          fi
        elif test "$build_libtool_libs" = yes; then
        elif test "$build_libtool_libs" = yes; then
          # Not a shared library
          # Not a shared library
          if test "$deplibs_check_method" != pass_all; then
          if test "$deplibs_check_method" != pass_all; then
            # We're trying link a shared library against a static one
            # We're trying link a shared library against a static one
            # but the system doesn't support it.
            # but the system doesn't support it.
 
 
            # Just print a warning and add the library to dependency_libs so
            # Just print a warning and add the library to dependency_libs so
            # that the program can be linked against the static library.
            # that the program can be linked against the static library.
            echo
            echo
            echo "*** Warning: This library needs some functionality provided by $lib."
            echo "*** Warning: This library needs some functionality provided by $lib."
            echo "*** I have the capability to make that library automatically link in when"
            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 "*** you link to this library.  But I can only do this if you have a"
            echo "*** shared version of the library, which you do not appear to have."
            echo "*** shared version of the library, which you do not appear to have."
            if test "$module" = yes; then
            if test "$module" = yes; then
              echo "*** Therefore, libtool will create a static module, that should work "
              echo "*** Therefore, libtool will create a static module, that should work "
              echo "*** as long as the dlopening application is linked with the -dlopen flag."
              echo "*** as long as the dlopening application is linked with the -dlopen flag."
              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
                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
            fi
            fi
          else
          else
            convenience="$convenience $dir/$old_library"
            convenience="$convenience $dir/$old_library"
            old_convenience="$old_convenience $dir/$old_library"
            old_convenience="$old_convenience $dir/$old_library"
            deplibs="$dir/$old_library $deplibs"
            deplibs="$dir/$old_library $deplibs"
            link_static=yes
            link_static=yes
          fi
          fi
        fi # link shared/static library?
        fi # link shared/static library?
 
 
        if test $linkmode = lib; then
        if test $linkmode = lib; then
          if test -n "$dependency_libs" &&
          if test -n "$dependency_libs" &&
             { test $hardcode_into_libs != yes || test $build_old_libs = yes ||
             { test $hardcode_into_libs != yes || test $build_old_libs = yes ||
               test $link_static = yes; }; then
               test $link_static = yes; }; then
            # Extract -R from dependency_libs
            # Extract -R from dependency_libs
            temp_deplibs=
            temp_deplibs=
            for libdir in $dependency_libs; do
            for libdir in $dependency_libs; do
              case $libdir in
              case $libdir in
              -R*) temp_xrpath=`$echo "X$libdir" | $Xsed -e 's/^-R//'`
              -R*) temp_xrpath=`$echo "X$libdir" | $Xsed -e 's/^-R//'`
                   case " $xrpath " in
                   case " $xrpath " in
                   *" $temp_xrpath "*) ;;
                   *" $temp_xrpath "*) ;;
                   *) xrpath="$xrpath $temp_xrpath";;
                   *) xrpath="$xrpath $temp_xrpath";;
                   esac;;
                   esac;;
              *) temp_deplibs="$temp_deplibs $libdir";;
              *) temp_deplibs="$temp_deplibs $libdir";;
              esac
              esac
            done
            done
            dependency_libs="$temp_deplibs"
            dependency_libs="$temp_deplibs"
          fi
          fi
 
 
          newlib_search_path="$newlib_search_path $absdir"
          newlib_search_path="$newlib_search_path $absdir"
          # Link against this library
          # Link against this library
          test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
          test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
          # ... and its dependency_libs
          # ... and its dependency_libs
          tmp_libs=
          tmp_libs=
          for deplib in $dependency_libs; do
          for deplib in $dependency_libs; do
            newdependency_libs="$deplib $newdependency_libs"
            newdependency_libs="$deplib $newdependency_libs"
            case "$tmp_libs " in
            case "$tmp_libs " in
            *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
            *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
            esac
            esac
            tmp_libs="$tmp_libs $deplib"
            tmp_libs="$tmp_libs $deplib"
          done
          done
 
 
          if test $link_all_deplibs != no; then
          if test $link_all_deplibs != no; then
            # Add the search paths of all dependency libraries
            # Add the search paths of all dependency libraries
            for deplib in $dependency_libs; do
            for deplib in $dependency_libs; do
              case $deplib in
              case $deplib in
              -L*) path="$deplib" ;;
              -L*) path="$deplib" ;;
              *.la)
              *.la)
                dir=`$echo "X$deplib" | $Xsed -e 's%/[^/]*$%%'`
                dir=`$echo "X$deplib" | $Xsed -e 's%/[^/]*$%%'`
                test "X$dir" = "X$deplib" && dir="."
                test "X$dir" = "X$deplib" && dir="."
                # We need an absolute path.
                # We need an absolute path.
                case $dir in
                case $dir in
                [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
                [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
                *)
                *)
                  absdir=`cd "$dir" && pwd`
                  absdir=`cd "$dir" && pwd`
                  if test -z "$absdir"; then
                  if test -z "$absdir"; then
                    $echo "$modename: warning: cannot determine absolute directory name of \`$dir'" 1>&2
                    $echo "$modename: warning: cannot determine absolute directory name of \`$dir'" 1>&2
                    absdir="$dir"
                    absdir="$dir"
                  fi
                  fi
                  ;;
                  ;;
                esac
                esac
                if grep "^installed=no" $deplib > /dev/null; then
                if grep "^installed=no" $deplib > /dev/null; then
                  path="-L$absdir/$objdir"
                  path="-L$absdir/$objdir"
                else
                else
                  eval libdir=`sed -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
                  eval libdir=`sed -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
                  if test -z "$libdir"; then
                  if test -z "$libdir"; then
                    $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
                    $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
                    exit 1
                    exit 1
                  fi
                  fi
                  if test "$absdir" != "$libdir"; then
                  if test "$absdir" != "$libdir"; then
                    $echo "$modename: warning: \`$deplib' seems to be moved" 1>&2
                    $echo "$modename: warning: \`$deplib' seems to be moved" 1>&2
                  fi
                  fi
                  path="-L$absdir"
                  path="-L$absdir"
                fi
                fi
                ;;
                ;;
              *) continue ;;
              *) continue ;;
              esac
              esac
              case " $deplibs " in
              case " $deplibs " in
              *" $path "*) ;;
              *" $path "*) ;;
              *) deplibs="$path $deplibs" ;;
              *) deplibs="$path $deplibs" ;;
              esac
              esac
            done
            done
          fi # link_all_deplibs != no
          fi # link_all_deplibs != no
        fi # linkmode = lib
        fi # linkmode = lib
      done # for deplib in $libs
      done # for deplib in $libs
      if test $pass = dlpreopen; then
      if test $pass = dlpreopen; then
        # Link the dlpreopened libraries before other libraries
        # Link the dlpreopened libraries before other libraries
        for deplib in $save_deplibs; do
        for deplib in $save_deplibs; do
          deplibs="$deplib $deplibs"
          deplibs="$deplib $deplibs"
        done
        done
      fi
      fi
      if test $pass != dlopen; then
      if test $pass != dlopen; then
        test $pass != scan && dependency_libs="$newdependency_libs"
        test $pass != scan && dependency_libs="$newdependency_libs"
        if test $pass != conv; then
        if test $pass != conv; then
          # Make sure lib_search_path contains only unique directories.
          # Make sure lib_search_path contains only unique directories.
          lib_search_path=
          lib_search_path=
          for dir in $newlib_search_path; do
          for dir in $newlib_search_path; do
            case "$lib_search_path " in
            case "$lib_search_path " in
            *" $dir "*) ;;
            *" $dir "*) ;;
            *) lib_search_path="$lib_search_path $dir" ;;
            *) lib_search_path="$lib_search_path $dir" ;;
            esac
            esac
          done
          done
          newlib_search_path=
          newlib_search_path=
        fi
        fi
 
 
        if test "$linkmode,$pass" != "prog,link"; then
        if test "$linkmode,$pass" != "prog,link"; then
          vars="deplibs"
          vars="deplibs"
        else
        else
          vars="compile_deplibs finalize_deplibs"
          vars="compile_deplibs finalize_deplibs"
        fi
        fi
        for var in $vars dependency_libs; do
        for var in $vars dependency_libs; do
          # Add libraries to $var in reverse order
          # Add libraries to $var in reverse order
          eval tmp_libs=\"\$$var\"
          eval tmp_libs=\"\$$var\"
          new_libs=
          new_libs=
          for deplib in $tmp_libs; do
          for deplib in $tmp_libs; do
            case $deplib in
            case $deplib in
            -L*) new_libs="$deplib $new_libs" ;;
            -L*) new_libs="$deplib $new_libs" ;;
            *)
            *)
              case " $specialdeplibs " in
              case " $specialdeplibs " in
              *" $deplib "*) new_libs="$deplib $new_libs" ;;
              *" $deplib "*) new_libs="$deplib $new_libs" ;;
              *)
              *)
                case " $new_libs " in
                case " $new_libs " in
                *" $deplib "*) ;;
                *" $deplib "*) ;;
                *) new_libs="$deplib $new_libs" ;;
                *) new_libs="$deplib $new_libs" ;;
                esac
                esac
                ;;
                ;;
              esac
              esac
              ;;
              ;;
            esac
            esac
          done
          done
          tmp_libs=
          tmp_libs=
          for deplib in $new_libs; do
          for deplib in $new_libs; do
            case $deplib in
            case $deplib in
            -L*)
            -L*)
              case " $tmp_libs " in
              case " $tmp_libs " in
              *" $deplib "*) ;;
              *" $deplib "*) ;;
              *) tmp_libs="$tmp_libs $deplib" ;;
              *) tmp_libs="$tmp_libs $deplib" ;;
              esac
              esac
              ;;
              ;;
            *) tmp_libs="$tmp_libs $deplib" ;;
            *) tmp_libs="$tmp_libs $deplib" ;;
            esac
            esac
          done
          done
          eval $var=\"$tmp_libs\"
          eval $var=\"$tmp_libs\"
        done # for var
        done # for var
      fi
      fi
      if test "$pass" = "conv" &&
      if test "$pass" = "conv" &&
       { test "$linkmode" = "lib" || test "$linkmode" = "prog"; }; then
       { test "$linkmode" = "lib" || test "$linkmode" = "prog"; }; then
        libs="$deplibs" # reset libs
        libs="$deplibs" # reset libs
        deplibs=
        deplibs=
      fi
      fi
    done # for pass
    done # for pass
    if test $linkmode = prog; then
    if test $linkmode = prog; then
      dlfiles="$newdlfiles"
      dlfiles="$newdlfiles"
      dlprefiles="$newdlprefiles"
      dlprefiles="$newdlprefiles"
    fi
    fi
 
 
    case $linkmode in
    case $linkmode in
    oldlib)
    oldlib)
      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
        $echo "$modename: warning: \`-dlopen' is ignored for archives" 1>&2
        $echo "$modename: warning: \`-dlopen' is ignored for archives" 1>&2
      fi
      fi
 
 
      if test -n "$rpath"; then
      if test -n "$rpath"; then
        $echo "$modename: warning: \`-rpath' is ignored for archives" 1>&2
        $echo "$modename: warning: \`-rpath' is ignored for archives" 1>&2
      fi
      fi
 
 
      if test -n "$xrpath"; then
      if test -n "$xrpath"; then
        $echo "$modename: warning: \`-R' is ignored for archives" 1>&2
        $echo "$modename: warning: \`-R' is ignored for archives" 1>&2
      fi
      fi
 
 
      if test -n "$vinfo"; then
      if test -n "$vinfo"; then
        $echo "$modename: warning: \`-version-info' is ignored for archives" 1>&2
        $echo "$modename: warning: \`-version-info' is ignored for archives" 1>&2
      fi
      fi
 
 
      if test -n "$release"; then
      if test -n "$release"; then
        $echo "$modename: warning: \`-release' is ignored for archives" 1>&2
        $echo "$modename: warning: \`-release' is ignored for archives" 1>&2
      fi
      fi
 
 
      if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
      if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
        $echo "$modename: warning: \`-export-symbols' is ignored for archives" 1>&2
        $echo "$modename: warning: \`-export-symbols' is ignored for archives" 1>&2
      fi
      fi
 
 
      # Now set the variables for building old libraries.
      # Now set the variables for building old libraries.
      build_libtool_libs=no
      build_libtool_libs=no
      oldlibs="$output"
      oldlibs="$output"
      objs="$objs$old_deplibs"
      objs="$objs$old_deplibs"
      ;;
      ;;
 
 
    lib)
    lib)
      # Make sure we only generate libraries of the form `libNAME.la'.
      # Make sure we only generate libraries of the form `libNAME.la'.
      case $outputname in
      case $outputname in
      lib*)
      lib*)
        name=`$echo "X$outputname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
        name=`$echo "X$outputname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
        eval libname=\"$libname_spec\"
        eval libname=\"$libname_spec\"
        ;;
        ;;
      *)
      *)
        if test "$module" = no; then
        if test "$module" = no; then
          $echo "$modename: libtool library \`$output' must begin with \`lib'" 1>&2
          $echo "$modename: libtool library \`$output' must begin with \`lib'" 1>&2
          $echo "$help" 1>&2
          $echo "$help" 1>&2
          exit 1
          exit 1
        fi
        fi
        if test "$need_lib_prefix" != no; then
        if test "$need_lib_prefix" != no; then
          # Add the "lib" prefix for modules if required
          # Add the "lib" prefix for modules if required
          name=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
          name=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
          eval libname=\"$libname_spec\"
          eval libname=\"$libname_spec\"
        else
        else
          libname=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
          libname=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
        fi
        fi
        ;;
        ;;
      esac
      esac
 
 
      if test -n "$objs"; then
      if test -n "$objs"; then
        if test "$deplibs_check_method" != pass_all; then
        if test "$deplibs_check_method" != pass_all; then
          $echo "$modename: cannot build libtool library \`$output' from non-libtool objects on this host:$objs" 2>&1
          $echo "$modename: cannot build libtool library \`$output' from non-libtool objects on this host:$objs" 2>&1
          exit 1
          exit 1
        else
        else
          echo
          echo
          echo "*** Warning: Linking the shared library $output against the non-libtool"
          echo "*** Warning: Linking the shared library $output against the non-libtool"
          echo "*** objects $objs is not portable!"
          echo "*** objects $objs is not portable!"
          libobjs="$libobjs $objs"
          libobjs="$libobjs $objs"
        fi
        fi
      fi
      fi
 
 
      if test "$dlself" != no; then
      if test "$dlself" != no; then
        $echo "$modename: warning: \`-dlopen self' is ignored for libtool libraries" 1>&2
        $echo "$modename: warning: \`-dlopen self' is ignored for libtool libraries" 1>&2
      fi
      fi
 
 
      set dummy $rpath
      set dummy $rpath
      if test $# -gt 2; then
      if test $# -gt 2; then
        $echo "$modename: warning: ignoring multiple \`-rpath's for a libtool library" 1>&2
        $echo "$modename: warning: ignoring multiple \`-rpath's for a libtool library" 1>&2
      fi
      fi
      install_libdir="$2"
      install_libdir="$2"
 
 
      oldlibs=
      oldlibs=
      if test -z "$rpath"; then
      if test -z "$rpath"; then
        if test "$build_libtool_libs" = yes; then
        if test "$build_libtool_libs" = yes; then
          # Building a libtool convenience library.
          # Building a libtool convenience library.
          # Some compilers have problems with a `.al' extension so
          # Some compilers have problems with a `.al' extension so
          # convenience libraries should have the same extension an
          # convenience libraries should have the same extension an
          # archive normally would.
          # archive normally would.
          oldlibs="$output_objdir/$libname.$libext $oldlibs"
          oldlibs="$output_objdir/$libname.$libext $oldlibs"
          build_libtool_libs=convenience
          build_libtool_libs=convenience
          build_old_libs=yes
          build_old_libs=yes
        fi
        fi
 
 
        if test -n "$vinfo"; then
        if test -n "$vinfo"; then
          $echo "$modename: warning: \`-version-info' is ignored for convenience libraries" 1>&2
          $echo "$modename: warning: \`-version-info' is ignored for convenience libraries" 1>&2
        fi
        fi
 
 
        if test -n "$release"; then
        if test -n "$release"; then
          $echo "$modename: warning: \`-release' is ignored for convenience libraries" 1>&2
          $echo "$modename: warning: \`-release' is ignored for convenience libraries" 1>&2
        fi
        fi
      else
      else
 
 
        # Parse the version information argument.
        # Parse the version information argument.
        IFS="${IFS=     }"; save_ifs="$IFS"; IFS=':'
        IFS="${IFS=     }"; save_ifs="$IFS"; IFS=':'
        set dummy $vinfo 0 0 0
        set dummy $vinfo 0 0 0
        IFS="$save_ifs"
        IFS="$save_ifs"
 
 
        if test -n "$8"; then
        if test -n "$8"; then
          $echo "$modename: too many parameters to \`-version-info'" 1>&2
          $echo "$modename: too many parameters to \`-version-info'" 1>&2
          $echo "$help" 1>&2
          $echo "$help" 1>&2
          exit 1
          exit 1
        fi
        fi
 
 
        current="$2"
        current="$2"
        revision="$3"
        revision="$3"
        age="$4"
        age="$4"
 
 
        # Check that each of the things are valid numbers.
        # Check that each of the things are valid numbers.
        case $current in
        case $current in
        0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
        0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
        *)
        *)
          $echo "$modename: CURRENT \`$current' is not a nonnegative integer" 1>&2
          $echo "$modename: CURRENT \`$current' is not a nonnegative integer" 1>&2
          $echo "$modename: \`$vinfo' is not valid version information" 1>&2
          $echo "$modename: \`$vinfo' is not valid version information" 1>&2
          exit 1
          exit 1
          ;;
          ;;
        esac
        esac
 
 
        case $revision in
        case $revision in
        0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
        0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
        *)
        *)
          $echo "$modename: REVISION \`$revision' is not a nonnegative integer" 1>&2
          $echo "$modename: REVISION \`$revision' is not a nonnegative integer" 1>&2
          $echo "$modename: \`$vinfo' is not valid version information" 1>&2
          $echo "$modename: \`$vinfo' is not valid version information" 1>&2
          exit 1
          exit 1
          ;;
          ;;
        esac
        esac
 
 
        case $age in
        case $age in
        0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
        0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
        *)
        *)
          $echo "$modename: AGE \`$age' is not a nonnegative integer" 1>&2
          $echo "$modename: AGE \`$age' is not a nonnegative integer" 1>&2
          $echo "$modename: \`$vinfo' is not valid version information" 1>&2
          $echo "$modename: \`$vinfo' is not valid version information" 1>&2
          exit 1
          exit 1
          ;;
          ;;
        esac
        esac
 
 
        if test $age -gt $current; then
        if test $age -gt $current; then
          $echo "$modename: AGE \`$age' is greater than the current interface number \`$current'" 1>&2
          $echo "$modename: AGE \`$age' is greater than the current interface number \`$current'" 1>&2
          $echo "$modename: \`$vinfo' is not valid version information" 1>&2
          $echo "$modename: \`$vinfo' is not valid version information" 1>&2
          exit 1
          exit 1
        fi
        fi
 
 
        # Calculate the version variables.
        # Calculate the version variables.
        major=
        major=
        versuffix=
        versuffix=
        verstring=
        verstring=
        case $version_type in
        case $version_type in
        none) ;;
        none) ;;
 
 
        darwin)
        darwin)
          # Like Linux, but with the current version available in
          # Like Linux, but with the current version available in
          # verstring for coding it into the library header
          # verstring for coding it into the library header
          major=.`expr $current - $age`
          major=.`expr $current - $age`
          versuffix="$major.$age.$revision"
          versuffix="$major.$age.$revision"
          # Darwin ld doesn't like 0 for these options...
          # Darwin ld doesn't like 0 for these options...
          minor_current=`expr $current + 1`
          minor_current=`expr $current + 1`
          verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
          verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
          ;;
          ;;
 
 
        freebsd-aout)
        freebsd-aout)
          major=".$current"
          major=".$current"
          versuffix=".$current.$revision";
          versuffix=".$current.$revision";
          ;;
          ;;
 
 
        freebsd-elf)
        freebsd-elf)
          major=".$current"
          major=".$current"
          versuffix=".$current";
          versuffix=".$current";
          ;;
          ;;
 
 
        irix)
        irix)
          major=`expr $current - $age + 1`
          major=`expr $current - $age + 1`
          verstring="sgi$major.$revision"
          verstring="sgi$major.$revision"
 
 
          # Add in all the interfaces that we are compatible with.
          # Add in all the interfaces that we are compatible with.
          loop=$revision
          loop=$revision
          while test $loop != 0; do
          while test $loop != 0; do
            iface=`expr $revision - $loop`
            iface=`expr $revision - $loop`
            loop=`expr $loop - 1`
            loop=`expr $loop - 1`
            verstring="sgi$major.$iface:$verstring"
            verstring="sgi$major.$iface:$verstring"
          done
          done
 
 
          # Before this point, $major must not contain `.'.
          # Before this point, $major must not contain `.'.
          major=.$major
          major=.$major
          versuffix="$major.$revision"
          versuffix="$major.$revision"
          ;;
          ;;
 
 
        linux)
        linux)
          major=.`expr $current - $age`
          major=.`expr $current - $age`
          versuffix="$major.$age.$revision"
          versuffix="$major.$age.$revision"
          ;;
          ;;
 
 
        osf)
        osf)
          major=`expr $current - $age`
          major=`expr $current - $age`
          versuffix=".$current.$age.$revision"
          versuffix=".$current.$age.$revision"
          verstring="$current.$age.$revision"
          verstring="$current.$age.$revision"
 
 
          # Add in all the interfaces that we are compatible with.
          # Add in all the interfaces that we are compatible with.
          loop=$age
          loop=$age
          while test $loop != 0; do
          while test $loop != 0; do
            iface=`expr $current - $loop`
            iface=`expr $current - $loop`
            loop=`expr $loop - 1`
            loop=`expr $loop - 1`
            verstring="$verstring:${iface}.0"
            verstring="$verstring:${iface}.0"
          done
          done
 
 
          # Make executables depend on our current version.
          # Make executables depend on our current version.
          verstring="$verstring:${current}.0"
          verstring="$verstring:${current}.0"
          ;;
          ;;
 
 
        sunos)
        sunos)
          major=".$current"
          major=".$current"
          versuffix=".$current.$revision"
          versuffix=".$current.$revision"
          ;;
          ;;
 
 
        windows)
        windows)
          # Use '-' rather than '.', since we only want one
          # Use '-' rather than '.', since we only want one
          # extension on DOS 8.3 filesystems.
          # extension on DOS 8.3 filesystems.
          major=`expr $current - $age`
          major=`expr $current - $age`
          versuffix="-$major"
          versuffix="-$major"
          ;;
          ;;
 
 
        *)
        *)
          $echo "$modename: unknown library version type \`$version_type'" 1>&2
          $echo "$modename: unknown library version type \`$version_type'" 1>&2
          echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
          echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
          exit 1
          exit 1
          ;;
          ;;
        esac
        esac
 
 
        # Clear the version info if we defaulted, and they specified a release.
        # Clear the version info if we defaulted, and they specified a release.
        if test -z "$vinfo" && test -n "$release"; then
        if test -z "$vinfo" && test -n "$release"; then
          major=
          major=
          verstring="0.0"
          verstring="0.0"
          if test "$need_version" = no; then
          if test "$need_version" = no; then
            versuffix=
            versuffix=
          else
          else
            versuffix=".0.0"
            versuffix=".0.0"
          fi
          fi
        fi
        fi
 
 
        # Remove version info from name if versioning should be avoided
        # Remove version info from name if versioning should be avoided
        if test "$avoid_version" = yes && test "$need_version" = no; then
        if test "$avoid_version" = yes && test "$need_version" = no; then
          major=
          major=
          versuffix=
          versuffix=
          verstring=""
          verstring=""
        fi
        fi
 
 
        # Check to see if the archive will have undefined symbols.
        # Check to see if the archive will have undefined symbols.
        if test "$allow_undefined" = yes; then
        if test "$allow_undefined" = yes; then
          if test "$allow_undefined_flag" = unsupported; then
          if test "$allow_undefined_flag" = unsupported; then
            $echo "$modename: warning: undefined symbols not allowed in $host shared libraries" 1>&2
            $echo "$modename: warning: undefined symbols not allowed in $host shared libraries" 1>&2
            build_libtool_libs=no
            build_libtool_libs=no
            build_old_libs=yes
            build_old_libs=yes
          fi
          fi
        else
        else
          # Don't allow undefined symbols.
          # Don't allow undefined symbols.
          allow_undefined_flag="$no_undefined_flag"
          allow_undefined_flag="$no_undefined_flag"
        fi
        fi
      fi
      fi
 
 
      if test "$mode" != relink; then
      if test "$mode" != relink; then
        # Remove our outputs, but don't remove object files since they
        # Remove our outputs, but don't remove object files since they
        # may have been created when compiling PIC objects.
        # may have been created when compiling PIC objects.
        removelist=
        removelist=
        tempremovelist=`echo "$output_objdir/*"`
        tempremovelist=`echo "$output_objdir/*"`
        for p in $tempremovelist; do
        for p in $tempremovelist; do
          case $p in
          case $p in
            *.$objext)
            *.$objext)
               ;;
               ;;
            $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
            $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
               removelist="$removelist $p"
               removelist="$removelist $p"
               ;;
               ;;
            *) ;;
            *) ;;
          esac
          esac
        done
        done
        if test -n "$removelist"; then
        if test -n "$removelist"; then
          $show "${rm}r $removelist"
          $show "${rm}r $removelist"
          $run ${rm}r $removelist
          $run ${rm}r $removelist
        fi
        fi
      fi
      fi
 
 
      # Now set the variables for building old libraries.
      # Now set the variables for building old libraries.
      if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
      if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
        oldlibs="$oldlibs $output_objdir/$libname.$libext"
        oldlibs="$oldlibs $output_objdir/$libname.$libext"
 
 
        # Transform .lo files to .o files.
        # Transform .lo files to .o files.
        oldobjs="$objs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
        oldobjs="$objs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
      fi
      fi
 
 
      # Eliminate all temporary directories.
      # Eliminate all temporary directories.
      for path in $notinst_path; do
      for path in $notinst_path; do
        lib_search_path=`echo "$lib_search_path " | sed -e 's% $path % %g'`
        lib_search_path=`echo "$lib_search_path " | sed -e 's% $path % %g'`
        deplibs=`echo "$deplibs " | sed -e 's% -L$path % %g'`
        deplibs=`echo "$deplibs " | sed -e 's% -L$path % %g'`
        dependency_libs=`echo "$dependency_libs " | sed -e 's% -L$path % %g'`
        dependency_libs=`echo "$dependency_libs " | sed -e 's% -L$path % %g'`
      done
      done
 
 
      if test -n "$xrpath"; then
      if test -n "$xrpath"; then
        # If the user specified any rpath flags, then add them.
        # If the user specified any rpath flags, then add them.
        temp_xrpath=
        temp_xrpath=
        for libdir in $xrpath; do
        for libdir in $xrpath; do
          temp_xrpath="$temp_xrpath -R$libdir"
          temp_xrpath="$temp_xrpath -R$libdir"
          case "$finalize_rpath " in
          case "$finalize_rpath " in
          *" $libdir "*) ;;
          *" $libdir "*) ;;
          *) finalize_rpath="$finalize_rpath $libdir" ;;
          *) finalize_rpath="$finalize_rpath $libdir" ;;
          esac
          esac
        done
        done
        if test $hardcode_into_libs != yes || test $build_old_libs = yes; then
        if test $hardcode_into_libs != yes || test $build_old_libs = yes; then
          dependency_libs="$temp_xrpath $dependency_libs"
          dependency_libs="$temp_xrpath $dependency_libs"
        fi
        fi
      fi
      fi
 
 
      # Make sure dlfiles contains only unique files that won't be dlpreopened
      # Make sure dlfiles contains only unique files that won't be dlpreopened
      old_dlfiles="$dlfiles"
      old_dlfiles="$dlfiles"
      dlfiles=
      dlfiles=
      for lib in $old_dlfiles; do
      for lib in $old_dlfiles; do
        case " $dlprefiles $dlfiles " in
        case " $dlprefiles $dlfiles " in
        *" $lib "*) ;;
        *" $lib "*) ;;
        *) dlfiles="$dlfiles $lib" ;;
        *) dlfiles="$dlfiles $lib" ;;
        esac
        esac
      done
      done
 
 
      # Make sure dlprefiles contains only unique files
      # Make sure dlprefiles contains only unique files
      old_dlprefiles="$dlprefiles"
      old_dlprefiles="$dlprefiles"
      dlprefiles=
      dlprefiles=
      for lib in $old_dlprefiles; do
      for lib in $old_dlprefiles; do
        case "$dlprefiles " in
        case "$dlprefiles " in
        *" $lib "*) ;;
        *" $lib "*) ;;
        *) dlprefiles="$dlprefiles $lib" ;;
        *) dlprefiles="$dlprefiles $lib" ;;
        esac
        esac
      done
      done
 
 
      if test "$build_libtool_libs" = yes; then
      if test "$build_libtool_libs" = yes; then
        if test -n "$rpath"; then
        if test -n "$rpath"; then
          case $host in
          case $host in
          *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos*)
          *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos*)
            # these systems don't actually have a c library (as such)!
            # these systems don't actually have a c library (as such)!
            ;;
            ;;
          *-*-rhapsody* | *-*-darwin1.[012])
          *-*-rhapsody* | *-*-darwin1.[012])
            # Rhapsody C library is in the System framework
            # Rhapsody C library is in the System framework
            deplibs="$deplibs -framework System"
            deplibs="$deplibs -framework System"
            ;;
            ;;
          *-*-netbsd*)
          *-*-netbsd*)
            # Don't link with libc until the a.out ld.so is fixed.
            # Don't link with libc until the a.out ld.so is fixed.
            ;;
            ;;
          *)
          *)
            # Add libc to deplibs on all other systems if necessary.
            # Add libc to deplibs on all other systems if necessary.
            if test $build_libtool_need_lc = "yes"; then
            if test $build_libtool_need_lc = "yes"; then
              deplibs="$deplibs -lc"
              deplibs="$deplibs -lc"
            fi
            fi
            ;;
            ;;
          esac
          esac
        fi
        fi
 
 
        # Transform deplibs into only deplibs that can be linked in shared.
        # Transform deplibs into only deplibs that can be linked in shared.
        name_save=$name
        name_save=$name
        libname_save=$libname
        libname_save=$libname
        release_save=$release
        release_save=$release
        versuffix_save=$versuffix
        versuffix_save=$versuffix
        major_save=$major
        major_save=$major
        # I'm not sure if I'm treating the release correctly.  I think
        # 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
        # release should show up in the -l (ie -lgmp5) so we don't want to
        # add it in twice.  Is that correct?
        # add it in twice.  Is that correct?
        release=""
        release=""
        versuffix=""
        versuffix=""
        major=""
        major=""
        newdeplibs=
        newdeplibs=
        droppeddeps=no
        droppeddeps=no
        case $deplibs_check_method in
        case $deplibs_check_method in
        pass_all)
        pass_all)
          # Don't check for shared/static.  Everything works.
          # Don't check for shared/static.  Everything works.
          # This might be a little naive.  We might want to check
          # This might be a little naive.  We might want to check
          # whether the library exists or not.  But this is on
          # whether the library exists or not.  But this is on
          # osf3 & osf4 and I'm not really sure... Just
          # osf3 & osf4 and I'm not really sure... Just
          # implementing what was already the behaviour.
          # implementing what was already the behaviour.
          newdeplibs=$deplibs
          newdeplibs=$deplibs
          ;;
          ;;
        test_compile)
        test_compile)
          # This code stresses the "libraries are programs" paradigm to its
          # This code stresses the "libraries are programs" paradigm to its
          # limits. Maybe even breaks it.  We compile a program, linking it
          # limits. Maybe even breaks it.  We compile a program, linking it
          # against the deplibs as a proxy for the library.  Then we can check
          # against the deplibs as a proxy for the library.  Then we can check
          # whether they linked in statically or dynamically with ldd.
          # whether they linked in statically or dynamically with ldd.
          $rm conftest.c
          $rm conftest.c
          cat > conftest.c <<EOF
          cat > conftest.c <<EOF
          int main() { return 0; }
          int main() { return 0; }
EOF
EOF
          $rm conftest
          $rm conftest
          $LTCC -o conftest conftest.c $deplibs
          $LTCC -o conftest conftest.c $deplibs
          if test $? -eq 0 ; then
          if test $? -eq 0 ; then
            ldd_output=`ldd conftest`
            ldd_output=`ldd conftest`
            for i in $deplibs; do
            for i in $deplibs; do
              name="`expr $i : '-l\(.*\)'`"
              name="`expr $i : '-l\(.*\)'`"
              # If $name is empty we are operating on a -L argument.
              # If $name is empty we are operating on a -L argument.
              if test -n "$name" && test "$name" != "0"; then
              if test -n "$name" && test "$name" != "0"; then
                libname=`eval \\$echo \"$libname_spec\"`
                libname=`eval \\$echo \"$libname_spec\"`
                deplib_matches=`eval \\$echo \"$library_names_spec\"`
                deplib_matches=`eval \\$echo \"$library_names_spec\"`
                set dummy $deplib_matches
                set dummy $deplib_matches
                deplib_match=$2
                deplib_match=$2
                if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
                if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
                  newdeplibs="$newdeplibs $i"
                  newdeplibs="$newdeplibs $i"
                else
                else
                  droppeddeps=yes
                  droppeddeps=yes
                  echo
                  echo
                  echo "*** Warning: This library needs some functionality provided by $i."
                  echo "*** Warning: This library needs some functionality provided by $i."
                  echo "*** I have the capability to make that library automatically link in when"
                  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 "*** you link to this library.  But I can only do this if you have a"
                  echo "*** shared version of the library, which you do not appear to have."
                  echo "*** shared version of the library, which you do not appear to have."
                fi
                fi
              else
              else
                newdeplibs="$newdeplibs $i"
                newdeplibs="$newdeplibs $i"
              fi
              fi
            done
            done
          else
          else
            # Error occured in the first compile.  Let's try to salvage the situation:
            # Error occured in the first compile.  Let's try to salvage the situation:
            # Compile a seperate program for each library.
            # Compile a seperate program for each library.
            for i in $deplibs; do
            for i in $deplibs; do
              name="`expr $i : '-l\(.*\)'`"
              name="`expr $i : '-l\(.*\)'`"
             # If $name is empty we are operating on a -L argument.
             # If $name is empty we are operating on a -L argument.
              if test -n "$name" && test "$name" != "0"; then
              if test -n "$name" && test "$name" != "0"; then
                $rm conftest
                $rm conftest
                $LTCC -o conftest conftest.c $i
                $LTCC -o conftest conftest.c $i
                # Did it work?
                # Did it work?
                if test $? -eq 0 ; then
                if test $? -eq 0 ; then
                  ldd_output=`ldd conftest`
                  ldd_output=`ldd conftest`
                  libname=`eval \\$echo \"$libname_spec\"`
                  libname=`eval \\$echo \"$libname_spec\"`
                  deplib_matches=`eval \\$echo \"$library_names_spec\"`
                  deplib_matches=`eval \\$echo \"$library_names_spec\"`
                  set dummy $deplib_matches
                  set dummy $deplib_matches
                  deplib_match=$2
                  deplib_match=$2
                  if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
                  if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
                    newdeplibs="$newdeplibs $i"
                    newdeplibs="$newdeplibs $i"
                  else
                  else
                    droppeddeps=yes
                    droppeddeps=yes
                    echo
                    echo
                    echo "*** Warning: This library needs some functionality provided by $i."
                    echo "*** Warning: This library needs some functionality provided by $i."
                    echo "*** I have the capability to make that library automatically link in when"
                    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 "*** you link to this library.  But I can only do this if you have a"
                    echo "*** shared version of the library, which you do not appear to have."
                    echo "*** shared version of the library, which you do not appear to have."
                  fi
                  fi
                else
                else
                  droppeddeps=yes
                  droppeddeps=yes
                  echo
                  echo
                  echo "*** Warning!  Library $i is needed by this library but I was not able to"
                  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 "***  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 "*** library that it depends on before this library will be fully"
                  echo "*** functional.  Installing it before continuing would be even better."
                  echo "*** functional.  Installing it before continuing would be even better."
                fi
                fi
              else
              else
                newdeplibs="$newdeplibs $i"
                newdeplibs="$newdeplibs $i"
              fi
              fi
            done
            done
          fi
          fi
          ;;
          ;;
        file_magic*)
        file_magic*)
          set dummy $deplibs_check_method
          set dummy $deplibs_check_method
          file_magic_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
          file_magic_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
          for a_deplib in $deplibs; do
          for a_deplib in $deplibs; do
            name="`expr $a_deplib : '-l\(.*\)'`"
            name="`expr $a_deplib : '-l\(.*\)'`"
            # If $name is empty we are operating on a -L argument.
            # If $name is empty we are operating on a -L argument.
            if test -n "$name" && test "$name" != "0"; then
            if test -n "$name" && test "$name" != "0"; then
              libname=`eval \\$echo \"$libname_spec\"`
              libname=`eval \\$echo \"$libname_spec\"`
              for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
              for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
                    potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
                    potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
                    for potent_lib in $potential_libs; do
                    for potent_lib in $potential_libs; do
                      # Follow soft links.
                      # Follow soft links.
                      if ls -lLd "$potent_lib" 2>/dev/null \
                      if ls -lLd "$potent_lib" 2>/dev/null \
                         | grep " -> " >/dev/null; then
                         | grep " -> " >/dev/null; then
                        continue
                        continue
                      fi
                      fi
                      # The statement above tries to avoid entering an
                      # The statement above tries to avoid entering an
                      # endless loop below, in case of cyclic links.
                      # endless loop below, in case of cyclic links.
                      # We might still enter an endless loop, since a link
                      # We might still enter an endless loop, since a link
                      # loop can be closed while we follow links,
                      # loop can be closed while we follow links,
                      # but so what?
                      # but so what?
                      potlib="$potent_lib"
                      potlib="$potent_lib"
                      while test -h "$potlib" 2>/dev/null; do
                      while test -h "$potlib" 2>/dev/null; do
                        potliblink=`ls -ld $potlib | sed 's/.* -> //'`
                        potliblink=`ls -ld $potlib | sed 's/.* -> //'`
                        case $potliblink in
                        case $potliblink in
                        [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
                        [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
                        *) potlib=`$echo "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
                        *) potlib=`$echo "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
                        esac
                        esac
                      done
                      done
                      if eval $file_magic_cmd \"\$potlib\" 2>/dev/null \
                      if eval $file_magic_cmd \"\$potlib\" 2>/dev/null \
                         | sed 10q \
                         | sed 10q \
                         | egrep "$file_magic_regex" > /dev/null; then
                         | egrep "$file_magic_regex" > /dev/null; then
                        newdeplibs="$newdeplibs $a_deplib"
                        newdeplibs="$newdeplibs $a_deplib"
                        a_deplib=""
                        a_deplib=""
                        break 2
                        break 2
                      fi
                      fi
                    done
                    done
              done
              done
              if test -n "$a_deplib" ; then
              if test -n "$a_deplib" ; then
                droppeddeps=yes
                droppeddeps=yes
                echo
                echo
                echo "*** Warning: This library needs some functionality provided by $a_deplib."
                echo "*** Warning: This library needs some functionality provided by $a_deplib."
                echo "*** I have the capability to make that library automatically link in when"
                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 "*** you link to this library.  But I can only do this if you have a"
                echo "*** shared version of the library, which you do not appear to have."
                echo "*** shared version of the library, which you do not appear to have."
              fi
              fi
            else
            else
              # Add a -L argument.
              # Add a -L argument.
              newdeplibs="$newdeplibs $a_deplib"
              newdeplibs="$newdeplibs $a_deplib"
            fi
            fi
          done # Gone through all deplibs.
          done # Gone through all deplibs.
          ;;
          ;;
        match_pattern*)
        match_pattern*)
          set dummy $deplibs_check_method
          set dummy $deplibs_check_method
          match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
          match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
          for a_deplib in $deplibs; do
          for a_deplib in $deplibs; do
            name="`expr $a_deplib : '-l\(.*\)'`"
            name="`expr $a_deplib : '-l\(.*\)'`"
            # If $name is empty we are operating on a -L argument.
            # If $name is empty we are operating on a -L argument.
            if test -n "$name" && test "$name" != "0"; then
            if test -n "$name" && test "$name" != "0"; then
              libname=`eval \\$echo \"$libname_spec\"`
              libname=`eval \\$echo \"$libname_spec\"`
              for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
              for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
                potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
                potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
                for potent_lib in $potential_libs; do
                for potent_lib in $potential_libs; do
                  if eval echo \"$potent_lib\" 2>/dev/null \
                  if eval echo \"$potent_lib\" 2>/dev/null \
                      | sed 10q \
                      | sed 10q \
                      | egrep "$match_pattern_regex" > /dev/null; then
                      | egrep "$match_pattern_regex" > /dev/null; then
                    newdeplibs="$newdeplibs $a_deplib"
                    newdeplibs="$newdeplibs $a_deplib"
                    a_deplib=""
                    a_deplib=""
                    break 2
                    break 2
                  fi
                  fi
                done
                done
              done
              done
              if test -n "$a_deplib" ; then
              if test -n "$a_deplib" ; then
                droppeddeps=yes
                droppeddeps=yes
                echo
                echo
                echo "*** Warning: This library needs some functionality provided by $a_deplib."
                echo "*** Warning: This library needs some functionality provided by $a_deplib."
                echo "*** I have the capability to make that library automatically link in when"
                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 "*** you link to this library.  But I can only do this if you have a"
                echo "*** shared version of the library, which you do not appear to have."
                echo "*** shared version of the library, which you do not appear to have."
              fi
              fi
            else
            else
              # Add a -L argument.
              # Add a -L argument.
              newdeplibs="$newdeplibs $a_deplib"
              newdeplibs="$newdeplibs $a_deplib"
            fi
            fi
          done # Gone through all deplibs.
          done # Gone through all deplibs.
          ;;
          ;;
        none | unknown | *)
        none | unknown | *)
          newdeplibs=""
          newdeplibs=""
          if $echo "X $deplibs" | $Xsed -e 's/ -lc$//' \
          if $echo "X $deplibs" | $Xsed -e 's/ -lc$//' \
               -e 's/ -[LR][^ ]*//g' -e 's/[    ]//g' |
               -e 's/ -[LR][^ ]*//g' -e 's/[    ]//g' |
             grep . >/dev/null; then
             grep . >/dev/null; then
            echo
            echo
            if test "X$deplibs_check_method" = "Xnone"; then
            if test "X$deplibs_check_method" = "Xnone"; then
              echo "*** Warning: inter-library dependencies are not supported in this platform."
              echo "*** Warning: inter-library dependencies are not supported in this platform."
            else
            else
              echo "*** Warning: inter-library dependencies are not known to be supported."
              echo "*** Warning: inter-library dependencies are not known to be supported."
            fi
            fi
            echo "*** All declared inter-library dependencies are being dropped."
            echo "*** All declared inter-library dependencies are being dropped."
            droppeddeps=yes
            droppeddeps=yes
          fi
          fi
          ;;
          ;;
        esac
        esac
        versuffix=$versuffix_save
        versuffix=$versuffix_save
        major=$major_save
        major=$major_save
        release=$release_save
        release=$release_save
        libname=$libname_save
        libname=$libname_save
        name=$name_save
        name=$name_save
 
 
        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 is the System framework
          newdeplibs=`$echo "X $newdeplibs" | $Xsed -e 's/ -lc / -framework System /'`
          newdeplibs=`$echo "X $newdeplibs" | $Xsed -e 's/ -lc / -framework System /'`
          ;;
          ;;
        esac
        esac
 
 
        if test "$droppeddeps" = yes; then
        if test "$droppeddeps" = yes; then
          if test "$module" = yes; then
          if test "$module" = yes; then
            echo
            echo
            echo "*** Warning: libtool could not satisfy all declared inter-library"
            echo "*** Warning: libtool could not satisfy all declared inter-library"
            echo "*** dependencies of module $libname.  Therefore, libtool will create"
            echo "*** dependencies of module $libname.  Therefore, libtool will create"
            echo "*** a static module, that should work as long as the dlopening"
            echo "*** a static module, that should work as long as the dlopening"
            echo "*** application is linked with the -dlopen flag."
            echo "*** application is linked with the -dlopen flag."
            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"
              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
          else
            echo "*** The inter-library dependencies that have been dropped here will be"
            echo "*** The inter-library dependencies that have been dropped here will be"
            echo "*** automatically added whenever a program is linked with this library"
            echo "*** automatically added whenever a program is linked with this library"
            echo "*** or is declared to -dlopen it."
            echo "*** or is declared to -dlopen it."
 
 
            if test $allow_undefined = no; then
            if test $allow_undefined = no; then
              echo
              echo
              echo "*** Since this library must not contain undefined symbols,"
              echo "*** Since this library must not contain undefined symbols,"
              echo "*** because either the platform does not support them or"
              echo "*** because either the platform does not support them or"
              echo "*** it was explicitly requested with -no-undefined,"
              echo "*** it was explicitly requested with -no-undefined,"
              echo "*** libtool will only create a static version of it."
              echo "*** libtool will only create a static version of it."
              if test "$build_old_libs" = no; then
              if test "$build_old_libs" = no; then
                oldlibs="$output_objdir/$libname.$libext"
                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
            fi
            fi
          fi
          fi
        fi
        fi
        # Done checking deplibs!
        # Done checking deplibs!
        deplibs=$newdeplibs
        deplibs=$newdeplibs
      fi
      fi
 
 
      # All the library-specific variables (install_libdir is set above).
      # All the library-specific variables (install_libdir is set above).
      library_names=
      library_names=
      old_library=
      old_library=
      dlname=
      dlname=
 
 
      # Test again, we may have decided not to build it any more
      # Test again, we may have decided not to build it any more
      if test "$build_libtool_libs" = yes; then
      if test "$build_libtool_libs" = yes; then
        if test $hardcode_into_libs = yes; then
        if test $hardcode_into_libs = yes; then
          # Hardcode the library paths
          # Hardcode the library paths
          hardcode_libdirs=
          hardcode_libdirs=
          dep_rpath=
          dep_rpath=
          rpath="$finalize_rpath"
          rpath="$finalize_rpath"
          test "$mode" != relink && rpath="$compile_rpath$rpath"
          test "$mode" != relink && rpath="$compile_rpath$rpath"
          for libdir in $rpath; do
          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
                  # Just accumulate the unique libdirs.
                  # Just accumulate the unique libdirs.
                  case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
                  case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
                  *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
                  *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
                    ;;
                    ;;
                  *)
                  *)
                    hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
                    hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
                    ;;
                    ;;
                  esac
                  esac
                fi
                fi
              else
              else
                eval flag=\"$hardcode_libdir_flag_spec\"
                eval flag=\"$hardcode_libdir_flag_spec\"
                dep_rpath="$dep_rpath $flag"
                dep_rpath="$dep_rpath $flag"
              fi
              fi
            elif test -n "$runpath_var"; then
            elif test -n "$runpath_var"; then
              case "$perm_rpath " in
              case "$perm_rpath " in
              *" $libdir "*) ;;
              *" $libdir "*) ;;
              *) perm_rpath="$perm_rpath $libdir" ;;
              *) perm_rpath="$perm_rpath $libdir" ;;
              esac
              esac
            fi
            fi
          done
          done
          # Substitute the hardcoded libdirs into the rpath.
          # Substitute the hardcoded libdirs into the rpath.
          if test -n "$hardcode_libdir_separator" &&
          if test -n "$hardcode_libdir_separator" &&
             test -n "$hardcode_libdirs"; then
             test -n "$hardcode_libdirs"; then
            libdir="$hardcode_libdirs"
            libdir="$hardcode_libdirs"
            eval dep_rpath=\"$hardcode_libdir_flag_spec\"
            eval dep_rpath=\"$hardcode_libdir_flag_spec\"
          fi
          fi
          if test -n "$runpath_var" && test -n "$perm_rpath"; then
          if test -n "$runpath_var" && test -n "$perm_rpath"; then
            # We should set the runpath_var.
            # We should set the runpath_var.
            rpath=
            rpath=
            for dir in $perm_rpath; do
            for dir in $perm_rpath; do
              rpath="$rpath$dir:"
              rpath="$rpath$dir:"
            done
            done
            eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
            eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
          fi
          fi
          test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
          test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
        fi
        fi
 
 
        shlibpath="$finalize_shlibpath"
        shlibpath="$finalize_shlibpath"
        test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
        test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
        if test -n "$shlibpath"; then
        if test -n "$shlibpath"; then
          eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
          eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
        fi
        fi
 
 
        # Get the real and link names of the library.
        # Get the real and link names of the library.
        eval library_names=\"$library_names_spec\"
        eval library_names=\"$library_names_spec\"
        set dummy $library_names
        set dummy $library_names
        realname="$2"
        realname="$2"
        shift; shift
        shift; shift
 
 
        if test -n "$soname_spec"; then
        if test -n "$soname_spec"; then
          eval soname=\"$soname_spec\"
          eval soname=\"$soname_spec\"
        else
        else
          soname="$realname"
          soname="$realname"
        fi
        fi
        test -z "$dlname" && dlname=$soname
        test -z "$dlname" && dlname=$soname
 
 
        lib="$output_objdir/$realname"
        lib="$output_objdir/$realname"
        for link
        for link
        do
        do
          linknames="$linknames $link"
          linknames="$linknames $link"
        done
        done
 
 
#       # Ensure that we have .o objects for linkers which dislike .lo
#       # Ensure that we have .o objects for linkers which dislike .lo
#       # (e.g. aix) in case we are running --disable-static
#       # (e.g. aix) in case we are running --disable-static
#       for obj in $libobjs; do
#       for obj in $libobjs; do
#         xdir=`$echo "X$obj" | $Xsed -e 's%/[^/]*$%%'`
#         xdir=`$echo "X$obj" | $Xsed -e 's%/[^/]*$%%'`
#         if test "X$xdir" = "X$obj"; then
#         if test "X$xdir" = "X$obj"; then
#           xdir="."
#           xdir="."
#         else
#         else
#           xdir="$xdir"
#           xdir="$xdir"
#         fi
#         fi
#         baseobj=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
#         baseobj=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
#         oldobj=`$echo "X$baseobj" | $Xsed -e "$lo2o"`
#         oldobj=`$echo "X$baseobj" | $Xsed -e "$lo2o"`
#         if test ! -f $xdir/$oldobj && test "$baseobj" != "$oldobj"; then
#         if test ! -f $xdir/$oldobj && test "$baseobj" != "$oldobj"; then
#           $show "(cd $xdir && ${LN_S} $baseobj $oldobj)"
#           $show "(cd $xdir && ${LN_S} $baseobj $oldobj)"
#           $run eval '(cd $xdir && ${LN_S} $baseobj $oldobj)' || exit $?
#           $run eval '(cd $xdir && ${LN_S} $baseobj $oldobj)' || exit $?
#         fi
#         fi
#       done
#       done
 
 
        # Use standard objects if they are pic
        # Use standard objects if they are pic
        test -z "$pic_flag" && libobjs=`$echo "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
        test -z "$pic_flag" && libobjs=`$echo "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
 
 
        # Prepare the list of exported symbols
        # Prepare the list of exported symbols
        if test -z "$export_symbols"; then
        if test -z "$export_symbols"; then
          if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
          if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
            $show "generating symbol list for \`$libname.la'"
            $show "generating symbol list for \`$libname.la'"
            export_symbols="$output_objdir/$libname.exp"
            export_symbols="$output_objdir/$libname.exp"
            $run $rm $export_symbols
            $run $rm $export_symbols
            eval cmds=\"$export_symbols_cmds\"
            eval cmds=\"$export_symbols_cmds\"
            IFS="${IFS=         }"; save_ifs="$IFS"; IFS='~'
            IFS="${IFS=         }"; save_ifs="$IFS"; IFS='~'
            for cmd in $cmds; do
            for cmd in $cmds; do
              IFS="$save_ifs"
              IFS="$save_ifs"
              $show "$cmd"
              $show "$cmd"
              $run eval "$cmd" || exit $?
              $run eval "$cmd" || exit $?
            done
            done
            IFS="$save_ifs"
            IFS="$save_ifs"
            if test -n "$export_symbols_regex"; then
            if test -n "$export_symbols_regex"; then
              $show "egrep -e \"$export_symbols_regex\" \"$export_symbols\" > \"${export_symbols}T\""
              $show "egrep -e \"$export_symbols_regex\" \"$export_symbols\" > \"${export_symbols}T\""
              $run eval 'egrep -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
              $run eval 'egrep -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
              $show "$mv \"${export_symbols}T\" \"$export_symbols\""
              $show "$mv \"${export_symbols}T\" \"$export_symbols\""
              $run eval '$mv "${export_symbols}T" "$export_symbols"'
              $run eval '$mv "${export_symbols}T" "$export_symbols"'
            fi
            fi
          fi
          fi
        fi
        fi
 
 
        if test -n "$export_symbols" && test -n "$include_expsyms"; then
        if test -n "$export_symbols" && test -n "$include_expsyms"; then
          $run eval '$echo "X$include_expsyms" | $SP2NL >> "$export_symbols"'
          $run eval '$echo "X$include_expsyms" | $SP2NL >> "$export_symbols"'
        fi
        fi
 
 
        if test -n "$convenience"; then
        if test -n "$convenience"; then
          if test -n "$whole_archive_flag_spec"; then
          if test -n "$whole_archive_flag_spec"; then
            save_libobjs=$libobjs
            save_libobjs=$libobjs
            eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
            eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
          else
          else
            gentop="$output_objdir/${outputname}x"
            gentop="$output_objdir/${outputname}x"
            $show "${rm}r $gentop"
            $show "${rm}r $gentop"
            $run ${rm}r "$gentop"
            $run ${rm}r "$gentop"
            $show "$mkdir $gentop"
            $show "$mkdir $gentop"
            $run $mkdir "$gentop"
            $run $mkdir "$gentop"
            status=$?
            status=$?
            if test $status -ne 0 && test ! -d "$gentop"; then
            if test $status -ne 0 && test ! -d "$gentop"; then
              exit $status
              exit $status
            fi
            fi
            generated="$generated $gentop"
            generated="$generated $gentop"
 
 
            for xlib in $convenience; do
            for xlib in $convenience; do
              # Extract the objects.
              # Extract the objects.
              case $xlib in
              case $xlib in
              [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;
              [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;
              *) xabs=`pwd`"/$xlib" ;;
              *) xabs=`pwd`"/$xlib" ;;
              esac
              esac
              xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
              xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
              xdir="$gentop/$xlib"
              xdir="$gentop/$xlib"
 
 
              $show "${rm}r $xdir"
              $show "${rm}r $xdir"
              $run ${rm}r "$xdir"
              $run ${rm}r "$xdir"
              $show "$mkdir $xdir"
              $show "$mkdir $xdir"
              $run $mkdir "$xdir"
              $run $mkdir "$xdir"
              status=$?
              status=$?
              if test $status -ne 0 && test ! -d "$xdir"; then
              if test $status -ne 0 && test ! -d "$xdir"; then
                exit $status
                exit $status
              fi
              fi
              $show "(cd $xdir && $AR x $xabs)"
              $show "(cd $xdir && $AR x $xabs)"
              $run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
              $run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
 
 
              libobjs="$libobjs "`find $xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
              libobjs="$libobjs "`find $xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
            done
            done
          fi
          fi
        fi
        fi
 
 
        if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
        if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
          eval flag=\"$thread_safe_flag_spec\"
          eval flag=\"$thread_safe_flag_spec\"
          linker_flags="$linker_flags $flag"
          linker_flags="$linker_flags $flag"
        fi
        fi
 
 
        # Make a backup of the uninstalled library when relinking
        # Make a backup of the uninstalled library when relinking
        if test "$mode" = relink; then
        if test "$mode" = relink; then
          $run eval '(cd $output_objdir && $rm ${realname}U && $mv $realname ${realname}U)' || exit $?
          $run eval '(cd $output_objdir && $rm ${realname}U && $mv $realname ${realname}U)' || exit $?
        fi
        fi
 
 
        # Do each of the archive commands.
        # Do each of the archive commands.
        if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
        if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
          eval cmds=\"$archive_expsym_cmds\"
          eval cmds=\"$archive_expsym_cmds\"
        else
        else
          eval cmds=\"$archive_cmds\"
          eval cmds=\"$archive_cmds\"
        fi
        fi
        if len=`expr "X$cmds" : ".*"` &&
        if len=`expr "X$cmds" : ".*"` &&
           test $len -le $max_cmd_len; then
           test $len -le $max_cmd_len; then
          :
          :
        else
        else
          # The command line is too long to link in one step, link piecewise.
          # The command line is too long to link in one step, link piecewise.
          $echo "creating reloadable object files..."
          $echo "creating reloadable object files..."
 
 
          # Save the value of $output and $libobjs because we want to
          # Save the value of $output and $libobjs because we want to
          # use them later.  If we have whole_archive_flag_spec, we
          # use them later.  If we have whole_archive_flag_spec, we
          # want to use save_libobjs as it was before
          # want to use save_libobjs as it was before
          # whole_archive_flag_spec was expanded, because we can't
          # whole_archive_flag_spec was expanded, because we can't
          # assume the linker understands whole_archive_flag_spec.
          # assume the linker understands whole_archive_flag_spec.
          # This may have to be revisited, in case too many
          # This may have to be revisited, in case too many
          # convenience libraries get linked in and end up exceeding
          # convenience libraries get linked in and end up exceeding
          # the spec.
          # the spec.
          if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
          if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
            save_libobjs=$libobjs
            save_libobjs=$libobjs
          fi
          fi
          save_output=$output
          save_output=$output
 
 
          # Clear the reloadable object creation command queue and
          # Clear the reloadable object creation command queue and
          # initialize k to one.
          # initialize k to one.
          test_cmds=
          test_cmds=
          concat_cmds=
          concat_cmds=
          objlist=
          objlist=
          delfiles=
          delfiles=
          last_robj=
          last_robj=
          k=1
          k=1
          output=$output_objdir/$save_output-${k}.$objext
          output=$output_objdir/$save_output-${k}.$objext
          # Loop over the list of objects to be linked.
          # Loop over the list of objects to be linked.
          for obj in $save_libobjs
          for obj in $save_libobjs
          do
          do
            eval test_cmds=\"$reload_cmds $objlist $last_robj\"
            eval test_cmds=\"$reload_cmds $objlist $last_robj\"
            if test "X$objlist" = X ||
            if test "X$objlist" = X ||
               { len=`expr "X$test_cmds" : ".*"` &&
               { len=`expr "X$test_cmds" : ".*"` &&
                 test $len -le $max_cmd_len; }; then
                 test $len -le $max_cmd_len; }; then
              objlist="$objlist $obj"
              objlist="$objlist $obj"
            else
            else
              # The command $test_cmds is almost too long, add a
              # The command $test_cmds is almost too long, add a
              # command to the queue.
              # command to the queue.
              if test $k -eq 1 ; then
              if test $k -eq 1 ; then
                # The first file doesn't have a previous command to add.
                # The first file doesn't have a previous command to add.
                eval concat_cmds=\"$reload_cmds $objlist $last_robj\"
                eval concat_cmds=\"$reload_cmds $objlist $last_robj\"
              else
              else
                # All subsequent reloadable object files will link in
                # All subsequent reloadable object files will link in
                # the last one created.
                # the last one created.
                eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj\"
                eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj\"
              fi
              fi
              last_robj=$output_objdir/$save_output-${k}.$objext
              last_robj=$output_objdir/$save_output-${k}.$objext
              k=`expr $k + 1`
              k=`expr $k + 1`
              output=$output_objdir/$save_output-${k}.$objext
              output=$output_objdir/$save_output-${k}.$objext
              objlist=$obj
              objlist=$obj
              len=1
              len=1
            fi
            fi
          done
          done
          # Handle the remaining objects by creating one last
          # Handle the remaining objects by creating one last
          # reloadable object file.  All subsequent reloadable object
          # reloadable object file.  All subsequent reloadable object
          # files will link in the last one created.
          # files will link in the last one created.
          test -z "$concat_cmds" || concat_cmds=$concat_cmds~
          test -z "$concat_cmds" || concat_cmds=$concat_cmds~
          eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"
          eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"
 
 
          # Set up a command to remove the reloadale object files
          # Set up a command to remove the reloadale object files
          # after they are used.
          # after they are used.
          i=0
          i=0
          while test $i -lt $k
          while test $i -lt $k
          do
          do
            i=`expr $i + 1`
            i=`expr $i + 1`
            delfiles="$delfiles $output_objdir/$save_output-${i}.$objext"
            delfiles="$delfiles $output_objdir/$save_output-${i}.$objext"
          done
          done
 
 
          $echo "creating a temporary reloadable object file: $output"
          $echo "creating a temporary reloadable object file: $output"
 
 
          # Loop through the commands generated above and execute them.
          # Loop through the commands generated above and execute them.
          IFS="${IFS=   }"; save_ifs="$IFS"; IFS='~'
          IFS="${IFS=   }"; save_ifs="$IFS"; IFS='~'
          for cmd in $concat_cmds; do
          for cmd in $concat_cmds; do
            IFS="$save_ifs"
            IFS="$save_ifs"
            $show "$cmd"
            $show "$cmd"
            $run eval "$cmd" || exit $?
            $run eval "$cmd" || exit $?
          done
          done
          IFS="$save_ifs"
          IFS="$save_ifs"
 
 
          libobjs=$output
          libobjs=$output
          # Restore the value of output.
          # Restore the value of output.
          output=$save_output
          output=$save_output
 
 
          if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
          if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
            eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
            eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
          fi
          fi
          # Expand the library linking commands again to reset the
          # Expand the library linking commands again to reset the
          # value of $libobjs for piecewise linking.
          # value of $libobjs for piecewise linking.
 
 
          # Do each of the archive commands.
          # Do each of the archive commands.
          if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
          if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
            eval cmds=\"$archive_expsym_cmds\"
            eval cmds=\"$archive_expsym_cmds\"
          else
          else
            eval cmds=\"$archive_cmds\"
            eval cmds=\"$archive_cmds\"
          fi
          fi
 
 
          # Append the command to remove the reloadable object files
          # Append the command to remove the reloadable object files
          # to the just-reset $cmds.
          # to the just-reset $cmds.
          eval cmds=\"\$cmds~$rm $delfiles\"
          eval cmds=\"\$cmds~$rm $delfiles\"
        fi
        fi
        IFS="${IFS=     }"; save_ifs="$IFS"; IFS='~'
        IFS="${IFS=     }"; save_ifs="$IFS"; IFS='~'
        for cmd in $cmds; do
        for cmd in $cmds; do
          IFS="$save_ifs"
          IFS="$save_ifs"
          $show "$cmd"
          $show "$cmd"
          $run eval "$cmd" || exit $?
          $run eval "$cmd" || exit $?
        done
        done
        IFS="$save_ifs"
        IFS="$save_ifs"
 
 
        # Restore the uninstalled library and exit
        # Restore the uninstalled library and exit
        if test "$mode" = relink; then
        if test "$mode" = relink; then
          $run eval '(cd $output_objdir && $rm ${realname}T && $mv $realname ${realname}T && $mv "$realname"U $realname)' || exit $?
          $run eval '(cd $output_objdir && $rm ${realname}T && $mv $realname ${realname}T && $mv "$realname"U $realname)' || exit $?
          exit 0
          exit 0
        fi
        fi
 
 
        # Create links to the real library.
        # Create links to the real library.
        for linkname in $linknames; do
        for linkname in $linknames; do
          if test "$realname" != "$linkname"; then
          if test "$realname" != "$linkname"; then
            $show "(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)"
            $show "(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)"
            $run eval '(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)' || exit $?
            $run eval '(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)' || exit $?
          fi
          fi
        done
        done
 
 
        # If -module or -export-dynamic was specified, set the dlname.
        # If -module or -export-dynamic was specified, set the dlname.
        if test "$module" = yes || test "$export_dynamic" = yes; then
        if test "$module" = yes || test "$export_dynamic" = yes; then
          # On all known operating systems, these are identical.
          # On all known operating systems, these are identical.
          dlname="$soname"
          dlname="$soname"
        fi
        fi
      fi
      fi
      ;;
      ;;
 
 
    obj)
    obj)
      if test -n "$deplibs"; then
      if test -n "$deplibs"; then
        $echo "$modename: warning: \`-l' and \`-L' are ignored for objects" 1>&2
        $echo "$modename: warning: \`-l' and \`-L' are ignored for objects" 1>&2
      fi
      fi
 
 
      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
        $echo "$modename: warning: \`-dlopen' is ignored for objects" 1>&2
        $echo "$modename: warning: \`-dlopen' is ignored for objects" 1>&2
      fi
      fi
 
 
      if test -n "$rpath"; then
      if test -n "$rpath"; then
        $echo "$modename: warning: \`-rpath' is ignored for objects" 1>&2
        $echo "$modename: warning: \`-rpath' is ignored for objects" 1>&2
      fi
      fi
 
 
      if test -n "$xrpath"; then
      if test -n "$xrpath"; then
        $echo "$modename: warning: \`-R' is ignored for objects" 1>&2
        $echo "$modename: warning: \`-R' is ignored for objects" 1>&2
      fi
      fi
 
 
      if test -n "$vinfo"; then
      if test -n "$vinfo"; then
        $echo "$modename: warning: \`-version-info' is ignored for objects" 1>&2
        $echo "$modename: warning: \`-version-info' is ignored for objects" 1>&2
      fi
      fi
 
 
      if test -n "$release"; then
      if test -n "$release"; then
        $echo "$modename: warning: \`-release' is ignored for objects" 1>&2
        $echo "$modename: warning: \`-release' is ignored for objects" 1>&2
      fi
      fi
 
 
      case $output in
      case $output in
      *.lo)
      *.lo)
        if test -n "$objs$old_deplibs"; then
        if test -n "$objs$old_deplibs"; then
          $echo "$modename: cannot build library object \`$output' from non-libtool objects" 1>&2
          $echo "$modename: cannot build library object \`$output' from non-libtool objects" 1>&2
          exit 1
          exit 1
        fi
        fi
        libobj="$output"
        libobj="$output"
        obj=`$echo "X$output" | $Xsed -e "$lo2o"`
        obj=`$echo "X$output" | $Xsed -e "$lo2o"`
        ;;
        ;;
      *)
      *)
        libobj=
        libobj=
        obj="$output"
        obj="$output"
        ;;
        ;;
      esac
      esac
 
 
      # Delete the old objects.
      # Delete the old objects.
      $run $rm $obj $libobj
      $run $rm $obj $libobj
 
 
      # Objects from convenience libraries.  This assumes
      # Objects from convenience libraries.  This assumes
      # single-version convenience libraries.  Whenever we create
      # single-version convenience libraries.  Whenever we create
      # different ones for PIC/non-PIC, this we'll have to duplicate
      # different ones for PIC/non-PIC, this we'll have to duplicate
      # the extraction.
      # the extraction.
      reload_conv_objs=
      reload_conv_objs=
      gentop=
      gentop=
      # reload_cmds runs $LD directly, so let us get rid of
      # reload_cmds runs $LD directly, so let us get rid of
      # -Wl from whole_archive_flag_spec
      # -Wl from whole_archive_flag_spec
      wl=
      wl=
 
 
      if test -n "$convenience"; then
      if test -n "$convenience"; then
        if test -n "$whole_archive_flag_spec"; then
        if test -n "$whole_archive_flag_spec"; then
          eval reload_conv_objs=\"\$reload_objs $whole_archive_flag_spec\"
          eval reload_conv_objs=\"\$reload_objs $whole_archive_flag_spec\"
        else
        else
          gentop="$output_objdir/${obj}x"
          gentop="$output_objdir/${obj}x"
          $show "${rm}r $gentop"
          $show "${rm}r $gentop"
          $run ${rm}r "$gentop"
          $run ${rm}r "$gentop"
          $show "$mkdir $gentop"
          $show "$mkdir $gentop"
          $run $mkdir "$gentop"
          $run $mkdir "$gentop"
          status=$?
          status=$?
          if test $status -ne 0 && test ! -d "$gentop"; then
          if test $status -ne 0 && test ! -d "$gentop"; then
            exit $status
            exit $status
          fi
          fi
          generated="$generated $gentop"
          generated="$generated $gentop"
 
 
          for xlib in $convenience; do
          for xlib in $convenience; do
            # Extract the objects.
            # Extract the objects.
            case $xlib in
            case $xlib in
            [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;
            [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;
            *) xabs=`pwd`"/$xlib" ;;
            *) xabs=`pwd`"/$xlib" ;;
            esac
            esac
            xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
            xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
            xdir="$gentop/$xlib"
            xdir="$gentop/$xlib"
 
 
            $show "${rm}r $xdir"
            $show "${rm}r $xdir"
            $run ${rm}r "$xdir"
            $run ${rm}r "$xdir"
            $show "$mkdir $xdir"
            $show "$mkdir $xdir"
            $run $mkdir "$xdir"
            $run $mkdir "$xdir"
            status=$?
            status=$?
            if test $status -ne 0 && test ! -d "$xdir"; then
            if test $status -ne 0 && test ! -d "$xdir"; then
              exit $status
              exit $status
            fi
            fi
            $show "(cd $xdir && $AR x $xabs)"
            $show "(cd $xdir && $AR x $xabs)"
            $run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
            $run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
 
 
            reload_conv_objs="$reload_objs "`find $xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
            reload_conv_objs="$reload_objs "`find $xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
          done
          done
        fi
        fi
      fi
      fi
 
 
      # Create the old-style object.
      # Create the old-style object.
      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
      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"
      output="$obj"
      eval cmds=\"$reload_cmds\"
      eval cmds=\"$reload_cmds\"
      IFS="${IFS=       }"; save_ifs="$IFS"; IFS='~'
      IFS="${IFS=       }"; save_ifs="$IFS"; IFS='~'
      for cmd in $cmds; do
      for cmd in $cmds; do
        IFS="$save_ifs"
        IFS="$save_ifs"
        $show "$cmd"
        $show "$cmd"
        $run eval "$cmd" || exit $?
        $run eval "$cmd" || exit $?
      done
      done
      IFS="$save_ifs"
      IFS="$save_ifs"
 
 
      # Exit if we aren't doing a library object file.
      # Exit if we aren't doing a library object file.
      if test -z "$libobj"; then
      if test -z "$libobj"; then
        if test -n "$gentop"; then
        if test -n "$gentop"; then
          $show "${rm}r $gentop"
          $show "${rm}r $gentop"
          $run ${rm}r $gentop
          $run ${rm}r $gentop
        fi
        fi
 
 
        exit 0
        exit 0
      fi
      fi
 
 
      if test "$build_libtool_libs" != yes; then
      if test "$build_libtool_libs" != yes; then
        if test -n "$gentop"; then
        if test -n "$gentop"; then
          $show "${rm}r $gentop"
          $show "${rm}r $gentop"
          $run ${rm}r $gentop
          $run ${rm}r $gentop
        fi
        fi
 
 
        # Create an invalid libtool object if no PIC, so that we don't
        # Create an invalid libtool object if no PIC, so that we don't
        # accidentally link it into a program.
        # accidentally link it into a program.
        # $show "echo timestamp > $libobj"
        # $show "echo timestamp > $libobj"
        # $run eval "echo timestamp > $libobj" || exit $?
        # $run eval "echo timestamp > $libobj" || exit $?
        exit 0
        exit 0
      fi
      fi
 
 
      if test -n "$pic_flag" || test "$pic_mode" != default; then
      if test -n "$pic_flag" || test "$pic_mode" != default; then
        # Only do commands if we really have different PIC objects.
        # Only do commands if we really have different PIC objects.
        reload_objs="$libobjs $reload_conv_objs"
        reload_objs="$libobjs $reload_conv_objs"
        output="$libobj"
        output="$libobj"
        eval cmds=\"$reload_cmds\"
        eval cmds=\"$reload_cmds\"
        IFS="${IFS=     }"; save_ifs="$IFS"; IFS='~'
        IFS="${IFS=     }"; save_ifs="$IFS"; IFS='~'
        for cmd in $cmds; do
        for cmd in $cmds; do
          IFS="$save_ifs"
          IFS="$save_ifs"
          $show "$cmd"
          $show "$cmd"
          $run eval "$cmd" || exit $?
          $run eval "$cmd" || exit $?
        done
        done
        IFS="$save_ifs"
        IFS="$save_ifs"
#     else
#     else
#       # Just create a symlink.
#       # Just create a symlink.
#       $show $rm $libobj
#       $show $rm $libobj
#       $run $rm $libobj
#       $run $rm $libobj
#       xdir=`$echo "X$libobj" | $Xsed -e 's%/[^/]*$%%'`
#       xdir=`$echo "X$libobj" | $Xsed -e 's%/[^/]*$%%'`
#       if test "X$xdir" = "X$libobj"; then
#       if test "X$xdir" = "X$libobj"; then
#         xdir="."
#         xdir="."
#       else
#       else
#         xdir="$xdir"
#         xdir="$xdir"
#       fi
#       fi
#       baseobj=`$echo "X$libobj" | $Xsed -e 's%^.*/%%'`
#       baseobj=`$echo "X$libobj" | $Xsed -e 's%^.*/%%'`
#       oldobj=`$echo "X$baseobj" | $Xsed -e "$lo2o"`
#       oldobj=`$echo "X$baseobj" | $Xsed -e "$lo2o"`
#       $show "(cd $xdir && $LN_S $oldobj $baseobj)"
#       $show "(cd $xdir && $LN_S $oldobj $baseobj)"
#       $run eval '(cd $xdir && $LN_S $oldobj $baseobj)' || exit $?
#       $run eval '(cd $xdir && $LN_S $oldobj $baseobj)' || exit $?
      fi
      fi
 
 
      if test -n "$gentop"; then
      if test -n "$gentop"; then
        $show "${rm}r $gentop"
        $show "${rm}r $gentop"
        $run ${rm}r $gentop
        $run ${rm}r $gentop
      fi
      fi
 
 
      exit 0
      exit 0
      ;;
      ;;
 
 
    prog)
    prog)
      case $host in
      case $host in
        *cygwin*) output=`echo $output | sed -e 's,.exe$,,;s,$,.exe,'` ;;
        *cygwin*) output=`echo $output | sed -e 's,.exe$,,;s,$,.exe,'` ;;
      esac
      esac
      if test -n "$vinfo"; then
      if test -n "$vinfo"; then
        $echo "$modename: warning: \`-version-info' is ignored for programs" 1>&2
        $echo "$modename: warning: \`-version-info' is ignored for programs" 1>&2
      fi
      fi
 
 
      if test -n "$release"; then
      if test -n "$release"; then
        $echo "$modename: warning: \`-release' is ignored for programs" 1>&2
        $echo "$modename: warning: \`-release' is ignored for programs" 1>&2
      fi
      fi
 
 
      if test "$preload" = yes; then
      if test "$preload" = yes; then
        if test "$dlopen_support" = unknown && test "$dlopen_self" = unknown &&
        if test "$dlopen_support" = unknown && test "$dlopen_self" = unknown &&
           test "$dlopen_self_static" = unknown; then
           test "$dlopen_self_static" = unknown; then
          $echo "$modename: warning: \`AC_LIBTOOL_DLOPEN' not used. Assuming no dlopen support."
          $echo "$modename: warning: \`AC_LIBTOOL_DLOPEN' not used. Assuming no dlopen support."
        fi
        fi
      fi
      fi
 
 
      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 is the System framework
        compile_deplibs=`$echo "X $compile_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
        compile_deplibs=`$echo "X $compile_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
        finalize_deplibs=`$echo "X $finalize_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
        finalize_deplibs=`$echo "X $finalize_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
        ;;
        ;;
      esac
      esac
 
 
      compile_command="$compile_command $compile_deplibs"
      compile_command="$compile_command $compile_deplibs"
      finalize_command="$finalize_command $finalize_deplibs"
      finalize_command="$finalize_command $finalize_deplibs"
 
 
      if test -n "$rpath$xrpath"; then
      if test -n "$rpath$xrpath"; then
        # If the user specified any rpath flags, then add them.
        # If the user specified any rpath flags, then add them.
        for libdir in $rpath $xrpath; do
        for libdir in $rpath $xrpath; do
          # This is the magic to use -rpath.
          # This is the magic to use -rpath.
          case "$finalize_rpath " in
          case "$finalize_rpath " in
          *" $libdir "*) ;;
          *" $libdir "*) ;;
          *) finalize_rpath="$finalize_rpath $libdir" ;;
          *) finalize_rpath="$finalize_rpath $libdir" ;;
          esac
          esac
        done
        done
      fi
      fi
 
 
      # Now hardcode the library paths
      # Now hardcode the library paths
      rpath=
      rpath=
      hardcode_libdirs=
      hardcode_libdirs=
      for libdir in $compile_rpath $finalize_rpath; do
      for libdir in $compile_rpath $finalize_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
              # Just accumulate the unique libdirs.
              # Just accumulate the unique libdirs.
              case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
              case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
              *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
              *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
                ;;
                ;;
              *)
              *)
                hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
                hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
                ;;
                ;;
              esac
              esac
            fi
            fi
          else
          else
            eval flag=\"$hardcode_libdir_flag_spec\"
            eval flag=\"$hardcode_libdir_flag_spec\"
            rpath="$rpath $flag"
            rpath="$rpath $flag"
          fi
          fi
        elif test -n "$runpath_var"; then
        elif test -n "$runpath_var"; then
          case "$perm_rpath " in
          case "$perm_rpath " in
          *" $libdir "*) ;;
          *" $libdir "*) ;;
          *) perm_rpath="$perm_rpath $libdir" ;;
          *) perm_rpath="$perm_rpath $libdir" ;;
          esac
          esac
        fi
        fi
        case $host in
        case $host in
        *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
        *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
          case :$dllsearchpath: in
          case :$dllsearchpath: in
          *":$libdir:"*) ;;
          *":$libdir:"*) ;;
          *) dllsearchpath="$dllsearchpath:$libdir";;
          *) dllsearchpath="$dllsearchpath:$libdir";;
          esac
          esac
          ;;
          ;;
        esac
        esac
      done
      done
      # Substitute the hardcoded libdirs into the rpath.
      # Substitute the hardcoded libdirs into the rpath.
      if test -n "$hardcode_libdir_separator" &&
      if test -n "$hardcode_libdir_separator" &&
         test -n "$hardcode_libdirs"; then
         test -n "$hardcode_libdirs"; then
        libdir="$hardcode_libdirs"
        libdir="$hardcode_libdirs"
        eval rpath=\" $hardcode_libdir_flag_spec\"
        eval rpath=\" $hardcode_libdir_flag_spec\"
      fi
      fi
      compile_rpath="$rpath"
      compile_rpath="$rpath"
 
 
      rpath=
      rpath=
      hardcode_libdirs=
      hardcode_libdirs=
      for libdir in $finalize_rpath; do
      for libdir in $finalize_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
              # Just accumulate the unique libdirs.
              # Just accumulate the unique libdirs.
              case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
              case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
              *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
              *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
                ;;
                ;;
              *)
              *)
                hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
                hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
                ;;
                ;;
              esac
              esac
            fi
            fi
          else
          else
            eval flag=\"$hardcode_libdir_flag_spec\"
            eval flag=\"$hardcode_libdir_flag_spec\"
            rpath="$rpath $flag"
            rpath="$rpath $flag"
          fi
          fi
        elif test -n "$runpath_var"; then
        elif test -n "$runpath_var"; then
          case "$finalize_perm_rpath " in
          case "$finalize_perm_rpath " in
          *" $libdir "*) ;;
          *" $libdir "*) ;;
          *) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
          *) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
          esac
          esac
        fi
        fi
      done
      done
      # Substitute the hardcoded libdirs into the rpath.
      # Substitute the hardcoded libdirs into the rpath.
      if test -n "$hardcode_libdir_separator" &&
      if test -n "$hardcode_libdir_separator" &&
         test -n "$hardcode_libdirs"; then
         test -n "$hardcode_libdirs"; then
        libdir="$hardcode_libdirs"
        libdir="$hardcode_libdirs"
        eval rpath=\" $hardcode_libdir_flag_spec\"
        eval rpath=\" $hardcode_libdir_flag_spec\"
      fi
      fi
      finalize_rpath="$rpath"
      finalize_rpath="$rpath"
 
 
      dlsyms=
      dlsyms=
      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
        if test -n "$NM" && test -n "$global_symbol_pipe"; then
        if test -n "$NM" && test -n "$global_symbol_pipe"; then
          dlsyms="${outputname}S.c"
          dlsyms="${outputname}S.c"
        else
        else
          $echo "$modename: not configured to extract global symbols from dlpreopened files" 1>&2
          $echo "$modename: not configured to extract global symbols from dlpreopened files" 1>&2
        fi
        fi
      fi
      fi
 
 
      if test -n "$dlsyms"; then
      if test -n "$dlsyms"; then
        case $dlsyms in
        case $dlsyms in
        "") ;;
        "") ;;
        *.c)
        *.c)
          # Discover the nlist of each of the dlfiles.
          # Discover the nlist of each of the dlfiles.
          nlist="$output_objdir/${outputname}.nm"
          nlist="$output_objdir/${outputname}.nm"
 
 
          $show "$rm $nlist ${nlist}S ${nlist}T"
          $show "$rm $nlist ${nlist}S ${nlist}T"
          $run $rm "$nlist" "${nlist}S" "${nlist}T"
          $run $rm "$nlist" "${nlist}S" "${nlist}T"
 
 
          # Parse the name list into a source file.
          # Parse the name list into a source file.
          $show "creating $output_objdir/$dlsyms"
          $show "creating $output_objdir/$dlsyms"
 
 
          test -z "$run" && $echo > "$output_objdir/$dlsyms" "\
          test -z "$run" && $echo > "$output_objdir/$dlsyms" "\
/* $dlsyms - symbol resolution table for \`$outputname' dlsym emulation. */
/* $dlsyms - symbol resolution table for \`$outputname' dlsym emulation. */
/* Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP */
/* Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP */
 
 
#ifdef __cplusplus
#ifdef __cplusplus
extern \"C\" {
extern \"C\" {
#endif
#endif
 
 
/* Prevent the only kind of declaration conflicts we can make. */
/* Prevent the only kind of declaration conflicts we can make. */
#define lt_preloaded_symbols some_other_symbol
#define lt_preloaded_symbols some_other_symbol
 
 
/* External symbol declarations for the compiler. */\
/* External symbol declarations for the compiler. */\
"
"
 
 
          if test "$dlself" = yes; then
          if test "$dlself" = yes; then
            $show "generating symbol list for \`$output'"
            $show "generating symbol list for \`$output'"
 
 
            test -z "$run" && $echo ': @PROGRAM@ ' > "$nlist"
            test -z "$run" && $echo ': @PROGRAM@ ' > "$nlist"
 
 
            # Add our own program objects to the symbol list.
            # Add our own program objects to the symbol list.
            progfiles="$objs$old_deplibs"
            progfiles="$objs$old_deplibs"
            for arg in $progfiles; do
            for arg in $progfiles; do
              $show "extracting global C symbols from \`$arg'"
              $show "extracting global C symbols from \`$arg'"
              $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
              $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
            done
            done
 
 
            if test -n "$exclude_expsyms"; then
            if test -n "$exclude_expsyms"; then
              $run eval 'egrep -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
              $run eval 'egrep -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
              $run eval '$mv "$nlist"T "$nlist"'
              $run eval '$mv "$nlist"T "$nlist"'
            fi
            fi
 
 
            if test -n "$export_symbols_regex"; then
            if test -n "$export_symbols_regex"; then
              $run eval 'egrep -e "$export_symbols_regex" "$nlist" > "$nlist"T'
              $run eval 'egrep -e "$export_symbols_regex" "$nlist" > "$nlist"T'
              $run eval '$mv "$nlist"T "$nlist"'
              $run eval '$mv "$nlist"T "$nlist"'
            fi
            fi
 
 
            # Prepare the list of exported symbols
            # Prepare the list of exported symbols
            if test -z "$export_symbols"; then
            if test -z "$export_symbols"; then
              export_symbols="$output_objdir/$output.exp"
              export_symbols="$output_objdir/$output.exp"
              $run $rm $export_symbols
              $run $rm $export_symbols
              $run eval "sed -n -e '/^: @PROGRAM@$/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
              $run eval "sed -n -e '/^: @PROGRAM@$/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
            else
            else
              $run eval "sed -e 's/\([][.*^$]\)/\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$output.exp"'
              $run eval "sed -e 's/\([][.*^$]\)/\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$output.exp"'
              $run eval 'grep -f "$output_objdir/$output.exp" < "$nlist" > "$nlist"T'
              $run eval 'grep -f "$output_objdir/$output.exp" < "$nlist" > "$nlist"T'
              $run eval 'mv "$nlist"T "$nlist"'
              $run eval 'mv "$nlist"T "$nlist"'
            fi
            fi
          fi
          fi
 
 
          for arg in $dlprefiles; do
          for arg in $dlprefiles; do
            $show "extracting global C symbols from \`$arg'"
            $show "extracting global C symbols from \`$arg'"
            name=`echo "$arg" | sed -e 's%^.*/%%'`
            name=`echo "$arg" | sed -e 's%^.*/%%'`
            $run eval 'echo ": $name " >> "$nlist"'
            $run eval 'echo ": $name " >> "$nlist"'
            $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
            $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
          done
          done
 
 
          if test -z "$run"; then
          if test -z "$run"; then
            # Make sure we have at least an empty file.
            # Make sure we have at least an empty file.
            test -f "$nlist" || : > "$nlist"
            test -f "$nlist" || : > "$nlist"
 
 
            if test -n "$exclude_expsyms"; then
            if test -n "$exclude_expsyms"; then
              egrep -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
              egrep -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
              $mv "$nlist"T "$nlist"
              $mv "$nlist"T "$nlist"
            fi
            fi
 
 
            # Try sorting and uniquifying the output.
            # Try sorting and uniquifying the output.
            if grep -v "^: " < "$nlist" | sort +2 | uniq > "$nlist"S; then
            if grep -v "^: " < "$nlist" | sort +2 | uniq > "$nlist"S; then
              :
              :
            else
            else
              grep -v "^: " < "$nlist" > "$nlist"S
              grep -v "^: " < "$nlist" > "$nlist"S
            fi
            fi
 
 
            if test -f "$nlist"S; then
            if test -f "$nlist"S; then
              eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$dlsyms"'
              eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$dlsyms"'
            else
            else
              echo '/* NONE */' >> "$output_objdir/$dlsyms"
              echo '/* NONE */' >> "$output_objdir/$dlsyms"
            fi
            fi
 
 
            $echo >> "$output_objdir/$dlsyms" "\
            $echo >> "$output_objdir/$dlsyms" "\
 
 
#undef lt_preloaded_symbols
#undef lt_preloaded_symbols
 
 
#if defined (__STDC__) && __STDC__
#if defined (__STDC__) && __STDC__
# define lt_ptr_t void *
# define lt_ptr_t void *
#else
#else
# define lt_ptr_t char *
# define lt_ptr_t char *
# define const
# define const
#endif
#endif
 
 
/* The mapping between symbol names and symbols. */
/* The mapping between symbol names and symbols. */
const struct {
const struct {
  const char *name;
  const char *name;
  lt_ptr_t address;
  lt_ptr_t address;
}
}
lt_preloaded_symbols[] =
lt_preloaded_symbols[] =
{\
{\
"
"
 
 
            sed -n -e 's/^: \([^ ]*\) $/  {\"\1\", (lt_ptr_t) 0},/p' \
            sed -n -e 's/^: \([^ ]*\) $/  {\"\1\", (lt_ptr_t) 0},/p' \
                -e 's/^. \([^ ]*\) \([^ ]*\)$/  {"\2", (lt_ptr_t) \&\2},/p' \
                -e 's/^. \([^ ]*\) \([^ ]*\)$/  {"\2", (lt_ptr_t) \&\2},/p' \
                  < "$nlist" >> "$output_objdir/$dlsyms"
                  < "$nlist" >> "$output_objdir/$dlsyms"
 
 
            $echo >> "$output_objdir/$dlsyms" "\
            $echo >> "$output_objdir/$dlsyms" "\
  {0, (lt_ptr_t) 0}
  {0, (lt_ptr_t) 0}
};
};
 
 
/* This works around a problem in FreeBSD linker */
/* This works around a problem in FreeBSD linker */
#ifdef FREEBSD_WORKAROUND
#ifdef FREEBSD_WORKAROUND
static const void *lt_preloaded_setup() {
static const void *lt_preloaded_setup() {
  return lt_preloaded_symbols;
  return lt_preloaded_symbols;
}
}
#endif
#endif
 
 
#ifdef __cplusplus
#ifdef __cplusplus
}
}
#endif\
#endif\
"
"
          fi
          fi
 
 
          pic_flag_for_symtable=
          pic_flag_for_symtable=
          case $host in
          case $host in
          # compiling the symbol table file with pic_flag works around
          # compiling the symbol table file with pic_flag works around
          # a FreeBSD bug that causes programs to crash when -lm is
          # a FreeBSD bug that causes programs to crash when -lm is
          # linked before any other PIC object.  But we must not use
          # linked before any other PIC object.  But we must not use
          # pic_flag when linking with -static.  The problem exists in
          # pic_flag when linking with -static.  The problem exists in
          # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
          # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
          *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
          *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
            case "$compile_command " in
            case "$compile_command " in
            *" -static "*) ;;
            *" -static "*) ;;
            *) pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND";;
            *) pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND";;
            esac;;
            esac;;
          *-*-hpux*)
          *-*-hpux*)
            case "$compile_command " in
            case "$compile_command " in
            *" -static "*) ;;
            *" -static "*) ;;
            *) pic_flag_for_symtable=" $pic_flag";;
            *) pic_flag_for_symtable=" $pic_flag";;
            esac
            esac
          esac
          esac
 
 
          # Now compile the dynamic symbol file.
          # Now compile the dynamic symbol file.
          $show "(cd $output_objdir && $LTCC -c$no_builtin_flag$pic_flag_for_symtable \"$dlsyms\")"
          $show "(cd $output_objdir && $LTCC -c$no_builtin_flag$pic_flag_for_symtable \"$dlsyms\")"
          $run eval '(cd $output_objdir && $LTCC -c$no_builtin_flag$pic_flag_for_symtable "$dlsyms")' || exit $?
          $run eval '(cd $output_objdir && $LTCC -c$no_builtin_flag$pic_flag_for_symtable "$dlsyms")' || exit $?
 
 
          # Clean up the generated files.
          # Clean up the generated files.
          $show "$rm $output_objdir/$dlsyms $nlist ${nlist}S ${nlist}T"
          $show "$rm $output_objdir/$dlsyms $nlist ${nlist}S ${nlist}T"
          $run $rm "$output_objdir/$dlsyms" "$nlist" "${nlist}S" "${nlist}T"
          $run $rm "$output_objdir/$dlsyms" "$nlist" "${nlist}S" "${nlist}T"
 
 
          # Transform the symbol file into the correct name.
          # Transform the symbol file into the correct name.
          compile_command=`$echo "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
          compile_command=`$echo "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
          finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
          finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
          ;;
          ;;
        *)
        *)
          $echo "$modename: unknown suffix for \`$dlsyms'" 1>&2
          $echo "$modename: unknown suffix for \`$dlsyms'" 1>&2
          exit 1
          exit 1
          ;;
          ;;
        esac
        esac
      else
      else
        # We keep going just in case the user didn't refer to
        # We keep going just in case the user didn't refer to
        # lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
        # lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
        # really was required.
        # really was required.
 
 
        # Nullify the symbol file.
        # Nullify the symbol file.
        compile_command=`$echo "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
        compile_command=`$echo "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
        finalize_command=`$echo "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
        finalize_command=`$echo "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
      fi
      fi
 
 
      if test $need_relink = no || test "$build_libtool_libs" != yes; then
      if test $need_relink = no || test "$build_libtool_libs" != yes; then
        # Replace the output file specification.
        # Replace the output file specification.
        compile_command=`$echo "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
        compile_command=`$echo "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
        link_command="$compile_command$compile_rpath"
        link_command="$compile_command$compile_rpath"
 
 
        # We have no uninstalled library dependencies, so finalize right now.
        # We have no uninstalled library dependencies, so finalize right now.
        $show "$link_command"
        $show "$link_command"
        $run eval "$link_command"
        $run eval "$link_command"
        status=$?
        status=$?
 
 
        # Delete the generated files.
        # Delete the generated files.
        if test -n "$dlsyms"; then
        if test -n "$dlsyms"; then
          $show "$rm $output_objdir/${outputname}S.${objext}"
          $show "$rm $output_objdir/${outputname}S.${objext}"
          $run $rm "$output_objdir/${outputname}S.${objext}"
          $run $rm "$output_objdir/${outputname}S.${objext}"
        fi
        fi
 
 
        exit $status
        exit $status
      fi
      fi
 
 
      if test -n "$shlibpath_var"; then
      if test -n "$shlibpath_var"; then
        # We should set the shlibpath_var
        # We should set the shlibpath_var
        rpath=
        rpath=
        for dir in $temp_rpath; do
        for dir in $temp_rpath; do
          case $dir in
          case $dir in
          [\\/]* | [A-Za-z]:[\\/]*)
          [\\/]* | [A-Za-z]:[\\/]*)
            # Absolute path.
            # Absolute path.
            rpath="$rpath$dir:"
            rpath="$rpath$dir:"
            ;;
            ;;
          *)
          *)
            # Relative path: add a thisdir entry.
            # Relative path: add a thisdir entry.
            rpath="$rpath\$thisdir/$dir:"
            rpath="$rpath\$thisdir/$dir:"
            ;;
            ;;
          esac
          esac
        done
        done
        temp_rpath="$rpath"
        temp_rpath="$rpath"
      fi
      fi
 
 
      if test -n "$compile_shlibpath$finalize_shlibpath"; then
      if test -n "$compile_shlibpath$finalize_shlibpath"; then
        compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
        compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
      fi
      fi
      if test -n "$finalize_shlibpath"; then
      if test -n "$finalize_shlibpath"; then
        finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
        finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
      fi
      fi
 
 
      compile_var=
      compile_var=
      finalize_var=
      finalize_var=
      if test -n "$runpath_var"; then
      if test -n "$runpath_var"; then
        if test -n "$perm_rpath"; then
        if test -n "$perm_rpath"; then
          # We should set the runpath_var.
          # We should set the runpath_var.
          rpath=
          rpath=
          for dir in $perm_rpath; do
          for dir in $perm_rpath; do
            rpath="$rpath$dir:"
            rpath="$rpath$dir:"
          done
          done
          compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
          compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
        fi
        fi
        if test -n "$finalize_perm_rpath"; then
        if test -n "$finalize_perm_rpath"; then
          # We should set the runpath_var.
          # We should set the runpath_var.
          rpath=
          rpath=
          for dir in $finalize_perm_rpath; do
          for dir in $finalize_perm_rpath; do
            rpath="$rpath$dir:"
            rpath="$rpath$dir:"
          done
          done
          finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
          finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
        fi
        fi
      fi
      fi
 
 
      if test "$no_install" = yes; then
      if test "$no_install" = yes; then
        # We don't need to create a wrapper script.
        # We don't need to create a wrapper script.
        link_command="$compile_var$compile_command$compile_rpath"
        link_command="$compile_var$compile_command$compile_rpath"
        # Replace the output file specification.
        # Replace the output file specification.
        link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
        link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
        # Delete the old output file.
        # Delete the old output file.
        $run $rm $output
        $run $rm $output
        # Link the executable and exit
        # Link the executable and exit
        $show "$link_command"
        $show "$link_command"
        $run eval "$link_command" || exit $?
        $run eval "$link_command" || exit $?
        exit 0
        exit 0
      fi
      fi
 
 
      if test "$hardcode_action" = relink; then
      if test "$hardcode_action" = relink; then
        # Fast installation is not supported
        # Fast installation is not supported
        link_command="$compile_var$compile_command$compile_rpath"
        link_command="$compile_var$compile_command$compile_rpath"
        relink_command="$finalize_var$finalize_command$finalize_rpath"
        relink_command="$finalize_var$finalize_command$finalize_rpath"
 
 
        $echo "$modename: warning: this platform does not like uninstalled shared libraries" 1>&2
        $echo "$modename: warning: this platform does not like uninstalled shared libraries" 1>&2
        $echo "$modename: \`$output' will be relinked during installation" 1>&2
        $echo "$modename: \`$output' will be relinked during installation" 1>&2
      else
      else
        if test "$fast_install" != no; then
        if test "$fast_install" != no; then
          link_command="$finalize_var$compile_command$finalize_rpath"
          link_command="$finalize_var$compile_command$finalize_rpath"
          if test "$fast_install" = yes; then
          if test "$fast_install" = yes; then
            relink_command=`$echo "X$compile_var$compile_command$compile_rpath" | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g'`
            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
            # fast_install is set to needless
            relink_command=
            relink_command=
          fi
          fi
        else
        else
          link_command="$compile_var$compile_command$compile_rpath"
          link_command="$compile_var$compile_command$compile_rpath"
          relink_command="$finalize_var$finalize_command$finalize_rpath"
          relink_command="$finalize_var$finalize_command$finalize_rpath"
        fi
        fi
      fi
      fi
 
 
      # Replace the output file specification.
      # Replace the output file specification.
      link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
      link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
 
 
      # Delete the old output files.
      # Delete the old output files.
      $run $rm $output $output_objdir/$outputname $output_objdir/lt-$outputname
      $run $rm $output $output_objdir/$outputname $output_objdir/lt-$outputname
 
 
      $show "$link_command"
      $show "$link_command"
      $run eval "$link_command" || exit $?
      $run eval "$link_command" || exit $?
 
 
      # Now create the wrapper script.
      # Now create the wrapper script.
      $show "creating $output"
      $show "creating $output"
 
 
      # Quote the relink command for shipping.
      # Quote the relink command for shipping.
      if test -n "$relink_command"; then
      if test -n "$relink_command"; then
        # 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}\" || unset $var || { $var=; export $var; }; }; $relink_command"
            relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"
          elif eval var_value=\$$var; test -z "$var_value"; then
          elif eval var_value=\$$var; test -z "$var_value"; then
            relink_command="$var=; export $var; $relink_command"
            relink_command="$var=; export $var; $relink_command"
          else
          else
            var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
            var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
            relink_command="$var=\"$var_value\"; export $var; $relink_command"
            relink_command="$var=\"$var_value\"; export $var; $relink_command"
          fi
          fi
        done
        done
        relink_command="cd `pwd`; $relink_command"
        relink_command="cd `pwd`; $relink_command"
        relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"`
        relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"`
      fi
      fi
 
 
      # Quote $echo for shipping.
      # Quote $echo for shipping.
      if test "X$echo" = "X$SHELL $0 --fallback-echo"; then
      if test "X$echo" = "X$SHELL $0 --fallback-echo"; then
        case $0 in
        case $0 in
        [\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $0 --fallback-echo";;
        [\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $0 --fallback-echo";;
        *) qecho="$SHELL `pwd`/$0 --fallback-echo";;
        *) qecho="$SHELL `pwd`/$0 --fallback-echo";;
        esac
        esac
        qecho=`$echo "X$qecho" | $Xsed -e "$sed_quote_subst"`
        qecho=`$echo "X$qecho" | $Xsed -e "$sed_quote_subst"`
      else
      else
        qecho=`$echo "X$echo" | $Xsed -e "$sed_quote_subst"`
        qecho=`$echo "X$echo" | $Xsed -e "$sed_quote_subst"`
      fi
      fi
 
 
      # Only actually do things if our run command is non-null.
      # Only actually do things if our run command is non-null.
      if test -z "$run"; then
      if test -z "$run"; then
        # win32 will think the script is a binary if it has
        # win32 will think the script is a binary if it has
        # a .exe suffix, so we strip it off here.
        # a .exe suffix, so we strip it off here.
        case $output in
        case $output in
          *.exe) output=`echo $output|sed 's,.exe$,,'` ;;
          *.exe) output=`echo $output|sed 's,.exe$,,'` ;;
        esac
        esac
        # test for cygwin because mv fails w/o .exe extensions
        # test for cygwin because mv fails w/o .exe extensions
        case $host in
        case $host in
          *cygwin*) exeext=.exe ;;
          *cygwin*) exeext=.exe ;;
          *) exeext= ;;
          *) exeext= ;;
        esac
        esac
        $rm $output
        $rm $output
        trap "$rm $output; exit 1" 1 2 15
        trap "$rm $output; exit 1" 1 2 15
 
 
        $echo > $output "\
        $echo > $output "\
#! $SHELL
#! $SHELL
 
 
# $output - temporary wrapper script for $objdir/$outputname
# $output - temporary wrapper script for $objdir/$outputname
# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
#
#
# The $output program cannot be directly executed until all the libtool
# The $output program cannot be directly executed until all the libtool
# libraries that it depends on are installed.
# libraries that it depends on are installed.
#
#
# This wrapper script should never be moved out of the build directory.
# This wrapper script should never be moved out of the build directory.
# If it is, it will not operate correctly.
# If it is, it will not operate correctly.
 
 
# Sed substitution that helps us do robust quoting.  It backslashifies
# Sed substitution that helps us do robust quoting.  It backslashifies
# metacharacters that are still active within double-quoted strings.
# metacharacters that are still active within double-quoted strings.
Xsed='sed -e 1s/^X//'
Xsed='sed -e 1s/^X//'
sed_quote_subst='$sed_quote_subst'
sed_quote_subst='$sed_quote_subst'
 
 
# The HP-UX ksh and POSIX shell print the target directory to stdout
# The HP-UX ksh and POSIX shell print the target directory to stdout
# if CDPATH is set.
# if CDPATH is set.
if test \"\${CDPATH+set}\" = set; then CDPATH=:; export CDPATH; fi
if test \"\${CDPATH+set}\" = set; then CDPATH=:; export CDPATH; fi
 
 
relink_command=\"$relink_command\"
relink_command=\"$relink_command\"
 
 
# This environment variable determines our operation mode.
# This environment variable determines our operation mode.
if test \"\$libtool_install_magic\" = \"$magic\"; then
if test \"\$libtool_install_magic\" = \"$magic\"; then
  # install mode needs the following variable:
  # install mode needs the following variable:
  notinst_deplibs='$notinst_deplibs'
  notinst_deplibs='$notinst_deplibs'
else
else
  # When we are sourced in execute mode, \$file and \$echo are already set.
  # When we are sourced in execute mode, \$file and \$echo are already set.
  if test \"\$libtool_execute_magic\" != \"$magic\"; then
  if test \"\$libtool_execute_magic\" != \"$magic\"; then
    echo=\"$qecho\"
    echo=\"$qecho\"
    file=\"\$0\"
    file=\"\$0\"
    # Make sure echo works.
    # Make sure echo works.
    if test \"X\$1\" = X--no-reexec; then
    if test \"X\$1\" = X--no-reexec; then
      # Discard the --no-reexec flag, and continue.
      # Discard the --no-reexec flag, and continue.
      shift
      shift
    elif test \"X\`(\$echo '\t') 2>/dev/null\`\" = 'X\t'; then
    elif test \"X\`(\$echo '\t') 2>/dev/null\`\" = 'X\t'; then
      # Yippee, \$echo works!
      # Yippee, \$echo works!
      :
      :
    else
    else
      # Restart under the correct shell, and then maybe \$echo will work.
      # Restart under the correct shell, and then maybe \$echo will work.
      exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}
      exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}
    fi
    fi
  fi\
  fi\
"
"
        $echo >> $output "\
        $echo >> $output "\
 
 
  # Find the directory that this script lives in.
  # Find the directory that this script lives in.
  thisdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
  thisdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
  test \"x\$thisdir\" = \"x\$file\" && thisdir=.
  test \"x\$thisdir\" = \"x\$file\" && thisdir=.
 
 
  # Follow symbolic links until we get to the real thisdir.
  # Follow symbolic links until we get to the real thisdir.
  file=\`ls -ld \"\$file\" | sed -n 's/.*-> //p'\`
  file=\`ls -ld \"\$file\" | sed -n 's/.*-> //p'\`
  while test -n \"\$file\"; do
  while test -n \"\$file\"; do
    destdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
    destdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
 
 
    # If there was a directory component, then change thisdir.
    # If there was a directory component, then change thisdir.
    if test \"x\$destdir\" != \"x\$file\"; then
    if test \"x\$destdir\" != \"x\$file\"; then
      case \"\$destdir\" in
      case \"\$destdir\" in
      [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
      [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
      *) thisdir=\"\$thisdir/\$destdir\" ;;
      *) thisdir=\"\$thisdir/\$destdir\" ;;
      esac
      esac
    fi
    fi
 
 
    file=\`\$echo \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
    file=\`\$echo \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
    file=\`ls -ld \"\$thisdir/\$file\" | sed -n 's/.*-> //p'\`
    file=\`ls -ld \"\$thisdir/\$file\" | sed -n 's/.*-> //p'\`
  done
  done
 
 
  # Try to get the absolute directory name.
  # Try to get the absolute directory name.
  absdir=\`cd \"\$thisdir\" && pwd\`
  absdir=\`cd \"\$thisdir\" && pwd\`
  test -n \"\$absdir\" && thisdir=\"\$absdir\"
  test -n \"\$absdir\" && thisdir=\"\$absdir\"
"
"
 
 
        if test "$fast_install" = yes; then
        if test "$fast_install" = yes; then
          echo >> $output "\
          echo >> $output "\
  program=lt-'$outputname'$exeext
  program=lt-'$outputname'$exeext
  progdir=\"\$thisdir/$objdir\"
  progdir=\"\$thisdir/$objdir\"
 
 
  if test ! -f \"\$progdir/\$program\" || \\
  if test ! -f \"\$progdir/\$program\" || \\
     { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | sed 1q\`; \\
     { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | sed 1q\`; \\
       test \"X\$file\" != \"X\$progdir/\$program\"; }; then
       test \"X\$file\" != \"X\$progdir/\$program\"; }; then
 
 
    file=\"\$\$-\$program\"
    file=\"\$\$-\$program\"
 
 
    if test ! -d \"\$progdir\"; then
    if test ! -d \"\$progdir\"; then
      $mkdir \"\$progdir\"
      $mkdir \"\$progdir\"
    else
    else
      $rm \"\$progdir/\$file\"
      $rm \"\$progdir/\$file\"
    fi"
    fi"
 
 
          echo >> $output "\
          echo >> $output "\
 
 
    # relink executable if necessary
    # relink executable if necessary
    if test -n \"\$relink_command\"; then
    if test -n \"\$relink_command\"; then
      if relink_command_output=\`eval \$relink_command 2>&1\`; then :
      if relink_command_output=\`eval \$relink_command 2>&1\`; then :
      else
      else
        $echo \"\$relink_command_output\" >&2
        $echo \"\$relink_command_output\" >&2
        $rm \"\$progdir/\$file\"
        $rm \"\$progdir/\$file\"
        exit 1
        exit 1
      fi
      fi
    fi
    fi
 
 
    $mv \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
    $mv \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
    { $rm \"\$progdir/\$program\";
    { $rm \"\$progdir/\$program\";
      $mv \"\$progdir/\$file\" \"\$progdir/\$program\"; }
      $mv \"\$progdir/\$file\" \"\$progdir/\$program\"; }
    $rm \"\$progdir/\$file\"
    $rm \"\$progdir/\$file\"
  fi"
  fi"
        else
        else
          echo >> $output "\
          echo >> $output "\
  program='$outputname'
  program='$outputname'
  progdir=\"\$thisdir/$objdir\"
  progdir=\"\$thisdir/$objdir\"
"
"
        fi
        fi
 
 
        echo >> $output "\
        echo >> $output "\
 
 
  if test -f \"\$progdir/\$program\"; then"
  if test -f \"\$progdir/\$program\"; then"
 
 
        # Export our shlibpath_var if we have one.
        # Export our shlibpath_var if we have one.
        if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
        if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
          $echo >> $output "\
          $echo >> $output "\
    # Add our own library path to $shlibpath_var
    # Add our own library path to $shlibpath_var
    $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
    $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
 
 
    # Some systems cannot cope with colon-terminated $shlibpath_var
    # Some systems cannot cope with colon-terminated $shlibpath_var
    # The second colon is a workaround for a bug in BeOS R4 sed
    # The second colon is a workaround for a bug in BeOS R4 sed
    $shlibpath_var=\`\$echo \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`
    $shlibpath_var=\`\$echo \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`
 
 
    export $shlibpath_var
    export $shlibpath_var
"
"
        fi
        fi
 
 
        # fixup the dll searchpath if we need to.
        # fixup the dll searchpath if we need to.
        if test -n "$dllsearchpath"; then
        if test -n "$dllsearchpath"; then
          $echo >> $output "\
          $echo >> $output "\
    # Add the dll search path components to the executable PATH
    # Add the dll search path components to the executable PATH
    PATH=$dllsearchpath:\$PATH
    PATH=$dllsearchpath:\$PATH
"
"
        fi
        fi
 
 
        $echo >> $output "\
        $echo >> $output "\
    if test \"\$libtool_execute_magic\" != \"$magic\"; then
    if test \"\$libtool_execute_magic\" != \"$magic\"; then
      # Run the actual program with our arguments.
      # Run the actual program with our arguments.
"
"
        case $host in
        case $host in
        # win32 systems need to use the prog path for dll
        # win32 systems need to use the prog path for dll
        # lookup to work
        # lookup to work
        *-*-cygwin* | *-*-pw32*)
        *-*-cygwin* | *-*-pw32*)
          $echo >> $output "\
          $echo >> $output "\
      exec \$progdir/\$program \${1+\"\$@\"}
      exec \$progdir/\$program \${1+\"\$@\"}
"
"
          ;;
          ;;
 
 
        # Backslashes separate directories on plain windows
        # Backslashes separate directories on plain windows
        *-*-mingw | *-*-os2*)
        *-*-mingw | *-*-os2*)
          $echo >> $output "\
          $echo >> $output "\
      exec \$progdir\\\\\$program \${1+\"\$@\"}
      exec \$progdir\\\\\$program \${1+\"\$@\"}
"
"
          ;;
          ;;
 
 
        *)
        *)
          $echo >> $output "\
          $echo >> $output "\
      # Export the path to the program.
      # Export the path to the program.
      PATH=\"\$progdir:\$PATH\"
      PATH=\"\$progdir:\$PATH\"
      export PATH
      export PATH
 
 
      exec \$program \${1+\"\$@\"}
      exec \$program \${1+\"\$@\"}
"
"
          ;;
          ;;
        esac
        esac
        $echo >> $output "\
        $echo >> $output "\
      \$echo \"\$0: cannot exec \$program \${1+\"\$@\"}\"
      \$echo \"\$0: cannot exec \$program \${1+\"\$@\"}\"
      exit 1
      exit 1
    fi
    fi
  else
  else
    # The program doesn't exist.
    # The program doesn't exist.
    \$echo \"\$0: error: \$progdir/\$program does not exist\" 1>&2
    \$echo \"\$0: error: \$progdir/\$program does not exist\" 1>&2
    \$echo \"This script is just a wrapper for \$program.\" 1>&2
    \$echo \"This script is just a wrapper for \$program.\" 1>&2
    echo \"See the $PACKAGE documentation for more information.\" 1>&2
    echo \"See the $PACKAGE documentation for more information.\" 1>&2
    exit 1
    exit 1
  fi
  fi
fi\
fi\
"
"
        chmod +x $output
        chmod +x $output
      fi
      fi
      exit 0
      exit 0
      ;;
      ;;
    esac
    esac
 
 
    # See if we need to build an old-fashioned archive.
    # See if we need to build an old-fashioned archive.
    for oldlib in $oldlibs; do
    for oldlib in $oldlibs; do
 
 
      if test "$build_libtool_libs" = convenience; then
      if test "$build_libtool_libs" = convenience; then
        oldobjs="$libobjs_save"
        oldobjs="$libobjs_save"
        addlibs="$convenience"
        addlibs="$convenience"
        build_libtool_libs=no
        build_libtool_libs=no
      else
      else
        if test "$build_libtool_libs" = module; then
        if test "$build_libtool_libs" = module; then
          oldobjs="$libobjs_save"
          oldobjs="$libobjs_save"
          build_libtool_libs=no
          build_libtool_libs=no
        else
        else
          oldobjs="$objs$old_deplibs $non_pic_objects"
          oldobjs="$objs$old_deplibs $non_pic_objects"
        fi
        fi
        addlibs="$old_convenience"
        addlibs="$old_convenience"
      fi
      fi
 
 
      if test -n "$addlibs"; then
      if test -n "$addlibs"; then
        gentop="$output_objdir/${outputname}x"
        gentop="$output_objdir/${outputname}x"
        $show "${rm}r $gentop"
        $show "${rm}r $gentop"
        $run ${rm}r "$gentop"
        $run ${rm}r "$gentop"
        $show "$mkdir $gentop"
        $show "$mkdir $gentop"
        $run $mkdir "$gentop"
        $run $mkdir "$gentop"
        status=$?
        status=$?
        if test $status -ne 0 && test ! -d "$gentop"; then
        if test $status -ne 0 && test ! -d "$gentop"; then
          exit $status
          exit $status
        fi
        fi
        generated="$generated $gentop"
        generated="$generated $gentop"
 
 
        # Add in members from convenience archives.
        # Add in members from convenience archives.
        for xlib in $addlibs; do
        for xlib in $addlibs; do
          # Extract the objects.
          # Extract the objects.
          case $xlib in
          case $xlib in
          [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;
          [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;
          *) xabs=`pwd`"/$xlib" ;;
          *) xabs=`pwd`"/$xlib" ;;
          esac
          esac
          xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
          xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
          xdir="$gentop/$xlib"
          xdir="$gentop/$xlib"
 
 
          $show "${rm}r $xdir"
          $show "${rm}r $xdir"
          $run ${rm}r "$xdir"
          $run ${rm}r "$xdir"
          $show "$mkdir $xdir"
          $show "$mkdir $xdir"
          $run $mkdir "$xdir"
          $run $mkdir "$xdir"
          status=$?
          status=$?
          if test $status -ne 0 && test ! -d "$xdir"; then
          if test $status -ne 0 && test ! -d "$xdir"; then
            exit $status
            exit $status
          fi
          fi
          $show "(cd $xdir && $AR x $xabs)"
          $show "(cd $xdir && $AR x $xabs)"
          $run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
          $run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
 
 
          oldobjs="$oldobjs "`find $xdir -name \*.${objext} -print | $NL2SP`
          oldobjs="$oldobjs "`find $xdir -name \*.${objext} -print | $NL2SP`
        done
        done
      fi
      fi
 
 
      # Do each command in the archive commands.
      # Do each command in the archive commands.
      if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
      if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
        eval cmds=\"$old_archive_from_new_cmds\"
        eval cmds=\"$old_archive_from_new_cmds\"
      else
      else
#       # Ensure that we have .o objects in place in case we decided
#       # Ensure that we have .o objects in place in case we decided
#       # not to build a shared library, and have fallen back to building
#       # not to build a shared library, and have fallen back to building
#       # static libs even though --disable-static was passed!
#       # static libs even though --disable-static was passed!
#       for oldobj in $oldobjs; do
#       for oldobj in $oldobjs; do
#         if test ! -f $oldobj; then
#         if test ! -f $oldobj; then
#           xdir=`$echo "X$oldobj" | $Xsed -e 's%/[^/]*$%%'`
#           xdir=`$echo "X$oldobj" | $Xsed -e 's%/[^/]*$%%'`
#           if test "X$xdir" = "X$oldobj"; then
#           if test "X$xdir" = "X$oldobj"; then
#             xdir="."
#             xdir="."
#           else
#           else
#             xdir="$xdir"
#             xdir="$xdir"
#           fi
#           fi
#           baseobj=`$echo "X$oldobj" | $Xsed -e 's%^.*/%%'`
#           baseobj=`$echo "X$oldobj" | $Xsed -e 's%^.*/%%'`
#           obj=`$echo "X$baseobj" | $Xsed -e "$o2lo"`
#           obj=`$echo "X$baseobj" | $Xsed -e "$o2lo"`
#           $show "(cd $xdir && ${LN_S} $obj $baseobj)"
#           $show "(cd $xdir && ${LN_S} $obj $baseobj)"
#           $run eval '(cd $xdir && ${LN_S} $obj $baseobj)' || exit $?
#           $run eval '(cd $xdir && ${LN_S} $obj $baseobj)' || exit $?
#         fi
#         fi
#       done
#       done
 
 
        eval cmds=\"$old_archive_cmds\"
        eval cmds=\"$old_archive_cmds\"
 
 
        if len=`expr "X$cmds" : ".*"` &&
        if len=`expr "X$cmds" : ".*"` &&
             test $len -le $max_cmd_len; then
             test $len -le $max_cmd_len; then
          :
          :
        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
          $echo "using piecewise archive linking..."
          $echo "using piecewise archive linking..."
          save_RANLIB=$RANLIB
          save_RANLIB=$RANLIB
          RANLIB=:
          RANLIB=:
          objlist=
          objlist=
          concat_cmds=
          concat_cmds=
          save_oldobjs=$oldobjs
          save_oldobjs=$oldobjs
          for obj in $save_oldobjs
          for obj in $save_oldobjs
          do
          do
            oldobjs="$objlist $obj"
            oldobjs="$objlist $obj"
            objlist="$objlist $obj"
            objlist="$objlist $obj"
            eval test_cmds=\"$old_archive_cmds\"
            eval test_cmds=\"$old_archive_cmds\"
            if len=`expr "X$test_cmds" : ".*"` &&
            if len=`expr "X$test_cmds" : ".*"` &&
               test $len -le $max_cmd_len; then
               test $len -le $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
              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=
            fi
            fi
          done
          done
          RANLIB=$save_RANLIB
          RANLIB=$save_RANLIB
          oldobjs=$objlist
          oldobjs=$objlist
          eval cmds=\"\$concat_cmds~$old_archive_cmds\"
          eval cmds=\"\$concat_cmds~$old_archive_cmds\"
        fi
        fi
      fi
      fi
      IFS="${IFS=       }"; save_ifs="$IFS"; IFS='~'
      IFS="${IFS=       }"; save_ifs="$IFS"; IFS='~'
      for cmd in $cmds; do
      for cmd in $cmds; do
        IFS="$save_ifs"
        IFS="$save_ifs"
        $show "$cmd"
        $show "$cmd"
        $run eval "$cmd" || exit $?
        $run eval "$cmd" || exit $?
      done
      done
      IFS="$save_ifs"
      IFS="$save_ifs"
    done
    done
 
 
    if test -n "$generated"; then
    if test -n "$generated"; then
      $show "${rm}r$generated"
      $show "${rm}r$generated"
      $run ${rm}r$generated
      $run ${rm}r$generated
    fi
    fi
 
 
    # 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"
      $show "creating $output"
      $show "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}\" || unset $var || { $var=; export $var; }; }; $relink_command"
          relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"
        elif eval var_value=\$$var; test -z "$var_value"; then
        elif eval var_value=\$$var; test -z "$var_value"; then
          relink_command="$var=; export $var; $relink_command"
          relink_command="$var=; export $var; $relink_command"
        else
        else
          var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
          var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
          relink_command="$var=\"$var_value\"; export $var; $relink_command"
          relink_command="$var=\"$var_value\"; export $var; $relink_command"
        fi
        fi
      done
      done
      # Quote the link command for shipping.
      # Quote the link command for shipping.
      relink_command="cd `pwd`; $SHELL $0 --mode=relink $libtool_args"
      relink_command="cd `pwd`; $SHELL $0 --mode=relink $libtool_args"
      relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"`
      relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"`
 
 
      # Only create the output if not a dry run.
      # Only create the output if not a dry run.
      if test -z "$run"; then
      if test -z "$run"; then
        for installed in no yes; do
        for installed in no yes; do
          if test "$installed" = yes; then
          if test "$installed" = yes; then
            if test -z "$install_libdir"; then
            if test -z "$install_libdir"; then
              break
              break
            fi
            fi
            output="$output_objdir/$outputname"i
            output="$output_objdir/$outputname"i
            # Replace all uninstalled libtool libraries with the installed ones
            # Replace all uninstalled libtool libraries with the installed ones
            newdependency_libs=
            newdependency_libs=
            for deplib in $dependency_libs; do
            for deplib in $dependency_libs; do
              case $deplib in
              case $deplib in
              *.la)
              *.la)
                name=`$echo "X$deplib" | $Xsed -e 's%^.*/%%'`
                name=`$echo "X$deplib" | $Xsed -e 's%^.*/%%'`
                eval libdir=`sed -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
                eval libdir=`sed -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
                if test -z "$libdir"; then
                if test -z "$libdir"; then
                  $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
                  $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
                  exit 1
                  exit 1
                fi
                fi
                newdependency_libs="$newdependency_libs $libdir/$name"
                newdependency_libs="$newdependency_libs $libdir/$name"
                ;;
                ;;
              *) newdependency_libs="$newdependency_libs $deplib" ;;
              *) newdependency_libs="$newdependency_libs $deplib" ;;
              esac
              esac
            done
            done
            dependency_libs="$newdependency_libs"
            dependency_libs="$newdependency_libs"
            newdlfiles=
            newdlfiles=
            for lib in $dlfiles; do
            for lib in $dlfiles; do
              name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
              name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
              eval libdir=`sed -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
              eval libdir=`sed -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
              if test -z "$libdir"; then
              if test -z "$libdir"; then
                $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
                $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
                exit 1
                exit 1
              fi
              fi
              newdlfiles="$newdlfiles $libdir/$name"
              newdlfiles="$newdlfiles $libdir/$name"
            done
            done
            dlfiles="$newdlfiles"
            dlfiles="$newdlfiles"
            newdlprefiles=
            newdlprefiles=
            for lib in $dlprefiles; do
            for lib in $dlprefiles; do
              name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
              name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
              eval libdir=`sed -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
              eval libdir=`sed -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
              if test -z "$libdir"; then
              if test -z "$libdir"; then
                $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
                $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
                exit 1
                exit 1
              fi
              fi
              newdlprefiles="$newdlprefiles $libdir/$name"
              newdlprefiles="$newdlprefiles $libdir/$name"
            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
          tdlname=$dlname
          tdlname=$dlname
          case $host,$output,$installed,$module,$dlname in
          case $host,$output,$installed,$module,$dlname in
            *cygwin*,*lai,yes,no,*.dll) tdlname=../bin/$dlname ;;
            *cygwin*,*lai,yes,no,*.dll) tdlname=../bin/$dlname ;;
          esac
          esac
          $echo > $output "\
          $echo > $output "\
# $outputname - a libtool library file
# $outputname - a libtool library file
# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
#
#
# Please DO NOT delete this file!
# Please DO NOT delete this file!
# It is necessary for linking the library.
# It is necessary for linking the library.
 
 
# The name that we can dlopen(3).
# The name that we can dlopen(3).
dlname='$tdlname'
dlname='$tdlname'
 
 
# Names of this library.
# Names of this library.
library_names='$library_names'
library_names='$library_names'
 
 
# The name of the static archive.
# The name of the static archive.
old_library='$old_library'
old_library='$old_library'
 
 
# Libraries that this one depends upon.
# Libraries that this one depends upon.
dependency_libs='$dependency_libs'
dependency_libs='$dependency_libs'
 
 
# Version information for $libname.
# Version information for $libname.
current=$current
current=$current
age=$age
age=$age
revision=$revision
revision=$revision
 
 
# Is this an already installed library?
# Is this an already installed library?
installed=$installed
installed=$installed
 
 
# Files to dlopen/dlpreopen
# Files to dlopen/dlpreopen
dlopen='$dlfiles'
dlopen='$dlfiles'
dlpreopen='$dlprefiles'
dlpreopen='$dlprefiles'
 
 
# Directory that this library needs to be installed in:
# Directory that this library needs to be installed in:
libdir='$install_libdir'"
libdir='$install_libdir'"
          if test "$installed" = no && test $need_relink = yes; then
          if test "$installed" = no && test $need_relink = yes; then
            $echo >> $output "\
            $echo >> $output "\
relink_command=\"$relink_command\""
relink_command=\"$relink_command\""
          fi
          fi
        done
        done
      fi
      fi
 
 
      # Do a symbolic link so that the libtool archive can be found in
      # Do a symbolic link so that the libtool archive can be found in
      # LD_LIBRARY_PATH before the program is installed.
      # LD_LIBRARY_PATH before the program is installed.
      $show "(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)"
      $show "(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)"
      $run eval '(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)' || exit $?
      $run eval '(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)' || exit $?
      ;;
      ;;
    esac
    esac
    exit 0
    exit 0
    ;;
    ;;
 
 
  # libtool install mode
  # libtool install mode
  install)
  install)
    modename="$modename: install"
    modename="$modename: install"
 
 
    # There may be an optional sh(1) argument at the beginning of
    # There may be an optional sh(1) argument at the beginning of
    # install_prog (especially on Windows NT).
    # install_prog (especially on Windows NT).
    if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
    if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
       # Allow the use of GNU shtool's install command.
       # Allow the use of GNU shtool's install command.
       $echo "X$nonopt" | $Xsed | grep shtool > /dev/null; then
       $echo "X$nonopt" | $Xsed | grep shtool > /dev/null; then
      # Aesthetically quote it.
      # Aesthetically quote it.
      arg=`$echo "X$nonopt" | $Xsed -e "$sed_quote_subst"`
      arg=`$echo "X$nonopt" | $Xsed -e "$sed_quote_subst"`
      case $arg in
      case $arg in
      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*)
      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*)
        arg="\"$arg\""
        arg="\"$arg\""
        ;;
        ;;
      esac
      esac
      install_prog="$arg "
      install_prog="$arg "
      arg="$1"
      arg="$1"
      shift
      shift
    else
    else
      install_prog=
      install_prog=
      arg="$nonopt"
      arg="$nonopt"
    fi
    fi
 
 
    # The real first argument should be the name of the installation program.
    # The real first argument should be the name of the installation program.
    # Aesthetically quote it.
    # Aesthetically quote it.
    arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
    arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
    case $arg in
    case $arg in
    *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*)
    *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*)
      arg="\"$arg\""
      arg="\"$arg\""
      ;;
      ;;
    esac
    esac
    install_prog="$install_prog$arg"
    install_prog="$install_prog$arg"
 
 
    # We need to accept at least all the BSD install flags.
    # We need to accept at least all the BSD install flags.
    dest=
    dest=
    files=
    files=
    opts=
    opts=
    prev=
    prev=
    install_type=
    install_type=
    isdir=no
    isdir=no
    stripme=
    stripme=
    for arg
    for arg
    do
    do
      if test -n "$dest"; then
      if test -n "$dest"; then
        files="$files $dest"
        files="$files $dest"
        dest="$arg"
        dest="$arg"
        continue
        continue
      fi
      fi
 
 
      case $arg in
      case $arg in
      -d) isdir=yes ;;
      -d) isdir=yes ;;
      -f) prev="-f" ;;
      -f) prev="-f" ;;
      -g) prev="-g" ;;
      -g) prev="-g" ;;
      -m) prev="-m" ;;
      -m) prev="-m" ;;
      -o) prev="-o" ;;
      -o) prev="-o" ;;
      -s)
      -s)
        stripme=" -s"
        stripme=" -s"
        continue
        continue
        ;;
        ;;
      -*) ;;
      -*) ;;
 
 
      *)
      *)
        # If the previous option needed an argument, then skip it.
        # If the previous option needed an argument, then skip it.
        if test -n "$prev"; then
        if test -n "$prev"; then
          prev=
          prev=
        else
        else
          dest="$arg"
          dest="$arg"
          continue
          continue
        fi
        fi
        ;;
        ;;
      esac
      esac
 
 
      # Aesthetically quote the argument.
      # Aesthetically quote the argument.
      arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
      arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
      case $arg in
      case $arg in
      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*)
      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*)
        arg="\"$arg\""
        arg="\"$arg\""
        ;;
        ;;
      esac
      esac
      install_prog="$install_prog $arg"
      install_prog="$install_prog $arg"
    done
    done
 
 
    if test -z "$install_prog"; then
    if test -z "$install_prog"; then
      $echo "$modename: you must specify an install program" 1>&2
      $echo "$modename: you must specify an install program" 1>&2
      $echo "$help" 1>&2
      $echo "$help" 1>&2
      exit 1
      exit 1
    fi
    fi
 
 
    if test -n "$prev"; then
    if test -n "$prev"; then
      $echo "$modename: the \`$prev' option requires an argument" 1>&2
      $echo "$modename: the \`$prev' option requires an argument" 1>&2
      $echo "$help" 1>&2
      $echo "$help" 1>&2
      exit 1
      exit 1
    fi
    fi
 
 
    if test -z "$files"; then
    if test -z "$files"; then
      if test -z "$dest"; then
      if test -z "$dest"; then
        $echo "$modename: no file or destination specified" 1>&2
        $echo "$modename: no file or destination specified" 1>&2
      else
      else
        $echo "$modename: you must specify a destination" 1>&2
        $echo "$modename: you must specify a destination" 1>&2
      fi
      fi
      $echo "$help" 1>&2
      $echo "$help" 1>&2
      exit 1
      exit 1
    fi
    fi
 
 
    # Strip any trailing slash from the destination.
    # Strip any trailing slash from the destination.
    dest=`$echo "X$dest" | $Xsed -e 's%/$%%'`
    dest=`$echo "X$dest" | $Xsed -e 's%/$%%'`
 
 
    # Check to see that the destination is a directory.
    # Check to see that the destination is a directory.
    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
      destdir=`$echo "X$dest" | $Xsed -e 's%/[^/]*$%%'`
      destdir=`$echo "X$dest" | $Xsed -e 's%/[^/]*$%%'`
      test "X$destdir" = "X$dest" && destdir=.
      test "X$destdir" = "X$dest" && destdir=.
      destname=`$echo "X$dest" | $Xsed -e 's%^.*/%%'`
      destname=`$echo "X$dest" | $Xsed -e 's%^.*/%%'`
 
 
      # 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
      set dummy $files
      if test $# -gt 2; then
      if test $# -gt 2; then
        $echo "$modename: \`$dest' is not a directory" 1>&2
        $echo "$modename: \`$dest' is not a directory" 1>&2
        $echo "$help" 1>&2
        $echo "$help" 1>&2
        exit 1
        exit 1
      fi
      fi
    fi
    fi
    case $destdir in
    case $destdir in
    [\\/]* | [A-Za-z]:[\\/]*) ;;
    [\\/]* | [A-Za-z]:[\\/]*) ;;
    *)
    *)
      for file in $files; do
      for file in $files; do
        case $file in
        case $file in
        *.lo) ;;
        *.lo) ;;
        *)
        *)
          $echo "$modename: \`$destdir' must be an absolute directory name" 1>&2
          $echo "$modename: \`$destdir' must be an absolute directory name" 1>&2
          $echo "$help" 1>&2
          $echo "$help" 1>&2
          exit 1
          exit 1
          ;;
          ;;
        esac
        esac
      done
      done
      ;;
      ;;
    esac
    esac
 
 
    # This variable tells wrapper scripts just to set variables rather
    # This variable tells wrapper scripts just to set variables rather
    # than running their programs.
    # than running their programs.
    libtool_install_magic="$magic"
    libtool_install_magic="$magic"
 
 
    staticlibs=
    staticlibs=
    future_libdirs=
    future_libdirs=
    current_libdirs=
    current_libdirs=
    for file in $files; do
    for file in $files; do
 
 
      # Do each installation.
      # Do each installation.
      case $file in
      case $file in
      *.$libext)
      *.$libext)
        # Do the static libraries later.
        # Do the static libraries later.
        staticlibs="$staticlibs $file"
        staticlibs="$staticlibs $file"
        ;;
        ;;
 
 
      *.la)
      *.la)
        # Check to see that this really is a libtool archive.
        # Check to see that this really is a libtool archive.
        if (sed -e '2q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
        if (sed -e '2q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
        else
        else
          $echo "$modename: \`$file' is not a valid libtool archive" 1>&2
          $echo "$modename: \`$file' is not a valid libtool archive" 1>&2
          $echo "$help" 1>&2
          $echo "$help" 1>&2
          exit 1
          exit 1
        fi
        fi
 
 
        library_names=
        library_names=
        old_library=
        old_library=
        relink_command=
        relink_command=
        # If there is no directory component, then add one.
        # If there is no directory component, then add one.
        case $file in
        case $file in
        */* | *\\*) . $file ;;
        */* | *\\*) . $file ;;
        *) . ./$file ;;
        *) . ./$file ;;
        esac
        esac
 
 
        # Add the libdir to current_libdirs if it is the destination.
        # Add the libdir to current_libdirs if it is the destination.
        if test "X$destdir" = "X$libdir"; then
        if test "X$destdir" = "X$libdir"; then
          case "$current_libdirs " in
          case "$current_libdirs " in
          *" $libdir "*) ;;
          *" $libdir "*) ;;
          *) current_libdirs="$current_libdirs $libdir" ;;
          *) current_libdirs="$current_libdirs $libdir" ;;
          esac
          esac
        else
        else
          # Note the libdir as a future libdir.
          # Note the libdir as a future libdir.
          case "$future_libdirs " in
          case "$future_libdirs " in
          *" $libdir "*) ;;
          *" $libdir "*) ;;
          *) future_libdirs="$future_libdirs $libdir" ;;
          *) future_libdirs="$future_libdirs $libdir" ;;
          esac
          esac
        fi
        fi
 
 
        dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`/
        dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`/
        test "X$dir" = "X$file/" && dir=
        test "X$dir" = "X$file/" && dir=
        dir="$dir$objdir"
        dir="$dir$objdir"
 
 
        if test -n "$relink_command"; then
        if test -n "$relink_command"; then
          $echo "$modename: warning: relinking \`$file'" 1>&2
          $echo "$modename: warning: relinking \`$file'" 1>&2
          $show "$relink_command"
          $show "$relink_command"
          if $run eval "$relink_command"; then :
          if $run eval "$relink_command"; then :
          else
          else
            $echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
            $echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
            continue
            continue
          fi
          fi
        fi
        fi
 
 
        # See the names of the shared library.
        # See the names of the shared library.
        set dummy $library_names
        set dummy $library_names
        if test -n "$2"; then
        if test -n "$2"; then
          realname="$2"
          realname="$2"
          shift
          shift
          shift
          shift
 
 
          srcname="$realname"
          srcname="$realname"
          test -n "$relink_command" && srcname="$realname"T
          test -n "$relink_command" && srcname="$realname"T
 
 
          # Install the shared library and build the symlinks.
          # Install the shared library and build the symlinks.
          $show "$install_prog $dir/$srcname $destdir/$realname"
          $show "$install_prog $dir/$srcname $destdir/$realname"
          $run eval "$install_prog $dir/$srcname $destdir/$realname" || exit $?
          $run eval "$install_prog $dir/$srcname $destdir/$realname" || exit $?
          if test -n "$stripme" && test -n "$striplib"; then
          if test -n "$stripme" && test -n "$striplib"; then
            $show "$striplib $destdir/$realname"
            $show "$striplib $destdir/$realname"
            $run eval "$striplib $destdir/$realname" || exit $?
            $run eval "$striplib $destdir/$realname" || exit $?
          fi
          fi
 
 
          if test $# -gt 0; then
          if test $# -gt 0; then
            # Delete the old symlinks, and create new ones.
            # Delete the old symlinks, and create new ones.
            for linkname
            for linkname
            do
            do
              if test "$linkname" != "$realname"; then
              if test "$linkname" != "$realname"; then
                $show "(cd $destdir && $rm $linkname && $LN_S $realname $linkname)"
                $show "(cd $destdir && $rm $linkname && $LN_S $realname $linkname)"
                $run eval "(cd $destdir && $rm $linkname && $LN_S $realname $linkname)"
                $run eval "(cd $destdir && $rm $linkname && $LN_S $realname $linkname)"
              fi
              fi
            done
            done
          fi
          fi
 
 
          # Do each command in the postinstall commands.
          # Do each command in the postinstall commands.
          lib="$destdir/$realname"
          lib="$destdir/$realname"
          eval cmds=\"$postinstall_cmds\"
          eval cmds=\"$postinstall_cmds\"
          IFS="${IFS=   }"; save_ifs="$IFS"; IFS='~'
          IFS="${IFS=   }"; save_ifs="$IFS"; IFS='~'
          for cmd in $cmds; do
          for cmd in $cmds; do
            IFS="$save_ifs"
            IFS="$save_ifs"
            $show "$cmd"
            $show "$cmd"
            $run eval "$cmd" || exit $?
            $run eval "$cmd" || exit $?
          done
          done
          IFS="$save_ifs"
          IFS="$save_ifs"
        fi
        fi
 
 
        # Install the pseudo-library for information purposes.
        # Install the pseudo-library for information purposes.
        name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
        name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
        instname="$dir/$name"i
        instname="$dir/$name"i
        $show "$install_prog $instname $destdir/$name"
        $show "$install_prog $instname $destdir/$name"
        $run eval "$install_prog $instname $destdir/$name" || exit $?
        $run eval "$install_prog $instname $destdir/$name" || exit $?
 
 
        # Maybe install the static library, too.
        # Maybe install the static library, too.
        test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
        test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
        ;;
        ;;
 
 
      *.lo)
      *.lo)
        # Install (i.e. copy) a libtool object.
        # Install (i.e. copy) a libtool object.
 
 
        # Figure out destination file name, if it wasn't already specified.
        # Figure out destination file name, if it wasn't already specified.
        if test -n "$destname"; then
        if test -n "$destname"; then
          destfile="$destdir/$destname"
          destfile="$destdir/$destname"
        else
        else
          destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
          destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
          destfile="$destdir/$destfile"
          destfile="$destdir/$destfile"
        fi
        fi
 
 
        # Deduce the name of the destination old-style object file.
        # Deduce the name of the destination old-style object file.
        case $destfile in
        case $destfile in
        *.lo)
        *.lo)
          staticdest=`$echo "X$destfile" | $Xsed -e "$lo2o"`
          staticdest=`$echo "X$destfile" | $Xsed -e "$lo2o"`
          ;;
          ;;
        *.$objext)
        *.$objext)
          staticdest="$destfile"
          staticdest="$destfile"
          destfile=
          destfile=
          ;;
          ;;
        *)
        *)
          $echo "$modename: cannot copy a libtool object to \`$destfile'" 1>&2
          $echo "$modename: cannot copy a libtool object to \`$destfile'" 1>&2
          $echo "$help" 1>&2
          $echo "$help" 1>&2
          exit 1
          exit 1
          ;;
          ;;
        esac
        esac
 
 
        # Install the libtool object if requested.
        # Install the libtool object if requested.
        if test -n "$destfile"; then
        if test -n "$destfile"; then
          $show "$install_prog $file $destfile"
          $show "$install_prog $file $destfile"
          $run eval "$install_prog $file $destfile" || exit $?
          $run eval "$install_prog $file $destfile" || exit $?
        fi
        fi
 
 
        # Install the old object if enabled.
        # Install the old object if enabled.
        if test "$build_old_libs" = yes; then
        if test "$build_old_libs" = yes; then
          # Deduce the name of the old-style object file.
          # Deduce the name of the old-style object file.
          staticobj=`$echo "X$file" | $Xsed -e "$lo2o"`
          staticobj=`$echo "X$file" | $Xsed -e "$lo2o"`
 
 
          $show "$install_prog $staticobj $staticdest"
          $show "$install_prog $staticobj $staticdest"
          $run eval "$install_prog \$staticobj \$staticdest" || exit $?
          $run eval "$install_prog \$staticobj \$staticdest" || exit $?
        fi
        fi
        exit 0
        exit 0
        ;;
        ;;
 
 
      *)
      *)
        # Figure out destination file name, if it wasn't already specified.
        # Figure out destination file name, if it wasn't already specified.
        if test -n "$destname"; then
        if test -n "$destname"; then
          destfile="$destdir/$destname"
          destfile="$destdir/$destname"
        else
        else
          destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
          destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
          destfile="$destdir/$destfile"
          destfile="$destdir/$destfile"
        fi
        fi
 
 
        # 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 (sed -e '4q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
        if (sed -e '4q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
          notinst_deplibs=
          notinst_deplibs=
          relink_command=
          relink_command=
 
 
          # If there is no directory component, then add one.
          # If there is no directory component, then add one.
          case $file in
          case $file in
          */* | *\\*) . $file ;;
          */* | *\\*) . $file ;;
          *) . ./$file ;;
          *) . ./$file ;;
          esac
          esac
 
 
          # Check the variables that should have been set.
          # Check the variables that should have been set.
          if test -z "$notinst_deplibs"; then
          if test -z "$notinst_deplibs"; then
            $echo "$modename: invalid libtool wrapper script \`$file'" 1>&2
            $echo "$modename: invalid libtool wrapper script \`$file'" 1>&2
            exit 1
            exit 1
          fi
          fi
 
 
          finalize=yes
          finalize=yes
          for lib in $notinst_deplibs; do
          for lib in $notinst_deplibs; do
            # Check to see that each library is installed.
            # Check to see that each library is installed.
            libdir=
            libdir=
            if test -f "$lib"; then
            if test -f "$lib"; then
              # If there is no directory component, then add one.
              # If there is no directory component, then add one.
              case $lib in
              case $lib in
              */* | *\\*) . $lib ;;
              */* | *\\*) . $lib ;;
              *) . ./$lib ;;
              *) . ./$lib ;;
              esac
              esac
            fi
            fi
            libfile="$libdir/"`$echo "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test
            libfile="$libdir/"`$echo "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test
            if test -n "$libdir" && test ! -f "$libfile"; then
            if test -n "$libdir" && test ! -f "$libfile"; then
              $echo "$modename: warning: \`$lib' has not been installed in \`$libdir'" 1>&2
              $echo "$modename: warning: \`$lib' has not been installed in \`$libdir'" 1>&2
              finalize=no
              finalize=no
            fi
            fi
          done
          done
 
 
          relink_command=
          relink_command=
          # If there is no directory component, then add one.
          # If there is no directory component, then add one.
          case $file in
          case $file in
          */* | *\\*) . $file ;;
          */* | *\\*) . $file ;;
          *) . ./$file ;;
          *) . ./$file ;;
          esac
          esac
 
 
          outputname=
          outputname=
          if test "$fast_install" = no && test -n "$relink_command"; then
          if test "$fast_install" = no && test -n "$relink_command"; then
            if test "$finalize" = yes && test -z "$run"; then
            if test "$finalize" = yes && test -z "$run"; then
              tmpdir="/tmp"
              tmpdir="/tmp"
              test -n "$TMPDIR" && tmpdir="$TMPDIR"
              test -n "$TMPDIR" && tmpdir="$TMPDIR"
              tmpdir="$tmpdir/libtool-$$"
              tmpdir="$tmpdir/libtool-$$"
              if $mkdir -p "$tmpdir" && chmod 700 "$tmpdir"; then :
              if $mkdir -p "$tmpdir" && chmod 700 "$tmpdir"; then :
              else
              else
                $echo "$modename: error: cannot create temporary directory \`$tmpdir'" 1>&2
                $echo "$modename: error: cannot create temporary directory \`$tmpdir'" 1>&2
                continue
                continue
              fi
              fi
              file=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
              file=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
              outputname="$tmpdir/$file"
              outputname="$tmpdir/$file"
              # Replace the output file specification.
              # Replace the output file specification.
              relink_command=`$echo "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`
              relink_command=`$echo "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`
 
 
              $show "$relink_command"
              $show "$relink_command"
              if $run eval "$relink_command"; then :
              if $run eval "$relink_command"; then :
              else
              else
                $echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
                $echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
                ${rm}r "$tmpdir"
                ${rm}r "$tmpdir"
                continue
                continue
              fi
              fi
              file="$outputname"
              file="$outputname"
            else
            else
              $echo "$modename: warning: cannot relink \`$file'" 1>&2
              $echo "$modename: warning: cannot relink \`$file'" 1>&2
            fi
            fi
          else
          else
            # Install the binary that we compiled earlier.
            # Install the binary that we compiled earlier.
            file=`$echo "X$file" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
            file=`$echo "X$file" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
          fi
          fi
        fi
        fi
 
 
 
 
        # remove .exe since cygwin /usr/bin/install will append another
        # remove .exe since cygwin /usr/bin/install will append another
        # one anyways
        # one anyways
        case $install_prog,$host in
        case $install_prog,$host in
        */usr/bin/install*,*cygwin*)
        */usr/bin/install*,*cygwin*)
          case $file:$destfile in
          case $file:$destfile in
          *.exe:*.exe)
          *.exe:*.exe)
            # this is ok
            # this is ok
            ;;
            ;;
          *.exe:*)
          *.exe:*)
            destfile=$destfile.exe
            destfile=$destfile.exe
            ;;
            ;;
          *:*.exe)
          *:*.exe)
            destfile=`echo $destfile | sed -e 's,.exe$,,'`
            destfile=`echo $destfile | sed -e 's,.exe$,,'`
            ;;
            ;;
          esac
          esac
          ;;
          ;;
        esac
        esac
 
 
        $show "$install_prog$stripme $file $destfile"
        $show "$install_prog$stripme $file $destfile"
        $run eval "$install_prog\$stripme \$file \$destfile" || exit $?
        $run eval "$install_prog\$stripme \$file \$destfile" || exit $?
        test -n "$outputname" && ${rm}r "$tmpdir"
        test -n "$outputname" && ${rm}r "$tmpdir"
        ;;
        ;;
      esac
      esac
    done
    done
 
 
    for file in $staticlibs; do
    for file in $staticlibs; do
      name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
      name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
 
 
      # Set up the ranlib parameters.
      # Set up the ranlib parameters.
      oldlib="$destdir/$name"
      oldlib="$destdir/$name"
 
 
      $show "$install_prog $file $oldlib"
      $show "$install_prog $file $oldlib"
      $run eval "$install_prog \$file \$oldlib" || exit $?
      $run eval "$install_prog \$file \$oldlib" || exit $?
 
 
      if test -n "$stripme" && test -n "$striplib"; then
      if test -n "$stripme" && test -n "$striplib"; then
        $show "$old_striplib $oldlib"
        $show "$old_striplib $oldlib"
        $run eval "$old_striplib $oldlib" || exit $?
        $run eval "$old_striplib $oldlib" || exit $?
      fi
      fi
 
 
      # Do each command in the postinstall commands.
      # Do each command in the postinstall commands.
      eval cmds=\"$old_postinstall_cmds\"
      eval cmds=\"$old_postinstall_cmds\"
      IFS="${IFS=       }"; save_ifs="$IFS"; IFS='~'
      IFS="${IFS=       }"; save_ifs="$IFS"; IFS='~'
      for cmd in $cmds; do
      for cmd in $cmds; do
        IFS="$save_ifs"
        IFS="$save_ifs"
        $show "$cmd"
        $show "$cmd"
        $run eval "$cmd" || exit $?
        $run eval "$cmd" || exit $?
      done
      done
      IFS="$save_ifs"
      IFS="$save_ifs"
    done
    done
 
 
    if test -n "$future_libdirs"; then
    if test -n "$future_libdirs"; then
      $echo "$modename: warning: remember to run \`$progname --finish$future_libdirs'" 1>&2
      $echo "$modename: warning: remember to run \`$progname --finish$future_libdirs'" 1>&2
    fi
    fi
 
 
    if test -n "$current_libdirs"; then
    if test -n "$current_libdirs"; then
      # Maybe just do a dry run.
      # Maybe just do a dry run.
      test -n "$run" && current_libdirs=" -n$current_libdirs"
      test -n "$run" && current_libdirs=" -n$current_libdirs"
      exec_cmd='$SHELL $0 --finish$current_libdirs'
      exec_cmd='$SHELL $0 --finish$current_libdirs'
    else
    else
      exit 0
      exit 0
    fi
    fi
    ;;
    ;;
 
 
  # libtool finish mode
  # libtool finish mode
  finish)
  finish)
    modename="$modename: finish"
    modename="$modename: finish"
    libdirs="$nonopt"
    libdirs="$nonopt"
    admincmds=
    admincmds=
 
 
    if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
    if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
      for dir
      for dir
      do
      do
        libdirs="$libdirs $dir"
        libdirs="$libdirs $dir"
      done
      done
 
 
      for libdir in $libdirs; do
      for libdir in $libdirs; do
        if test -n "$finish_cmds"; then
        if test -n "$finish_cmds"; then
          # Do each command in the finish commands.
          # Do each command in the finish commands.
          eval cmds=\"$finish_cmds\"
          eval cmds=\"$finish_cmds\"
          IFS="${IFS=   }"; save_ifs="$IFS"; IFS='~'
          IFS="${IFS=   }"; save_ifs="$IFS"; IFS='~'
          for cmd in $cmds; do
          for cmd in $cmds; do
            IFS="$save_ifs"
            IFS="$save_ifs"
            $show "$cmd"
            $show "$cmd"
            $run eval "$cmd" || admincmds="$admincmds
            $run eval "$cmd" || admincmds="$admincmds
       $cmd"
       $cmd"
          done
          done
          IFS="$save_ifs"
          IFS="$save_ifs"
        fi
        fi
        if test -n "$finish_eval"; then
        if test -n "$finish_eval"; then
          # Do the single finish_eval.
          # Do the single finish_eval.
          eval cmds=\"$finish_eval\"
          eval cmds=\"$finish_eval\"
          $run eval "$cmds" || admincmds="$admincmds
          $run eval "$cmds" || admincmds="$admincmds
       $cmds"
       $cmds"
        fi
        fi
      done
      done
    fi
    fi
 
 
    # Exit here if they wanted silent mode.
    # Exit here if they wanted silent mode.
    test "$show" = ":" && exit 0
    test "$show" = ":" && exit 0
 
 
    echo "----------------------------------------------------------------------"
    echo "----------------------------------------------------------------------"
    echo "Libraries have been installed in:"
    echo "Libraries have been installed in:"
    for libdir in $libdirs; do
    for libdir in $libdirs; do
      echo "   $libdir"
      echo "   $libdir"
    done
    done
    echo
    echo
    echo "If you ever happen to want to link against installed libraries"
    echo "If you ever happen to want to link against installed libraries"
    echo "in a given directory, LIBDIR, you must either use libtool, and"
    echo "in a given directory, LIBDIR, you must either use libtool, and"
    echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
    echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
    echo "flag during linking and do at least one of the following:"
    echo "flag during linking and do at least one of the following:"
    if test -n "$shlibpath_var"; then
    if test -n "$shlibpath_var"; then
      echo "   - add LIBDIR to the \`$shlibpath_var' environment variable"
      echo "   - add LIBDIR to the \`$shlibpath_var' environment variable"
      echo "     during execution"
      echo "     during execution"
    fi
    fi
    if test -n "$runpath_var"; then
    if test -n "$runpath_var"; then
      echo "   - add LIBDIR to the \`$runpath_var' environment variable"
      echo "   - add LIBDIR to the \`$runpath_var' environment variable"
      echo "     during linking"
      echo "     during linking"
    fi
    fi
    if test -n "$hardcode_libdir_flag_spec"; then
    if test -n "$hardcode_libdir_flag_spec"; then
      libdir=LIBDIR
      libdir=LIBDIR
      eval flag=\"$hardcode_libdir_flag_spec\"
      eval flag=\"$hardcode_libdir_flag_spec\"
 
 
      echo "   - use the \`$flag' linker flag"
      echo "   - use the \`$flag' linker flag"
    fi
    fi
    if test -n "$admincmds"; then
    if test -n "$admincmds"; then
      echo "   - have your system administrator run these commands:$admincmds"
      echo "   - have your system administrator run these commands:$admincmds"
    fi
    fi
    if test -f /etc/ld.so.conf; then
    if test -f /etc/ld.so.conf; then
      echo "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
      echo "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
    fi
    fi
    echo
    echo
    echo "See any operating system documentation about shared libraries for"
    echo "See any operating system documentation about shared libraries for"
    echo "more information, such as the ld(1) and ld.so(8) manual pages."
    echo "more information, such as the ld(1) and ld.so(8) manual pages."
    echo "----------------------------------------------------------------------"
    echo "----------------------------------------------------------------------"
    exit 0
    exit 0
    ;;
    ;;
 
 
  # libtool execute mode
  # libtool execute mode
  execute)
  execute)
    modename="$modename: execute"
    modename="$modename: execute"
 
 
    # The first argument is the command name.
    # The first argument is the command name.
    cmd="$nonopt"
    cmd="$nonopt"
    if test -z "$cmd"; then
    if test -z "$cmd"; then
      $echo "$modename: you must specify a COMMAND" 1>&2
      $echo "$modename: you must specify a COMMAND" 1>&2
      $echo "$help"
      $echo "$help"
      exit 1
      exit 1
    fi
    fi
 
 
    # Handle -dlopen flags immediately.
    # Handle -dlopen flags immediately.
    for file in $execute_dlfiles; do
    for file in $execute_dlfiles; do
      if test ! -f "$file"; then
      if test ! -f "$file"; then
        $echo "$modename: \`$file' is not a file" 1>&2
        $echo "$modename: \`$file' is not a file" 1>&2
        $echo "$help" 1>&2
        $echo "$help" 1>&2
        exit 1
        exit 1
      fi
      fi
 
 
      dir=
      dir=
      case $file in
      case $file in
      *.la)
      *.la)
        # Check to see that this really is a libtool archive.
        # Check to see that this really is a libtool archive.
        if (sed -e '2q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
        if (sed -e '2q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
        else
        else
          $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
          $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
          $echo "$help" 1>&2
          $echo "$help" 1>&2
          exit 1
          exit 1
        fi
        fi
 
 
        # Read the libtool library.
        # Read the libtool library.
        dlname=
        dlname=
        library_names=
        library_names=
 
 
        # If there is no directory component, then add one.
        # If there is no directory component, then add one.
        case $file in
        case $file in
        */* | *\\*) . $file ;;
        */* | *\\*) . $file ;;
        *) . ./$file ;;
        *) . ./$file ;;
        esac
        esac
 
 
        # Skip this library if it cannot be dlopened.
        # Skip this library if it cannot be dlopened.
        if test -z "$dlname"; then
        if test -z "$dlname"; then
          # Warn if it was a shared library.
          # Warn if it was a shared library.
          test -n "$library_names" && $echo "$modename: warning: \`$file' was not linked with \`-export-dynamic'"
          test -n "$library_names" && $echo "$modename: warning: \`$file' was not linked with \`-export-dynamic'"
          continue
          continue
        fi
        fi
 
 
        dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
        dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
        test "X$dir" = "X$file" && dir=.
        test "X$dir" = "X$file" && dir=.
 
 
        if test -f "$dir/$objdir/$dlname"; then
        if test -f "$dir/$objdir/$dlname"; then
          dir="$dir/$objdir"
          dir="$dir/$objdir"
        else
        else
          $echo "$modename: cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'" 1>&2
          $echo "$modename: cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'" 1>&2
          exit 1
          exit 1
        fi
        fi
        ;;
        ;;
 
 
      *.lo)
      *.lo)
        # Just add the directory containing the .lo file.
        # Just add the directory containing the .lo file.
        dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
        dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
        test "X$dir" = "X$file" && dir=.
        test "X$dir" = "X$file" && dir=.
        ;;
        ;;
 
 
      *)
      *)
        $echo "$modename: warning \`-dlopen' is ignored for non-libtool libraries and objects" 1>&2
        $echo "$modename: warning \`-dlopen' is ignored for non-libtool libraries and objects" 1>&2
        continue
        continue
        ;;
        ;;
      esac
      esac
 
 
      # Get the absolute pathname.
      # Get the absolute pathname.
      absdir=`cd "$dir" && pwd`
      absdir=`cd "$dir" && pwd`
      test -n "$absdir" && dir="$absdir"
      test -n "$absdir" && dir="$absdir"
 
 
      # Now add the directory to shlibpath_var.
      # Now add the directory to shlibpath_var.
      if eval "test -z \"\$$shlibpath_var\""; then
      if eval "test -z \"\$$shlibpath_var\""; then
        eval "$shlibpath_var=\"\$dir\""
        eval "$shlibpath_var=\"\$dir\""
      else
      else
        eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
        eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
      fi
      fi
    done
    done
 
 
    # This variable tells wrapper scripts just to set shlibpath_var
    # This variable tells wrapper scripts just to set shlibpath_var
    # rather than running their programs.
    # rather than running their programs.
    libtool_execute_magic="$magic"
    libtool_execute_magic="$magic"
 
 
    # Check if any of the arguments is a wrapper script.
    # Check if any of the arguments is a wrapper script.
    args=
    args=
    for file
    for file
    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 (sed -e '4q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
        if (sed -e '4q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
          # If there is no directory component, then add one.
          # If there is no directory component, then add one.
          case $file in
          case $file in
          */* | *\\*) . $file ;;
          */* | *\\*) . $file ;;
          *) . ./$file ;;
          *) . ./$file ;;
          esac
          esac
 
 
          # Transform arg to wrapped name.
          # Transform arg to wrapped name.
          file="$progdir/$program"
          file="$progdir/$program"
        fi
        fi
        ;;
        ;;
      esac
      esac
      # Quote arguments (to preserve shell metacharacters).
      # Quote arguments (to preserve shell metacharacters).
      file=`$echo "X$file" | $Xsed -e "$sed_quote_subst"`
      file=`$echo "X$file" | $Xsed -e "$sed_quote_subst"`
      args="$args \"$file\""
      args="$args \"$file\""
    done
    done
 
 
    if test -z "$run"; then
    if test -z "$run"; then
      if test -n "$shlibpath_var"; then
      if test -n "$shlibpath_var"; then
        # Export the shlibpath_var.
        # Export the shlibpath_var.
        eval "export $shlibpath_var"
        eval "export $shlibpath_var"
      fi
      fi
 
 
      # Restore saved enviroment variables
      # Restore saved enviroment variables
      if test "${save_LC_ALL+set}" = set; then
      if test "${save_LC_ALL+set}" = set; then
        LC_ALL="$save_LC_ALL"; export LC_ALL
        LC_ALL="$save_LC_ALL"; export LC_ALL
      fi
      fi
      if test "${save_LANG+set}" = set; then
      if test "${save_LANG+set}" = set; then
        LANG="$save_LANG"; export LANG
        LANG="$save_LANG"; export LANG
      fi
      fi
 
 
      # Now prepare to actually exec the command.
      # Now prepare to actually exec the command.
      exec_cmd='"$cmd"$args'
      exec_cmd='"$cmd"$args'
    else
    else
      # Display what would be done.
      # Display what would be done.
      if test -n "$shlibpath_var"; then
      if test -n "$shlibpath_var"; then
        eval "\$echo \"\$shlibpath_var=\$$shlibpath_var\""
        eval "\$echo \"\$shlibpath_var=\$$shlibpath_var\""
        $echo "export $shlibpath_var"
        $echo "export $shlibpath_var"
      fi
      fi
      $echo "$cmd$args"
      $echo "$cmd$args"
      exit 0
      exit 0
    fi
    fi
    ;;
    ;;
 
 
  # libtool clean and uninstall mode
  # libtool clean and uninstall mode
  clean | uninstall)
  clean | uninstall)
    modename="$modename: $mode"
    modename="$modename: $mode"
    rm="$nonopt"
    rm="$nonopt"
    files=
    files=
    rmforce=
    rmforce=
    exit_status=0
    exit_status=0
 
 
    # This variable tells wrapper scripts just to set variables rather
    # This variable tells wrapper scripts just to set variables rather
    # than running their programs.
    # than running their programs.
    libtool_install_magic="$magic"
    libtool_install_magic="$magic"
 
 
    for arg
    for arg
    do
    do
      case $arg in
      case $arg in
      -f) rm="$rm $arg"; rmforce=yes ;;
      -f) rm="$rm $arg"; rmforce=yes ;;
      -*) rm="$rm $arg" ;;
      -*) rm="$rm $arg" ;;
      *) files="$files $arg" ;;
      *) files="$files $arg" ;;
      esac
      esac
    done
    done
 
 
    if test -z "$rm"; then
    if test -z "$rm"; then
      $echo "$modename: you must specify an RM program" 1>&2
      $echo "$modename: you must specify an RM program" 1>&2
      $echo "$help" 1>&2
      $echo "$help" 1>&2
      exit 1
      exit 1
    fi
    fi
 
 
    rmdirs=
    rmdirs=
 
 
    for file in $files; do
    for file in $files; do
      dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
      dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
      if test "X$dir" = "X$file"; then
      if test "X$dir" = "X$file"; then
        dir=.
        dir=.
        objdir="$objdir"
        objdir="$objdir"
      else
      else
        objdir="$dir/$objdir"
        objdir="$dir/$objdir"
      fi
      fi
      name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
      name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
      test $mode = uninstall && objdir="$dir"
      test $mode = uninstall && objdir="$dir"
 
 
      # Remember objdir for removal later, being careful to avoid duplicates
      # Remember objdir for removal later, being careful to avoid duplicates
      if test $mode = clean; then
      if test $mode = clean; then
        case " $rmdirs " in
        case " $rmdirs " in
          *" $objdir "*) ;;
          *" $objdir "*) ;;
          *) rmdirs="$rmdirs $objdir" ;;
          *) rmdirs="$rmdirs $objdir" ;;
        esac
        esac
      fi
      fi
 
 
      # Don't error if the file doesn't exist and rm -f was used.
      # Don't error if the file doesn't exist and rm -f was used.
      if (test -L "$file") >/dev/null 2>&1 \
      if (test -L "$file") >/dev/null 2>&1 \
        || (test -h "$file") >/dev/null 2>&1 \
        || (test -h "$file") >/dev/null 2>&1 \
        || test -f "$file"; then
        || test -f "$file"; then
        :
        :
      elif test -d "$file"; then
      elif test -d "$file"; then
        exit_status=1
        exit_status=1
        continue
        continue
      elif test "$rmforce" = yes; then
      elif test "$rmforce" = yes; then
        continue
        continue
      fi
      fi
 
 
      rmfiles="$file"
      rmfiles="$file"
 
 
      case $name in
      case $name in
      *.la)
      *.la)
        # Possibly a libtool archive, so verify it.
        # Possibly a libtool archive, so verify it.
        if (sed -e '2q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
        if (sed -e '2q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
          . $dir/$name
          . $dir/$name
 
 
          # Delete the libtool libraries and symlinks.
          # Delete the libtool libraries and symlinks.
          for n in $library_names; do
          for n in $library_names; do
            rmfiles="$rmfiles $objdir/$n"
            rmfiles="$rmfiles $objdir/$n"
          done
          done
          test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library"
          test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library"
          test $mode = clean && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"
          test $mode = clean && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"
 
 
          if test $mode = uninstall; then
          if test $mode = uninstall; then
            if test -n "$library_names"; then
            if test -n "$library_names"; then
              # Do each command in the postuninstall commands.
              # Do each command in the postuninstall commands.
              eval cmds=\"$postuninstall_cmds\"
              eval cmds=\"$postuninstall_cmds\"
              IFS="${IFS=       }"; save_ifs="$IFS"; IFS='~'
              IFS="${IFS=       }"; save_ifs="$IFS"; IFS='~'
              for cmd in $cmds; do
              for cmd in $cmds; do
                IFS="$save_ifs"
                IFS="$save_ifs"
                $show "$cmd"
                $show "$cmd"
                $run eval "$cmd"
                $run eval "$cmd"
                if test $? != 0 && test "$rmforce" != yes; then
                if test $? != 0 && test "$rmforce" != yes; then
                  exit_status=1
                  exit_status=1
                fi
                fi
              done
              done
              IFS="$save_ifs"
              IFS="$save_ifs"
            fi
            fi
 
 
            if test -n "$old_library"; then
            if test -n "$old_library"; then
              # Do each command in the old_postuninstall commands.
              # Do each command in the old_postuninstall commands.
              eval cmds=\"$old_postuninstall_cmds\"
              eval cmds=\"$old_postuninstall_cmds\"
              IFS="${IFS=       }"; save_ifs="$IFS"; IFS='~'
              IFS="${IFS=       }"; save_ifs="$IFS"; IFS='~'
              for cmd in $cmds; do
              for cmd in $cmds; do
                IFS="$save_ifs"
                IFS="$save_ifs"
                $show "$cmd"
                $show "$cmd"
                $run eval "$cmd"
                $run eval "$cmd"
                if test $? != 0 && test "$rmforce" != yes; then
                if test $? != 0 && test "$rmforce" != yes; then
                  exit_status=1
                  exit_status=1
                fi
                fi
              done
              done
              IFS="$save_ifs"
              IFS="$save_ifs"
            fi
            fi
            # FIXME: should reinstall the best remaining shared library.
            # FIXME: should reinstall the best remaining shared library.
          fi
          fi
        fi
        fi
        ;;
        ;;
 
 
      *.lo)
      *.lo)
        # Possibly a libtool object, so verify it.
        # Possibly a libtool object, so verify it.
        if (sed -e '2q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
        if (sed -e '2q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
 
 
          # Read the .lo file
          # Read the .lo file
          . $dir/$name
          . $dir/$name
 
 
          # Add PIC object to the list of files to remove.
          # Add PIC object to the list of files to remove.
          if test -n "$pic_object" \
          if test -n "$pic_object" \
             && test "$pic_object" != none; then
             && test "$pic_object" != none; then
            rmfiles="$rmfiles $dir/$pic_object"
            rmfiles="$rmfiles $dir/$pic_object"
          fi
          fi
 
 
          # Add non-PIC object to the list of files to remove.
          # Add non-PIC object to the list of files to remove.
          if test -n "$non_pic_object" \
          if test -n "$non_pic_object" \
             && test "$non_pic_object" != none; then
             && test "$non_pic_object" != none; then
            rmfiles="$rmfiles $dir/$non_pic_object"
            rmfiles="$rmfiles $dir/$non_pic_object"
          fi
          fi
        fi
        fi
        ;;
        ;;
 
 
      *)
      *)
        # Do a test to see if this is a libtool program.
        # Do a test to see if this is a libtool program.
        if test $mode = clean &&
        if test $mode = clean &&
           (sed -e '4q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
           (sed -e '4q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
          relink_command=
          relink_command=
          . $dir/$file
          . $dir/$file
 
 
          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
            rmfiles="$rmfiles $objdir/lt-$name"
            rmfiles="$rmfiles $objdir/lt-$name"
          fi
          fi
        fi
        fi
        ;;
        ;;
      esac
      esac
      $show "$rm $rmfiles"
      $show "$rm $rmfiles"
      $run $rm $rmfiles || exit_status=1
      $run $rm $rmfiles || exit_status=1
    done
    done
 
 
    # Try to remove the ${objdir}s in the directories where we deleted files
    # Try to remove the ${objdir}s in the directories where we deleted files
    for dir in $rmdirs; do
    for dir in $rmdirs; do
      if test -d "$dir"; then
      if test -d "$dir"; then
        $show "rmdir $dir"
        $show "rmdir $dir"
        $run rmdir $dir >/dev/null 2>&1
        $run rmdir $dir >/dev/null 2>&1
      fi
      fi
    done
    done
 
 
    exit $exit_status
    exit $exit_status
    ;;
    ;;
 
 
  "")
  "")
    $echo "$modename: you must specify a MODE" 1>&2
    $echo "$modename: you must specify a MODE" 1>&2
    $echo "$generic_help" 1>&2
    $echo "$generic_help" 1>&2
    exit 1
    exit 1
    ;;
    ;;
  esac
  esac
 
 
  if test -z "$exec_cmd"; then
  if test -z "$exec_cmd"; then
    $echo "$modename: invalid operation mode \`$mode'" 1>&2
    $echo "$modename: invalid operation mode \`$mode'" 1>&2
    $echo "$generic_help" 1>&2
    $echo "$generic_help" 1>&2
    exit 1
    exit 1
  fi
  fi
fi # test -z "$show_help"
fi # test -z "$show_help"
 
 
if test -n "$exec_cmd"; then
if test -n "$exec_cmd"; then
  eval exec $exec_cmd
  eval exec $exec_cmd
  exit 1
  exit 1
fi
fi
 
 
# We need to display help for each of the modes.
# We need to display help for each of the modes.
case $mode in
case $mode in
"") $echo \
"") $echo \
"Usage: $modename [OPTION]... [MODE-ARG]...
"Usage: $modename [OPTION]... [MODE-ARG]...
 
 
Provide generalized library-building support services.
Provide generalized library-building support services.
 
 
    --config          show all configuration variables
    --config          show all configuration variables
    --debug           enable verbose shell tracing
    --debug           enable verbose shell tracing
-n, --dry-run         display commands without modifying any files
-n, --dry-run         display commands without modifying any files
    --features        display basic configuration information and exit
    --features        display basic configuration information and exit
    --finish          same as \`--mode=finish'
    --finish          same as \`--mode=finish'
    --help            display this help message and exit
    --help            display this help message and exit
    --mode=MODE       use operation mode MODE [default=inferred from MODE-ARGS]
    --mode=MODE       use operation mode MODE [default=inferred from MODE-ARGS]
    --quiet           same as \`--silent'
    --quiet           same as \`--silent'
    --silent          don't print informational messages
    --silent          don't print informational messages
    --tag=TAG         use configuration variables from tag TAG
    --tag=TAG         use configuration variables from tag TAG
    --version         print version information
    --version         print version information
 
 
MODE must be one of the following:
MODE must be one of the following:
 
 
      clean           remove files from the build directory
      clean           remove files from the build directory
      compile         compile a source file into a libtool object
      compile         compile a source file into a libtool object
      execute         automatically set library path, then run a program
      execute         automatically set library path, then run a program
      finish          complete the installation of libtool libraries
      finish          complete the installation of libtool libraries
      install         install libraries or executables
      install         install libraries or executables
      link            create a library or an executable
      link            create a library or an executable
      uninstall       remove libraries from an installed directory
      uninstall       remove libraries from an installed directory
 
 
MODE-ARGS vary depending on the MODE.  Try \`$modename --help --mode=MODE' for
MODE-ARGS vary depending on the MODE.  Try \`$modename --help --mode=MODE' for
a more detailed description of MODE."
a more detailed description of MODE."
  exit 0
  exit 0
  ;;
  ;;
 
 
clean)
clean)
  $echo \
  $echo \
"Usage: $modename [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
"Usage: $modename [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
 
 
Remove files from the build directory.
Remove files from the build directory.
 
 
RM is the name of the program to use to delete files associated with each FILE
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
(typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
to RM.
to RM.
 
 
If FILE is a libtool library, object or program, all the files associated
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."
with it are deleted. Otherwise, only FILE itself is deleted using RM."
  ;;
  ;;
 
 
compile)
compile)
  $echo \
  $echo \
"Usage: $modename [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
"Usage: $modename [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
 
 
Compile a source file into a libtool library object.
Compile a source file into a libtool library object.
 
 
This mode accepts the following additional options:
This mode accepts the following additional options:
 
 
  -o OUTPUT-FILE    set the output file name to OUTPUT-FILE
  -o OUTPUT-FILE    set the output file name to OUTPUT-FILE
  -prefer-pic       try to building PIC objects only
  -prefer-pic       try to building PIC objects only
  -prefer-non-pic   try to building non-PIC objects only
  -prefer-non-pic   try to building non-PIC objects only
  -static           always build a \`.o' file suitable for static linking
  -static           always build a \`.o' file suitable for static linking
 
 
COMPILE-COMMAND is a command to be used in creating a \`standard' object file
COMPILE-COMMAND is a command to be used in creating a \`standard' object file
from the given SOURCEFILE.
from the given SOURCEFILE.
 
 
The output file name is determined by removing the directory component from
The output file name is determined by removing the directory component from
SOURCEFILE, then substituting the C source code suffix \`.c' with the
SOURCEFILE, then substituting the C source code suffix \`.c' with the
library object suffix, \`.lo'."
library object suffix, \`.lo'."
  ;;
  ;;
 
 
execute)
execute)
  $echo \
  $echo \
"Usage: $modename [OPTION]... --mode=execute COMMAND [ARGS]...
"Usage: $modename [OPTION]... --mode=execute COMMAND [ARGS]...
 
 
Automatically set library path, then run a program.
Automatically set library path, then run a program.
 
 
This mode accepts the following additional options:
This mode accepts the following additional options:
 
 
  -dlopen FILE      add the directory containing FILE to the library path
  -dlopen FILE      add the directory containing FILE to the library path
 
 
This mode sets the library path environment variable according to \`-dlopen'
This mode sets the library path environment variable according to \`-dlopen'
flags.
flags.
 
 
If any of the ARGS are libtool executable wrappers, then they are translated
If any of the ARGS are libtool executable wrappers, then they are translated
into their corresponding uninstalled binary, and any of their required library
into their corresponding uninstalled binary, and any of their required library
directories are added to the library path.
directories are added to the library path.
 
 
Then, COMMAND is executed, with ARGS as arguments."
Then, COMMAND is executed, with ARGS as arguments."
  ;;
  ;;
 
 
finish)
finish)
  $echo \
  $echo \
"Usage: $modename [OPTION]... --mode=finish [LIBDIR]...
"Usage: $modename [OPTION]... --mode=finish [LIBDIR]...
 
 
Complete the installation of libtool libraries.
Complete the installation of libtool libraries.
 
 
Each LIBDIR is a directory that contains libtool libraries.
Each LIBDIR is a directory that contains libtool libraries.
 
 
The commands that this mode executes may require superuser privileges.  Use
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."
the \`--dry-run' option if you just want to see what would be executed."
  ;;
  ;;
 
 
install)
install)
  $echo \
  $echo \
"Usage: $modename [OPTION]... --mode=install INSTALL-COMMAND...
"Usage: $modename [OPTION]... --mode=install INSTALL-COMMAND...
 
 
Install executables or libraries.
Install executables or libraries.
 
 
INSTALL-COMMAND is the installation command.  The first component should be
INSTALL-COMMAND is the installation command.  The first component should be
either the \`install' or \`cp' program.
either the \`install' or \`cp' program.
 
 
The rest of the components are interpreted as arguments to that command (only
The rest of the components are interpreted as arguments to that command (only
BSD-compatible install options are recognized)."
BSD-compatible install options are recognized)."
  ;;
  ;;
 
 
link)
link)
  $echo \
  $echo \
"Usage: $modename [OPTION]... --mode=link LINK-COMMAND...
"Usage: $modename [OPTION]... --mode=link LINK-COMMAND...
 
 
Link object files or libraries together to form another library, or to
Link object files or libraries together to form another library, or to
create an executable program.
create an executable program.
 
 
LINK-COMMAND is a command using the C compiler that you would use to create
LINK-COMMAND is a command using the C compiler that you would use to create
a program from several object files.
a program from several object files.
 
 
The following components of LINK-COMMAND are treated specially:
The following components of LINK-COMMAND are treated specially:
 
 
  -all-static       do not do any dynamic linking at all
  -all-static       do not do any dynamic linking at all
  -avoid-version    do not add a version suffix if possible
  -avoid-version    do not add a version suffix if possible
  -dlopen FILE      \`-dlpreopen' FILE if it cannot be dlopened 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
  -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-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
  -export-symbols SYMFILE
  -export-symbols SYMFILE
                    try to export only the symbols listed in SYMFILE
                    try to export only the symbols listed in SYMFILE
  -export-symbols-regex REGEX
  -export-symbols-regex REGEX
                    try to export only the symbols matching REGEX
                    try to export only the symbols matching REGEX
  -LLIBDIR          search LIBDIR for required installed libraries
  -LLIBDIR          search LIBDIR for required installed libraries
  -lNAME            OUTPUT-FILE requires the installed library libNAME
  -lNAME            OUTPUT-FILE requires the installed library libNAME
  -module           build a library that can dlopened
  -module           build a library that can dlopened
  -no-fast-install  disable the fast-install mode
  -no-fast-install  disable the fast-install mode
  -no-install       link a not-installable executable
  -no-install       link a not-installable executable
  -no-undefined     declare that a library does not refer to external symbols
  -no-undefined     declare that a library does not refer to external symbols
  -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
  -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
  -objectlist FILE  Use a list of object files found in FILE to specify objects
  -objectlist FILE  Use a list of object files found in FILE to specify objects
  -release RELEASE  specify package release information
  -release RELEASE  specify package release information
  -rpath LIBDIR     the created library will eventually be installed in LIBDIR
  -rpath LIBDIR     the created library will eventually be installed in LIBDIR
  -R[ ]LIBDIR       add LIBDIR to the runtime path of programs and libraries
  -R[ ]LIBDIR       add LIBDIR to the runtime path of programs and libraries
  -static           do not do any dynamic linking of libtool libraries
  -static           do not do any dynamic linking of libtool libraries
  -version-info CURRENT[:REVISION[:AGE]]
  -version-info CURRENT[:REVISION[:AGE]]
                    specify library version info [each variable defaults to 0]
                    specify library version info [each variable defaults to 0]
 
 
All other options (arguments beginning with \`-') are ignored.
All other options (arguments beginning with \`-') are ignored.
 
 
Every other argument is treated as a filename.  Files ending in \`.la' are
Every other argument is treated as a filename.  Files ending in \`.la' are
treated as uninstalled libtool libraries, other files are standard or library
treated as uninstalled libtool libraries, other files are standard or library
object files.
object files.
 
 
If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
only library objects (\`.lo' files) may be specified, and \`-rpath' is
only library objects (\`.lo' files) may be specified, and \`-rpath' is
required, except when creating a convenience library.
required, except when creating a convenience library.
 
 
If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
using \`ar' and \`ranlib', or on Windows using \`lib'.
using \`ar' and \`ranlib', or on Windows using \`lib'.
 
 
If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
is created, otherwise an executable program is created."
is created, otherwise an executable program is created."
  ;;
  ;;
 
 
uninstall)
uninstall)
  $echo \
  $echo \
"Usage: $modename [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
"Usage: $modename [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
 
 
Remove libraries from an installation directory.
Remove libraries from an installation directory.
 
 
RM is the name of the program to use to delete files associated with each FILE
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
(typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
to RM.
to RM.
 
 
If FILE is a libtool library, all the files associated with it are deleted.
If FILE is a libtool library, all the files associated with it are deleted.
Otherwise, only FILE itself is deleted using RM."
Otherwise, only FILE itself is deleted using RM."
  ;;
  ;;
 
 
*)
*)
  $echo "$modename: invalid operation mode \`$mode'" 1>&2
  $echo "$modename: invalid operation mode \`$mode'" 1>&2
  $echo "$help" 1>&2
  $echo "$help" 1>&2
  exit 1
  exit 1
  ;;
  ;;
esac
esac
 
 
echo
echo
$echo "Try \`$modename --help' for more information about other modes."
$echo "Try \`$modename --help' for more information about other modes."
 
 
exit 0
exit 0
 
 
# The TAGs below are defined such that we never get into a situation
# The TAGs below are defined such that we never get into a situation
# in which we disable both kinds of libraries.  Given conflicting
# in which we disable both kinds of libraries.  Given conflicting
# choices, we go for a static library, that is the most portable,
# choices, we go for a static library, that is the most portable,
# since we can't tell whether shared libraries were disabled because
# since we can't tell whether shared libraries were disabled because
# the user asked for that or because the platform doesn't support
# the user asked for that or because the platform doesn't support
# them.  This is particularly important on AIX, because we don't
# them.  This is particularly important on AIX, because we don't
# support having both static and shared libraries enabled at the same
# support having both static and shared libraries enabled at the same
# time on that platform, so we default to a shared-only configuration.
# time on that platform, so we default to a shared-only configuration.
# If a disable-shared tag is given, we'll fallback to a static-only
# If a disable-shared tag is given, we'll fallback to a static-only
# configuration.  But we'll never go from static-only to shared-only.
# configuration.  But we'll never go from static-only to shared-only.
 
 
### BEGIN LIBTOOL TAG CONFIG: disable-shared
### BEGIN LIBTOOL TAG CONFIG: disable-shared
build_libtool_libs=no
build_libtool_libs=no
build_old_libs=yes
build_old_libs=yes
### END LIBTOOL TAG CONFIG: disable-shared
### END LIBTOOL TAG CONFIG: disable-shared
 
 
### BEGIN LIBTOOL TAG CONFIG: disable-static
### BEGIN LIBTOOL TAG CONFIG: disable-static
build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
### END LIBTOOL TAG CONFIG: disable-static
### END LIBTOOL TAG CONFIG: disable-static
 
 
# Local Variables:
# Local Variables:
# mode:shell-script
# mode:shell-script
# sh-indentation:2
# sh-indentation:2
# End:
# End:
 
 

powered by: WebSVN 2.1.0

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