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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [rtos/] [ecos-2.0/] [tools/] [acsupport/] [ltmain.sh] - Diff between revs 26 and 174

Go to most recent revision | Only display areas with differences | Details | Blame | View Log

Rev 26 Rev 174
# 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-1999 Free Software Foundation, Inc.
# Copyright (C) 1996-1999 Free Software Foundation, Inc.
# Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
# 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
  # used as fallback echo
  # used as fallback echo
  shift
  shift
  cat <<EOF
  cat <<EOF
$*
$*
EOF
EOF
  exit 0
  exit 0
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
 
 
# 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.2f
VERSION=1.2f
TIMESTAMP=" (1.385 1999/03/15 17:24:54)"
TIMESTAMP=" (1.385 1999/03/15 17:24:54)"
 
 
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 \012 \040'
NL2SP='tr \012 \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}/"
 
 
# 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)
      eval "$prev=\"\$$prev \$arg\""
      eval "$prev=\"\$$prev \$arg\""
      ;;
      ;;
    *)
    *)
      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 -e '1,/^### BEGIN LIBTOOL CONFIG/d' -e '/^### END LIBTOOL CONFIG/,$d' $0
    sed -e '1,/^### BEGIN LIBTOOL CONFIG/d' -e '/^### END LIBTOOL CONFIG/,$d' $0
    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=:
    ;;
    ;;
 
 
  -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 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=
    lastarg=
    lastarg=
    srcfile="$nonopt"
    srcfile="$nonopt"
    suppress_output=
    suppress_output=
 
 
    user_target=no
    user_target=no
    for arg
    for arg
    do
    do
      # 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
        ;;
        ;;
      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 in scan
      # Many Bourne shells cannot handle close brackets correctly in scan
      # sets, so we specify it separately.
      # 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 ;;
    *.cpp) xform=cpp ;;
    *.cpp) xform=cpp ;;
    *.cxx) xform=cxx ;;
    *.cxx) xform=cxx ;;
    *.f90) xform=f90 ;;
    *.f90) xform=f90 ;;
    *.for) xform=for ;;
    *.for) xform=for ;;
    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
 
 
    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 $libobj"
      removelist="$obj $libobj"
    else
    else
      removelist="$libobj"
      removelist="$libobj"
    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
 
 
    # 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
      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 ln "$0" "$lockfile" 2>/dev/null; do
      until 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
 
 
    # 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
 
 
      # All platforms use -DPIC, to notify preprocessed assembler code.
      # All platforms use -DPIC, to notify preprocessed assembler code.
      command="$base_compile $pic_flag -DPIC $srcfile"
      command="$base_compile $pic_flag -DPIC $srcfile"
      if test "$build_old_libs" = yes; then
      if test "$build_old_libs" = yes; then
        lo_libobj="$libobj"
        lo_libobj="$libobj"
        dir=`$echo "X$libobj" | $Xsed -e 's%/[^/]*$%%'`
        dir=`$echo "X$libobj" | $Xsed -e 's%/[^/]*$%%'`
        if test "X$dir" = "X$libobj"; then
        if test "X$dir" = "X$libobj"; then
          dir="$objdir"
          dir="$objdir"
        else
        else
          dir="$dir/$objdir"
          dir="$dir/$objdir"
        fi
        fi
        libobj="$dir/"`$echo "X$libobj" | $Xsed -e 's%^.*/%%'`
        libobj="$dir/"`$echo "X$libobj" | $Xsed -e 's%^.*/%%'`
 
 
        if test -d "$dir"; then
        if test -d "$dir"; then
          $show "$rm $libobj"
          $show "$rm $libobj"
          $run $rm $libobj
          $run $rm $libobj
        else
        else
          $show "$mkdir $dir"
          $show "$mkdir $dir"
          $run $mkdir $dir
          $run $mkdir $dir
          status=$?
          status=$?
          if test $status -ne 0 && test ! -d $dir; then
          if test $status -ne 0 && test ! -d $dir; then
            exit $status
            exit $status
          fi
          fi
        fi
        fi
      fi
      fi
      if test "$compiler_o_lo" = yes; then
      if test "$compiler_o_lo" = yes; then
        output_obj="$libobj"
        output_obj="$libobj"
        command="$command -o $output_obj"
        command="$command -o $output_obj"
      elif test "$compiler_c_o" = yes; then
      elif test "$compiler_c_o" = yes; then
        output_obj="$obj"
        output_obj="$obj"
        command="$command -o $output_obj"
        command="$command -o $output_obj"
      fi
      fi
 
 
      $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 x"$output_obj" != x"$libobj"; then
      if test x"$output_obj" != x"$libobj"; then
        $show "$mv $output_obj $libobj"
        $show "$mv $output_obj $libobj"
        if $run $mv $output_obj $libobj; then :
        if $run $mv $output_obj $libobj; then :
        else
        else
          error=$?
          error=$?
          $run $rm $removelist
          $run $rm $removelist
          exit $error
          exit $error
        fi
        fi
      fi
      fi
 
 
      # If we have no pic_flag, then copy the object into place and finish.
      # If we have no pic_flag, then copy the object into place and finish.
      if test -z "$pic_flag" && test "$build_old_libs" = yes; then
      if test -z "$pic_flag" && test "$build_old_libs" = yes; then
        # Rename the .lo from within objdir to obj
        # Rename the .lo from within objdir to obj
        if test -f $obj; then
        if test -f $obj; then
          $show $rm $obj
          $show $rm $obj
          $run $rm $obj
          $run $rm $obj
        fi
        fi
 
 
        $show "$mv $libobj $obj"
        $show "$mv $libobj $obj"
        if $run $mv $libobj $obj; then :
        if $run $mv $libobj $obj; then :
        else
        else
          error=$?
          error=$?
          $run $rm $removelist
          $run $rm $removelist
          exit $error
          exit $error
        fi
        fi
 
 
        # Now arrange that obj and lo_libobj become the same file
        # Now arrange that obj and lo_libobj become the same file
        $show "$LN_S $obj $lo_libobj"
        $show "$LN_S $obj $lo_libobj"
        if $run $LN_S $obj $lo_libobj; then
        if $run $LN_S $obj $lo_libobj; then
          exit 0
          exit 0
        else
        else
          error=$?
          error=$?
          $run $rm $removelist
          $run $rm $removelist
          exit $error
          exit $error
        fi
        fi
      fi
      fi
 
 
      # 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'
    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
      command="$base_compile $srcfile"
      command="$base_compile $srcfile"
      if test "$compiler_c_o" = yes; then
      if test "$compiler_c_o" = yes; then
        command="$command -o $obj"
        command="$command -o $obj"
        output_obj="$obj"
        output_obj="$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"
      $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 x"$output_obj" != x"$obj"; then
      if 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
 
 
      # Create an invalid libtool object if no PIC, so that we do not
      # Create an invalid libtool object if no PIC, so that we do not
      # accidentally link it into a program.
      # accidentally link it into a program.
      if test "$build_libtool_libs" != yes; then
      if test "$build_libtool_libs" != yes; then
        $show "echo timestamp > $libobj"
        $show "echo timestamp > $libobj"
        $run eval "echo timestamp > \$libobj" || exit $?
        $run eval "echo timestamp > \$libobj" || exit $?
      else
      else
        # Move the .lo from within objdir
        # Move the .lo from within objdir
        $show "$mv $libobj $lo_libobj"
        $show "$mv $libobj $lo_libobj"
        if $run $mv $libobj $lo_libobj; then :
        if $run $mv $libobj $lo_libobj; then :
        else
        else
          error=$?
          error=$?
          $run $rm $removelist
          $run $rm $removelist
          exit $error
          exit $error
        fi
        fi
      fi
      fi
    fi
    fi
 
 
    # 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
      $rm "$lockfile"
      $rm "$lockfile"
    fi
    fi
 
 
    exit 0
    exit 0
    ;;
    ;;
 
 
  # libtool link mode
  # libtool link mode
  link)
  link)
    modename="$modename: link"
    modename="$modename: link"
    C_compiler="$CC" # save it, to compile generated C sources
    C_compiler="$CC" # save it, to compile generated C sources
    CC="$nonopt"
    CC="$nonopt"
    case "$host" in
    case "$host" in
    *-*-cygwin* | *-*-mingw* | *-*-os2*)
    *-*-cygwin* | *-*-mingw* | *-*-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
 
 
      # This is a source program that is used to create dlls on Windows
      # This is a source program that is used to create dlls on Windows
      # Don't remove nor modify the starting and closing comments
      # Don't remove nor modify the starting and closing comments
