Open Source Projects Europe

# aclocal.m4 generated automatically by aclocal 1.5

# Copyright 1996, 1997, 1998, 1999, 2000, 2001

# Free Software Foundation, Inc.

dnl Copyright (C) 2000, 2001, 2002 Loic Dachary <loic@senga.org>

dnl

dnl This program is free software; you can redistribute it and/or modify

dnl it under the terms of the GNU General Public License as published by

dnl the Free Software Foundation; either version 2 of the License, or

dnl (at your option) any later version.

dnl

dnl This program is distributed in the hope that it will be useful,

dnl but WITHOUT ANY WARRANTY; without even the implied warranty of

dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

dnl GNU General Public License for more details.

dnl

dnl You should have received a copy of the GNU General Public License

dnl along with this program; if not, write to the Free Software

dnl Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

dnl

dnl Local autoconf definitions. Try to follow the guidelines of the autoconf

dnl macro repository so that integration in the repository is easy.

dnl To submit a macro to the repository send the macro (one macro per mail)

dnl to Peter Simons <simons@cryp.to>.

dnl The repository itself is at httphttp://savannah.gnu.org/projects/ac-archive/

dnl

dnl @synopsis AC_MANDATORY_HEADER(HEADER-FILE, [ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]])

dnl

dnl Same semantic as AC_CHECK_HEADER except that it aborts the configuration

dnl script if the header file is not found.

dnl

dnl @version $Id: aclocal.m4,v 1.10 2002/09/02 10:51:42 loic Exp $

dnl @author Loic Dachary <loic@senga.org>

dnl

