Edit

kc3-lang/libqrencode/acinclude.m4

Branch :

  • Show log

    Commit

  • Author : Kentaro Fukuchi
    Date : 2016-05-18 00:21:52
    Hash : c1856736
    Message : iconv.m4 has been updated to serial 19.

  • acinclude.m4
  • # iconv.m4 serial 19 (gettext-0.18.2)
    dnl Copyright (C) 2000-2002, 2007-2014 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 From Bruno Haible.
    
    AC_DEFUN([AM_ICONV_LINKFLAGS_BODY],
    [
      dnl Prerequisites of AC_LIB_LINKFLAGS_BODY.
      AC_REQUIRE([AC_LIB_PREPARE_PREFIX])
      AC_REQUIRE([AC_LIB_RPATH])
    
      dnl Search for libiconv and define LIBICONV, LTLIBICONV and INCICONV
      dnl accordingly.
      AC_LIB_LINKFLAGS_BODY([iconv])
    ])
    
    AC_DEFUN([AM_ICONV_LINK],
    [
      dnl Some systems have iconv in libc, some have it in libiconv (OSF/1 and
      dnl those with the standalone portable GNU libiconv installed).
      AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles
    
      dnl Search for libiconv and define LIBICONV, LTLIBICONV and INCICONV
      dnl accordingly.
      AC_REQUIRE([AM_ICONV_LINKFLAGS_BODY])
    
      dnl Add $INCICONV to CPPFLAGS before performing the following checks,
      dnl because if the user has installed libiconv and not disabled its use
      dnl via --without-libiconv-prefix, he wants to use it. The first
      dnl AC_LINK_IFELSE will then fail, the second AC_LINK_IFELSE will succeed.
      am_save_CPPFLAGS="$CPPFLAGS"
      AC_LIB_APPENDTOVAR([CPPFLAGS], [$INCICONV])
    
      AC_CACHE_CHECK([for iconv], [am_cv_func_iconv], [
        am_cv_func_iconv="no, consider installing GNU libiconv"
        am_cv_lib_iconv=no
        AC_LINK_IFELSE(
          [AC_LANG_PROGRAM(
             [[
    #include <stdlib.h>
    #include <iconv.h>
             ]],
             [[iconv_t cd = iconv_open("","");
               iconv(cd,NULL,NULL,NULL,NULL);
               iconv_close(cd);]])],
          [am_cv_func_iconv=yes])
        if test "$am_cv_func_iconv" != yes; then
          am_save_LIBS="$LIBS"
          LIBS="$LIBS $LIBICONV"
          AC_LINK_IFELSE(
            [AC_LANG_PROGRAM(
               [[
    #include <stdlib.h>
    #include <iconv.h>
               ]],
               [[iconv_t cd = iconv_open("","");
                 iconv(cd,NULL,NULL,NULL,NULL);
                 iconv_close(cd);]])],
            [am_cv_lib_iconv=yes]
            [am_cv_func_iconv=yes])
          LIBS="$am_save_LIBS"
        fi
      ])
      if test "$am_cv_func_iconv" = yes; then
        AC_CACHE_CHECK([for working iconv], [am_cv_func_iconv_works], [
          dnl This tests against bugs in AIX 5.1, AIX 6.1..7.1, HP-UX 11.11,
          dnl Solaris 10.
          am_save_LIBS="$LIBS"
          if test $am_cv_lib_iconv = yes; then
            LIBS="$LIBS $LIBICONV"
          fi
          am_cv_func_iconv_works=no
          for ac_iconv_const in '' 'const'; do
            AC_RUN_IFELSE(
              [AC_LANG_PROGRAM(
                 [[
    #include <iconv.h>
    #include <string.h>
    
    #ifndef ICONV_CONST
    # define ICONV_CONST $ac_iconv_const
    #endif
                 ]],
                 [[int result = 0;
      /* Test against AIX 5.1 bug: Failures are not distinguishable from successful
         returns.  */
      {
        iconv_t cd_utf8_to_88591 = iconv_open ("ISO8859-1", "UTF-8");
        if (cd_utf8_to_88591 != (iconv_t)(-1))
          {
            static ICONV_CONST char input[] = "\342\202\254"; /* EURO SIGN */
            char buf[10];
            ICONV_CONST char *inptr = input;
            size_t inbytesleft = strlen (input);
            char *outptr = buf;
            size_t outbytesleft = sizeof (buf);
            size_t res = iconv (cd_utf8_to_88591,
                                &inptr, &inbytesleft,
                                &outptr, &outbytesleft);
            if (res == 0)
              result |= 1;
            iconv_close (cd_utf8_to_88591);
          }
      }
      /* Test against Solaris 10 bug: Failures are not distinguishable from
         successful returns.  */
      {
        iconv_t cd_ascii_to_88591 = iconv_open ("ISO8859-1", "646");
        if (cd_ascii_to_88591 != (iconv_t)(-1))
          {
            static ICONV_CONST char input[] = "\263";
            char buf[10];
            ICONV_CONST char *inptr = input;
            size_t inbytesleft = strlen (input);
            char *outptr = buf;
            size_t outbytesleft = sizeof (buf);
            size_t res = iconv (cd_ascii_to_88591,
                                &inptr, &inbytesleft,
                                &outptr, &outbytesleft);
            if (res == 0)
              result |= 2;
            iconv_close (cd_ascii_to_88591);
          }
      }
      /* Test against AIX 6.1..7.1 bug: Buffer overrun.  */
      {
        iconv_t cd_88591_to_utf8 = iconv_open ("UTF-8", "ISO-8859-1");
        if (cd_88591_to_utf8 != (iconv_t)(-1))
          {
            static ICONV_CONST char input[] = "\304";
            static char buf[2] = { (char)0xDE, (char)0xAD };
            ICONV_CONST char *inptr = input;
            size_t inbytesleft = 1;
            char *outptr = buf;
            size_t outbytesleft = 1;
            size_t res = iconv (cd_88591_to_utf8,
                                &inptr, &inbytesleft,
                                &outptr, &outbytesleft);
            if (res != (size_t)(-1) || outptr - buf > 1 || buf[1] != (char)0xAD)
              result |= 4;
            iconv_close (cd_88591_to_utf8);
          }
      }
    #if 0 /* This bug could be worked around by the caller.  */
      /* Test against HP-UX 11.11 bug: Positive return value instead of 0.  */
      {
        iconv_t cd_88591_to_utf8 = iconv_open ("utf8", "iso88591");
        if (cd_88591_to_utf8 != (iconv_t)(-1))
          {
            static ICONV_CONST char input[] = "\304rger mit b\366sen B\374bchen ohne Augenma\337";
            char buf[50];
            ICONV_CONST char *inptr = input;
            size_t inbytesleft = strlen (input);
            char *outptr = buf;
            size_t outbytesleft = sizeof (buf);
            size_t res = iconv (cd_88591_to_utf8,
                                &inptr, &inbytesleft,
                                &outptr, &outbytesleft);
            if ((int)res > 0)
              result |= 8;
            iconv_close (cd_88591_to_utf8);
          }
      }
    #endif
      /* Test against HP-UX 11.11 bug: No converter from EUC-JP to UTF-8 is
         provided.  */
      if (/* Try standardized names.  */
          iconv_open ("UTF-8", "EUC-JP") == (iconv_t)(-1)
          /* Try IRIX, OSF/1 names.  */
          && iconv_open ("UTF-8", "eucJP") == (iconv_t)(-1)
          /* Try AIX names.  */
          && iconv_open ("UTF-8", "IBM-eucJP") == (iconv_t)(-1)
          /* Try HP-UX names.  */
          && iconv_open ("utf8", "eucJP") == (iconv_t)(-1))
        result |= 16;
      return result;
    ]])],
              [am_cv_func_iconv_works=yes], ,
              [case "$host_os" in
                 aix* | hpux*) am_cv_func_iconv_works="guessing no" ;;
                 *)            am_cv_func_iconv_works="guessing yes" ;;
               esac])
            test "$am_cv_func_iconv_works" = no || break
          done
          LIBS="$am_save_LIBS"
        ])
        case "$am_cv_func_iconv_works" in
          *no) am_func_iconv=no am_cv_lib_iconv=no ;;
          *)   am_func_iconv=yes ;;
        esac
      else
        am_func_iconv=no am_cv_lib_iconv=no
      fi
      if test "$am_func_iconv" = yes; then
        AC_DEFINE([HAVE_ICONV], [1],
          [Define if you have the iconv() function and it works.])
      fi
      if test "$am_cv_lib_iconv" = yes; then
        AC_MSG_CHECKING([how to link with libiconv])
        AC_MSG_RESULT([$LIBICONV])
      else
        dnl If $LIBICONV didn't lead to a usable library, we don't need $INCICONV
        dnl either.
        CPPFLAGS="$am_save_CPPFLAGS"
        LIBICONV=
        LTLIBICONV=
      fi
      AC_SUBST([LIBICONV])
      AC_SUBST([LTLIBICONV])
    ])
    
    dnl Define AM_ICONV using AC_DEFUN_ONCE for Autoconf >= 2.64, in order to
    dnl avoid warnings like
    dnl "warning: AC_REQUIRE: `AM_ICONV' was expanded before it was required".
    dnl This is tricky because of the way 'aclocal' is implemented:
    dnl - It requires defining an auxiliary macro whose name ends in AC_DEFUN.
    dnl   Otherwise aclocal's initial scan pass would miss the macro definition.
    dnl - It requires a line break inside the AC_DEFUN_ONCE and AC_DEFUN expansions.
    dnl   Otherwise aclocal would emit many "Use of uninitialized value $1"
    dnl   warnings.
    m4_define([gl_iconv_AC_DEFUN],
      m4_version_prereq([2.64],
        [[AC_DEFUN_ONCE(
            [$1], [$2])]],
        [m4_ifdef([gl_00GNULIB],
           [[AC_DEFUN_ONCE(
               [$1], [$2])]],
           [[AC_DEFUN(
               [$1], [$2])]])]))
    gl_iconv_AC_DEFUN([AM_ICONV],
    [
      AM_ICONV_LINK
      if test "$am_cv_func_iconv" = yes; then
        AC_MSG_CHECKING([for iconv declaration])
        AC_CACHE_VAL([am_cv_proto_iconv], [
          AC_COMPILE_IFELSE(
            [AC_LANG_PROGRAM(
               [[
    #include <stdlib.h>
    #include <iconv.h>
    extern
    #ifdef __cplusplus
    "C"
    #endif
    #if defined(__STDC__) || defined(_MSC_VER) || defined(__cplusplus)
    size_t iconv (iconv_t cd, char * *inbuf, size_t *inbytesleft, char * *outbuf, size_t *outbytesleft);
    #else
    size_t iconv();
    #endif
               ]],
               [[]])],
            [am_cv_proto_iconv_arg1=""],
            [am_cv_proto_iconv_arg1="const"])
          am_cv_proto_iconv="extern size_t iconv (iconv_t cd, $am_cv_proto_iconv_arg1 char * *inbuf, size_t *inbytesleft, char * *outbuf, size_t *outbytesleft);"])
        am_cv_proto_iconv=`echo "[$]am_cv_proto_iconv" | tr -s ' ' | sed -e 's/( /(/'`
        AC_MSG_RESULT([
             $am_cv_proto_iconv])
        AC_DEFINE_UNQUOTED([ICONV_CONST], [$am_cv_proto_iconv_arg1],
          [Define as const if the declaration of iconv() needs const.])
        dnl Also substitute ICONV_CONST in the gnulib generated <iconv.h>.
        m4_ifdef([gl_ICONV_H_DEFAULTS],
          [AC_REQUIRE([gl_ICONV_H_DEFAULTS])
           if test -n "$am_cv_proto_iconv_arg1"; then
             ICONV_CONST="const"
           fi
          ])
      fi
    ])
    # lib-ld.m4 serial 6
    dnl Copyright (C) 1996-2003, 2009-2013 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 Subroutines of libtool.m4,
    dnl with replacements s/_*LT_PATH/AC_LIB_PROG/ and s/lt_/acl_/ to avoid
    dnl collision with libtool.m4.
    
    dnl From libtool-2.4. Sets the variable with_gnu_ld to yes or no.
    AC_DEFUN([AC_LIB_PROG_LD_GNU],
    [AC_CACHE_CHECK([if the linker ($LD) is GNU ld], [acl_cv_prog_gnu_ld],
    [# I'd rather use --version here, but apparently some GNU lds only accept -v.
    case `$LD -v 2>&1 </dev/null` in
    *GNU* | *'with BFD'*)
      acl_cv_prog_gnu_ld=yes
      ;;
    *)
      acl_cv_prog_gnu_ld=no
      ;;
    esac])
    with_gnu_ld=$acl_cv_prog_gnu_ld
    ])
    
    dnl From libtool-2.4. Sets the variable LD.
    AC_DEFUN([AC_LIB_PROG_LD],
    [AC_REQUIRE([AC_PROG_CC])dnl
    AC_REQUIRE([AC_CANONICAL_HOST])dnl
    
    AC_ARG_WITH([gnu-ld],
        [AS_HELP_STRING([--with-gnu-ld],
            [assume the C compiler uses GNU ld [default=no]])],
        [test "$withval" = no || with_gnu_ld=yes],
        [with_gnu_ld=no])dnl
    
    # Prepare PATH_SEPARATOR.
    # The user is always right.
    if test "${PATH_SEPARATOR+set}" != set; then
      # Determine PATH_SEPARATOR by trying to find /bin/sh in a PATH which
      # contains only /bin. Note that ksh looks also at the FPATH variable,
      # so we have to set that as well for the test.
      PATH_SEPARATOR=:
      (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 \
        && { (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 \
               || PATH_SEPARATOR=';'
           }
    fi
    
    ac_prog=ld
    if test "$GCC" = yes; then
      # Check if gcc -print-prog-name=ld gives a path.
      AC_MSG_CHECKING([for ld used by $CC])
      case $host in
      *-*-mingw*)
        # gcc leaves a trailing carriage return which upsets mingw
        ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
      *)
        ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
      esac
      case $ac_prog in
        # Accept absolute paths.
        [[\\/]]* | ?:[[\\/]]*)
          re_direlt='/[[^/]][[^/]]*/\.\./'
          # Canonicalize the pathname 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([acl_cv_path_LD],
    [if test -z "$LD"; then
      acl_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
      for ac_dir in $PATH; do
        IFS="$acl_save_ifs"
        test -z "$ac_dir" && ac_dir=.
        if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
          acl_cv_path_LD="$ac_dir/$ac_prog"
          # Check to see if the program is GNU ld.  I'd rather use --version,
          # but apparently some variants of GNU ld only accept -v.
          # Break only if it was the GNU/non-GNU ld that we prefer.
          case `"$acl_cv_path_LD" -v 2>&1 </dev/null` in
          *GNU* | *'with BFD'*)
            test "$with_gnu_ld" != no && break
            ;;
          *)
            test "$with_gnu_ld" != yes && break
            ;;
          esac
        fi
      done
      IFS="$acl_save_ifs"
    else
      acl_cv_path_LD="$LD" # Let the user override the test with a path.
    fi])
    LD="$acl_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_LIB_PROG_LD_GNU
    ])
    # lib-link.m4 serial 26 (gettext-0.18.2)
    dnl Copyright (C) 2001-2013 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 From Bruno Haible.
    
    AC_PREREQ([2.54])
    
    dnl AC_LIB_LINKFLAGS(name [, dependencies]) searches for libname and
    dnl the libraries corresponding to explicit and implicit dependencies.
    dnl Sets and AC_SUBSTs the LIB${NAME} and LTLIB${NAME} variables and
    dnl augments the CPPFLAGS variable.
    dnl Sets and AC_SUBSTs the LIB${NAME}_PREFIX variable to nonempty if libname
    dnl was found in ${LIB${NAME}_PREFIX}/$acl_libdirstem.
    AC_DEFUN([AC_LIB_LINKFLAGS],
    [
      AC_REQUIRE([AC_LIB_PREPARE_PREFIX])
      AC_REQUIRE([AC_LIB_RPATH])
      pushdef([Name],[m4_translit([$1],[./+-], [____])])
      pushdef([NAME],[m4_translit([$1],[abcdefghijklmnopqrstuvwxyz./+-],
                                       [ABCDEFGHIJKLMNOPQRSTUVWXYZ____])])
      AC_CACHE_CHECK([how to link with lib[]$1], [ac_cv_lib[]Name[]_libs], [
        AC_LIB_LINKFLAGS_BODY([$1], [$2])
        ac_cv_lib[]Name[]_libs="$LIB[]NAME"
        ac_cv_lib[]Name[]_ltlibs="$LTLIB[]NAME"
        ac_cv_lib[]Name[]_cppflags="$INC[]NAME"
        ac_cv_lib[]Name[]_prefix="$LIB[]NAME[]_PREFIX"
      ])
      LIB[]NAME="$ac_cv_lib[]Name[]_libs"
      LTLIB[]NAME="$ac_cv_lib[]Name[]_ltlibs"
      INC[]NAME="$ac_cv_lib[]Name[]_cppflags"
      LIB[]NAME[]_PREFIX="$ac_cv_lib[]Name[]_prefix"
      AC_LIB_APPENDTOVAR([CPPFLAGS], [$INC]NAME)
      AC_SUBST([LIB]NAME)
      AC_SUBST([LTLIB]NAME)
      AC_SUBST([LIB]NAME[_PREFIX])
      dnl Also set HAVE_LIB[]NAME so that AC_LIB_HAVE_LINKFLAGS can reuse the
      dnl results of this search when this library appears as a dependency.
      HAVE_LIB[]NAME=yes
      popdef([NAME])
      popdef([Name])
    ])
    
    dnl AC_LIB_HAVE_LINKFLAGS(name, dependencies, includes, testcode, [missing-message])
    dnl searches for libname and the libraries corresponding to explicit and
    dnl implicit dependencies, together with the specified include files and
    dnl the ability to compile and link the specified testcode. The missing-message
    dnl defaults to 'no' and may contain additional hints for the user.
    dnl If found, it sets and AC_SUBSTs HAVE_LIB${NAME}=yes and the LIB${NAME}
    dnl and LTLIB${NAME} variables and augments the CPPFLAGS variable, and
    dnl #defines HAVE_LIB${NAME} to 1. Otherwise, it sets and AC_SUBSTs
    dnl HAVE_LIB${NAME}=no and LIB${NAME} and LTLIB${NAME} to empty.
    dnl Sets and AC_SUBSTs the LIB${NAME}_PREFIX variable to nonempty if libname
    dnl was found in ${LIB${NAME}_PREFIX}/$acl_libdirstem.
    AC_DEFUN([AC_LIB_HAVE_LINKFLAGS],
    [
      AC_REQUIRE([AC_LIB_PREPARE_PREFIX])
      AC_REQUIRE([AC_LIB_RPATH])
      pushdef([Name],[m4_translit([$1],[./+-], [____])])
      pushdef([NAME],[m4_translit([$1],[abcdefghijklmnopqrstuvwxyz./+-],
                                       [ABCDEFGHIJKLMNOPQRSTUVWXYZ____])])
    
      dnl Search for lib[]Name and define LIB[]NAME, LTLIB[]NAME and INC[]NAME
      dnl accordingly.
      AC_LIB_LINKFLAGS_BODY([$1], [$2])
    
      dnl Add $INC[]NAME to CPPFLAGS before performing the following checks,
      dnl because if the user has installed lib[]Name and not disabled its use
      dnl via --without-lib[]Name-prefix, he wants to use it.
      ac_save_CPPFLAGS="$CPPFLAGS"
      AC_LIB_APPENDTOVAR([CPPFLAGS], [$INC]NAME)
    
      AC_CACHE_CHECK([for lib[]$1], [ac_cv_lib[]Name], [
        ac_save_LIBS="$LIBS"
        dnl If $LIB[]NAME contains some -l options, add it to the end of LIBS,
        dnl because these -l options might require -L options that are present in
        dnl LIBS. -l options benefit only from the -L options listed before it.
        dnl Otherwise, add it to the front of LIBS, because it may be a static
        dnl library that depends on another static library that is present in LIBS.
        dnl Static libraries benefit only from the static libraries listed after
        dnl it.
        case " $LIB[]NAME" in
          *" -l"*) LIBS="$LIBS $LIB[]NAME" ;;
          *)       LIBS="$LIB[]NAME $LIBS" ;;
        esac
        AC_LINK_IFELSE(
          [AC_LANG_PROGRAM([[$3]], [[$4]])],
          [ac_cv_lib[]Name=yes],
          [ac_cv_lib[]Name='m4_if([$5], [], [no], [[$5]])'])
        LIBS="$ac_save_LIBS"
      ])
      if test "$ac_cv_lib[]Name" = yes; then
        HAVE_LIB[]NAME=yes
        AC_DEFINE([HAVE_LIB]NAME, 1, [Define if you have the lib][$1 library.])
        AC_MSG_CHECKING([how to link with lib[]$1])
        AC_MSG_RESULT([$LIB[]NAME])
      else
        HAVE_LIB[]NAME=no
        dnl If $LIB[]NAME didn't lead to a usable library, we don't need
        dnl $INC[]NAME either.
        CPPFLAGS="$ac_save_CPPFLAGS"
        LIB[]NAME=
        LTLIB[]NAME=
        LIB[]NAME[]_PREFIX=
      fi
      AC_SUBST([HAVE_LIB]NAME)
      AC_SUBST([LIB]NAME)
      AC_SUBST([LTLIB]NAME)
      AC_SUBST([LIB]NAME[_PREFIX])
      popdef([NAME])
      popdef([Name])
    ])
    
    dnl Determine the platform dependent parameters needed to use rpath:
    dnl   acl_libext,
    dnl   acl_shlibext,
    dnl   acl_libname_spec,
    dnl   acl_library_names_spec,
    dnl   acl_hardcode_libdir_flag_spec,
    dnl   acl_hardcode_libdir_separator,
    dnl   acl_hardcode_direct,
    dnl   acl_hardcode_minus_L.
    AC_DEFUN([AC_LIB_RPATH],
    [
      dnl Tell automake >= 1.10 to complain if config.rpath is missing.
      m4_ifdef([AC_REQUIRE_AUX_FILE], [AC_REQUIRE_AUX_FILE([config.rpath])])
      AC_REQUIRE([AC_PROG_CC])                dnl we use $CC, $GCC, $LDFLAGS
      AC_REQUIRE([AC_LIB_PROG_LD])            dnl we use $LD, $with_gnu_ld
      AC_REQUIRE([AC_CANONICAL_HOST])         dnl we use $host
      AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT]) dnl we use $ac_aux_dir
      AC_CACHE_CHECK([for shared library run path origin], [acl_cv_rpath], [
        CC="$CC" GCC="$GCC" LDFLAGS="$LDFLAGS" LD="$LD" with_gnu_ld="$with_gnu_ld" \
        ${CONFIG_SHELL-/bin/sh} "$ac_aux_dir/config.rpath" "$host" > conftest.sh
        . ./conftest.sh
        rm -f ./conftest.sh
        acl_cv_rpath=done
      ])
      wl="$acl_cv_wl"
      acl_libext="$acl_cv_libext"
      acl_shlibext="$acl_cv_shlibext"
      acl_libname_spec="$acl_cv_libname_spec"
      acl_library_names_spec="$acl_cv_library_names_spec"
      acl_hardcode_libdir_flag_spec="$acl_cv_hardcode_libdir_flag_spec"
      acl_hardcode_libdir_separator="$acl_cv_hardcode_libdir_separator"
      acl_hardcode_direct="$acl_cv_hardcode_direct"
      acl_hardcode_minus_L="$acl_cv_hardcode_minus_L"
      dnl Determine whether the user wants rpath handling at all.
      AC_ARG_ENABLE([rpath],
        [  --disable-rpath         do not hardcode runtime library paths],
        :, enable_rpath=yes)
    ])
    
    dnl AC_LIB_FROMPACKAGE(name, package)
    dnl declares that libname comes from the given package. The configure file
    dnl will then not have a --with-libname-prefix option but a
    dnl --with-package-prefix option. Several libraries can come from the same
    dnl package. This declaration must occur before an AC_LIB_LINKFLAGS or similar
    dnl macro call that searches for libname.
    AC_DEFUN([AC_LIB_FROMPACKAGE],
    [
      pushdef([NAME],[m4_translit([$1],[abcdefghijklmnopqrstuvwxyz./+-],
                                       [ABCDEFGHIJKLMNOPQRSTUVWXYZ____])])
      define([acl_frompackage_]NAME, [$2])
      popdef([NAME])
      pushdef([PACK],[$2])
      pushdef([PACKUP],[m4_translit(PACK,[abcdefghijklmnopqrstuvwxyz./+-],
                                         [ABCDEFGHIJKLMNOPQRSTUVWXYZ____])])
      define([acl_libsinpackage_]PACKUP,
        m4_ifdef([acl_libsinpackage_]PACKUP, [m4_defn([acl_libsinpackage_]PACKUP)[, ]],)[lib$1])
      popdef([PACKUP])
      popdef([PACK])
    ])
    
    dnl AC_LIB_LINKFLAGS_BODY(name [, dependencies]) searches for libname and
    dnl the libraries corresponding to explicit and implicit dependencies.
    dnl Sets the LIB${NAME}, LTLIB${NAME} and INC${NAME} variables.
    dnl Also, sets the LIB${NAME}_PREFIX variable to nonempty if libname was found
    dnl in ${LIB${NAME}_PREFIX}/$acl_libdirstem.
    AC_DEFUN([AC_LIB_LINKFLAGS_BODY],
    [
      AC_REQUIRE([AC_LIB_PREPARE_MULTILIB])
      pushdef([NAME],[m4_translit([$1],[abcdefghijklmnopqrstuvwxyz./+-],
                                       [ABCDEFGHIJKLMNOPQRSTUVWXYZ____])])
      pushdef([PACK],[m4_ifdef([acl_frompackage_]NAME, [acl_frompackage_]NAME, lib[$1])])
      pushdef([PACKUP],[m4_translit(PACK,[abcdefghijklmnopqrstuvwxyz./+-],
                                         [ABCDEFGHIJKLMNOPQRSTUVWXYZ____])])
      pushdef([PACKLIBS],[m4_ifdef([acl_frompackage_]NAME, [acl_libsinpackage_]PACKUP, lib[$1])])
      dnl Autoconf >= 2.61 supports dots in --with options.
      pushdef([P_A_C_K],[m4_if(m4_version_compare(m4_defn([m4_PACKAGE_VERSION]),[2.61]),[-1],[m4_translit(PACK,[.],[_])],PACK)])
      dnl By default, look in $includedir and $libdir.
      use_additional=yes
      AC_LIB_WITH_FINAL_PREFIX([
        eval additional_includedir=\"$includedir\"
        eval additional_libdir=\"$libdir\"
      ])
      AC_ARG_WITH(P_A_C_K[-prefix],
    [[  --with-]]P_A_C_K[[-prefix[=DIR]  search for ]PACKLIBS[ in DIR/include and DIR/lib
      --without-]]P_A_C_K[[-prefix     don't search for ]PACKLIBS[ in includedir and libdir]],
    [
        if test "X$withval" = "Xno"; then
          use_additional=no
        else
          if test "X$withval" = "X"; then
            AC_LIB_WITH_FINAL_PREFIX([
              eval additional_includedir=\"$includedir\"
              eval additional_libdir=\"$libdir\"
            ])
          else
            additional_includedir="$withval/include"
            additional_libdir="$withval/$acl_libdirstem"
            if test "$acl_libdirstem2" != "$acl_libdirstem" \
               && ! test -d "$withval/$acl_libdirstem"; then
              additional_libdir="$withval/$acl_libdirstem2"
            fi
          fi
        fi
    ])
      dnl Search the library and its dependencies in $additional_libdir and
      dnl $LDFLAGS. Using breadth-first-seach.
      LIB[]NAME=
      LTLIB[]NAME=
      INC[]NAME=
      LIB[]NAME[]_PREFIX=
      dnl HAVE_LIB${NAME} is an indicator that LIB${NAME}, LTLIB${NAME} have been
      dnl computed. So it has to be reset here.
      HAVE_LIB[]NAME=
      rpathdirs=
      ltrpathdirs=
      names_already_handled=
      names_next_round='$1 $2'
      while test -n "$names_next_round"; do
        names_this_round="$names_next_round"
        names_next_round=
        for name in $names_this_round; do
          already_handled=
          for n in $names_already_handled; do
            if test "$n" = "$name"; then
              already_handled=yes
              break
            fi
          done
          if test -z "$already_handled"; then
            names_already_handled="$names_already_handled $name"
            dnl See if it was already located by an earlier AC_LIB_LINKFLAGS
            dnl or AC_LIB_HAVE_LINKFLAGS call.
            uppername=`echo "$name" | sed -e 'y|abcdefghijklmnopqrstuvwxyz./+-|ABCDEFGHIJKLMNOPQRSTUVWXYZ____|'`
            eval value=\"\$HAVE_LIB$uppername\"
            if test -n "$value"; then
              if test "$value" = yes; then
                eval value=\"\$LIB$uppername\"
                test -z "$value" || LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$value"
                eval value=\"\$LTLIB$uppername\"
                test -z "$value" || LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }$value"
              else
                dnl An earlier call to AC_LIB_HAVE_LINKFLAGS has determined
                dnl that this library doesn't exist. So just drop it.
                :
              fi
            else
              dnl Search the library lib$name in $additional_libdir and $LDFLAGS
              dnl and the already constructed $LIBNAME/$LTLIBNAME.
              found_dir=
              found_la=
              found_so=
              found_a=
              eval libname=\"$acl_libname_spec\"    # typically: libname=lib$name
              if test -n "$acl_shlibext"; then
                shrext=".$acl_shlibext"             # typically: shrext=.so
              else
                shrext=
              fi
              if test $use_additional = yes; then
                dir="$additional_libdir"
                dnl The same code as in the loop below:
                dnl First look for a shared library.
                if test -n "$acl_shlibext"; then
                  if test -f "$dir/$libname$shrext"; then
                    found_dir="$dir"
                    found_so="$dir/$libname$shrext"
                  else
                    if test "$acl_library_names_spec" = '$libname$shrext$versuffix'; then
                      ver=`(cd "$dir" && \
                            for f in "$libname$shrext".*; do echo "$f"; done \
                            | sed -e "s,^$libname$shrext\\\\.,," \
                            | sort -t '.' -n -r -k1,1 -k2,2 -k3,3 -k4,4 -k5,5 \
                            | sed 1q ) 2>/dev/null`
                      if test -n "$ver" && test -f "$dir/$libname$shrext.$ver"; then
                        found_dir="$dir"
                        found_so="$dir/$libname$shrext.$ver"
                      fi
                    else
                      eval library_names=\"$acl_library_names_spec\"
                      for f in $library_names; do
                        if test -f "$dir/$f"; then
                          found_dir="$dir"
                          found_so="$dir/$f"
                          break
                        fi
                      done
                    fi
                  fi
                fi
                dnl Then look for a static library.
                if test "X$found_dir" = "X"; then
                  if test -f "$dir/$libname.$acl_libext"; then
                    found_dir="$dir"
                    found_a="$dir/$libname.$acl_libext"
                  fi
                fi
                if test "X$found_dir" != "X"; then
                  if test -f "$dir/$libname.la"; then
                    found_la="$dir/$libname.la"
                  fi
                fi
              fi
              if test "X$found_dir" = "X"; then
                for x in $LDFLAGS $LTLIB[]NAME; do
                  AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
                  case "$x" in
                    -L*)
                      dir=`echo "X$x" | sed -e 's/^X-L//'`
                      dnl First look for a shared library.
                      if test -n "$acl_shlibext"; then
                        if test -f "$dir/$libname$shrext"; then
                          found_dir="$dir"
                          found_so="$dir/$libname$shrext"
                        else
                          if test "$acl_library_names_spec" = '$libname$shrext$versuffix'; then
                            ver=`(cd "$dir" && \
                                  for f in "$libname$shrext".*; do echo "$f"; done \
                                  | sed -e "s,^$libname$shrext\\\\.,," \
                                  | sort -t '.' -n -r -k1,1 -k2,2 -k3,3 -k4,4 -k5,5 \
                                  | sed 1q ) 2>/dev/null`
                            if test -n "$ver" && test -f "$dir/$libname$shrext.$ver"; then
                              found_dir="$dir"
                              found_so="$dir/$libname$shrext.$ver"
                            fi
                          else
                            eval library_names=\"$acl_library_names_spec\"
                            for f in $library_names; do
                              if test -f "$dir/$f"; then
                                found_dir="$dir"
                                found_so="$dir/$f"
                                break
                              fi
                            done
                          fi
                        fi
                      fi
                      dnl Then look for a static library.
                      if test "X$found_dir" = "X"; then
                        if test -f "$dir/$libname.$acl_libext"; then
                          found_dir="$dir"
                          found_a="$dir/$libname.$acl_libext"
                        fi
                      fi
                      if test "X$found_dir" != "X"; then
                        if test -f "$dir/$libname.la"; then
                          found_la="$dir/$libname.la"
                        fi
                      fi
                      ;;
                  esac
                  if test "X$found_dir" != "X"; then
                    break
                  fi
                done
              fi
              if test "X$found_dir" != "X"; then
                dnl Found the library.
                LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-L$found_dir -l$name"
                if test "X$found_so" != "X"; then
                  dnl Linking with a shared library. We attempt to hardcode its
                  dnl directory into the executable's runpath, unless it's the
                  dnl standard /usr/lib.
                  if test "$enable_rpath" = no \
                     || test "X$found_dir" = "X/usr/$acl_libdirstem" \
                     || test "X$found_dir" = "X/usr/$acl_libdirstem2"; then
                    dnl No hardcoding is needed.
                    LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so"
                  else
                    dnl Use an explicit option to hardcode DIR into the resulting
                    dnl binary.
                    dnl Potentially add DIR to ltrpathdirs.
                    dnl The ltrpathdirs will be appended to $LTLIBNAME at the end.
                    haveit=
                    for x in $ltrpathdirs; do
                      if test "X$x" = "X$found_dir"; then
                        haveit=yes
                        break
                      fi
                    done
                    if test -z "$haveit"; then
                      ltrpathdirs="$ltrpathdirs $found_dir"
                    fi
                    dnl The hardcoding into $LIBNAME is system dependent.
                    if test "$acl_hardcode_direct" = yes; then
                      dnl Using DIR/libNAME.so during linking hardcodes DIR into the
                      dnl resulting binary.
                      LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so"
                    else
                      if test -n "$acl_hardcode_libdir_flag_spec" && test "$acl_hardcode_minus_L" = no; then
                        dnl Use an explicit option to hardcode DIR into the resulting
                        dnl binary.
                        LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so"
                        dnl Potentially add DIR to rpathdirs.
                        dnl The rpathdirs will be appended to $LIBNAME at the end.
                        haveit=
                        for x in $rpathdirs; do
                          if test "X$x" = "X$found_dir"; then
                            haveit=yes
                            break
                          fi
                        done
                        if test -z "$haveit"; then
                          rpathdirs="$rpathdirs $found_dir"
                        fi
                      else
                        dnl Rely on "-L$found_dir".
                        dnl But don't add it if it's already contained in the LDFLAGS
                        dnl or the already constructed $LIBNAME
                        haveit=
                        for x in $LDFLAGS $LIB[]NAME; do
                          AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
                          if test "X$x" = "X-L$found_dir"; then
                            haveit=yes
                            break
                          fi
                        done
                        if test -z "$haveit"; then
                          LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$found_dir"
                        fi
                        if test "$acl_hardcode_minus_L" != no; then
                          dnl FIXME: Not sure whether we should use
                          dnl "-L$found_dir -l$name" or "-L$found_dir $found_so"
                          dnl here.
                          LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so"
                        else
                          dnl We cannot use $acl_hardcode_runpath_var and LD_RUN_PATH
                          dnl here, because this doesn't fit in flags passed to the
                          dnl compiler. So give up. No hardcoding. This affects only
                          dnl very old systems.
                          dnl FIXME: Not sure whether we should use
                          dnl "-L$found_dir -l$name" or "-L$found_dir $found_so"
                          dnl here.
                          LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-l$name"
                        fi
                      fi
                    fi
                  fi
                else
                  if test "X$found_a" != "X"; then
                    dnl Linking with a static library.
                    LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_a"
                  else
                    dnl We shouldn't come here, but anyway it's good to have a
                    dnl fallback.
                    LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$found_dir -l$name"
                  fi
                fi
                dnl Assume the include files are nearby.
                additional_includedir=
                case "$found_dir" in
                  */$acl_libdirstem | */$acl_libdirstem/)
                    basedir=`echo "X$found_dir" | sed -e 's,^X,,' -e "s,/$acl_libdirstem/"'*$,,'`
                    if test "$name" = '$1'; then
                      LIB[]NAME[]_PREFIX="$basedir"
                    fi
                    additional_includedir="$basedir/include"
                    ;;
                  */$acl_libdirstem2 | */$acl_libdirstem2/)
                    basedir=`echo "X$found_dir" | sed -e 's,^X,,' -e "s,/$acl_libdirstem2/"'*$,,'`
                    if test "$name" = '$1'; then
                      LIB[]NAME[]_PREFIX="$basedir"
                    fi
                    additional_includedir="$basedir/include"
                    ;;
                esac
                if test "X$additional_includedir" != "X"; then
                  dnl Potentially add $additional_includedir to $INCNAME.
                  dnl But don't add it
                  dnl   1. if it's the standard /usr/include,
                  dnl   2. if it's /usr/local/include and we are using GCC on Linux,
                  dnl   3. if it's already present in $CPPFLAGS or the already
                  dnl      constructed $INCNAME,
                  dnl   4. if it doesn't exist as a directory.
                  if test "X$additional_includedir" != "X/usr/include"; then
                    haveit=
                    if test "X$additional_includedir" = "X/usr/local/include"; then
                      if test -n "$GCC"; then
                        case $host_os in
                          linux* | gnu* | k*bsd*-gnu) haveit=yes;;
                        esac
                      fi
                    fi
                    if test -z "$haveit"; then
                      for x in $CPPFLAGS $INC[]NAME; do
                        AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
                        if test "X$x" = "X-I$additional_includedir"; then
                          haveit=yes
                          break
                        fi
                      done
                      if test -z "$haveit"; then
                        if test -d "$additional_includedir"; then
                          dnl Really add $additional_includedir to $INCNAME.
                          INC[]NAME="${INC[]NAME}${INC[]NAME:+ }-I$additional_includedir"
                        fi
                      fi
                    fi
                  fi
                fi
                dnl Look for dependencies.
                if test -n "$found_la"; then
                  dnl Read the .la file. It defines the variables
                  dnl dlname, library_names, old_library, dependency_libs, current,
                  dnl age, revision, installed, dlopen, dlpreopen, libdir.
                  save_libdir="$libdir"
                  case "$found_la" in
                    */* | *\\*) . "$found_la" ;;
                    *) . "./$found_la" ;;
                  esac
                  libdir="$save_libdir"
                  dnl We use only dependency_libs.
                  for dep in $dependency_libs; do
                    case "$dep" in
                      -L*)
                        additional_libdir=`echo "X$dep" | sed -e 's/^X-L//'`
                        dnl Potentially add $additional_libdir to $LIBNAME and $LTLIBNAME.
                        dnl But don't add it
                        dnl   1. if it's the standard /usr/lib,
                        dnl   2. if it's /usr/local/lib and we are using GCC on Linux,
                        dnl   3. if it's already present in $LDFLAGS or the already
                        dnl      constructed $LIBNAME,
                        dnl   4. if it doesn't exist as a directory.
                        if test "X$additional_libdir" != "X/usr/$acl_libdirstem" \
                           && test "X$additional_libdir" != "X/usr/$acl_libdirstem2"; then
                          haveit=
                          if test "X$additional_libdir" = "X/usr/local/$acl_libdirstem" \
                             || test "X$additional_libdir" = "X/usr/local/$acl_libdirstem2"; then
                            if test -n "$GCC"; then
                              case $host_os in
                                linux* | gnu* | k*bsd*-gnu) haveit=yes;;
                              esac
                            fi
                          fi
                          if test -z "$haveit"; then
                            haveit=
                            for x in $LDFLAGS $LIB[]NAME; do
                              AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
                              if test "X$x" = "X-L$additional_libdir"; then
                                haveit=yes
                                break
                              fi
                            done
                            if test -z "$haveit"; then
                              if test -d "$additional_libdir"; then
                                dnl Really add $additional_libdir to $LIBNAME.
                                LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$additional_libdir"
                              fi
                            fi
                            haveit=
                            for x in $LDFLAGS $LTLIB[]NAME; do
                              AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
                              if test "X$x" = "X-L$additional_libdir"; then
                                haveit=yes
                                break
                              fi
                            done
                            if test -z "$haveit"; then
                              if test -d "$additional_libdir"; then
                                dnl Really add $additional_libdir to $LTLIBNAME.
                                LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-L$additional_libdir"
                              fi
                            fi
                          fi
                        fi
                        ;;
                      -R*)
                        dir=`echo "X$dep" | sed -e 's/^X-R//'`
                        if test "$enable_rpath" != no; then
                          dnl Potentially add DIR to rpathdirs.
                          dnl The rpathdirs will be appended to $LIBNAME at the end.
                          haveit=
                          for x in $rpathdirs; do
                            if test "X$x" = "X$dir"; then
                              haveit=yes
                              break
                            fi
                          done
                          if test -z "$haveit"; then
                            rpathdirs="$rpathdirs $dir"
                          fi
                          dnl Potentially add DIR to ltrpathdirs.
                          dnl The ltrpathdirs will be appended to $LTLIBNAME at the end.
                          haveit=
                          for x in $ltrpathdirs; do
                            if test "X$x" = "X$dir"; then
                              haveit=yes
                              break
                            fi
                          done
                          if test -z "$haveit"; then
                            ltrpathdirs="$ltrpathdirs $dir"
                          fi
                        fi
                        ;;
                      -l*)
                        dnl Handle this in the next round.
                        names_next_round="$names_next_round "`echo "X$dep" | sed -e 's/^X-l//'`
                        ;;
                      *.la)
                        dnl Handle this in the next round. Throw away the .la's
                        dnl directory; it is already contained in a preceding -L
                        dnl option.
                        names_next_round="$names_next_round "`echo "X$dep" | sed -e 's,^X.*/,,' -e 's,^lib,,' -e 's,\.la$,,'`
                        ;;
                      *)
                        dnl Most likely an immediate library name.
                        LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$dep"
                        LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }$dep"
                        ;;
                    esac
                  done
                fi
              else
                dnl Didn't find the library; assume it is in the system directories
                dnl known to the linker and runtime loader. (All the system
                dnl directories known to the linker should also be known to the
                dnl runtime loader, otherwise the system is severely misconfigured.)
                LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-l$name"
                LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-l$name"
              fi
            fi
          fi
        done
      done
      if test "X$rpathdirs" != "X"; then
        if test -n "$acl_hardcode_libdir_separator"; then
          dnl Weird platform: only the last -rpath option counts, the user must
          dnl pass all path elements in one option. We can arrange that for a
          dnl single library, but not when more than one $LIBNAMEs are used.
          alldirs=
          for found_dir in $rpathdirs; do
            alldirs="${alldirs}${alldirs:+$acl_hardcode_libdir_separator}$found_dir"
          done
          dnl Note: acl_hardcode_libdir_flag_spec uses $libdir and $wl.
          acl_save_libdir="$libdir"
          libdir="$alldirs"
          eval flag=\"$acl_hardcode_libdir_flag_spec\"
          libdir="$acl_save_libdir"
          LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$flag"
        else
          dnl The -rpath options are cumulative.
          for found_dir in $rpathdirs; do
            acl_save_libdir="$libdir"
            libdir="$found_dir"
            eval flag=\"$acl_hardcode_libdir_flag_spec\"
            libdir="$acl_save_libdir"
            LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$flag"
          done
        fi
      fi
      if test "X$ltrpathdirs" != "X"; then
        dnl When using libtool, the option that works for both libraries and
        dnl executables is -R. The -R options are cumulative.
        for found_dir in $ltrpathdirs; do
          LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-R$found_dir"
        done
      fi
      popdef([P_A_C_K])
      popdef([PACKLIBS])
      popdef([PACKUP])
      popdef([PACK])
      popdef([NAME])
    ])
    
    dnl AC_LIB_APPENDTOVAR(VAR, CONTENTS) appends the elements of CONTENTS to VAR,
    dnl unless already present in VAR.
    dnl Works only for CPPFLAGS, not for LIB* variables because that sometimes
    dnl contains two or three consecutive elements that belong together.
    AC_DEFUN([AC_LIB_APPENDTOVAR],
    [
      for element in [$2]; do
        haveit=
        for x in $[$1]; do
          AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
          if test "X$x" = "X$element"; then
            haveit=yes
            break
          fi
        done
        if test -z "$haveit"; then
          [$1]="${[$1]}${[$1]:+ }$element"
        fi
      done
    ])
    
    dnl For those cases where a variable contains several -L and -l options
    dnl referring to unknown libraries and directories, this macro determines the
    dnl necessary additional linker options for the runtime path.
    dnl AC_LIB_LINKFLAGS_FROM_LIBS([LDADDVAR], [LIBSVALUE], [USE-LIBTOOL])
    dnl sets LDADDVAR to linker options needed together with LIBSVALUE.
    dnl If USE-LIBTOOL evaluates to non-empty, linking with libtool is assumed,
    dnl otherwise linking without libtool is assumed.
    AC_DEFUN([AC_LIB_LINKFLAGS_FROM_LIBS],
    [
      AC_REQUIRE([AC_LIB_RPATH])
      AC_REQUIRE([AC_LIB_PREPARE_MULTILIB])
      $1=
      if test "$enable_rpath" != no; then
        if test -n "$acl_hardcode_libdir_flag_spec" && test "$acl_hardcode_minus_L" = no; then
          dnl Use an explicit option to hardcode directories into the resulting
          dnl binary.
          rpathdirs=
          next=
          for opt in $2; do
            if test -n "$next"; then
              dir="$next"
              dnl No need to hardcode the standard /usr/lib.
              if test "X$dir" != "X/usr/$acl_libdirstem" \
                 && test "X$dir" != "X/usr/$acl_libdirstem2"; then
                rpathdirs="$rpathdirs $dir"
              fi
              next=
            else
              case $opt in
                -L) next=yes ;;
                -L*) dir=`echo "X$opt" | sed -e 's,^X-L,,'`
                     dnl No need to hardcode the standard /usr/lib.
                     if test "X$dir" != "X/usr/$acl_libdirstem" \
                        && test "X$dir" != "X/usr/$acl_libdirstem2"; then
                       rpathdirs="$rpathdirs $dir"
                     fi
                     next= ;;
                *) next= ;;
              esac
            fi
          done
          if test "X$rpathdirs" != "X"; then
            if test -n ""$3""; then
              dnl libtool is used for linking. Use -R options.
              for dir in $rpathdirs; do
                $1="${$1}${$1:+ }-R$dir"
              done
            else
              dnl The linker is used for linking directly.
              if test -n "$acl_hardcode_libdir_separator"; then
                dnl Weird platform: only the last -rpath option counts, the user
                dnl must pass all path elements in one option.
                alldirs=
                for dir in $rpathdirs; do
                  alldirs="${alldirs}${alldirs:+$acl_hardcode_libdir_separator}$dir"
                done
                acl_save_libdir="$libdir"
                libdir="$alldirs"
                eval flag=\"$acl_hardcode_libdir_flag_spec\"
                libdir="$acl_save_libdir"
                $1="$flag"
              else
                dnl The -rpath options are cumulative.
                for dir in $rpathdirs; do
                  acl_save_libdir="$libdir"
                  libdir="$dir"
                  eval flag=\"$acl_hardcode_libdir_flag_spec\"
                  libdir="$acl_save_libdir"
                  $1="${$1}${$1:+ }$flag"
                done
              fi
            fi
          fi
        fi
      fi
      AC_SUBST([$1])
    ])
    # lib-prefix.m4 serial 7 (gettext-0.18)
    dnl Copyright (C) 2001-2005, 2008-2013 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 From Bruno Haible.
    
    dnl AC_LIB_ARG_WITH is synonymous to AC_ARG_WITH in autoconf-2.13, and
    dnl similar to AC_ARG_WITH in autoconf 2.52...2.57 except that is doesn't
    dnl require excessive bracketing.
    ifdef([AC_HELP_STRING],
    [AC_DEFUN([AC_LIB_ARG_WITH], [AC_ARG_WITH([$1],[[$2]],[$3],[$4])])],
    [AC_DEFUN([AC_][LIB_ARG_WITH], [AC_ARG_WITH([$1],[$2],[$3],[$4])])])
    
    dnl AC_LIB_PREFIX adds to the CPPFLAGS and LDFLAGS the flags that are needed
    dnl to access previously installed libraries. The basic assumption is that
    dnl a user will want packages to use other packages he previously installed
    dnl with the same --prefix option.
    dnl This macro is not needed if only AC_LIB_LINKFLAGS is used to locate
    dnl libraries, but is otherwise very convenient.
    AC_DEFUN([AC_LIB_PREFIX],
    [
      AC_BEFORE([$0], [AC_LIB_LINKFLAGS])
      AC_REQUIRE([AC_PROG_CC])
      AC_REQUIRE([AC_CANONICAL_HOST])
      AC_REQUIRE([AC_LIB_PREPARE_MULTILIB])
      AC_REQUIRE([AC_LIB_PREPARE_PREFIX])
      dnl By default, look in $includedir and $libdir.
      use_additional=yes
      AC_LIB_WITH_FINAL_PREFIX([
        eval additional_includedir=\"$includedir\"
        eval additional_libdir=\"$libdir\"
      ])
      AC_LIB_ARG_WITH([lib-prefix],
    [  --with-lib-prefix[=DIR] search for libraries in DIR/include and DIR/lib
      --without-lib-prefix    don't search for libraries in includedir and libdir],
    [
        if test "X$withval" = "Xno"; then
          use_additional=no
        else
          if test "X$withval" = "X"; then
            AC_LIB_WITH_FINAL_PREFIX([
              eval additional_includedir=\"$includedir\"
              eval additional_libdir=\"$libdir\"
            ])
          else
            additional_includedir="$withval/include"
            additional_libdir="$withval/$acl_libdirstem"
          fi
        fi
    ])
      if test $use_additional = yes; then
        dnl Potentially add $additional_includedir to $CPPFLAGS.
        dnl But don't add it
        dnl   1. if it's the standard /usr/include,
        dnl   2. if it's already present in $CPPFLAGS,
        dnl   3. if it's /usr/local/include and we are using GCC on Linux,
        dnl   4. if it doesn't exist as a directory.
        if test "X$additional_includedir" != "X/usr/include"; then
          haveit=
          for x in $CPPFLAGS; do
            AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
            if test "X$x" = "X-I$additional_includedir"; then
              haveit=yes
              break
            fi
          done
          if test -z "$haveit"; then
            if test "X$additional_includedir" = "X/usr/local/include"; then
              if test -n "$GCC"; then
                case $host_os in
                  linux* | gnu* | k*bsd*-gnu) haveit=yes;;
                esac
              fi
            fi
            if test -z "$haveit"; then
              if test -d "$additional_includedir"; then
                dnl Really add $additional_includedir to $CPPFLAGS.
                CPPFLAGS="${CPPFLAGS}${CPPFLAGS:+ }-I$additional_includedir"
              fi
            fi
          fi
        fi
        dnl Potentially add $additional_libdir to $LDFLAGS.
        dnl But don't add it
        dnl   1. if it's the standard /usr/lib,
        dnl   2. if it's already present in $LDFLAGS,
        dnl   3. if it's /usr/local/lib and we are using GCC on Linux,
        dnl   4. if it doesn't exist as a directory.
        if test "X$additional_libdir" != "X/usr/$acl_libdirstem"; then
          haveit=
          for x in $LDFLAGS; do
            AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
            if test "X$x" = "X-L$additional_libdir"; then
              haveit=yes
              break
            fi
          done
          if test -z "$haveit"; then
            if test "X$additional_libdir" = "X/usr/local/$acl_libdirstem"; then
              if test -n "$GCC"; then
                case $host_os in
                  linux*) haveit=yes;;
                esac
              fi
            fi
            if test -z "$haveit"; then
              if test -d "$additional_libdir"; then
                dnl Really add $additional_libdir to $LDFLAGS.
                LDFLAGS="${LDFLAGS}${LDFLAGS:+ }-L$additional_libdir"
              fi
            fi
          fi
        fi
      fi
    ])
    
    dnl AC_LIB_PREPARE_PREFIX creates variables acl_final_prefix,
    dnl acl_final_exec_prefix, containing the values to which $prefix and
    dnl $exec_prefix will expand at the end of the configure script.
    AC_DEFUN([AC_LIB_PREPARE_PREFIX],
    [
      dnl Unfortunately, prefix and exec_prefix get only finally determined
      dnl at the end of configure.
      if test "X$prefix" = "XNONE"; then
        acl_final_prefix="$ac_default_prefix"
      else
        acl_final_prefix="$prefix"
      fi
      if test "X$exec_prefix" = "XNONE"; then
        acl_final_exec_prefix='${prefix}'
      else
        acl_final_exec_prefix="$exec_prefix"
      fi
      acl_save_prefix="$prefix"
      prefix="$acl_final_prefix"
      eval acl_final_exec_prefix=\"$acl_final_exec_prefix\"
      prefix="$acl_save_prefix"
    ])
    
    dnl AC_LIB_WITH_FINAL_PREFIX([statement]) evaluates statement, with the
    dnl variables prefix and exec_prefix bound to the values they will have
    dnl at the end of the configure script.
    AC_DEFUN([AC_LIB_WITH_FINAL_PREFIX],
    [
      acl_save_prefix="$prefix"
      prefix="$acl_final_prefix"
      acl_save_exec_prefix="$exec_prefix"
      exec_prefix="$acl_final_exec_prefix"
      $1
      exec_prefix="$acl_save_exec_prefix"
      prefix="$acl_save_prefix"
    ])
    
    dnl AC_LIB_PREPARE_MULTILIB creates
    dnl - a variable acl_libdirstem, containing the basename of the libdir, either
    dnl   "lib" or "lib64" or "lib/64",
    dnl - a variable acl_libdirstem2, as a secondary possible value for
    dnl   acl_libdirstem, either the same as acl_libdirstem or "lib/sparcv9" or
    dnl   "lib/amd64".
    AC_DEFUN([AC_LIB_PREPARE_MULTILIB],
    [
      dnl There is no formal standard regarding lib and lib64.
      dnl On glibc systems, the current practice is that on a system supporting
      dnl 32-bit and 64-bit instruction sets or ABIs, 64-bit libraries go under
      dnl $prefix/lib64 and 32-bit libraries go under $prefix/lib. We determine
      dnl the compiler's default mode by looking at the compiler's library search
      dnl path. If at least one of its elements ends in /lib64 or points to a
      dnl directory whose absolute pathname ends in /lib64, we assume a 64-bit ABI.
      dnl Otherwise we use the default, namely "lib".
      dnl On Solaris systems, the current practice is that on a system supporting
      dnl 32-bit and 64-bit instruction sets or ABIs, 64-bit libraries go under
      dnl $prefix/lib/64 (which is a symlink to either $prefix/lib/sparcv9 or
      dnl $prefix/lib/amd64) and 32-bit libraries go under $prefix/lib.
      AC_REQUIRE([AC_CANONICAL_HOST])
      acl_libdirstem=lib
      acl_libdirstem2=
      case "$host_os" in
        solaris*)
          dnl See Solaris 10 Software Developer Collection > Solaris 64-bit Developer's Guide > The Development Environment
          dnl <http://docs.sun.com/app/docs/doc/816-5138/dev-env?l=en&a=view>.
          dnl "Portable Makefiles should refer to any library directories using the 64 symbolic link."
          dnl But we want to recognize the sparcv9 or amd64 subdirectory also if the
          dnl symlink is missing, so we set acl_libdirstem2 too.
          AC_CACHE_CHECK([for 64-bit host], [gl_cv_solaris_64bit],
            [AC_EGREP_CPP([sixtyfour bits], [
    #ifdef _LP64
    sixtyfour bits
    #endif
               ], [gl_cv_solaris_64bit=yes], [gl_cv_solaris_64bit=no])
            ])
          if test $gl_cv_solaris_64bit = yes; then
            acl_libdirstem=lib/64
            case "$host_cpu" in
              sparc*)        acl_libdirstem2=lib/sparcv9 ;;
              i*86 | x86_64) acl_libdirstem2=lib/amd64 ;;
            esac
          fi
          ;;
        *)
          searchpath=`(LC_ALL=C $CC -print-search-dirs) 2>/dev/null | sed -n -e 's,^libraries: ,,p' | sed -e 's,^=,,'`
          if test -n "$searchpath"; then
            acl_save_IFS="${IFS= 	}"; IFS=":"
            for searchdir in $searchpath; do
              if test -d "$searchdir"; then
                case "$searchdir" in
                  */lib64/ | */lib64 ) acl_libdirstem=lib64 ;;
                  */../ | */.. )
                    # Better ignore directories of this form. They are misleading.
                    ;;
                  *) searchdir=`cd "$searchdir" && pwd`
                     case "$searchdir" in
                       */lib64 ) acl_libdirstem=lib64 ;;
                     esac ;;
                esac
              fi
            done
            IFS="$acl_save_IFS"
          fi
          ;;
      esac
      test -n "$acl_libdirstem2" || acl_libdirstem2="$acl_libdirstem"
    ])