# /* ltdll.c starts here */
# /* ltdll.c starts here */
# #define WIN32_LEAN_AND_MEAN
# #define WIN32_LEAN_AND_MEAN
# #include <windows.h>
# #include <windows.h>
# #undef WIN32_LEAN_AND_MEAN
# #undef WIN32_LEAN_AND_MEAN
# #include <stdio.h>
# #include <stdio.h>
#
#
# BOOL APIENTRY DllMain (HINSTANCE hInst, DWORD reason, LPVOID reserved);
# BOOL APIENTRY DllMain (HINSTANCE hInst, DWORD reason, LPVOID reserved);
#
#
# #include <cygwin/cygwin_dll.h>
# #include <cygwin/cygwin_dll.h>
# DECLARE_CYGWIN_DLL( DllMain );
# DECLARE_CYGWIN_DLL( DllMain );
# HINSTANCE __hDllInstance_base;
# HINSTANCE __hDllInstance_base;
#
#
# BOOL APIENTRY
# BOOL APIENTRY
# DllMain (HINSTANCE hInst, DWORD reason, LPVOID reserved)
# DllMain (HINSTANCE hInst, DWORD reason, LPVOID reserved)
# {
# {
#   __hDllInstance_base = hInst;
#   __hDllInstance_base = hInst;
#   return TRUE;
#   return TRUE;
# }
# }
# /* ltdll.c ends here */
# /* ltdll.c ends here */
      # This is a source program that is used to create import libraries
      # This is a source program that is used to create import libraries
      # on Windows for dlls which lack them. Don't remove nor modify the
      # on Windows for dlls which lack them. Don't remove nor modify the
      # starting and closing comments
      # starting and closing comments