AC_DEFUN([AC_MANDATORY_HEADER],

[dnl Do the transliteration at runtime so arg 1 can be a shell variable.

ac_safe=`echo "$1" | sed 'y%./+-%__p_%'`

AC_MSG_CHECKING([for $1])

AC_CACHE_VAL(ac_cv_header_$ac_safe,

[AC_TRY_CPP([#include <$1>], eval "ac_cv_header_$ac_safe=yes",

  eval "ac_cv_header_$ac_safe=no")])dnl

if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then

  AC_MSG_RESULT(yes)

  ifelse([$2], , :, [$2])

else

  AC_MSG_ERROR(header not found check config.log)

ifelse([$3], , , [$3

])dnl

fi

dnl @synopsis AC_MANDATORY_HEADERS(HEADER-FILE... [, ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]])

dnl

dnl Same semantic as AC_CHECK_HEADERS except that it aborts the configuration

dnl script if one of the headers file is not found.

dnl

dnl @version $Id: aclocal.m4,v 1.10 2002/09/02 10:51:42 loic Exp $

dnl @author Loic Dachary <loic@senga.org>

dnl 

AC_DEFUN([AC_MANDATORY_HEADERS],

[for ac_hdr in $1

do

AC_MANDATORY_HEADER($ac_hdr,

[changequote(, )dnl

  ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`

changequote([, ])dnl

  AC_DEFINE_UNQUOTED($ac_tr_hdr) $2], $3)dnl

done

])

dnl @synopsis AC_MANDATORY_LIB(LIBRARY, FUNCTION [, ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND [, OTHER-LIBRARIES]]])

dnl

dnl Same semantic as AC_CHECK_LIB except that it aborts the configuration

dnl script if the library is not found or compilation fails.

dnl

dnl @version $Id: aclocal.m4,v 1.10 2002/09/02 10:51:42 loic Exp $

dnl @author Loic Dachary <loic@senga.org>

dnl

AC_DEFUN([AC_MANDATORY_LIB],

[AC_MSG_CHECKING([for $2 in -l$1])

dnl Use a cache variable name containing both the library and function name,

dnl because the test really is for library $1 defining function $2, not

dnl just for library $1.  Separate tests with the same $1 and different $2s

dnl may have different results.

ac_lib_var=`echo $1['_']$2 | sed 'y%./+-%__p_%'`

AC_CACHE_VAL(ac_cv_lib_$ac_lib_var,

LIBS="-l$1 $5 $LIBS"

AC_TRY_LINK(dnl

ifelse(AC_LANG, [FORTRAN77], ,

ifelse([$2], [main], , dnl Avoid conflicting decl of main.

[/* Override any gcc2 internal prototype to avoid an error.  */

]ifelse(AC_LANG, CPLUSPLUS, [#ifdef __cplusplus

extern "C"

#endif

])dnl

[/* We use char because int might match the return type of a gcc2

    builtin and then its argument prototype would still apply.  */

char $2();

])),

      [$2()],

      eval "ac_cv_lib_$ac_lib_var=yes",

      eval "ac_cv_lib_$ac_lib_var=no")

])dnl

if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then

  AC_MSG_RESULT(yes)

  ifelse([$3], ,

[changequote(, )dnl

  ac_tr_lib=HAVE_LIB`echo $1 | sed -e 's/[^a-zA-Z0-9_]/_/g' \

    -e 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/'`

changequote([, ])dnl

  AC_DEFINE_UNQUOTED($ac_tr_lib)

  LIBS="-l$1 $LIBS"

], [$3])

else

  AC_MSG_ERROR(library not found check config.log)

ifelse([$4], , , [$4

])dnl

fi

])

dnl @synopsis AC_COMPILE_WARNINGS

dnl

dnl Set the maximum warning verbosity according to compiler used.

dnl Currently supports g++ and gcc.

dnl This macro must be put after AC_PROG_CC and AC_PROG_CXX in

dnl configure.in

dnl

dnl @version $Id: aclocal.m4,v 1.10 2002/09/02 10:51:42 loic Exp $

dnl @author Loic Dachary <loic@senga.org>

dnl

AC_DEFUN(AC_COMPILE_WARNINGS,

[AC_MSG_CHECKING(maximum warning verbosity option)

if test -n "$CXX"

then

  if test "$GXX" = "yes"

  then

    ac_compile_warnings_opt='-Wall -Woverloaded-virtual'

  fi

  CXXFLAGS="$CXXFLAGS $ac_compile_warnings_opt"

  ac_compile_warnings_msg="$ac_compile_warnings_opt for C++"

fi

if test -n "$CC"

then

  if test "$GCC" = "yes"

  then

    ac_compile_warnings_opt='-Wall -Wmissing-declarations -Wmissing-prototypes'

  fi

  CFLAGS="$CFLAGS $ac_compile_warnings_opt"

  ac_compile_warnings_msg="$ac_compile_warnings_msg $ac_compile_warnings_opt for C"

fi

AC_MSG_RESULT($ac_compile_warnings_msg)

unset ac_compile_warnings_msg

unset ac_compile_warnings_opt

])

# Do all the work for Automake.  This macro actually does too much --

# some checks are only needed if your package does certain things.

# But this isn't really a big deal.

# serial 5

# There are a few dirty hacks below to avoid letting `AC_PROG_CC' be

# written in clear, in which case automake, when reading aclocal.m4,

# will think it sees a *use*, and therefore will trigger all it's

# C support machinery.  Also note that it means that autoscan, seeing

# CC etc. in the Makefile, will ask for an AC_PROG_CC use...

# We require 2.13 because we rely on SHELL being computed by configure.

AC_PREREQ([2.13])

# AC_PROVIDE_IFELSE(MACRO-NAME, IF-PROVIDED, IF-NOT-PROVIDED)

# -----------------------------------------------------------

# If MACRO-NAME is provided do IF-PROVIDED, else IF-NOT-PROVIDED.

# The purpose of this macro is to provide the user with a means to

# check macros which are provided without letting her know how the

# information is coded.

# If this macro is not defined by Autoconf, define it here.

ifdef([AC_PROVIDE_IFELSE],

      [],

      [define([AC_PROVIDE_IFELSE],

              [ifdef([AC_PROVIDE_$1],

                     [$2], [$3])])])

# AM_INIT_AUTOMAKE(PACKAGE,VERSION, [NO-DEFINE])

# ----------------------------------------------

AC_DEFUN([AM_INIT_AUTOMAKE],

[AC_REQUIRE([AC_PROG_INSTALL])dnl

# test to see if srcdir already configured

if test "`CDPATH=:; cd $srcdir && pwd`" != "`pwd`" &&

   test -f $srcdir/config.status; then

  AC_MSG_ERROR([source directory already configured; run \"make distclean\" there first])

fi

# Define the identity of the package.

PACKAGE=$1

AC_SUBST(PACKAGE)dnl

VERSION=$2

AC_SUBST(VERSION)dnl

ifelse([$3],,

[AC_DEFINE_UNQUOTED(PACKAGE, "$PACKAGE", [Name of package])

AC_DEFINE_UNQUOTED(VERSION, "$VERSION", [Version number of package])])

# Autoconf 2.50 wants to disallow AM_ names.  We explicitly allow

# the ones we care about.

ifdef([m4_pattern_allow],

      [m4_pattern_allow([^AM_[A-Z]+FLAGS])])dnl

# Autoconf 2.50 always computes EXEEXT.  However we need to be

# compatible with 2.13, for now.  So we always define EXEEXT, but we

# don't compute it.

AC_SUBST(EXEEXT)

# Similar for OBJEXT -- only we only use OBJEXT if the user actually

# requests that it be used.  This is a bit dumb.

: ${OBJEXT=o}

AC_SUBST(OBJEXT)

# Some tools Automake needs.

AC_REQUIRE([AM_SANITY_CHECK])dnl

AC_REQUIRE([AC_ARG_PROGRAM])dnl

AM_MISSING_PROG(ACLOCAL, aclocal)

AM_MISSING_PROG(AUTOCONF, autoconf)

AM_MISSING_PROG(AUTOMAKE, automake)

AM_MISSING_PROG(AUTOHEADER, autoheader)

AM_MISSING_PROG(MAKEINFO, makeinfo)

AM_MISSING_PROG(AMTAR, tar)

AM_PROG_INSTALL_SH

AM_PROG_INSTALL_STRIP

# We need awk for the "check" target.  The system "awk" is bad on

# some platforms.

AC_REQUIRE([AC_PROG_AWK])dnl

AC_REQUIRE([AC_PROG_MAKE_SET])dnl

AC_REQUIRE([AM_DEP_TRACK])dnl

AC_REQUIRE([AM_SET_DEPDIR])dnl

AC_PROVIDE_IFELSE([AC_PROG_][CC],

                  [_AM_DEPENDENCIES(CC)],

                  [define([AC_PROG_][CC],

                          defn([AC_PROG_][CC])[_AM_DEPENDENCIES(CC)])])dnl

AC_PROVIDE_IFELSE([AC_PROG_][CXX],

                  [_AM_DEPENDENCIES(CXX)],

                  [define([AC_PROG_][CXX],

                          defn([AC_PROG_][CXX])[_AM_DEPENDENCIES(CXX)])])dnl

])

#

# Check to make sure that the build environment is sane.

#

# serial 3

# AM_SANITY_CHECK

# ---------------

AC_DEFUN([AM_SANITY_CHECK],

[AC_MSG_CHECKING([whether build environment is sane])

# Just in case

sleep 1

echo timestamp > conftest.file

# Do `set' in a subshell so we don't clobber the current shell's

# arguments.  Must try -L first in case configure is actually a

# symlink; some systems play weird games with the mod time of symlinks

# (eg FreeBSD returns the mod time of the symlink's containing

# directory).

if (

   set X `ls -Lt $srcdir/configure conftest.file 2> /dev/null`

   if test "$[*]" = "X"; then

      # -L didn't work.

      set X `ls -t $srcdir/configure conftest.file`

   rm -f conftest.file

   if test "$[*]" != "X $srcdir/configure conftest.file" \

      && test "$[*]" != "X conftest.file $srcdir/configure"; then

      # If neither matched, then we have a broken ls.  This can happen

      # if, for instance, CONFIG_SHELL is bash and it inherits a

      # broken ls alias from the environment.  This has actually

      # happened.  Such a system could not be considered "sane".

      AC_MSG_ERROR([ls -t appears to fail.  Make sure there is not a broken

alias in your environment])

   fi

   test "$[2]" = conftest.file

then

   # Ok.

   :

else

   AC_MSG_ERROR([newly created file is older than distributed files!

Check your system clock])

fi

AC_MSG_RESULT(yes)])

# serial 2

# AM_MISSING_PROG(NAME, PROGRAM)

# ------------------------------

AC_DEFUN([AM_MISSING_PROG],

[AC_REQUIRE([AM_MISSING_HAS_RUN])

$1=${$1-"${am_missing_run}$2"}

AC_SUBST($1)])

# AM_MISSING_HAS_RUN

# ------------------

# Define MISSING if not defined so far and test if it supports --run.

# If it does, set am_missing_run to use it, otherwise, to nothing.

AC_DEFUN([AM_MISSING_HAS_RUN],

[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl

test x"${MISSING+set}" = xset || MISSING="\${SHELL} $am_aux_dir/missing"

# Use eval to expand $SHELL

if eval "$MISSING --run true"; then

  am_missing_run="$MISSING --run "

else

  am_missing_run=

  am_backtick='`'

  AC_MSG_WARN([${am_backtick}missing' script is too old or missing])

fi

])

# AM_AUX_DIR_EXPAND

# For projects using AC_CONFIG_AUX_DIR([foo]), Autoconf sets

# $ac_aux_dir to `$srcdir/foo'.  In other projects, it is set to

# `$srcdir', `$srcdir/..', or `$srcdir/../..'.

#

# Of course, Automake must honor this variable whenever it calls a

# tool from the auxiliary directory.  The problem is that $srcdir (and

# therefore $ac_aux_dir as well) can be either absolute or relative,

# depending on how configure is run.  This is pretty annoying, since

# it makes $ac_aux_dir quite unusable in subdirectories: in the top

# source directory, any form will work fine, but in subdirectories a

# relative path needs to be adjusted first.

#

# $ac_aux_dir/missing

#    fails when called from a subdirectory if $ac_aux_dir is relative

# $top_srcdir/$ac_aux_dir/missing

#    fails if $ac_aux_dir is absolute,

#    fails when called from a subdirectory in a VPATH build with

#          a relative $ac_aux_dir

#

# The reason of the latter failure is that $top_srcdir and $ac_aux_dir

# are both prefixed by $srcdir.  In an in-source build this is usually

# harmless because $srcdir is `.', but things will broke when you

# start a VPATH build or use an absolute $srcdir.

#

# So we could use something similar to $top_srcdir/$ac_aux_dir/missing,

# iff we strip the leading $srcdir from $ac_aux_dir.  That would be:

#   am_aux_dir='\$(top_srcdir)/'`expr "$ac_aux_dir" : "$srcdir//*\(.*\)"`

# and then we would define $MISSING as

#   MISSING="\${SHELL} $am_aux_dir/missing"

# This will work as long as MISSING is not called from configure, because

# unfortunately $(top_srcdir) has no meaning in configure.

# However there are other variables, like CC, which are often used in

# configure, and could therefore not use this "fixed" $ac_aux_dir.

#

# Another solution, used here, is to always expand $ac_aux_dir to an

# absolute PATH.  The drawback is that using absolute paths prevent a

# configured tree to be moved without reconfiguration.

AC_DEFUN([AM_AUX_DIR_EXPAND], [

# expand $ac_aux_dir to an absolute path

am_aux_dir=`CDPATH=:; cd $ac_aux_dir && pwd`

])

# AM_PROG_INSTALL_SH

# ------------------

# Define $install_sh.

AC_DEFUN([AM_PROG_INSTALL_SH],

[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl

install_sh=${install_sh-"$am_aux_dir/install-sh"}

AC_SUBST(install_sh)])

# One issue with vendor `install' (even GNU) is that you can't

# specify the program used to strip binaries.  This is especially

# annoying in cross-compiling environments, where the build's strip

# is unlikely to handle the host's binaries.

# Fortunately install-sh will honor a STRIPPROG variable, so we

# always use install-sh in `make install-strip', and initialize

# STRIPPROG with the value of the STRIP variable (set by the user).

AC_DEFUN([AM_PROG_INSTALL_STRIP],

[AC_REQUIRE([AM_PROG_INSTALL_SH])dnl

INSTALL_STRIP_PROGRAM="\${SHELL} \$(install_sh) -c -s"

AC_SUBST([INSTALL_STRIP_PROGRAM])])

# serial 4                        -*- Autoconf -*-

# There are a few dirty hacks below to avoid letting `AC_PROG_CC' be

# written in clear, in which case automake, when reading aclocal.m4,

# will think it sees a *use*, and therefore will trigger all it's

# C support machinery.  Also note that it means that autoscan, seeing

# CC etc. in the Makefile, will ask for an AC_PROG_CC use...

# _AM_DEPENDENCIES(NAME)

# ---------------------

# See how the compiler implements dependency checking.

# NAME is "CC", "CXX" or "OBJC".

# We try a few techniques and use that to set a single cache variable.

#

# We don't AC_REQUIRE the corresponding AC_PROG_CC since the latter was

# modified to invoke _AM_DEPENDENCIES(CC); we would have a circular

# dependency, and given that the user is not expected to run this macro,

# just rely on AC_PROG_CC.

AC_DEFUN([_AM_DEPENDENCIES],

[AC_REQUIRE([AM_SET_DEPDIR])dnl

AC_REQUIRE([AM_OUTPUT_DEPENDENCY_COMMANDS])dnl

AC_REQUIRE([AM_MAKE_INCLUDE])dnl

AC_REQUIRE([AM_DEP_TRACK])dnl

ifelse([$1], CC,   [depcc="$CC"   am_compiler_list=],

       [$1], CXX,  [depcc="$CXX"  am_compiler_list=],

       [$1], OBJC, [depcc="$OBJC" am_compiler_list='gcc3 gcc']

       [$1], GCJ,  [depcc="$GCJ"  am_compiler_list='gcc3 gcc'],

                   [depcc="$$1"   am_compiler_list=])

AC_CACHE_CHECK([dependency style of $depcc],

               [am_cv_$1_dependencies_compiler_type],

[if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then

  # We make a subdir and do the tests there.  Otherwise we can end up

  # making bogus files that we don't know about and never remove.  For

  # instance it was reported that on HP-UX the gcc test will end up

  # making a dummy file named `D' -- because `-MD' means `put the output

  # in D'.

  mkdir conftest.dir

  # Copy depcomp to subdir because otherwise we won't find it if we're

  # using a relative directory.

  cp "$am_depcomp" conftest.dir

  cd conftest.dir

  am_cv_$1_dependencies_compiler_type=none

  if test "$am_compiler_list" = ""; then

     am_compiler_list=`sed -n ['s/^#*\([a-zA-Z0-9]*\))$/\1/p'] < ./depcomp`

  fi

  for depmode in $am_compiler_list; do

    # We need to recreate these files for each test, as the compiler may

    # overwrite some of them when testing with obscure command lines.

    # This happens at least with the AIX C compiler.

    echo '#include "conftest.h"' > conftest.c

    echo 'int i;' > conftest.h

    echo "${am__include} ${am__quote}conftest.Po${am__quote}" > confmf

    case $depmode in

    nosideeffect)

      # after this tag, mechanisms are not by side-effect, so they'll

      # only be used when explicitly requested

      if test "x$enable_dependency_tracking" = xyes; then

  continue

      else

  break

      ;;

    none) break ;;

    esac

    # We check with `-c' and `-o' for the sake of the "dashmstdout"

    # mode.  It turns out that the SunPro C++ compiler does not properly

    # handle `-M -o', and we need to detect this.

    if depmode=$depmode \

       source=conftest.c object=conftest.o \

       depfile=conftest.Po tmpdepfile=conftest.TPo \

       $SHELL ./depcomp $depcc -c conftest.c -o conftest.o >/dev/null 2>&1 &&

       grep conftest.h conftest.Po > /dev/null 2>&1 &&

       ${MAKE-make} -s -f confmf > /dev/null 2>&1; then

      am_cv_$1_dependencies_compiler_type=$depmode

      break

    fi

  done

  cd ..

  rm -rf conftest.dir

else

  am_cv_$1_dependencies_compiler_type=none

fi

])

$1DEPMODE="depmode=$am_cv_$1_dependencies_compiler_type"

AC_SUBST([$1DEPMODE])

])

# AM_SET_DEPDIR

# -------------

# Choose a directory name for dependency files.

# This macro is AC_REQUIREd in _AM_DEPENDENCIES

AC_DEFUN([AM_SET_DEPDIR],

[rm -f .deps 2>/dev/null

mkdir .deps 2>/dev/null

if test -d .deps; then

  DEPDIR=.deps

else

  # MS-DOS does not allow filenames that begin with a dot.

  DEPDIR=_deps

fi

rmdir .deps 2>/dev/null

AC_SUBST(DEPDIR)

])

# AM_DEP_TRACK

# ------------

AC_DEFUN([AM_DEP_TRACK],

[AC_ARG_ENABLE(dependency-tracking,

[  --disable-dependency-tracking Speeds up one-time builds

  --enable-dependency-tracking  Do not reject slow dependency extractors])

if test "x$enable_dependency_tracking" != xno; then

  am_depcomp="$ac_aux_dir/depcomp"

  AMDEPBACKSLASH='\'

fi

AM_CONDITIONAL([AMDEP], [test "x$enable_dependency_tracking" != xno])

pushdef([subst], defn([AC_SUBST]))

subst(AMDEPBACKSLASH)

popdef([subst])

])

# Generate code to set up dependency tracking.

# This macro should only be invoked once -- use via AC_REQUIRE.

# Usage:

# AM_OUTPUT_DEPENDENCY_COMMANDS

#

# This code is only required when automatic dependency tracking

# is enabled.  FIXME.  This creates each `.P' file that we will

# need in order to bootstrap the dependency handling code.

AC_DEFUN([AM_OUTPUT_DEPENDENCY_COMMANDS],[

AC_OUTPUT_COMMANDS([

test x"$AMDEP_TRUE" != x"" ||

for mf in $CONFIG_FILES; do

  case "$mf" in

  Makefile) dirpart=.;;

  */Makefile) dirpart=`echo "$mf" | sed -e 's|/[^/]*$||'`;;

  *) continue;;

  esac

  grep '^DEP_FILES *= *[^ #]' < "$mf" > /dev/null || continue

  # Extract the definition of DEP_FILES from the Makefile without

  # running `make'.

  DEPDIR=`sed -n -e '/^DEPDIR = / s///p' < "$mf"`

  test -z "$DEPDIR" && continue

  # When using ansi2knr, U may be empty or an underscore; expand it

  U=`sed -n -e '/^U = / s///p' < "$mf"`

  test -d "$dirpart/$DEPDIR" || mkdir "$dirpart/$DEPDIR"

  # We invoke sed twice because it is the simplest approach to

  # changing $(DEPDIR) to its actual value in the expansion.

  for file in `sed -n -e '

    /^DEP_FILES = .*\\\\$/ {

      s/^DEP_FILES = //

      :loop

  s/\\\\$//

  p

  n

  /\\\\$/ b loop

      p

    }

    /^DEP_FILES = / s/^DEP_FILES = //p' < "$mf" | \

       sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g' -e 's/\$U/'"$U"'/g'`; do

    # Make sure the directory exists.

    test -f "$dirpart/$file" && continue

    fdir=`echo "$file" | sed -e 's|/[^/]*$||'`

    $ac_aux_dir/mkinstalldirs "$dirpart/$fdir" > /dev/null 2>&1

    # echo "creating $dirpart/$file"

    echo '# dummy' > "$dirpart/$file"

  done

done

], [AMDEP_TRUE="$AMDEP_TRUE"

ac_aux_dir="$ac_aux_dir"])])

# AM_MAKE_INCLUDE()

# -----------------

# Check to see how make treats includes.

AC_DEFUN([AM_MAKE_INCLUDE],

[am_make=${MAKE-make}

cat > confinc << 'END'

doit:

  @echo done

END

# If we don't find an include directive, just comment out the code.

AC_MSG_CHECKING([for style of include used by $am_make])

am__include='#'

am__quote=

_am_result=none

# First try GNU make style include.

echo "include confinc" > confmf

# We grep out `Entering directory' and `Leaving directory'

# messages which can occur if `w' ends up in MAKEFLAGS.

# In particular we don't look at `^make:' because GNU make might

# be invoked under some other name (usually "gmake"), in which

# case it prints its new name instead of `make'.

if test "`$am_make -s -f confmf 2> /dev/null | fgrep -v 'ing directory'`" = "done"; then

   am__include=include

   am__quote=

   _am_result=GNU

fi

# Now try BSD make style include.

if test "$am__include" = "#"; then

   echo '.include "confinc"' > confmf

   if test "`$am_make -s -f confmf 2> /dev/null`" = "done"; then

      am__include=.include

      am__quote='"'

      _am_result=BSD

   fi

fi

AC_SUBST(am__include)

AC_SUBST(am__quote)

AC_MSG_RESULT($_am_result)

rm -f confinc confmf

])

# serial 3

# AM_CONDITIONAL(NAME, SHELL-CONDITION)

# -------------------------------------

# Define a conditional.

#

# FIXME: Once using 2.50, use this:

# m4_match([$1], [^TRUE\|FALSE$], [AC_FATAL([$0: invalid condition: $1])])dnl

AC_DEFUN([AM_CONDITIONAL],

[ifelse([$1], [TRUE],

        [errprint(__file__:__line__: [$0: invalid condition: $1

])dnl

m4exit(1)])dnl

ifelse([$1], [FALSE],

       [errprint(__file__:__line__: [$0: invalid condition: $1

])dnl

m4exit(1)])dnl

AC_SUBST([$1_TRUE])

AC_SUBST([$1_FALSE])

if $2; then

  $1_TRUE=

  $1_FALSE='#'

else

  $1_TRUE='#'

  $1_FALSE=

fi])

# Like AC_CONFIG_HEADER, but automatically create stamp file.

# serial 3

# When config.status generates a header, we must update the stamp-h file.

# This file resides in the same directory as the config header

# that is generated.  We must strip everything past the first ":",

# and everything past the last "/".

AC_PREREQ([2.12])

AC_DEFUN([AM_CONFIG_HEADER],

[ifdef([AC_FOREACH],dnl

   [dnl init our file count if it isn't already

   m4_ifndef([_AM_Config_Header_Index], m4_define([_AM_Config_Header_Index], [0]))

   dnl prepare to store our destination file list for use in config.status

   AC_FOREACH([_AM_File], [$1],

          [m4_pushdef([_AM_Dest], m4_patsubst(_AM_File, [:.*]))

          m4_define([_AM_Config_Header_Index], m4_incr(_AM_Config_Header_Index))

          dnl and add it to the list of files AC keeps track of, along

          dnl with our hook

          AC_CONFIG_HEADERS(_AM_File,

dnl COMMANDS, [, INIT-CMDS]

[# update the timestamp

echo timestamp >"AS_ESCAPE(_AM_DIRNAME(]_AM_Dest[))/stamp-h]_AM_Config_Header_Index["

][$2]m4_ifval([$3], [, [$3]]))dnl AC_CONFIG_HEADERS

          m4_popdef([_AM_Dest])])],dnl

[AC_CONFIG_HEADER([$1])

  AC_OUTPUT_COMMANDS(

   ifelse(patsubst([$1], [[^ ]], []),

    [],

    [test -z "$CONFIG_HEADERS" || echo timestamp >dnl

     patsubst([$1], [^\([^:]*/\)?.*], [\1])stamp-h]),dnl

[am_indx=1

for am_file in $1; do

  case " \$CONFIG_HEADERS " in

  *" \$am_file "*)

    am_dir=\`echo \$am_file |sed 's%:.*%%;s%[^/]*\$%%'\`

    if test -n "\$am_dir"; then

      am_tmpdir=\`echo \$am_dir |sed 's%^\(/*\).*\$%\1%'\`

      for am_subdir in \`echo \$am_dir |sed 's%/% %'\`; do

        am_tmpdir=\$am_tmpdir\$am_subdir/

        if test ! -d \$am_tmpdir; then

          mkdir \$am_tmpdir

        fi

      done

    fi

    echo timestamp > "\$am_dir"stamp-h\$am_indx

    ;;

  esac

  am_indx=\`expr \$am_indx + 1\`

done])

])]) # AM_CONFIG_HEADER

# _AM_DIRNAME(PATH)

# -----------------

# Like AS_DIRNAME, only do it during macro expansion

AC_DEFUN([_AM_DIRNAME],

       [m4_if(m4_regexp([$1], [^.*[^/]//*[^/][^/]*/*$]), -1,

        m4_if(m4_regexp([$1], [^//\([^/]\|$\)]), -1,

          m4_if(m4_regexp([$1], [^/.*]), -1,

            [.],

            m4_patsubst([$1], [^\(/\).*], [\1])),

          m4_patsubst([$1], [^\(//\)\([^/].*\|$\)], [\1])),

        m4_patsubst([$1], [^\(.*[^/]\)//*[^/][^/]*/*$], [\1]))[]dnl

]) # _AM_DIRNAME

# libtool.m4 - Configure libtool for the host system. -*-Shell-script-*-

# serial 46 AC_PROG_LIBTOOL

AC_DEFUN([AC_PROG_LIBTOOL],

[AC_REQUIRE([AC_LIBTOOL_SETUP])dnl

# This can be used to rebuild libtool when needed

LIBTOOL_DEPS="$ac_aux_dir/ltmain.sh"

# Always use our own libtool.

LIBTOOL='$(SHELL) $(top_builddir)/libtool'

AC_SUBST(LIBTOOL)dnl

# Prevent multiple expansion

define([AC_PROG_LIBTOOL], [])

])

AC_DEFUN([AC_LIBTOOL_SETUP],

[AC_PREREQ(2.13)dnl

AC_REQUIRE([AC_ENABLE_SHARED])dnl

AC_REQUIRE([AC_ENABLE_STATIC])dnl

AC_REQUIRE([AC_ENABLE_FAST_INSTALL])dnl

AC_REQUIRE([AC_CANONICAL_HOST])dnl

AC_REQUIRE([AC_CANONICAL_BUILD])dnl

AC_REQUIRE([AC_PROG_CC])dnl

AC_REQUIRE([AC_PROG_LD])dnl

AC_REQUIRE([AC_PROG_LD_RELOAD_FLAG])dnl

AC_REQUIRE([AC_PROG_NM])dnl

AC_REQUIRE([LT_AC_PROG_SED])dnl

AC_REQUIRE([AC_PROG_LN_S])dnl

AC_REQUIRE([AC_DEPLIBS_CHECK_METHOD])dnl

AC_REQUIRE([AC_OBJEXT])dnl

AC_REQUIRE([AC_EXEEXT])dnl

dnl

_LT_AC_PROG_ECHO_BACKSLASH

# Only perform the check for file, if the check method requires it

case $deplibs_check_method in

file_magic*)

  if test "$file_magic_cmd" = '$MAGIC_CMD'; then

    AC_PATH_MAGIC

  fi

  ;;

esac

AC_CHECK_TOOL(RANLIB, ranlib, :)

AC_CHECK_TOOL(STRIP, strip, :)

ifdef([AC_PROVIDE_AC_LIBTOOL_DLOPEN], enable_dlopen=yes, enable_dlopen=no)

ifdef([AC_PROVIDE_AC_LIBTOOL_WIN32_DLL],

enable_win32_dll=yes, enable_win32_dll=no)

AC_ARG_ENABLE(libtool-lock,

  [  --disable-libtool-lock  avoid locking (might break parallel builds)])

test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes

# Some flags need to be propagated to the compiler or linker for good

# libtool support.

case $host in

*-*-irix6*)

  # Find out which ABI we are using.

  echo '[#]line __oline__ "configure"' > conftest.$ac_ext

  if AC_TRY_EVAL(ac_compile); then

    case `/usr/bin/file conftest.$ac_objext` in

    *32-bit*)

      LD="${LD-ld} -32"

      ;;

    *N32*)

      LD="${LD-ld} -n32"

      ;;

    *64-bit*)

      LD="${LD-ld} -64"

      ;;

    esac

  fi

  rm -rf conftest*

  ;;

*-*-sco3.2v5*)

  # On SCO OpenServer 5, we need -belf to get full-featured binaries.

  SAVE_CFLAGS="$CFLAGS"

  CFLAGS="$CFLAGS -belf"

  AC_CACHE_CHECK([whether the C compiler needs -belf], lt_cv_cc_needs_belf,

    [AC_LANG_SAVE

     AC_LANG_C

     AC_TRY_LINK([],[],[lt_cv_cc_needs_belf=yes],[lt_cv_cc_needs_belf=no])

     AC_LANG_RESTORE])

  if test x"$lt_cv_cc_needs_belf" != x"yes"; then

    # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf

    CFLAGS="$SAVE_CFLAGS"

  fi

  ;;

ifdef([AC_PROVIDE_AC_LIBTOOL_WIN32_DLL],

[*-*-cygwin* | *-*-mingw* | *-*-pw32*)

  AC_CHECK_TOOL(DLLTOOL, dlltool, false)

  AC_CHECK_TOOL(AS, as, false)

  AC_CHECK_TOOL(OBJDUMP, objdump, false)

  # recent cygwin and mingw systems supply a stub DllMain which the user

  # can override, but on older systems we have to supply one

  AC_CACHE_CHECK([if libtool should supply DllMain function], lt_cv_need_dllmain,

    [AC_TRY_LINK([],

      [extern int __attribute__((__stdcall__)) DllMain(void*, int, void*);

      DllMain (0, 0, 0);],

      [lt_cv_need_dllmain=no],[lt_cv_need_dllmain=yes])])

  case $host/$CC in

  *-*-cygwin*/gcc*-mno-cygwin*|*-*-mingw*)

    # old mingw systems require "-dll" to link a DLL, while more recent ones

    # require "-mdll"

    SAVE_CFLAGS="$CFLAGS"

    CFLAGS="$CFLAGS -mdll"

    AC_CACHE_CHECK([how to link DLLs], lt_cv_cc_dll_switch,

      [AC_TRY_LINK([], [], [lt_cv_cc_dll_switch=-mdll],[lt_cv_cc_dll_switch=-dll])])

    CFLAGS="$SAVE_CFLAGS" ;;

  *-*-cygwin* | *-*-pw32*)

    # cygwin systems need to pass --dll to the linker, and not link

    # crt.o which will require a WinMain@16 definition.

    lt_cv_cc_dll_switch="-Wl,--dll -nostartfiles" ;;

  esac

  ;;

  ])

esac

_LT_AC_LTCONFIG_HACK

])

# AC_LIBTOOL_HEADER_ASSERT

# ------------------------

AC_DEFUN([AC_LIBTOOL_HEADER_ASSERT],

[AC_CACHE_CHECK([whether $CC supports assert without backlinking],

    [lt_cv_func_assert_works],

    [case $host in

    *-*-solaris*)

      if test "$GCC" = yes && test "$with_gnu_ld" != yes; then

        case `$CC --version 2>/dev/null` in

        [[12]].*) lt_cv_func_assert_works=no ;;

        *)        lt_cv_func_assert_works=yes ;;

        esac

      fi

      ;;

    esac])

if test "x$lt_cv_func_assert_works" = xyes; then

  AC_CHECK_HEADERS(assert.h)

fi

])# AC_LIBTOOL_HEADER_ASSERT

# _LT_AC_CHECK_DLFCN

# --------------------

AC_DEFUN([_LT_AC_CHECK_DLFCN],

[AC_CHECK_HEADERS(dlfcn.h)

])# _LT_AC_CHECK_DLFCN

# AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE

# ---------------------------------

AC_DEFUN([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE],

[AC_REQUIRE([AC_CANONICAL_HOST])

AC_REQUIRE([AC_PROG_NM])

AC_REQUIRE([AC_OBJEXT])

# Check for command to grab the raw symbol name followed by C symbol from nm.

AC_MSG_CHECKING([command to parse $NM output])

AC_CACHE_VAL([lt_cv_sys_global_symbol_pipe], [dnl

# These are sane defaults that work on at least a few old systems.

# [They come from Ultrix.  What could be older than Ultrix?!! ;)]

# Character class describing NM global symbol codes.

symcode='[[BCDEGRST]]'

# Regexp to match symbols that can be accessed directly from C.

sympat='\([[_A-Za-z]][[_A-Za-z0-9]]*\)'

# Transform the above into a raw symbol and a C symbol.

symxfrm='\1 \2\3 \3'

# Transform an extracted symbol line into a proper C declaration

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

# Transform an extracted symbol line into symbol name and symbol address

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

# Define system-specific variables.

case $host_os in

aix*)

  symcode='[[BCDT]]'

  ;;

cygwin* | mingw* | pw32*)

  symcode='[[ABCDGISTW]]'

  ;;

hpux*) # Its linker distinguishes data from code symbols

  lt_cv_global_symbol_to_cdecl="sed -n -e 's/^T .* \(.*\)$/extern char \1();/p' -e 's/^$symcode* .* \(.*\)$/extern char \1;/p'"

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

  ;;

irix* | nonstopux*)

  symcode='[[BCDEGRST]]'

  ;;

solaris* | sysv5*)

  symcode='[[BDT]]'

  ;;

sysv4)

  symcode='[[DFNSTU]]'

  ;;

esac

# Handle CRLF in mingw tool chain

opt_cr=

case $host_os in

mingw*)

  opt_cr=`echo 'x\{0,1\}' | tr x '\015'` # option cr in regexp

  ;;

esac

# If we're using GNU nm, then use its standard symbol codes.

if $NM -V 2>&1 | egrep '(GNU|with BFD)' > /dev/null; then

  symcode='[[ABCDGISTW]]'

fi

# Try without a prefix undercore, then with it.

for ac_symprfx in "" "_"; do

  # Write the raw and C identifiers.

lt_cv_sys_global_symbol_pipe="sed -n -e 's/^.*[[  ]]\($symcode$symcode*\)[[   ]][[    ]]*\($ac_symprfx\)$sympat$opt_cr$/$symxfrm/p'"

  # Check to see that the pipe works correctly.

  pipe_works=no

  rm -f conftest*

  cat > conftest.$ac_ext <<EOF

#ifdef __cplusplus

extern "C" {

#endif

char nm_test_var;

void nm_test_func(){}

#ifdef __cplusplus

}

#endif

int main(){nm_test_var='a';nm_test_func();return(0);}

EOF

  if AC_TRY_EVAL(ac_compile); then

    # Now try to grab the symbols.

    nlist=conftest.nm

    if AC_TRY_EVAL(NM conftest.$ac_objext \| $lt_cv_sys_global_symbol_pipe \> $nlist) && test -s "$nlist"; then

      # Try sorting and uniquifying the output.

      if sort "$nlist" | uniq > "$nlist"T; then

  mv -f "$nlist"T "$nlist"

      else

  rm -f "$nlist"T

      fi

      # Make sure that we snagged all the symbols we need.

      if egrep ' nm_test_var$' "$nlist" >/dev/null; then

  if egrep ' nm_test_func$' "$nlist" >/dev/null; then

    cat <<EOF > conftest.$ac_ext

#ifdef __cplusplus

extern "C" {

#endif

EOF

    # Now generate the symbol file.

    eval "$lt_cv_global_symbol_to_cdecl"' < "$nlist" >> conftest.$ac_ext'

    cat <<EOF >> conftest.$ac_ext

#if defined (__STDC__) && __STDC__

# define lt_ptr void *

#else

# define lt_ptr char *

# define const

#endif

/* The mapping between symbol names and symbols. */

const struct {

  const char *name;

  lt_ptr address;

}

lt_preloaded_symbols[[]] =

{

EOF

    sed "s/^$symcode$symcode* \(.*\) \(.*\)$/  {\"\2\", (lt_ptr) \&\2},/" < "$nlist" >> conftest.$ac_ext

    cat <<\EOF >> conftest.$ac_ext

  {0, (lt_ptr) 0}

};

#ifdef __cplusplus

}

#endif

EOF

    # Now try linking the two files.

    mv conftest.$ac_objext conftstm.$ac_objext

    save_LIBS="$LIBS"

    save_CFLAGS="$CFLAGS"

    LIBS="conftstm.$ac_objext"

    CFLAGS="$CFLAGS$no_builtin_flag"

    if AC_TRY_EVAL(ac_link) && test -s conftest; then

      pipe_works=yes

    fi

    LIBS="$save_LIBS"

    CFLAGS="$save_CFLAGS"

  else

    echo "cannot find nm_test_func in $nlist" >&AC_FD_CC

  fi

      else

  echo "cannot find nm_test_var in $nlist" >&AC_FD_CC

      fi

    else

      echo "cannot run $lt_cv_sys_global_symbol_pipe" >&AC_FD_CC

    fi

  else

    echo "$progname: failed program was:" >&AC_FD_CC

    cat conftest.$ac_ext >&5

  fi

  rm -f conftest* conftst*

  # Do not use the global_symbol_pipe unless it works.

  if test "$pipe_works" = yes; then

    break

  else

    lt_cv_sys_global_symbol_pipe=

  fi

done

])

global_symbol_pipe="$lt_cv_sys_global_symbol_pipe"

if test -z "$lt_cv_sys_global_symbol_pipe"; then

  global_symbol_to_cdecl=

  global_symbol_to_c_name_address=

else

  global_symbol_to_cdecl="$lt_cv_global_symbol_to_cdecl"

  global_symbol_to_c_name_address="$lt_cv_global_symbol_to_c_name_address"

fi

if test -z "$global_symbol_pipe$global_symbol_to_cdec$global_symbol_to_c_name_address";

then

  AC_MSG_RESULT(failed)

else

  AC_MSG_RESULT(ok)

fi

]) # AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE

# _LT_AC_LIBTOOL_SYS_PATH_SEPARATOR

# ---------------------------------

AC_DEFUN([_LT_AC_LIBTOOL_SYS_PATH_SEPARATOR],

[# Find the correct PATH separator.  Usually this is `:', but

# DJGPP uses `;' like DOS.

if test "X${PATH_SEPARATOR+set}" != Xset; then

  UNAME=${UNAME-`uname 2>/dev/null`}

  case X$UNAME in

    *-DOS) lt_cv_sys_path_separator=';' ;;

    *)     lt_cv_sys_path_separator=':' ;;

  esac

  PATH_SEPARATOR=$lt_cv_sys_path_separator

fi

])# _LT_AC_LIBTOOL_SYS_PATH_SEPARATOR

# _LT_AC_PROG_ECHO_BACKSLASH

# --------------------------

# Add some code to the start of the generated configure script which

# will find an echo command which doesn't interpret backslashes.

AC_DEFUN([_LT_AC_PROG_ECHO_BACKSLASH],

[ifdef([AC_DIVERSION_NOTICE], [AC_DIVERT_PUSH(AC_DIVERSION_NOTICE)],

                [AC_DIVERT_PUSH(NOTICE)])

_LT_AC_LIBTOOL_SYS_PATH_SEPARATOR

# Check that we are running under the correct shell.

SHELL=${CONFIG_SHELL-/bin/sh}

case X$ECHO in

X*--fallback-echo)

  # Remove one level of quotation (which was required for Make).

  ECHO=`echo "$ECHO" | sed 's,\\\\\[$]\\[$]0,'[$]0','`

  ;;

esac

echo=${ECHO-echo}

if test "X[$]1" = X--no-reexec; then

  # Discard the --no-reexec flag, and continue.

  shift

elif test "X[$]1" = X--fallback-echo; then

  # Avoid inline document here, it may be left over

  :

elif test "X`($echo '\t') 2>/dev/null`" = 'X\t'; then

  # Yippee, $echo works!

  :

else

  # Restart under the correct shell.

  exec $SHELL "[$]0" --no-reexec ${1+"[$]@"}

fi

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

  # used as fallback echo

  shift

  cat <<EOF

$*

EOF

  exit 0

fi

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

# if CDPATH is set.

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

if test -z "$ECHO"; then

if test "X${echo_test_string+set}" != Xset; then

# find a string as large as possible, as long as the shell can cope with it

  for cmd in 'sed 50q "[$]0"' 'sed 20q "[$]0"' 'sed 10q "[$]0"' 'sed 2q "[$]0"' 'echo test'; do

    # expected sizes: less than 2Kb, 1Kb, 512 bytes, 16 bytes, ...

    if (echo_test_string="`eval $cmd`") 2>/dev/null &&

       echo_test_string="`eval $cmd`" &&

       (test "X$echo_test_string" = "X$echo_test_string") 2>/dev/null

    then