Edit

thodg/libiconv/libcharset/autoconf/aclocal.m4

Branch :

  • Show log

    Commit

  • Author : Bruno Haible
    Date : 2000-11-01 14:01:29
    Hash : 507052f0
    Message : Charset determination library.

  • libcharset/autoconf/aclocal.m4
  • dnl autoconf/aclocal.m4 generated automatically by aclocal 1.4
    
    dnl Copyright (C) 1994, 1995-8, 1999 Free Software Foundation, Inc.
    dnl This file is free software; the Free Software Foundation
    dnl gives unlimited permission to copy and/or distribute it,
    dnl with or without modifications, as long as this notice is preserved.
    
    dnl This program is distributed in the hope that it will be useful,
    dnl but WITHOUT ANY WARRANTY, to the extent permitted by law; without
    dnl even the implied warranty of MERCHANTABILITY or FITNESS FOR A
    dnl PARTICULAR PURPOSE.
    
    dnl Excerpt from CLISP'a aclocal.m4
    dnl
    AC_DEFUN(CL_PROG_RANLIB, [AC_CHECK_PROG(RANLIB, ranlib, ranlib, true)])dnl
    dnl
    AC_DEFUN(CL_PROG_INSTALL,
    [dnl This is mostly copied from AC_PROG_INSTALL.
    # Find a good install program.  We prefer a C program (faster),
    # so one script is as good as another.  But avoid the broken or
    # incompatible versions:
    # SysV /etc/install, /usr/sbin/install
    # SunOS /usr/etc/install
    # IRIX /sbin/install
    # AIX /bin/install
    # AFS /usr/afsws/bin/install, which mishandles nonexistent args
    # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
    # ./install, which can be erroneously created by make from ./install.sh.
    AC_MSG_CHECKING(for a BSD compatible install)
    if test -z "$INSTALL"; then
    AC_CACHE_VAL(cl_cv_path_install,
    [  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS="${IFS}:"
      for ac_dir in $PATH; do
        # Account for people who put trailing slashes in PATH elements.
        case "$ac_dir/" in
        /|./|.//|/etc/*|/usr/sbin/*|/usr/etc/*|/sbin/*|/usr/afsws/bin/*|/usr/ucb/*) ;;
        *)
          # OSF1 and SCO ODT 3.0 have their own names for install.
          for ac_prog in ginstall installbsd scoinst install; do
            if test -f $ac_dir/$ac_prog; then
    	  if test $ac_prog = install &&
                grep dspmsg $ac_dir/$ac_prog >/dev/null 2>&1; then
    	    # AIX install.  It has an incompatible calling convention.
    	    # OSF/1 installbsd also uses dspmsg, but is usable.
    	    :
    	  else
    	    if test $ac_prog = installbsd &&
    	      grep src/bos $ac_dir/$ac_prog >/dev/null 2>&1; then
    	      # AIX installbsd doesn't work without option "-g".
    	      :
    	    else
    	      cl_cv_path_install="$ac_dir/$ac_prog -c"
    	      break 2
    	    fi
    	  fi
    	fi
          done
          ;;
        esac
      done
      IFS="$ac_save_ifs"
      # As a last resort, use cp.
      test -z "$cl_cv_path_install" && cl_cv_path_install="cp"
    ])dnl
      INSTALL="$cl_cv_path_install"
    fi
    dnl We do special magic for INSTALL instead of AC_SUBST, to get
    dnl relative paths right. 
    AC_MSG_RESULT($INSTALL)
    AC_SUBST(INSTALL)dnl
    # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
    # It thinks the first close brace ends the variable substitution.
    test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='$(INSTALL)'
    AC_SUBST(INSTALL_PROGRAM)dnl
    if test -z "$INSTALL_DATA"; then
      case "$INSTALL" in
        cp | */cp ) INSTALL_DATA='$(INSTALL)' ;;
        * )         INSTALL_DATA='$(INSTALL) -m 644' ;;
      esac
    fi
    AC_SUBST(INSTALL_DATA)dnl
    ])dnl
    dnl
    AC_DEFUN(CL_PROG_CP,
    [AC_CACHE_CHECK(how to copy files, cl_cv_prog_cp, [
    echo "blabla" > conftest.x
    err=`/bin/sh -c "cp -p conftest.x conftest.y 2>&1"`
    if test -z "$err"; then
      cl_cv_prog_cp='cp -p'
    else
      cl_cv_prog_cp='cp'
    fi
    rm -f conftest*
    ])
    CP="$cl_cv_prog_cp"
    AC_SUBST(CP)dnl
    ])dnl
    dnl
    AC_DEFUN(CL_PROG_LN,
    [AC_REQUIRE([CL_PROG_CP])dnl
    AC_CACHE_CHECK(how to make hard links, cl_cv_prog_LN, [
    rm -f conftestdata conftestfile
    echo data > conftestfile
    if ln conftestfile conftestdata 2>/dev/null; then
      cl_cv_prog_LN=ln
    else
      cl_cv_prog_LN="$cl_cv_prog_cp"
    fi
    rm -f conftestdata conftestfile
    ])
    LN="$cl_cv_prog_LN"
    AC_SUBST(LN)dnl
    ])dnl
    dnl
    AC_DEFUN(CL_PROG_LN_S,
    [AC_REQUIRE([CL_PROG_LN])dnl
    dnl Make a symlink if possible; otherwise try a hard link. On filesystems
    dnl which support neither symlink nor hard link, use a plain copy.
    AC_MSG_CHECKING(whether ln -s works)
    AC_CACHE_VAL(cl_cv_prog_LN_S, [
    rm -f conftestdata
    if ln -s X conftestdata 2>/dev/null; then
      cl_cv_prog_LN_S="ln -s"
    else
      cl_cv_prog_LN_S="$cl_cv_prog_LN"
    fi
    rm -f conftestdata
    ])dnl
    if test "$cl_cv_prog_LN_S" = "ln -s"; then
      AC_MSG_RESULT(yes)
    else
      AC_MSG_RESULT(no)
    fi
    LN_S="$cl_cv_prog_LN_S"
    AC_SUBST(LN_S)dnl
    ])dnl
    dnl
    
    
    # serial 40 AC_PROG_LIBTOOL
    AC_DEFUN(AC_PROG_LIBTOOL,
    [AC_REQUIRE([AC_LIBTOOL_SETUP])dnl
    
    # Save cache, so that ltconfig can load it
    AC_CACHE_SAVE
    
    # Actually configure libtool.  ac_aux_dir is where install-sh is found.
    CC="$CC" CFLAGS="$CFLAGS" CPPFLAGS="$CPPFLAGS" \
    LD="$LD" LDFLAGS="$LDFLAGS" LIBS="$LIBS" \
    LN_S="$LN_S" NM="$NM" RANLIB="$RANLIB" \
    DLLTOOL="$DLLTOOL" AS="$AS" OBJDUMP="$OBJDUMP" \
    ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/ltconfig \
    $libtool_flags --no-verify $ac_aux_dir/ltmain.sh $lt_target \
    || AC_MSG_ERROR([libtool configure failed])
    
    # Reload cache, that may have been modified by ltconfig
    AC_CACHE_LOAD
    
    # This can be used to rebuild libtool when needed
    LIBTOOL_DEPS="$ac_aux_dir/ltconfig $ac_aux_dir/ltmain.sh"
    
    # Always use our own libtool.
    LIBTOOL='$(SHELL) $(top_builddir)/libtool'
    AC_SUBST(LIBTOOL)dnl
    
    # Redirect the config.log output again, so that the ltconfig log is not
    # clobbered by the next message.
    exec 5>>./config.log
    ])
    
    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_RANLIB])dnl
    AC_REQUIRE([AC_PROG_CC])dnl
    AC_REQUIRE([AC_PROG_LD])dnl
    AC_REQUIRE([AC_PROG_NM])dnl
    AC_REQUIRE([AC_PROG_LN_S])dnl
    dnl
    
    case "$target" in
    NONE) lt_target="$host" ;;
    *) lt_target="$target" ;;
    esac
    
    # Check for any special flags to pass to ltconfig.
    libtool_flags=""
    test "$enable_shared" = no && libtool_flags="$libtool_flags --disable-shared"
    test "$enable_static" = no && libtool_flags="$libtool_flags --disable-static"
    test "$enable_fast_install" = no && libtool_flags="$libtool_flags --disable-fast-install"
    test "$ac_cv_prog_gcc" = yes && libtool_flags="$libtool_flags --with-gcc"
    test "$ac_cv_prog_gnu_ld" = yes && libtool_flags="$libtool_flags --with-gnu-ld"
    ifdef([AC_PROVIDE_AC_LIBTOOL_DLOPEN],
    [libtool_flags="$libtool_flags --enable-dlopen"])
    ifdef([AC_PROVIDE_AC_LIBTOOL_WIN32_DLL],
    [libtool_flags="$libtool_flags --enable-win32-dll"])
    AC_ARG_ENABLE(libtool-lock,
      [  --disable-libtool-lock  avoid locking (might break parallel builds)])
    test "x$enable_libtool_lock" = xno && libtool_flags="$libtool_flags --disable-lock"
    test x"$silent" = xyes && libtool_flags="$libtool_flags --silent"
    
    # Some flags need to be propagated to the compiler or linker for good
    # libtool support.
    case "$lt_target" 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.o`" 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_TRY_LINK([],[],[lt_cv_cc_needs_belf=yes],[lt_cv_cc_needs_belf=no])])
      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*)
      AC_CHECK_TOOL(DLLTOOL, dlltool, false)
      AC_CHECK_TOOL(AS, as, false)
      AC_CHECK_TOOL(OBJDUMP, objdump, false)
      ;;
    ])
    esac
    ])
    
    # AC_LIBTOOL_DLOPEN - enable checks for dlopen support
    AC_DEFUN(AC_LIBTOOL_DLOPEN, [AC_BEFORE([$0],[AC_LIBTOOL_SETUP])])
    
    # AC_LIBTOOL_WIN32_DLL - declare package support for building win32 dll's
    AC_DEFUN(AC_LIBTOOL_WIN32_DLL, [AC_BEFORE([$0], [AC_LIBTOOL_SETUP])])
    
    # AC_ENABLE_SHARED - implement the --enable-shared flag
    # Usage: AC_ENABLE_SHARED[(DEFAULT)]
    #   Where DEFAULT is either `yes' or `no'.  If omitted, it defaults to
    #   `yes'.
    AC_DEFUN(AC_ENABLE_SHARED, [dnl
    define([AC_ENABLE_SHARED_DEFAULT], ifelse($1, no, no, yes))dnl
    AC_ARG_ENABLE(shared,
    changequote(<<, >>)dnl
    <<  --enable-shared[=PKGS]  build shared libraries [default=>>AC_ENABLE_SHARED_DEFAULT],
    changequote([, ])dnl
    [p=${PACKAGE-default}
    case "$enableval" in
    yes) enable_shared=yes ;;
    no) enable_shared=no ;;
    *)
      enable_shared=no
      # Look at the argument we got.  We use all the common list separators.
      IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
      for pkg in $enableval; do
        if test "X$pkg" = "X$p"; then
          enable_shared=yes
        fi
      done
      IFS="$ac_save_ifs"
      ;;
    esac],
    enable_shared=AC_ENABLE_SHARED_DEFAULT)dnl
    ])
    
    # AC_DISABLE_SHARED - set the default shared flag to --disable-shared
    AC_DEFUN(AC_DISABLE_SHARED, [AC_BEFORE([$0],[AC_LIBTOOL_SETUP])dnl
    AC_ENABLE_SHARED(no)])
    
    # AC_ENABLE_STATIC - implement the --enable-static flag
    # Usage: AC_ENABLE_STATIC[(DEFAULT)]
    #   Where DEFAULT is either `yes' or `no'.  If omitted, it defaults to
    #   `yes'.
    AC_DEFUN(AC_ENABLE_STATIC, [dnl
    define([AC_ENABLE_STATIC_DEFAULT], ifelse($1, no, no, yes))dnl
    AC_ARG_ENABLE(static,
    changequote(<<, >>)dnl
    <<  --enable-static[=PKGS]  build static libraries [default=>>AC_ENABLE_STATIC_DEFAULT],
    changequote([, ])dnl
    [p=${PACKAGE-default}
    case "$enableval" in
    yes) enable_static=yes ;;
    no) enable_static=no ;;
    *)
      enable_static=no
      # Look at the argument we got.  We use all the common list separators.
      IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
      for pkg in $enableval; do
        if test "X$pkg" = "X$p"; then
          enable_static=yes
        fi
      done
      IFS="$ac_save_ifs"
      ;;
    esac],
    enable_static=AC_ENABLE_STATIC_DEFAULT)dnl
    ])
    
    # AC_DISABLE_STATIC - set the default static flag to --disable-static
    AC_DEFUN(AC_DISABLE_STATIC, [AC_BEFORE([$0],[AC_LIBTOOL_SETUP])dnl
    AC_ENABLE_STATIC(no)])
    
    
    # AC_ENABLE_FAST_INSTALL - implement the --enable-fast-install flag
    # Usage: AC_ENABLE_FAST_INSTALL[(DEFAULT)]
    #   Where DEFAULT is either `yes' or `no'.  If omitted, it defaults to
    #   `yes'.
    AC_DEFUN(AC_ENABLE_FAST_INSTALL, [dnl
    define([AC_ENABLE_FAST_INSTALL_DEFAULT], ifelse($1, no, no, yes))dnl
    AC_ARG_ENABLE(fast-install,
    changequote(<<, >>)dnl
    <<  --enable-fast-install[=PKGS]  optimize for fast installation [default=>>AC_ENABLE_FAST_INSTALL_DEFAULT],
    changequote([, ])dnl
    [p=${PACKAGE-default}
    case "$enableval" in
    yes) enable_fast_install=yes ;;
    no) enable_fast_install=no ;;
    *)
      enable_fast_install=no
      # Look at the argument we got.  We use all the common list separators.
      IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
      for pkg in $enableval; do
        if test "X$pkg" = "X$p"; then
          enable_fast_install=yes
        fi
      done
      IFS="$ac_save_ifs"
      ;;
    esac],
    enable_fast_install=AC_ENABLE_FAST_INSTALL_DEFAULT)dnl
    ])
    
    # AC_ENABLE_FAST_INSTALL - set the default to --disable-fast-install
    AC_DEFUN(AC_DISABLE_FAST_INSTALL, [AC_BEFORE([$0],[AC_LIBTOOL_SETUP])dnl
    AC_ENABLE_FAST_INSTALL(no)])
    
    # AC_PROG_LD - find the path to the GNU or non-GNU linker
    AC_DEFUN(AC_PROG_LD,
    [AC_ARG_WITH(gnu-ld,
    [  --with-gnu-ld           assume the C compiler uses GNU ld [default=no]],
    test "$withval" = no || with_gnu_ld=yes, with_gnu_ld=no)
    AC_REQUIRE([AC_PROG_CC])dnl
    AC_REQUIRE([AC_CANONICAL_HOST])dnl
    AC_REQUIRE([AC_CANONICAL_BUILD])dnl
    ac_prog=ld
    if test "$ac_cv_prog_gcc" = yes; then
      # Check if gcc -print-prog-name=ld gives a path.
      AC_MSG_CHECKING([for ld used by GCC])
      ac_prog=`($CC -print-prog-name=ld) 2>&5`
      case "$ac_prog" in
        # Accept absolute paths.
    changequote(,)dnl
        [\\/]* | [A-Za-z]:[\\/]*)
          re_direlt='/[^/][^/]*/\.\./'
    changequote([,])dnl
          # Canonicalize the path of ld
          ac_prog=`echo $ac_prog| sed 's%\\\\%/%g'`
          while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do
    	ac_prog=`echo $ac_prog| sed "s%$re_direlt%/%"`
          done
          test -z "$LD" && LD="$ac_prog"
          ;;
      "")
        # If it fails, then pretend we aren't using GCC.
        ac_prog=ld
        ;;
      *)
        # If it is relative, then search for the first ld in PATH.
        with_gnu_ld=unknown
        ;;
      esac
    elif test "$with_gnu_ld" = yes; then
      AC_MSG_CHECKING([for GNU ld])
    else
      AC_MSG_CHECKING([for non-GNU ld])
    fi
    AC_CACHE_VAL(ac_cv_path_LD,
    [if test -z "$LD"; then
      IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
      for ac_dir in $PATH; do
        test -z "$ac_dir" && ac_dir=.
        if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
          ac_cv_path_LD="$ac_dir/$ac_prog"
          # Check to see if the program is GNU ld.  I'd rather use --version,
          # but apparently some GNU ld's only accept -v.
          # Break only if it was the GNU/non-GNU ld that we prefer.
          if "$ac_cv_path_LD" -v 2>&1 < /dev/null | egrep '(GNU|with BFD)' > /dev/null; then
    	test "$with_gnu_ld" != no && break
          else
    	test "$with_gnu_ld" != yes && break
          fi
        fi
      done
      IFS="$ac_save_ifs"
    else
      ac_cv_path_LD="$LD" # Let the user override the test with a path.
    fi])
    LD="$ac_cv_path_LD"
    if test -n "$LD"; then
      AC_MSG_RESULT($LD)
    else
      AC_MSG_RESULT(no)
    fi
    test -z "$LD" && AC_MSG_ERROR([no acceptable ld found in \$PATH])
    AC_PROG_LD_GNU
    ])
    
    AC_DEFUN(AC_PROG_LD_GNU,
    [AC_CACHE_CHECK([if the linker ($LD) is GNU ld], ac_cv_prog_gnu_ld,
    [# I'd rather use --version here, but apparently some GNU ld's only accept -v.
    if $LD -v 2>&1 </dev/null | egrep '(GNU|with BFD)' 1>&5; then
      ac_cv_prog_gnu_ld=yes
    else
      ac_cv_prog_gnu_ld=no
    fi])
    ])
    
    # AC_PROG_NM - find the path to a BSD-compatible name lister
    AC_DEFUN(AC_PROG_NM,
    [AC_MSG_CHECKING([for BSD-compatible nm])
    AC_CACHE_VAL(ac_cv_path_NM,
    [if test -n "$NM"; then
      # Let the user override the test.
      ac_cv_path_NM="$NM"
    else
      IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
      for ac_dir in $PATH /usr/ccs/bin /usr/ucb /bin; do
        test -z "$ac_dir" && ac_dir=.
        if test -f $ac_dir/nm || test -f $ac_dir/nm$ac_exeext ; then
          # Check to see if the nm accepts a BSD-compat flag.
          # Adding the `sed 1q' prevents false positives on HP-UX, which says:
          #   nm: unknown option "B" ignored
          if ($ac_dir/nm -B /dev/null 2>&1 | sed '1q'; exit 0) | egrep /dev/null >/dev/null; then
    	ac_cv_path_NM="$ac_dir/nm -B"
    	break
          elif ($ac_dir/nm -p /dev/null 2>&1 | sed '1q'; exit 0) | egrep /dev/null >/dev/null; then
    	ac_cv_path_NM="$ac_dir/nm -p"
    	break
          else
    	ac_cv_path_NM=${ac_cv_path_NM="$ac_dir/nm"} # keep the first match, but
    	continue # so that we can try to find one that supports BSD flags
          fi
        fi
      done
      IFS="$ac_save_ifs"
      test -z "$ac_cv_path_NM" && ac_cv_path_NM=nm
    fi])
    NM="$ac_cv_path_NM"
    AC_MSG_RESULT([$NM])
    ])
    
    # AC_CHECK_LIBM - check for math library
    AC_DEFUN(AC_CHECK_LIBM,
    [AC_REQUIRE([AC_CANONICAL_HOST])dnl
    LIBM=
    case "$lt_target" in
    *-*-beos* | *-*-cygwin*)
      # These system don't have libm
      ;;
    *-ncr-sysv4.3*)
      AC_CHECK_LIB(mw, _mwvalidcheckl, LIBM="-lmw")
      AC_CHECK_LIB(m, main, LIBM="$LIBM -lm")
      ;;
    *)
      AC_CHECK_LIB(m, main, LIBM="-lm")
      ;;
    esac
    ])
    
    # AC_LIBLTDL_CONVENIENCE[(dir)] - sets LIBLTDL to the link flags for
    # the libltdl convenience library and INCLTDL to the include flags for
    # the libltdl header and adds --enable-ltdl-convenience to the
    # configure arguments.  Note that LIBLTDL and INCLTDL are not
    # AC_SUBSTed, nor is AC_CONFIG_SUBDIRS called.  If DIR is not
    # provided, it is assumed to be `libltdl'.  LIBLTDL will be prefixed
    # with '${top_builddir}/' and INCLTDL will be prefixed with
    # '${top_srcdir}/' (note the single quotes!).  If your package is not
    # flat and you're not using automake, define top_builddir and
    # top_srcdir appropriately in the Makefiles.
    AC_DEFUN(AC_LIBLTDL_CONVENIENCE, [AC_BEFORE([$0],[AC_LIBTOOL_SETUP])dnl
      case "$enable_ltdl_convenience" in
      no) AC_MSG_ERROR([this package needs a convenience libltdl]) ;;
      "") enable_ltdl_convenience=yes
          ac_configure_args="$ac_configure_args --enable-ltdl-convenience" ;;
      esac
      LIBLTDL='${top_builddir}/'ifelse($#,1,[$1],['libltdl'])/libltdlc.la
      INCLTDL='-I${top_srcdir}/'ifelse($#,1,[$1],['libltdl'])
    ])
    
    # AC_LIBLTDL_INSTALLABLE[(dir)] - sets LIBLTDL to the link flags for
    # the libltdl installable library and INCLTDL to the include flags for
    # the libltdl header and adds --enable-ltdl-install to the configure
    # arguments.  Note that LIBLTDL and INCLTDL are not AC_SUBSTed, nor is
    # AC_CONFIG_SUBDIRS called.  If DIR is not provided and an installed
    # libltdl is not found, it is assumed to be `libltdl'.  LIBLTDL will
    # be prefixed with '${top_builddir}/' and INCLTDL will be prefixed
    # with '${top_srcdir}/' (note the single quotes!).  If your package is
    # not flat and you're not using automake, define top_builddir and
    # top_srcdir appropriately in the Makefiles.
    # In the future, this macro may have to be called after AC_PROG_LIBTOOL.
    AC_DEFUN(AC_LIBLTDL_INSTALLABLE, [AC_BEFORE([$0],[AC_LIBTOOL_SETUP])dnl
      AC_CHECK_LIB(ltdl, main,
      [test x"$enable_ltdl_install" != xyes && enable_ltdl_install=no],
      [if test x"$enable_ltdl_install" = xno; then
         AC_MSG_WARN([libltdl not installed, but installation disabled])
       else
         enable_ltdl_install=yes
       fi
      ])
      if test x"$enable_ltdl_install" = x"yes"; then
        ac_configure_args="$ac_configure_args --enable-ltdl-install"
        LIBLTDL='${top_builddir}/'ifelse($#,1,[$1],['libltdl'])/libltdl.la
        INCLTDL='-I${top_srcdir}/'ifelse($#,1,[$1],['libltdl'])
      else
        ac_configure_args="$ac_configure_args --enable-ltdl-install=no"
        LIBLTDL="-lltdl"
        INCLTDL=
      fi
    ])
    
    dnl old names
    AC_DEFUN(AM_PROG_LIBTOOL, [indir([AC_PROG_LIBTOOL])])dnl
    AC_DEFUN(AM_ENABLE_SHARED, [indir([AC_ENABLE_SHARED], $@)])dnl
    AC_DEFUN(AM_ENABLE_STATIC, [indir([AC_ENABLE_STATIC], $@)])dnl
    AC_DEFUN(AM_DISABLE_SHARED, [indir([AC_DISABLE_SHARED], $@)])dnl
    AC_DEFUN(AM_DISABLE_STATIC, [indir([AC_DISABLE_STATIC], $@)])dnl
    AC_DEFUN(AM_PROG_LD, [indir([AC_PROG_LD])])dnl
    AC_DEFUN(AM_PROG_NM, [indir([AC_PROG_NM])])dnl
    
    dnl This is just to silence aclocal about the macro not being used
    ifelse([AC_DISABLE_FAST_INSTALL])dnl
    
    #serial 2
    
    dnl From Bruno Haible.
    
    AC_DEFUN(jm_LANGINFO_CODESET,
    [
      AC_CHECK_HEADERS(langinfo.h)
      AC_CHECK_FUNCS(nl_langinfo)
    
      AC_CACHE_CHECK([for nl_langinfo and CODESET], jm_cv_langinfo_codeset,
        [AC_TRY_LINK([#include <langinfo.h>],
          [char* cs = nl_langinfo(CODESET);],
          jm_cv_langinfo_codeset=yes,
          jm_cv_langinfo_codeset=no)
        ])
      if test $jm_cv_langinfo_codeset = yes; then
        AC_DEFINE(HAVE_LANGINFO_CODESET, 1,
          [Define if you have <langinfo.h> and nl_langinfo(CODESET).])
      fi
    ])
    
    #serial 2
    
    # Test for the GNU C Library, version 2.1 or newer.
    # From Bruno Haible.
    
    AC_DEFUN(jm_GLIBC21,
      [
        AC_CACHE_CHECK(whether we are using the GNU C Library 2.1 or newer,
          ac_cv_gnu_library_2_1,
          [AC_EGREP_CPP([Lucky GNU user],
    	[
    #include <features.h>
    #ifdef __GNU_LIBRARY__
     #if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 1) || (__GLIBC__ > 2)
      Lucky GNU user
     #endif
    #endif
    	],
    	ac_cv_gnu_library_2_1=yes,
    	ac_cv_gnu_library_2_1=no)
          ]
        )
        AC_SUBST(GLIBC21)
        GLIBC21="$ac_cv_gnu_library_2_1"
      ]
    )