# /* impgen.c starts here */
# /* impgen.c starts here */
# /*   Copyright (C) 1999 Free Software Foundation, Inc.
# /*   Copyright (C) 1999 Free Software Foundation, Inc.
#
#
#  This file is part of GNU libtool.
#  This file is part of GNU libtool.
#
#
#  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,
#  This program is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
#  GNU 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.
#  */
#  */
#
#
#  #include <stdio.h>           /* for printf() */
#  #include <stdio.h>           /* for printf() */
#  #include <unistd.h>          /* for open(), lseek(), read() */
#  #include <unistd.h>          /* for open(), lseek(), read() */
#  #include <fcntl.h>           /* for O_RDONLY, O_BINARY */
#  #include <fcntl.h>           /* for O_RDONLY, O_BINARY */
#  #include <string.h>          /* for strdup() */
#  #include <string.h>          /* for strdup() */
#
#
#  static unsigned int
#  static unsigned int
#  pe_get16 (fd, offset)
#  pe_get16 (fd, offset)
#       int fd;
#       int fd;
#       int offset;
#       int offset;
#  {
#  {
#    unsigned char b[2];
#    unsigned char b[2];
#    lseek (fd, offset, SEEK_SET);
#    lseek (fd, offset, SEEK_SET);
#    read (fd, b, 2);
#    read (fd, b, 2);
#    return b[0] + (b[1]<<8);
#    return b[0] + (b[1]<<8);
#  }
#  }
#
#
#  static unsigned int
#  static unsigned int
#  pe_get32 (fd, offset)
#  pe_get32 (fd, offset)
#      int fd;
#      int fd;
#      int offset;
#      int offset;
#  {
#  {
#    unsigned char b[4];
#    unsigned char b[4];
#    lseek (fd, offset, SEEK_SET);
#    lseek (fd, offset, SEEK_SET);
#    read (fd, b, 4);
#    read (fd, b, 4);
#    return b[0] + (b[1]<<8) + (b[2]<<16) + (b[3]<<24);
#    return b[0] + (b[1]<<8) + (b[2]<<16) + (b[3]<<24);
#  }
#  }
#
#
#  static unsigned int
#  static unsigned int
#  pe_as32 (ptr)
#  pe_as32 (ptr)
#       void *ptr;
#       void *ptr;
#  {
#  {
#    unsigned char *b = ptr;
#    unsigned char *b = ptr;
#    return b[0] + (b[1]<<8) + (b[2]<<16) + (b[3]<<24);
#    return b[0] + (b[1]<<8) + (b[2]<<16) + (b[3]<<24);
#  }
#  }
#
#
#  int
#  int
#  main (argc, argv)
#  main (argc, argv)
#      int argc;
#      int argc;
#      char *argv[];
#      char *argv[];
#  {
#  {
#      int dll;
#      int dll;
#      unsigned long pe_header_offset, opthdr_ofs, num_entries, i;
#      unsigned long pe_header_offset, opthdr_ofs, num_entries, i;
#      unsigned long export_rva, export_size, nsections, secptr, expptr;
#      unsigned long export_rva, export_size, nsections, secptr, expptr;
#      unsigned long name_rvas, nexp;
#      unsigned long name_rvas, nexp;
#      unsigned char *expdata, *erva;
#      unsigned char *expdata, *erva;
#      char *filename, *dll_name;
#      char *filename, *dll_name;
#
#
#      filename = argv[1];
#      filename = argv[1];
#
#
#      dll = open(filename, O_RDONLY|O_BINARY);
#      dll = open(filename, O_RDONLY|O_BINARY);
#      if (!dll)
#      if (!dll)
#       return 1;
#       return 1;
#
#
#      dll_name = filename;
#      dll_name = filename;
#
#
#      for (i=0; filename[i]; i++)
#      for (i=0; filename[i]; i++)
#       if (filename[i] == '/' || filename[i] == '\\'  || filename[i] == ':')
#       if (filename[i] == '/' || filename[i] == '\\'  || filename[i] == ':')
#           dll_name = filename + i +1;
#           dll_name = filename + i +1;
#
#
#      pe_header_offset = pe_get32 (dll, 0x3c);
#      pe_header_offset = pe_get32 (dll, 0x3c);
#      opthdr_ofs = pe_header_offset + 4 + 20;
#      opthdr_ofs = pe_header_offset + 4 + 20;
#      num_entries = pe_get32 (dll, opthdr_ofs + 92);
#      num_entries = pe_get32 (dll, opthdr_ofs + 92);
#
#
#      if (num_entries < 1) /* no exports */
#      if (num_entries < 1) /* no exports */
#       return 1;
#       return 1;
#
#
#      export_rva = pe_get32 (dll, opthdr_ofs + 96);
#      export_rva = pe_get32 (dll, opthdr_ofs + 96);
#      export_size = pe_get32 (dll, opthdr_ofs + 100);
#      export_size = pe_get32 (dll, opthdr_ofs + 100);
#      nsections = pe_get16 (dll, pe_header_offset + 4 +2);
#      nsections = pe_get16 (dll, pe_header_offset + 4 +2);
#      secptr = (pe_header_offset + 4 + 20 +
#      secptr = (pe_header_offset + 4 + 20 +
#             pe_get16 (dll, pe_header_offset + 4 + 16));
#             pe_get16 (dll, pe_header_offset + 4 + 16));
#
#
#      expptr = 0;
#      expptr = 0;
#      for (i = 0; i < nsections; i++)
#      for (i = 0; i < nsections; i++)
#      {
#      {
#       char sname[8];
#       char sname[8];
#       unsigned long secptr1 = secptr + 40 * i;
#       unsigned long secptr1 = secptr + 40 * i;
#       unsigned long vaddr = pe_get32 (dll, secptr1 + 12);
#       unsigned long vaddr = pe_get32 (dll, secptr1 + 12);
#       unsigned long vsize = pe_get32 (dll, secptr1 + 16);
#       unsigned long vsize = pe_get32 (dll, secptr1 + 16);
#       unsigned long fptr = pe_get32 (dll, secptr1 + 20);
#       unsigned long fptr = pe_get32 (dll, secptr1 + 20);
#       lseek(dll, secptr1, SEEK_SET);
#       lseek(dll, secptr1, SEEK_SET);
#       read(dll, sname, 8);
#       read(dll, sname, 8);
#       if (vaddr <= export_rva && vaddr+vsize > export_rva)
#       if (vaddr <= export_rva && vaddr+vsize > export_rva)
#       {
#       {
#           expptr = fptr + (export_rva - vaddr);
#           expptr = fptr + (export_rva - vaddr);
#           if (export_rva + export_size > vaddr + vsize)
#           if (export_rva + export_size > vaddr + vsize)
#               export_size = vsize - (export_rva - vaddr);
#               export_size = vsize - (export_rva - vaddr);
#           break;
#           break;
#       }
#       }
#      }
#      }
#
#
#      expdata = (unsigned char*)malloc(export_size);
#      expdata = (unsigned char*)malloc(export_size);
#      lseek (dll, expptr, SEEK_SET);
#      lseek (dll, expptr, SEEK_SET);
#      read (dll, expdata, export_size);
#      read (dll, expdata, export_size);
#      erva = expdata - export_rva;
#      erva = expdata - export_rva;
#
#
#      nexp = pe_as32 (expdata+24);
#      nexp = pe_as32 (expdata+24);
#      name_rvas = pe_as32 (expdata+32);
#      name_rvas = pe_as32 (expdata+32);
#
#
#      printf ("EXPORTS\n");
#      printf ("EXPORTS\n");
#      for (i = 0; i<nexp; i++)
#      for (i = 0; i<nexp; i++)
#      {
#      {
#       unsigned long name_rva = pe_as32 (erva+name_rvas+i*4);
#       unsigned long name_rva = pe_as32 (erva+name_rvas+i*4);
#       printf ("\t%s @ %ld ;\n", erva+name_rva, 1+ i);
#       printf ("\t%s @ %ld ;\n", erva+name_rva, 1+ i);
#      }
#      }
#
#
#      return 0;
#      return 0;
#  }
#  }
# /* impgen.c ends here */
# /* impgen.c ends here */
      ;;
      ;;
    *)
    *)
      allow_undefined=yes
      allow_undefined=yes
      ;;
      ;;
    esac
    esac
    compile_command="$CC"
    compile_command="$CC"
    finalize_command="$CC"
    finalize_command="$CC"
 
 
    compile_rpath=
    compile_rpath=
    finalize_rpath=
    finalize_rpath=
    compile_shlibpath=
    compile_shlibpath=
    finalize_shlibpath=
    finalize_shlibpath=
    convenience=
    convenience=
    old_convenience=
    old_convenience=
    deplibs=
    deplibs=
    linkopts=
    linkopts=
 
 
    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 lib_search_path=\`\$echo \"X \${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
      eval lib_search_path=\`\$echo \"X \${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
    else
    else
      lib_search_path=
      lib_search_path=
    fi
    fi
    # now prepend the system-specific ones
    # now prepend the system-specific ones
    eval lib_search_path=\"$sys_lib_search_path_spec\$lib_search_path\"
    eval lib_search_path=\"$sys_lib_search_path_spec\$lib_search_path\"
    eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
    eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
 
 
    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=
    link_against_libtool_libs=
    link_against_libtool_libs=
    ltlibs=
    ltlibs=
    module=no
    module=no
    objs=
    objs=
    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" && test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
        if test "X$arg" = "X-all-static" && 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
        build_libtool_libs=no
        build_libtool_libs=no
        build_old_libs=yes
        build_old_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"
      shift
      shift
 
 
      # 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.
          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
            fi
            fi
            prev=
            prev=
            continue
            continue
            ;;
            ;;
          *)
          *)
            dlprefiles="$dlprefiles $arg"
            dlprefiles="$dlprefiles $arg"
            test "$prev" = dlfiles && dlfiles="$dlfiles $arg"
            test "$prev" = dlfiles && dlfiles="$dlfiles $arg"
            prev=
            prev=
            ;;
            ;;
          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
          ;;
          ;;
        rpath)
        rpath)
          rpath="$rpath $arg"
          rpath="$rpath $arg"
          prev=
          prev=
          continue
          continue
          ;;
          ;;
        xrpath)
        xrpath)
          xrpath="$xrpath $arg"
          xrpath="$xrpath $arg"
          prev=
          prev=
          continue
          continue
          ;;
          ;;
        *)
        *)
          eval "$prev=\"\$arg\""
          eval "$prev=\"\$arg\""
          prev=
          prev=
          continue
          continue
          ;;
          ;;
        esac
        esac
      fi
      fi
 
 
      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"
          dlopen_self=$dlopen_self_static
          dlopen_self=$dlopen_self_static
        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)
        if test "$export_dynamic" != yes; then
        if test "$export_dynamic" != yes; then
          export_dynamic=yes
          export_dynamic=yes
          if test -n "$export_dynamic_flag_spec"; then
          if test -n "$export_dynamic_flag_spec"; then
            eval arg=\"$export_dynamic_flag_spec\"
            eval arg=\"$export_dynamic_flag_spec\"
          else
          else
            arg=
            arg=
          fi
          fi
        fi
        fi
        ;;
        ;;
 
 
      -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: cannot have more than one -exported-symbols"
          $echo "$modename: cannot have more than one -exported-symbols"
          exit 1
          exit 1
        fi
        fi
        if test "$arg" = "-export-symbols"; then
        if test "$arg" = "-export-symbols"; then
          prev=expsyms
          prev=expsyms
        else
        else
          prev=expsyms_regex
          prev=expsyms_regex
        fi
        fi
        continue
        continue
        ;;
        ;;
 
 
      -L*)
      -L*)
        dir=`$echo "X$arg" | $Xsed -e 's%^-L\(.*\)$%\1%'`
        dir=`$echo "X$arg" | $Xsed -e 's%^-L\(.*\)$%\1%'`
        case "$dir" in
        case "$dir" in
        /* | [A-Za-z]:[/\\]*)
        /* | [A-Za-z]:[/\\]*)
          # Add the corresponding hardcode_libdir_flag, if it is not identical.
          # Add the corresponding hardcode_libdir_flag, if it is not identical.
          ;;
          ;;
        *)
        *)
          $echo "$modename: \`-L$dir' cannot specify a relative directory" 1>&2
          $echo "$modename: \`-L$dir' cannot specify a relative directory" 1>&2
          exit 1
          exit 1
          ;;
          ;;
        esac
        esac
        case " $deplibs " in
        case " $deplibs " in
        *" $arg "*) ;;
        *" $arg "*) ;;
        *) deplibs="$deplibs $arg";;
        *) deplibs="$deplibs $arg";;
        esac
        esac
        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
        case "$host" in
        case "$host" in
        *-*-cygwin* | *-*-mingw* | *-*-os2*)
        *-*-cygwin* | *-*-mingw* | *-*-os2*)
          dllsearchdir=`cd "$dir" && pwd || echo "$dir"`
          dllsearchdir=`cd "$dir" && pwd || echo "$dir"`
          case ":$dllsearchpath:" in
          case ":$dllsearchpath:" in
          ::) dllsearchpath="$dllsearchdir";;
          ::) dllsearchpath="$dllsearchdir";;
          *":$dllsearchdir:"*) ;;
          *":$dllsearchdir:"*) ;;
          *) dllsearchpath="$dllsearchpath:$dllsearchdir";;
          *) dllsearchpath="$dllsearchpath:$dllsearchdir";;
          esac
          esac
          ;;
          ;;
        esac
        esac
        ;;
        ;;
 
 
      -l*)
      -l*)
        deplibs="$deplibs $arg"
        deplibs="$deplibs $arg"
        ;;
        ;;
 
 
      -module)
      -module)
        if test "$module" != yes; then
        if test "$module" != yes; then
          module=yes
          module=yes
          if test -n "$export_dynamic_flag_spec"; then
          if test -n "$export_dynamic_flag_spec"; then
            eval arg=\"$export_dynamic_flag_spec\"
            eval arg=\"$export_dynamic_flag_spec\"
          else
          else
            arg=
            arg=
          fi
          fi
        fi
        fi
        ;;
        ;;
 
 
      -no-undefined)
      -no-undefined)
        allow_undefined=no
        allow_undefined=no
        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*)
        xrpath="$xrpath "`$echo "X$arg" | $Xsed -e 's/^-R//'`
        xrpath="$xrpath "`$echo "X$arg" | $Xsed -e 's/^-R//'`
        continue
        continue
        ;;
        ;;
 
 
      -static)
      -static)
        # If we have no pic_flag, then this is the same as -all-static.
        # If we have no pic_flag, then this is the same as -all-static.
        if test -z "$pic_flag" && test -n "$link_static_flag"; then
        if test -z "$pic_flag" && 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"
          dlopen_self=$dlopen_self_static
          dlopen_self=$dlopen_self_static
        fi
        fi
        continue
        continue
        ;;
        ;;
 
 
      -thread-safe)
      -thread-safe)
        thread_safe=yes
        thread_safe=yes
        continue
        continue
        ;;
        ;;
 
 
      -version-info)
      -version-info)
        prev=vinfo
        prev=vinfo
        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
        ;;
        ;;
 
 
      *.o | *.obj | *.a | *.lib)
      *.o | *.obj | *.a | *.lib)
        # A standard object.
        # A standard object.
        objs="$objs $arg"
        objs="$objs $arg"
        ;;
        ;;
 
 
      *.lo)
      *.lo)
        # A library object.
        # A library object.
        if test "$prev" = dlfiles; then
        if test "$prev" = dlfiles; then
          dlfiles="$dlfiles $arg"
          dlfiles="$dlfiles $arg"
          if test "$build_libtool_libs" = yes && test "$dlopen" = yes; then
          if test "$build_libtool_libs" = yes && test "$dlopen" = yes; then
            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
 
 
        if test "$prev" = dlprefiles; then
        if test "$prev" = dlprefiles; then
          # Preload the old-style object.
          # Preload the old-style object.
          dlprefiles="$dlprefiles "`$echo "X$arg" | $Xsed -e "$lo2o"`
          dlprefiles="$dlprefiles "`$echo "X$arg" | $Xsed -e "$lo2o"`
          prev=
          prev=
        fi
        fi
        libobjs="$libobjs $arg"
        libobjs="$libobjs $arg"
        ;;
        ;;
 
 
      *.la)
      *.la)
        # A libtool-controlled library.
        # A libtool-controlled library.
 
 
        dlname=
        dlname=
        libdir=
        libdir=
        library_names=
        library_names=
        old_library=
        old_library=
 
 
        # Check to see that this really is a libtool archive.
        # Check to see that this really is a libtool archive.
        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 :
        else
        else
          $echo "$modename: \`$arg' is not a valid libtool archive" 1>&2
          $echo "$modename: \`$arg' is not a valid libtool archive" 1>&2
          exit 1
          exit 1
        fi
        fi
 
 
        # 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
 
 
        # 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
 
 
        # 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 \`$arg'" 1>&2
          $echo "$modename: cannot find name of link library for \`$arg'" 1>&2
          exit 1
          exit 1
        fi
        fi
 
 
        # Find the relevant object directory and library name.
        # Find the relevant object directory and library name.
        name=`$echo "X$arg" | $Xsed -e 's%^.*/%%' -e 's/\.la$//' -e 's/^lib//'`
        name=`$echo "X$arg" | $Xsed -e 's%^.*/%%' -e 's/\.la$//' -e 's/^lib//'`
 
 
        if test "X$installed" = Xyes; then
        if test "X$installed" = Xyes; then
          dir="$libdir"
          dir="$libdir"
        else
        else
          dir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
          dir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
          if test "X$dir" = "X$arg"; then
          if test "X$dir" = "X$arg"; then
            dir="$objdir"
            dir="$objdir"
          else
          else
            dir="$dir/$objdir"
            dir="$dir/$objdir"
          fi
          fi
        fi
        fi
 
 
        if test -n "$dependency_libs"; then
        if test -n "$dependency_libs"; then
          # Extract -R from dependency_libs
          # Extract -R from dependency_libs
          temp_deplibs=
          temp_deplibs=
          for deplib in $dependency_libs; do
          for deplib in $dependency_libs; do
            case "$deplib" in
            case "$deplib" in
            -R*) temp_xrpath=`$echo "X$deplib" | $Xsed -e 's/^-R//'`
            -R*) temp_xrpath=`$echo "X$deplib" | $Xsed -e 's/^-R//'`
                 case " $rpath $xrpath " in
                 case " $rpath $xrpath " in
                 *" $temp_xrpath "*) ;;
                 *" $temp_xrpath "*) ;;
                 *) xrpath="$xrpath $temp_xrpath";;
                 *) xrpath="$xrpath $temp_xrpath";;
                 esac;;
                 esac;;
            -L*) case "$compile_command $temp_deplibs " in
            -L*) case "$compile_command $temp_deplibs " in
                 *" $deplib "*) ;;
                 *" $deplib "*) ;;
                 *) temp_deplibs="$temp_deplibs $deplib";;
                 *) temp_deplibs="$temp_deplibs $deplib";;
                 esac;;
                 esac;;
            *) temp_deplibs="$temp_deplibs $deplib";;
            *) temp_deplibs="$temp_deplibs $deplib";;
            esac
            esac
          done
          done
          dependency_libs="$temp_deplibs"
          dependency_libs="$temp_deplibs"
        fi
        fi
 
 
        if test -z "$libdir"; then
        if test -z "$libdir"; then
          # It is a libtool convenience library, so add in its objects.
          # It is a libtool convenience library, so add in its objects.
          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="$deplibs$dependency_libs"
          deplibs="$deplibs$dependency_libs"
          compile_command="$compile_command $dir/$old_library$dependency_libs"
          compile_command="$compile_command $dir/$old_library$dependency_libs"
          finalize_command="$finalize_command $dir/$old_library$dependency_libs"
          finalize_command="$finalize_command $dir/$old_library$dependency_libs"
          continue
          continue
        fi
        fi
 
 
        # This library was specified with -dlopen.
        # This library was specified with -dlopen.
        if test "$prev" = dlfiles; then
        if test "$prev" = dlfiles; then
          dlfiles="$dlfiles $arg"
          dlfiles="$dlfiles $arg"
          if test -z "$dlname" || test "$dlopen" != yes || test "$build_libtool_libs" = no; then
          if test -z "$dlname" || test "$dlopen" != yes || test "$build_libtool_libs" = no; then
            # If there is no dlname, no dlopen support or we're linking statically,
            # If there is no dlname, no dlopen support or we're linking statically,
            # we need to preload.
            # we need to preload.
            prev=dlprefiles
            prev=dlprefiles
          else
          else
            # We should not create a dependency on this library, but we
            # We should not create a dependency on this library, but we
            # may need any libraries it requires.
            # may need any libraries it requires.
            compile_command="$compile_command$dependency_libs"
            compile_command="$compile_command$dependency_libs"
            finalize_command="$finalize_command$dependency_libs"
            finalize_command="$finalize_command$dependency_libs"
            prev=
            prev=
            continue
            continue
          fi
          fi
        fi
        fi
 
 
        # The library was specified with -dlpreopen.
        # The library was specified with -dlpreopen.
        if test "$prev" = dlprefiles; then
        if test "$prev" = dlprefiles; then
          # 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
            dlprefiles="$dlprefiles $dir/$old_library"
            dlprefiles="$dlprefiles $dir/$old_library"
          else
          else
            dlprefiles="$dlprefiles $dir/$linklib"
            dlprefiles="$dlprefiles $dir/$linklib"
          fi
          fi
          prev=
          prev=
        fi
        fi
 
 
        if test "$build_libtool_libs" = yes && test -n "$library_names"; then
        if test "$build_libtool_libs" = yes && test -n "$library_names"; then
          link_against_libtool_libs="$link_against_libtool_libs $arg"
          link_against_libtool_libs="$link_against_libtool_libs $arg"
          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 "*) ;;
            *) temp_rpath="$temp_rpath $dir" ;;
            *) temp_rpath="$temp_rpath $dir" ;;
            esac
            esac
          fi
          fi
 
 
          # 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: cannot determine absolute directory name of \`$libdir'" 1>&2
              $echo "$modename: cannot determine absolute directory name of \`$libdir'" 1>&2
              exit 1
              exit 1
            fi
            fi
            ;;
            ;;
          esac
          esac
 
 
          # This is the magic to use -rpath.
          # This is the magic to use -rpath.
          # Skip directories that are in the system default run-time
          # Skip directories that are in the system default run-time
          # search path, unless they have been requested with -R.
          # search path, unless they have been requested with -R.
          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
 
 
          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
              compile_command="$compile_command $dir/$linklib"
              compile_command="$compile_command $dir/$linklib"
              deplibs="$deplibs $dir/$linklib"
              deplibs="$deplibs $dir/$linklib"
              case "$host" in
              case "$host" in
              *-*-cygwin* | *-*-mingw* | *-*-os2*)
              *-*-cygwin* | *-*-mingw* | *-*-os2*)
                dllsearchdir=`cd "$dir" && pwd || echo "$dir"`
                dllsearchdir=`cd "$dir" && pwd || echo "$dir"`
                if test -n "$dllsearchpath"; then
                if test -n "$dllsearchpath"; then
                  dllsearchpath="$dllsearchpath:$dllsearchdir"
                  dllsearchpath="$dllsearchpath:$dllsearchdir"
                else
                else
                  dllsearchpath="$dllsearchdir"
                  dllsearchpath="$dllsearchdir"
                fi
                fi
                ;;
                ;;
              esac
              esac
            elif test "$hardcode_minus_L" = no; then
            elif test "$hardcode_minus_L" = no; then
              case "$host" in
              case "$host" in
              *-*-sunos*)
              *-*-sunos*)
                compile_shlibpath="$compile_shlibpath$dir:"
                compile_shlibpath="$compile_shlibpath$dir:"
                ;;
                ;;
              esac
              esac
              case "$compile_command " in
              case "$compile_command " in
              *" -L$dir "*) ;;
              *" -L$dir "*) ;;
              *) compile_command="$compile_command -L$dir";;
              *) compile_command="$compile_command -L$dir";;
              esac
              esac
              compile_command="$compile_command -l$name"
              compile_command="$compile_command -l$name"
              deplibs="$deplibs -L$dir -l$name"
              deplibs="$deplibs -L$dir -l$name"
            elif test "$hardcode_shlibpath_var" = no; then
            elif test "$hardcode_shlibpath_var" = no; then
              case ":$compile_shlibpath:" in
              case ":$compile_shlibpath:" in
              *":$dir:"*) ;;
              *":$dir:"*) ;;
              *) compile_shlibpath="$compile_shlibpath$dir:";;
              *) compile_shlibpath="$compile_shlibpath$dir:";;
              esac
              esac
              compile_command="$compile_command -l$name"
              compile_command="$compile_command -l$name"
              deplibs="$deplibs -l$name"
              deplibs="$deplibs -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
              compile_command="$compile_command $absdir/$linklib"
              compile_command="$compile_command $absdir/$linklib"
              deplibs="$deplibs $absdir/$linklib"
              deplibs="$deplibs $absdir/$linklib"
            elif test "$hardcode_minus_L" = yes; then
            elif test "$hardcode_minus_L" = yes; then
              case "$compile_command " in
              case "$compile_command " in
              *" -L$absdir "*) ;;
              *" -L$absdir "*) ;;
              *) compile_command="$compile_command -L$absdir";;
              *) compile_command="$compile_command -L$absdir";;
              esac
              esac
              compile_command="$compile_command -l$name"
              compile_command="$compile_command -l$name"
              deplibs="$deplibs -L$absdir -l$name"
              deplibs="$deplibs -L$absdir -l$name"
            elif test "$hardcode_shlibpath_var" = yes; then
            elif test "$hardcode_shlibpath_var" = yes; then
              case ":$compile_shlibpath:" in
              case ":$compile_shlibpath:" in
              *":$absdir:"*) ;;
              *":$absdir:"*) ;;
              *) compile_shlibpath="$compile_shlibpath$absdir:";;
              *) compile_shlibpath="$compile_shlibpath$absdir:";;
              esac
              esac
              compile_command="$compile_command -l$name"
              compile_command="$compile_command -l$name"
              deplibs="$deplibs -l$name"
              deplibs="$deplibs -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
 
 
          # 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
            finalize_command="$finalize_command $libdir/$linklib"
            finalize_command="$finalize_command $libdir/$linklib"
          elif test "$hardcode_minus_L" = yes; then
          elif test "$hardcode_minus_L" = yes; then
            case "$finalize_command " in
            case "$finalize_command " in
            *" -L$libdir "*) ;;
            *" -L$libdir "*) ;;
            *) finalize_command="$finalize_command -L$libdir";;
            *) finalize_command="$finalize_command -L$libdir";;
            esac
            esac
            finalize_command="$finalize_command -l$name"
            finalize_command="$finalize_command -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
            finalize_command="$finalize_command -l$name"
            finalize_command="$finalize_command -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.
            case "$finalize_command " in
            case "$finalize_command " in
            *" -L$dir "*) ;;
            *" -L$dir "*) ;;
            *) finalize_command="$finalize_command -L$libdir";;
            *) finalize_command="$finalize_command -L$libdir";;
            esac
            esac
            finalize_command="$finalize_command -l$name"
            finalize_command="$finalize_command -l$name"
          fi
          fi
        else
        else
          # Transform directly to old archives if we don't build new libraries.
          # Transform directly to old archives if we don't build new libraries.
          if test -n "$pic_flag" && test -z "$old_library"; then
          if test -n "$pic_flag" && test -z "$old_library"; then
            $echo "$modename: cannot find static library for \`$arg'" 1>&2
            $echo "$modename: cannot find static library for \`$arg'" 1>&2
            exit 1
            exit 1
          fi
          fi
 
 
          # 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_command="$compile_command $dir/$linklib"
            compile_command="$compile_command $dir/$linklib"
            finalize_command="$finalize_command $dir/$linklib"
            finalize_command="$finalize_command $dir/$linklib"
          else
          else
            case "$compile_command " in
            case "$compile_command " in
            *" -L$dir "*) ;;
            *" -L$dir "*) ;;
            *) compile_command="$compile_command -L$dir";;
            *) compile_command="$compile_command -L$dir";;
            esac
            esac
            compile_command="$compile_command -l$name"
            compile_command="$compile_command -l$name"
            case "$finalize_command " in
            case "$finalize_command " in
            *" -L$dir "*) ;;
            *" -L$dir "*) ;;
            *) finalize_command="$finalize_command -L$dir";;
            *) finalize_command="$finalize_command -L$dir";;
            esac
            esac
            finalize_command="$finalize_command -l$name"
            finalize_command="$finalize_command -l$name"
          fi
          fi
        fi
        fi
 
 
        # Add in any libraries that this one depends upon.
        # Add in any libraries that this one depends upon.
        compile_command="$compile_command$dependency_libs"
        compile_command="$compile_command$dependency_libs"
        finalize_command="$finalize_command$dependency_libs"
        finalize_command="$finalize_command$dependency_libs"
        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
      esac
 
 
      # 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
    done
 
 
    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
 
 
    oldlibs=
    oldlibs=
    # 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"
 
 
    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
      ;;
      ;;
 
 
    *.a | *.lib)
    *.a | *.lib)
      if test -n "$link_against_libtool_libs"; then
      if test -n "$link_against_libtool_libs"; then
        $echo "$modename: error: cannot link libtool libraries into archives" 1>&2
        $echo "$modename: error: cannot link libtool libraries into archives" 1>&2
        exit 1
        exit 1
      fi
      fi
 
 
      if test -n "$deplibs"; then
      if test -n "$deplibs"; then
        $echo "$modename: warning: \`-l' and \`-L' are ignored for archives" 1>&2
        $echo "$modename: warning: \`-l' and \`-L' are ignored for archives" 1>&2
      fi
      fi
 
 
      if test -n "$dlfiles$dlprefiles"; then
      if test -n "$dlfiles$dlprefiles"; 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"; then
      if test -n "$export_symbols"; 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"
      ;;
      ;;
 
 
    *.la)
    *.la)
      # 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
 
 
      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
 
 
      # 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=
 
 
      if test -n "$objs"; then
      if test -n "$objs"; then
        $echo "$modename: cannot build libtool library \`$output' from non-libtool objects:$objs" 2>&1
        $echo "$modename: cannot build libtool library \`$output' from non-libtool objects:$objs" 2>&1
        exit 1
        exit 1
      fi
      fi
 
 
      # How the heck are we supposed to write a wrapper for a shared library?
      # How the heck are we supposed to write a wrapper for a shared library?
      if test -n "$link_against_libtool_libs"; then
      if test -n "$link_against_libtool_libs"; then
         $echo "$modename: error: cannot link shared libraries into libtool libraries" 1>&2
         $echo "$modename: error: cannot link shared libraries into libtool libraries" 1>&2
         exit 1
         exit 1
      fi
      fi
 
 
      if test -n "$dlfiles$dlprefiles"; then
      if test -n "$dlfiles$dlprefiles"; then
        $echo "$modename: warning: \`-dlopen' is ignored for libtool libraries" 1>&2
        $echo "$modename: warning: \`-dlopen' 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.
          libext=al
          libext=al
          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
        dependency_libs="$deplibs"
        dependency_libs="$deplibs"
 
 
        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]*) ;;
        0 | [1-9] | [1-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]*) ;;
        0 | [1-9] | [1-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]*) ;;
        0 | [1-9] | [1-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) ;;
 
 
        irix)
        irix)
          major=`expr $current - $age + 1`
          major=`expr $current - $age + 1`
          versuffix="$major.$revision"
          versuffix="$major.$revision"
          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
          ;;
          ;;
 
 
        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"
          ;;
          ;;
 
 
        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";
          ;;
          ;;
 
 
        windows)
        windows)
          # Like Linux, but with '-' rather than '.', since we only
          # Like Linux, but with '-' rather than '.', since we only
          # want one extension on Windows 95.
          # want one extension on Windows 95.
          major=`expr $current - $age`
          major=`expr $current - $age`
          versuffix="-$major-$age-$revision"
          versuffix="-$major-$age-$revision"
          ;;
          ;;
 
 
        *)
        *)
          $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
 
 
        dependency_libs="$deplibs"
        dependency_libs="$deplibs"
        case "$host" in
        case "$host" in
        *-*-cygwin* | *-*-mingw* | *-*-os2*)
        *-*-cygwin* | *-*-mingw* | *-*-os2*)
          # these systems don't actually have a c library (as such)!
          # these systems don't actually have a c library (as such)!
          ;;
          ;;
        *)
        *)
          # Add libc to deplibs on all other systems.
          # Add libc to deplibs on all other systems.
          deplibs="$deplibs -lc"
          deplibs="$deplibs -lc"
          ;;
          ;;
        esac
        esac
      fi
      fi
 
 
      # Create the output directory, or remove our outputs if we need to.
      # Create the output directory, or remove our outputs if we need to.
      if test -d $output_objdir; then
      if test -d $output_objdir; then
        $show "${rm}r $output_objdir/$outputname $output_objdir/$libname.* $output_objdir/${libname}${release}.*"
        $show "${rm}r $output_objdir/$outputname $output_objdir/$libname.* $output_objdir/${libname}${release}.*"
        $run ${rm}r $output_objdir/$outputname $output_objdir/$libname.* $output_objdir/${libname}${release}.*
        $run ${rm}r $output_objdir/$outputname $output_objdir/$libname.* $output_objdir/${libname}${release}.*
      else
      else
        $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
 
 
      # 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
 
 
      if test "$build_libtool_libs" = yes; then
      if test "$build_libtool_libs" = yes; then
        # 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)
          newdeplibs=$deplibs
          newdeplibs=$deplibs
                    ;; # 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.
        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
          $C_compiler -o conftest conftest.c $deplibs
          $C_compiler -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 "$name" != "" ; then
              if test "$name" != "" ; 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 "$name" != "" ; then
              if test "$name" != "" ; then
                $rm conftest
                $rm conftest
                $C_compiler -o conftest conftest.c $i
                $C_compiler -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
          deplibs=$newdeplibs
          deplibs=$newdeplibs
          ;;
          ;;
        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 "$name" != "" ; then
            if test "$name" != "" ; then
              libname=`eval \\$echo \"$libname_spec\"`
              libname=`eval \\$echo \"$libname_spec\"`
              for i in $lib_search_path; do
              for i in $lib_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 "$potlib" 2>/dev/null \
                      if ls -lLd "$potlib" 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
                        /*) potlib="$potliblink";;
                        /*) 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\" \
                      if eval $file_magic_cmd \"\$potlib\" \
                         | 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.
          ;;
          ;;
        none | unknown | *) newdeplibs=""
        none | unknown | *) 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
 
 
        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
            dlname=
            dlname=
            library_names=
            library_names=
          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."
          fi
          fi
        fi
        fi
      fi
      fi
 
 
      # 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
        deplibs=$newdeplibs
        deplibs=$newdeplibs
        # Done checking deplibs!
        # Done checking deplibs!
 
 
        # 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
 
 
        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) incase we are running --disable-static
        # (e.g. aix) incase we are running --disable-static
        for obj in $libobjs; do
        for obj in $libobjs; do
          oldobj=`$echo "X$obj" | $Xsed -e "$lo2o"`
          oldobj=`$echo "X$obj" | $Xsed -e "$lo2o"`
          test -f $oldobj || ${LN_S} $obj $oldobj
          test -f $oldobj || ${LN_S} $obj $oldobj
        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`
 
 
        if test -n "$whole_archive_flag_spec"; then
        if test -n "$whole_archive_flag_spec"; then
          if test -n "$convenience"; then
          if test -n "$convenience"; then
            eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
            eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
          fi
          fi
        else
        else
          for xlib in $convenience; do
          for xlib in $convenience; do
            # Extract the objects.
            # Extract the objects.
            xdir="$xlib"x
            xdir="$xlib"x
            generated="$generated $xdir"
            generated="$generated $xdir"
            xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
            xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
 
 
            $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 ../$xlib)"
            $show "(cd $xdir && $AR x ../$xlib)"
            $run eval "(cd \$xdir && $AR x ../\$xlib)" || exit $?
            $run eval "(cd \$xdir && $AR x ../\$xlib)" || exit $?
 
 
            libobjs="$libobjs "`find $xdir -name \*.o -print -o -name \*.lo -print | $NL2SP`
            libobjs="$libobjs "`find $xdir -name \*.o -print -o -name \*.lo -print | $NL2SP`
          done
          done
        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\"
 
 
          linkopts="$linkopts $flag"
          linkopts="$linkopts $flag"
        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
          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="$objdir/$libname.exp"
            export_symbols="$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
 
 
        # 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
        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"
 
 
        # 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
      ;;
      ;;
 
 
    *.lo | *.o | *.obj)
    *.lo | *.o | *.obj)
      if test -n "$link_against_libtool_libs"; then
      if test -n "$link_against_libtool_libs"; then
        $echo "$modename: error: cannot link libtool libraries into objects" 1>&2
        $echo "$modename: error: cannot link libtool libraries into objects" 1>&2
        exit 1
        exit 1
      fi
      fi
 
 
      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"; then
      if test -n "$dlfiles$dlprefiles"; 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"; then
        if test -n "$objs"; 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
 
 
      # Create the old-style object.
      # Create the old-style object.
      reload_objs="$objs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}$'/d' -e '/\.lib$/d' -e "$lo2o" | $NL2SP`
      reload_objs="$objs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}$'/d' -e '/\.lib$/d' -e "$lo2o" | $NL2SP`
 
 
      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.
      test -z "$libobj" && exit 0
      test -z "$libobj" && exit 0
 
 
      if test "$build_libtool_libs" != yes; then
      if test "$build_libtool_libs" != yes; then
        # 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"; then
      if test -n "$pic_flag"; 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_objs="$libobjs"
        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
        $show "$LN_S $obj $libobj"
        $show "$LN_S $obj $libobj"
        $run $LN_S $obj $libobj || exit $?
        $run $LN_S $obj $libobj || exit $?
      fi
      fi
 
 
      exit 0
      exit 0
      ;;
      ;;
 
 
    # Anything else should be a program.
    # Anything else should be a program.
    *)
    *)
      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" = unknown && test "$dlopen_self" = unknown &&
        if test "$dlopen" = 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
 
 
      if test "$dlself" = yes && test "$export_dynamic" = no; then
      if test "$dlself" = yes && test "$export_dynamic" = no; then
        $echo "$modename: error: \`-dlopen self' requires \`-export-dynamic'" 1>&2
        $echo "$modename: error: \`-dlopen self' requires \`-export-dynamic'" 1>&2
        exit 1
        exit 1
      fi
      fi
 
 
      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 "$compile_rpath " in
          case "$compile_rpath " in
          *" $libdir "*) ;;
          *" $libdir "*) ;;
          *) compile_rpath="$compile_rpath $libdir" ;;
          *) compile_rpath="$compile_rpath $libdir" ;;
          esac
          esac
          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
      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"
 
 
      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
 
 
      if test -n "$libobjs" && test "$build_old_libs" = yes; then
      if test -n "$libobjs" && test "$build_old_libs" = yes; then
        # Transform all the library objects into standard objects.
        # Transform all the library objects into standard objects.
        compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
        compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
        finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
        finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
      fi
      fi
 
 
      dlsyms=
      dlsyms=
      if test -n "$dlfiles$dlprefiles" || test "$dlself" = yes; then
      if test -n "$dlfiles$dlprefiles" || test "$dlself" = yes; 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="$objdir/${output}.nm"
          nlist="$objdir/${output}.nm"
 
 
          if test -d $objdir; then
          if test -d $objdir; then
            $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"
          else
          else
            $show "$mkdir $objdir"
            $show "$mkdir $objdir"
            $run $mkdir $objdir
            $run $mkdir $objdir
            status=$?
            status=$?
            if test $status -ne 0 && test ! -d $objdir; then
            if test $status -ne 0 && test ! -d $objdir; then
              exit $status
              exit $status
            fi
            fi
          fi
          fi
 
 
          # Parse the name list into a source file.
          # Parse the name list into a source file.
          $show "creating $objdir/$dlsyms"
          $show "creating $objdir/$dlsyms"
 
 
          $echo > "$objdir/$dlsyms" "\
          $echo > "$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'"
 
 
            echo ': @PROGRAM@ ' > "$nlist"
            echo ': @PROGRAM@ ' > "$nlist"
 
 
            # Add our own program objects to the symbol list.
            # Add our own program objects to the symbol list.
            progfiles=`$echo "X$objs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
            progfiles=`$echo "X$objs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
            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="$objdir/$output.exp"
              export_symbols="$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 $rm $export_symbols
              $run $rm $export_symbols
              $run eval "sed -e 's/\([][.*^$]\)/\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$objdir/$output.exp"'
              $run eval "sed -e 's/\([][.*^$]\)/\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$objdir/$output.exp"'
              $run eval 'grep -f "$objdir/$output.exp" < "$nlist" > "$nlist"T'
              $run eval 'grep -f "$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*)
          *-*-freebsd2*|*-*-freebsd3.0*)
            case "$compile_command " in
            case "$compile_command " in
            *" -static "*) ;;
            *" -static "*) ;;
            *) pic_flag_for_symtable=" $pic_flag -DPIC -DFREEBSD_WORKAROUND";;
            *) pic_flag_for_symtable=" $pic_flag -DPIC -DFREEBSD_WORKAROUND";;
            esac
            esac
          esac
          esac
 
 
          # Now compile the dynamic symbol file.
          # Now compile the dynamic symbol file.
          $show "(cd $objdir && $C_compiler -c$no_builtin_flag$pic_flag_for_symtable \"$dlsyms\")"
          $show "(cd $objdir && $C_compiler -c$no_builtin_flag$pic_flag_for_symtable \"$dlsyms\")"
          $run eval '(cd $objdir && $C_compiler -c$no_builtin_flag$pic_flag_for_symtable "$dlsyms")' || exit $?
          $run eval '(cd $objdir && $C_compiler -c$no_builtin_flag$pic_flag_for_symtable "$dlsyms")' || exit $?
 
 
          # 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@%$objdir/${output}S.${objext}%"`
          compile_command=`$echo "X$compile_command" | $Xsed -e "s%@SYMFILE@%$objdir/${output}S.${objext}%"`
          finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$objdir/${output}S.${objext}%"`
          finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$objdir/${output}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 -z "$link_against_libtool_libs" || test "$build_libtool_libs" != yes; then
      if test -z "$link_against_libtool_libs" || 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"
        exit $?
        exit $?
      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 "$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"
 
 
        # AGH! Flame the AIX and HP-UX people for me, will ya?
        # AGH! Flame the AIX and HP-UX people for me, will ya?
        $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'`
 
 
      # Create the binary in the object directory, then wrap it.
      # Create the binary in the object directory, then wrap it.
      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 $objdir; then
        if test $status -ne 0 && test ! -d $objdir; then
          exit $status
          exit $status
        fi
        fi
      fi
      fi
 
 
      # Delete the old output file.
      # Delete the old output file.
      $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
        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
        $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:
  link_against_libtool_libs='$link_against_libtool_libs'
  link_against_libtool_libs='$link_against_libtool_libs'
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'
  program=lt-'$outputname'
  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 (cd \"\$thisdir\" && eval \$relink_command); then :
      if (cd \"\$thisdir\" && eval \$relink_command); then :
      else
      else
        $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
        *-*-cygwin* | *-*-mingw | *-*-os2*)
        *-*-cygwin* | *-*-mingw | *-*-os2*)
          # 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
          $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 "`$echo "X$libobjs_save" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e '/\.lib$/d' -e "$lo2o" | $NL2SP`
          oldobjs="$objs "`$echo "X$libobjs_save" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e '/\.lib$/d' -e "$lo2o" | $NL2SP`
        fi
        fi
        addlibs="$old_convenience"
        addlibs="$old_convenience"
      fi
      fi
 
 
      # 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.
        xdir="$xlib"x
        xdir="$xlib"x
        generated="$generated $xdir"
        generated="$generated $xdir"
        xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
        xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
 
 
        $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 ../$xlib)"
        $show "(cd $xdir && $AR x ../$xlib)"
        $run eval "(cd \$xdir && $AR x ../\$xlib)" || exit $?
        $run eval "(cd \$xdir && $AR x ../\$xlib)" || exit $?
 
 
        oldobjs="$oldobjs "`find $xdir -name \*.o -print -o -name \*.lo -print | $NL2SP`
        oldobjs="$oldobjs "`find $xdir -name \*.o -print -o -name \*.lo -print | $NL2SP`
      done
      done
 
 
      # 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
        eval cmds=\"$old_archive_cmds\"
        eval cmds=\"$old_archive_cmds\"
      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"
 
 
      if test -n "$xrpath"; then
      if test -n "$xrpath"; then
        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"
        done
        done
        dependency_libs="$temp_xrpath $dependency_libs"
        dependency_libs="$temp_xrpath $dependency_libs"
      fi
      fi
 
 
      # 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
        $echo > $output "\
        $echo > $output "\
# $output - a libtool library file
# $output - a libtool library file
# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
 
 
# The name that we can dlopen(3).
# The name that we can dlopen(3).
dlname='$dlname'
dlname='$dlname'
 
 
# 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=no
installed=no
 
 
# Directory that this library needs to be installed in:
# Directory that this library needs to be installed in:
libdir='$install_libdir'\
libdir='$install_libdir'\
"
"
 
 
        $rm "$output_objdir/$outputname"i
        $rm "$output_objdir/$outputname"i
        sed 's/^installed=no$/installed=yes/' \
        sed 's/^installed=no$/installed=yes/' \
          < "$output" > "$output_objdir/$outputname"i || exit 1
          < "$output" > "$output_objdir/$outputname"i || exit 1
      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; then
    if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh; 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
      *.a | *.lib)
      *.a | *.lib)
        # 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=
        # 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"
 
 
        # 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
 
 
          # Install the shared library and build the symlinks.
          # Install the shared library and build the symlinks.
          $show "$install_prog $dir/$realname $destdir/$realname"
          $show "$install_prog $dir/$realname $destdir/$realname"
          $run eval "$install_prog $dir/$realname $destdir/$realname" || exit $?
          $run eval "$install_prog $dir/$realname $destdir/$realname" || exit $?
          test "X$dlname" = "X$realname" && dlname=
          test "X$dlname" = "X$realname" && dlname=
 
 
          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
              test "X$dlname" = "X$linkname" && dlname=
              test "X$dlname" = "X$linkname" && dlname=
              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
 
 
          if test -n "$dlname"; then
          if test -n "$dlname"; then
            # Install the dynamically-loadable library.
            # Install the dynamically-loadable library.
            $show "$install_prog $dir/$dlname $destdir/$dlname"
            $show "$install_prog $dir/$dlname $destdir/$dlname"
            $run eval "$install_prog $dir/$dlname $destdir/$dlname" || exit $?
            $run eval "$install_prog $dir/$dlname $destdir/$dlname" || exit $?
          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
        if test ! -f "$instname"; then
        if test ! -f "$instname"; then
          # Just in case it was removed...
          # Just in case it was removed...
          $show "Creating $instname"
          $show "Creating $instname"
          $rm "$instname"
          $rm "$instname"
          sed 's/^installed=no$/installed=yes/' "$file" > "$instname"
          sed 's/^installed=no$/installed=yes/' "$file" > "$instname"
        fi
        fi
        $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"`
          ;;
          ;;
        *.o | *.obj)
        *.o | *.obj)
          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
          link_against_libtool_libs=
          link_against_libtool_libs=
          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 "$link_against_libtool_libs"; then
          if test -z "$link_against_libtool_libs"; 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 $link_against_libtool_libs; do
          for lib in $link_against_libtool_libs; 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'`"
            libfile="$libdir/`$echo "X$lib" | $Xsed -e 's%^.*/%%g'`"
            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
 
 
          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; then
            if test "$finalize" = yes; then
              outputname="/tmp/$$-$file"
              outputname="/tmp/$$-$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'`
 
 
              $echo "$modename: warning: relinking \`$file' on behalf of your buggy system linker" 1>&2
              $echo "$modename: warning: relinking \`$file' on behalf of your buggy system linker" 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
              file="$outputname"
              file="$outputname"
            else
            else
              $echo "$modename: warning: cannot relink \`$file' on behalf of your buggy system linker" 1>&2
              $echo "$modename: warning: cannot relink \`$file' on behalf of your buggy system linker" 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
 
 
        $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 $outputname
        test -n "$outputname" && $rm $outputname
        ;;
        ;;
      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 $?
 
 
      # 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 $SHELL $0 --finish$current_libdirs
      exec $SHELL $0 --finish$current_libdirs
      exit 1
      exit 1
    fi
    fi
 
 
    exit 0
    exit 0
    ;;
    ;;
 
 
  # 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 \`-LLIBDIR'"
    echo "specify the full pathname of the library, or use \`-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
      # Export the shlibpath_var.
      # Export the shlibpath_var.
      eval "export $shlibpath_var"
      eval "export $shlibpath_var"
 
 
      # 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 actually exec the command.
      # Now actually exec the command.
      eval "exec \$cmd$args"
      eval "exec \$cmd$args"
 
 
      $echo "$modename: cannot exec \$cmd$args"
      $echo "$modename: cannot exec \$cmd$args"
      exit 1
      exit 1
    else
    else
      # Display what would be done.
      # Display what would be done.
      eval "\$echo \"\$shlibpath_var=\$$shlibpath_var\""
      eval "\$echo \"\$shlibpath_var=\$$shlibpath_var\""
      $echo "export $shlibpath_var"
      $echo "export $shlibpath_var"
      $echo "$cmd$args"
      $echo "$cmd$args"
      exit 0
      exit 0
    fi
    fi
    ;;
    ;;
 
 
  # libtool uninstall mode
  # libtool uninstall mode
  uninstall)
  uninstall)
    modename="$modename: uninstall"
    modename="$modename: uninstall"
    rm="$nonopt"
    rm="$nonopt"
    files=
    files=
 
 
    for arg
    for arg
    do
    do
      case "$arg" in
      case "$arg" in
      -*) 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
 
 
    for file in $files; do
    for file in $files; do
      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=.
      name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
      name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
 
 
      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 $dir/$n"
            rmfiles="$rmfiles $dir/$n"
            test "X$n" = "X$dlname" && dlname=
            test "X$n" = "X$dlname" && dlname=
          done
          done
          test -n "$dlname" && rmfiles="$rmfiles $dir/$dlname"
          test -n "$dlname" && rmfiles="$rmfiles $dir/$dlname"
          test -n "$old_library" && rmfiles="$rmfiles $dir/$old_library"
          test -n "$old_library" && rmfiles="$rmfiles $dir/$old_library"
 
 
          $show "$rm $rmfiles"
          $show "$rm $rmfiles"
          $run $rm $rmfiles
          $run $rm $rmfiles
 
 
          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"
            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"
            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
        ;;
        ;;
 
 
      *.lo)
      *.lo)
        if test "$build_old_libs" = yes; then
        if test "$build_old_libs" = yes; then
          oldobj=`$echo "X$name" | $Xsed -e "$lo2o"`
          oldobj=`$echo "X$name" | $Xsed -e "$lo2o"`
          rmfiles="$rmfiles $dir/$oldobj"
          rmfiles="$rmfiles $dir/$oldobj"
        fi
        fi
        $show "$rm $rmfiles"
        $show "$rm $rmfiles"
        $run $rm $rmfiles
        $run $rm $rmfiles
        ;;
        ;;
 
 
      *)
      *)
        $show "$rm $rmfiles"
        $show "$rm $rmfiles"
        $run $rm $rmfiles
        $run $rm $rmfiles
        ;;
        ;;
      esac
      esac
    done
    done
    exit 0
    exit 0
    ;;
    ;;
 
 
  "")
  "")
    $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
 
 
  $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 # test -z "$show_help"
fi # test -z "$show_help"
 
 
# 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
    --version         print version information
    --version         print version information
 
 
MODE must be one of the following:
MODE must be one of the following:
 
 
      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
  ;;
  ;;
 
 
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
  -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
  -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-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
  -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
 
 
# 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.