diff --git a/configure.ac b/configure.ac
index 58957b7..9d629d4 100644
--- a/configure.ac
+++ b/configure.ac
@@ -1,660 +1,661 @@
# configure.ac for libgpg-error
# Copyright (C) 2003, 2004, 2006, 2010, 2013-2017 g10 Code GmbH
#
# This file is part of libgpg-error.
#
# libgpg-error is free software; you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as
# published by the Free Software Foundation; either version 2.1 of the
# License, or (at your option) any later version.
#
# libgpg-error is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see .
# SPDX-License-Identifier: LGPL-2.1+
# (Process this file with autoconf to produce a configure script.)
# The following lines are used by ./autogen.sh.
AC_PREREQ(2.59)
min_automake_version="1.14"
# To build a release you need to create a tag with the version number
# (git tag -s libgpg-error-n.m) and run "./autogen.sh --force".
# Please bump the version number immediately after the release, do
# another commit, and a push so that the git magic is able to work.
# See below for the LT versions.
m4_define([mym4_package],[libgpg-error])
m4_define([mym4_major], [1])
m4_define([mym4_minor], [33])
# Below is m4 magic to extract and compute the revision number, the
# decimalized short revision number, a beta version string, and a flag
# indicating a development version (mym4_isgit). Note that the m4
# processing is done by autoconf and not during the configure run.
m4_define([mym4_verslist], m4_split(m4_esyscmd([./autogen.sh --find-version] \
mym4_package mym4_major mym4_minor),[:]))
m4_define([mym4_isbeta], m4_argn(2, mym4_verslist))
m4_define([mym4_version], m4_argn(4, mym4_verslist))
m4_define([mym4_revision], m4_argn(7, mym4_verslist))
m4_define([mym4_revision_dec], m4_argn(8, mym4_verslist))
m4_esyscmd([echo ]mym4_version[>VERSION])
AC_INIT([mym4_package],[mym4_version], [https://bugs.gnupg.org])
# LT Version numbers, remember to change them just *before* a release.
# (Code changed: REVISION++)
# (Interfaces added/removed/changed: CURRENT++, REVISION=0)
# (Interfaces added: AGE++)
# (Interfaces removed: AGE=0)
# Note that added error codes don't constitute an interface change.
LIBGPG_ERROR_LT_CURRENT=24
LIBGPG_ERROR_LT_AGE=24
LIBGPG_ERROR_LT_REVISION=3
################################################
AC_SUBST(LIBGPG_ERROR_LT_CURRENT)
AC_SUBST(LIBGPG_ERROR_LT_AGE)
AC_SUBST(LIBGPG_ERROR_LT_REVISION)
VERSION_NUMBER=m4_esyscmd(printf "0x%02x%02x00" mym4_major mym4_minor)
AC_SUBST(VERSION_NUMBER)
AC_CONFIG_AUX_DIR([build-aux])
AM_INIT_AUTOMAKE([serial-tests dist-bzip2])
AM_MAINTAINER_MODE
AC_CONFIG_SRCDIR([src/err-sources.h.in])
AC_CONFIG_HEADER([config.h])
AC_CONFIG_MACRO_DIR([m4])
AM_SILENT_RULES
# We need to know about the host architecture to avoid spurious
# warnings.
AC_CANONICAL_HOST
AB_INIT
# Checks for programs.
AC_PROG_CC
AM_PROG_CC_C_O
AC_PROG_CPP
AC_PROG_AWK
AC_CHECK_TOOL(AR, ar, :)
AC_GNU_SOURCE
# Set some variables depending on the platform for later use.
have_w32_system=no
have_w64_system=no
have_w32ce_system=no
case "${host}" in
x86_64-*mingw32*)
have_w32_system=yes
have_w64_system=yes
;;
*-mingw32ce*)
have_w32_system=yes
have_w32ce_system=yes
;;
*-mingw32*)
have_w32_system=yes
;;
*-apple-darwin*)
# This is the equivalent of the _GNU_SOURCE feature-test-macro
# on GNU libc systems.
AC_DEFINE(_DARWIN_C_SOURCE, 900000L,
Expose all libc features (__DARWIN_C_FULL).)
;;
*)
;;
esac
if test "$have_w32_system" != yes; then
gl_THREADLIB_EARLY
fi
# We build libgpg-error with large file support so that we have a 64
# bit off_t. Our external interface uses the gpgrt_off_t which is
# anyway specified as 64 bit. Thus the same libgpg-error can be used
# by software which is not build with large file support.
AC_SYS_LARGEFILE
LT_PREREQ([2.2.6])
LT_INIT([win32-dll disable-static])
LT_LANG([Windows Resource])
# We need to compile and run a program on the build machine.
AX_CC_FOR_BUILD
AH_BOTTOM([
/* Force using of NLS for W32 even if no libintl has been found. This is
okay because we have our own gettext implementation for W32. */
#if defined(HAVE_W32_SYSTEM) && !defined(ENABLE_NLS)
#define ENABLE_NLS 1
#endif
/* Connect the generic estream-printf.c to our framework. */
#define _ESTREAM_PRINTF_REALLOC _gpgrt_realloc
#define _ESTREAM_PRINTF_EXTRA_INCLUDE "gpgrt-int.h"
/* For building we need to define these macro. */
#define GPG_ERR_ENABLE_GETTEXT_MACROS 1
#define GPG_ERR_ENABLE_ERRNO_MACROS 1
#define GPGRT_ENABLE_ES_MACROS 1
#define GPGRT_ENABLE_LOG_MACROS 1
#define GPGRT_ENABLE_ARGPARSE_MACROS 1
])
# Note, that autogen.sh greps for the next line.
AM_GNU_GETTEXT_VERSION([0.19.3])
AM_GNU_GETTEXT([external])
# Checks for header files.
AC_HEADER_STDC
AC_CHECK_HEADERS([stdlib.h locale.h stdint.h sys/select.h sys/time.h \
signal.h])
AC_FUNC_STRERROR_R
case "${host_os}" in
solaris*)
# All versions of Solaris from 2.4 have a thread-safe strerror().
# Since Solaris 10, in addition strerror_r() exists.
;;
*)
AC_CHECK_FUNC([strerror_r], [],
AC_MSG_WARN([[Without strerror_r, gpg_strerror_r might not be thread-safe]]))
;;
esac
AC_FUNC_FORK
AC_CHECK_FUNCS([flockfile vasprintf mmap rand strlwr stpcpy setenv stat \
getrlimit ])
#
# Checks for typedefs, structures, and compiler characteristics.
#
AC_C_CONST
AC_CHECK_SIZEOF(int)
AC_CHECK_SIZEOF(long)
AC_CHECK_SIZEOF(long long)
AC_HEADER_TIME
AC_CHECK_SIZEOF(time_t,,[[
#include
#if TIME_WITH_SYS_TIME
# include
# include
#else
# if HAVE_SYS_TIME_H
# include
# else
# include
# endif
#endif
]])
GNUPG_FUNC_MKDIR_TAKES_ONE_ARG
# Find a 64 bit integer type to be used instead of off_t. We prefer
# the standard integer types over int64_t and finally try long long.
if test "$ac_cv_sizeof_int" = "8"; then
replacement_for_off_t="int"
elif test "$ac_cv_sizeof_long" = "8"; then
replacement_for_off_t="long"
elif test "$ac_cv_header_stdint_h" = yes; then
replacement_for_off_t="int64_t"
elif test "$ac_cv_sizeof_long_long" = "8"; then
replacement_for_off_t="long long"
else
AC_MSG_ERROR([[
***
*** No 64 bit signed integer type found. Can't build this library.
***]])
fi
AC_DEFINE_UNQUOTED(REPLACEMENT_FOR_OFF_T, "$replacement_for_off_t",
[Used by mkheader to insert the replacement type.])
#
# Setup gcc specific options
#
AC_MSG_NOTICE([checking for cc features])
if test "$GCC" = yes; then
# Check whether gcc does not emit a diagnostic for unknown -Wno-*
# options. This is the case for gcc >= 4.6
AC_MSG_CHECKING([if gcc ignores unknown -Wno-* options])
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 6 )
#kickerror
#endif]],[])],[_gcc_silent_wno=yes],[_gcc_silent_wno=no])
AC_MSG_RESULT($_gcc_silent_wno)
# Note that it is okay to use CFLAGS here because these are just
# warning options and the user should have a chance of overriding
# them.
if test "$USE_MAINTAINER_MODE" = "yes"; then
M_CFLAGS="-O3 -Wall -Wcast-align -Wshadow -Wstrict-prototypes"
M_CFLAGS="$M_CFLAGS -Wformat -Wno-format-y2k -Wformat-security"
if test x"$_gcc_silent_wno" = xyes ; then
_gcc_wopt=yes
else
AC_MSG_CHECKING([if gcc supports -Wno-missing-field-initializers])
_gcc_cflags_save=$CFLAGS
CFLAGS="-Wno-missing-field-initializers"
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],[])],
[_gcc_wopt=yes],[_gcc_wopt=no])
AC_MSG_RESULT($_gcc_wopt)
CFLAGS=$_gcc_cflags_save;
fi
if test x"$_gcc_wopt" = xyes ; then
M_CFLAGS="$M_CFLAGS -W -Wno-sign-compare -Wno-missing-field-initializers"
fi
AC_MSG_CHECKING([if gcc supports -Wdeclaration-after-statement])
_gcc_cflags_save=$CFLAGS
CFLAGS="-Wdeclaration-after-statement"
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],[])],_gcc_wopt=yes,_gcc_wopt=no)
AC_MSG_RESULT($_gcc_wopt)
CFLAGS=$_gcc_cflags_save;
if test x"$_gcc_wopt" = xyes ; then
M_CFLAGS="$M_CFLAGS -Wdeclaration-after-statement"
fi
# Prepend the maintainer-cflags so that the user can override
# them, e.g. to override the optimization flags for debugging.
CFLAGS="$M_CFLAGS $CFLAGS"
else
CFLAGS="$CFLAGS -Wall"
fi
AC_MSG_CHECKING([if gcc supports -Wpointer-arith])
_gcc_cflags_save=$CFLAGS
CFLAGS="-Wpointer-arith"
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],[])],_gcc_psign=yes,_gcc_psign=no)
AC_MSG_RESULT($_gcc_psign)
CFLAGS=$_gcc_cflags_save;
if test x"$_gcc_psign" = xyes ; then
CFLAGS="$CFLAGS -Wpointer-arith"
fi
# The undocumented option -Wno-psabi suppresses the annoying
# "the ABI of passing union with long double has changed in GCC 4.4"
# which is emitted in estream-printf.c but entirely irrelvant
# because that union is local to the file.
if test x"$_gcc_silent_wno" = xyes ; then
CFLAGS="$CFLAGS -Wno-psabi"
fi
fi
#
# Check whether the compiler supports the GCC style aligned attribute
#
AC_CACHE_CHECK([whether the GCC style aligned attribute is supported],
[gcry_cv_gcc_attribute_aligned],
[gcry_cv_gcc_attribute_aligned=no
AC_COMPILE_IFELSE([AC_LANG_SOURCE(
[[struct { int a; } foo __attribute__ ((aligned (16)));]])],
[gcry_cv_gcc_attribute_aligned=yes])])
if test "$gcry_cv_gcc_attribute_aligned" = "yes" ; then
AC_DEFINE(HAVE_GCC_ATTRIBUTE_ALIGNED,1,
[Defined if a GCC style "__attribute__ ((aligned (n))" is supported])
fi
#
# Check for ELF visibility support.
#
AC_CACHE_CHECK(whether the visibility attribute is supported,
gcry_cv_visibility_attribute,
[gcry_cv_visibility_attribute=no
AC_LANG_CONFTEST([AC_LANG_SOURCE(
[[int foo __attribute__ ((visibility ("hidden"))) = 1;
int bar __attribute__ ((visibility ("protected"))) = 1;
]])])
if ${CC-cc} -Werror -S conftest.c -o conftest.s \
1>&AS_MESSAGE_LOG_FD 2>&AS_MESSAGE_LOG_FD ; then
if grep '\.hidden.*foo' conftest.s >/dev/null 2>&1 ; then
if grep '\.protected.*bar' conftest.s >/dev/null 2>&1; then
gcry_cv_visibility_attribute=yes
fi
fi
fi
])
if test "$gcry_cv_visibility_attribute" = "yes"; then
AC_CACHE_CHECK(for broken visibility attribute,
gcry_cv_broken_visibility_attribute,
[gcry_cv_broken_visibility_attribute=yes
AC_LANG_CONFTEST([AC_LANG_SOURCE(
[[int foo (int x);
int bar (int x) __asm__ ("foo")
__attribute__ ((visibility ("hidden")));
int bar (int x) { return x; }
]])])
if ${CC-cc} -Werror -S conftest.c -o conftest.s \
1>&AS_MESSAGE_LOG_FD 2>&AS_MESSAGE_LOG_FD ; then
if grep '\.hidden@<:@ _@:>@foo' conftest.s >/dev/null 2>&1;
then
gcry_cv_broken_visibility_attribute=no
fi
fi
])
fi
if test "$gcry_cv_visibility_attribute" = "yes"; then
AC_CACHE_CHECK(for broken alias attribute,
gcry_cv_broken_alias_attribute,
[gcry_cv_broken_alias_attribute=yes
AC_LANG_CONFTEST([AC_LANG_SOURCE(
[[extern int foo (int x) __asm ("xyzzy");
int bar (int x) { return x; }
extern __typeof (bar) foo __attribute ((weak, alias ("bar")));
extern int dfoo;
extern __typeof (dfoo) dfoo __asm ("abccb");
int dfoo = 1;
]])])
if ${CC-cc} -Werror -S conftest.c -o conftest.s \
1>&AS_MESSAGE_LOG_FD 2>&AS_MESSAGE_LOG_FD ; then
if grep 'xyzzy' conftest.s >/dev/null 2>&1 && \
grep 'abccb' conftest.s >/dev/null 2>&1; then
gcry_cv_broken_alias_attribute=no
fi
fi
])
fi
if test "$gcry_cv_visibility_attribute" = "yes"; then
AC_CACHE_CHECK(if gcc supports -fvisibility=hidden,
gcry_cv_gcc_has_f_visibility,
[gcry_cv_gcc_has_f_visibility=no
_gcc_cflags_save=$CFLAGS
CFLAGS="-fvisibility=hidden"
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],[])],
gcry_cv_gcc_has_f_visibility=yes)
CFLAGS=$_gcc_cflags_save;
])
fi
if test "$gcry_cv_visibility_attribute" = "yes" \
&& test "$gcry_cv_broken_visibility_attribute" != "yes" \
&& test "$gcry_cv_broken_alias_attribute" != "yes" \
&& test "$gcry_cv_gcc_has_f_visibility" = "yes"
then
AC_DEFINE(GPGRT_USE_VISIBILITY, 1,
[Define to use the GNU C visibility attribute.])
CFLAGS="$CFLAGS -fvisibility=hidden"
fi
#
# Check whether ld supports a version script.
# (Actually not a check but a list of systems which are known to support it.)
#
have_ld_version_script=no
case "${host}" in
*-*-linux*)
have_ld_version_script=yes
;;
*-*-gnu*)
have_ld_version_script=yes
;;
esac
AC_ARG_ENABLE([ld-version-script],
AC_HELP_STRING([--enable-ld-version-script],
[enable/disable use of linker version script.
(default is system dependent)]),
[have_ld_version_script=$enableval],
[ : ] )
AM_CONDITIONAL(HAVE_LD_VERSION_SCRIPT, test "$have_ld_version_script" = "yes")
#
# Check for thread library.
#
# Windows has always thread support; thus we don't bother to test for
# it as it may lead to false results when cross building.
if test "$have_w32_system" = yes; then
AC_DEFINE([USE_WINDOWS_THREADS], [1])
LIBTHREAD=
LTLIBTHREAD=
LIBMULTITHREAD=
LTLIBMULTITHREAD=
THREADLIB_CPPFLAGS=""
AC_SUBST([LIBTHREAD])
AC_SUBST([LTLIBTHREAD])
AC_SUBST([LIBMULTITHREAD])
AC_SUBST([LTLIBMULTITHREAD])
else
gl_LOCK
if test "$gl_threads_api" = posix; then
AC_CHECK_SIZEOF(pthread_mutex_t,,[AC_INCLUDES_DEFAULT
#include ])
fi
fi
# Default value for GPG_ERROR_CONFIG_LIBS
config_libs="-lgpg-error"
#
# Check for other libraries
#
LIB_SCHED_YIELD=
AC_SUBST([LIB_SCHED_YIELD])
AC_SEARCH_LIBS([sched_yield], [rt posix4],
[if test "$ac_cv_search_sched_yield" != "none required"; then
LIB_SCHED_YIELD=$ac_cv_search_sched_yield
config_libs="$config_libs $LIB_SCHED_YIELD"
fi])
LIB_NETWORK=
AC_SUBST([LIB_NETWORK])
AC_SEARCH_LIBS([inet_addr], [nsl],
[if test "$ac_cv_search_inet_addr" != "none required"; then
LIB_NETWORK=$ac_cv_search_inet_addr
fi])
AC_SEARCH_LIBS([socket], [socket],
[if test "$ac_cv_search_socket" != "none required"; then
LIB_NETWORK="$ac_cv_search_socket $LIB_NETWORK"
fi], [], [$LIB_NETWORK])
if test "x$LIB_NETWORK" != x; then
config_libs="$config_libs $LIB_NETWORK"
fi
# Check for optional readline support
GNUPG_CHECK_READLINE
#
# Prepare building of estream
#
estream_INIT
#
# Substitution used for gpg-error-config
#
GPG_ERROR_CONFIG_LIBS="$config_libs"
if test "x$LIBTHREAD" != x; then
GPG_ERROR_CONFIG_LIBS="${GPG_ERROR_CONFIG_LIBS} ${LIBTHREAD}"
fi
if test "x$LIBMULTITHREAD" != x; then
GPG_ERROR_CONFIG_MT_LIBS="${LIBMULTITHREAD}"
else
GPG_ERROR_CONFIG_MT_LIBS=""
fi
if test "$have_w32ce_system" = yes; then
GPG_ERROR_CONFIG_CFLAGS="-idirafter \${includedir}/gpg-extra"
else
GPG_ERROR_CONFIG_CFLAGS=""
fi
if test "x$THREADLIB_CPPFLAGS" != x; then
GPG_ERROR_CONFIG_MT_CFLAGS="${THREADLIB_CPPFLAGS}"
else
GPG_ERROR_CONFIG_MT_CFLAGS=""
fi
GPG_ERROR_CONFIG_HOST="$host"
case "$includedir" in
'${prefix}/include'|/usr/include|/include) ;;
*) GPG_ERROR_CONFIG_CFLAGS="-I$includedir $GPG_ERROR_CONFIG_CFLAGS" ;;
esac
case "$libdir" in
'${exec_prefix}/lib'|/usr/lib|/usr/lib64|/lib|/lib64) ;;
*) GPG_ERROR_CONFIG_LIBS="-L$libdir $GPG_ERROR_CONFIG_LIBS" ;;
esac
AC_SUBST(GPG_ERROR_CONFIG_LIBS)
AC_SUBST(GPG_ERROR_CONFIG_CFLAGS)
AC_SUBST(GPG_ERROR_CONFIG_MT_LIBS)
AC_SUBST(GPG_ERROR_CONFIG_MT_CFLAGS)
AC_SUBST(GPG_ERROR_CONFIG_HOST)
#
# Special defines for certain platforms
#
force_use_syscfg=no
if test "$have_w32_system" = yes; then
AC_DEFINE(HAVE_W32_SYSTEM,1,[Defined if we run on a W32 API based system])
if test "$have_w64_system" = yes; then
AC_DEFINE(HAVE_W64_SYSTEM,1,[Defined if we run on 64 bit W32 API system])
fi
if test "$have_w32ce_system" = yes; then
AC_DEFINE(HAVE_W32CE_SYSTEM,1,[Defined if we run on WindowsCE])
fi
force_use_syscfg=yes
fi
if test x$cross_compiling = xyes; then
force_use_syscfg=yes
fi
AM_CONDITIONAL(HAVE_W32_SYSTEM, test "$have_w32_system" = yes)
AM_CONDITIONAL(HAVE_W64_SYSTEM, test "$have_w64_system" = yes)
AM_CONDITIONAL(HAVE_W32CE_SYSTEM, test "$have_w32ce_system" = yes)
AM_CONDITIONAL(CROSS_COMPILING, test x$cross_compiling = xyes)
AM_CONDITIONAL(FORCE_USE_SYSCFG, test x$force_use_syscfg = xyes)
AC_DEFINE_UNQUOTED(HOST_TRIPLET_STRING, "$host", [The host triplet])
#
# gpgrt_log_clock may require linking with extra libaries. As long as
# we don't have a good test for this we require the use of this
# configure option to enabling printing of a timestamp.
#
AC_MSG_CHECKING([whether to enable log_clock])
AC_ARG_ENABLE(log_clock,
AC_HELP_STRING([--enable-log-clock],
[enable log_clock timestamps]),
enable_log_clock=$enableval, enable_log_clock=no)
AC_MSG_RESULT($enable_log_clock)
if test "$enable_log_clock" = yes ; then
AC_DEFINE(ENABLE_LOG_CLOCK,1,[Defined to use log_clock timestamps])
fi
#
# For now we do not build gpgscm by default.
# Eventually we will reverse the meaning of that option.
#
build_gpgscm=no
#AC_MSG_CHECKING([whether to build gpgscm])
#AC_ARG_ENABLE(gpgscm,
# AC_HELP_STRING([--enable-gpgscm],
# [build the gpgscm tool]),
# build_gpgscm=$enableval, build_gpgscm=no)
#AC_MSG_RESULT($build_gpgscm)
AM_CONDITIONAL([BUILD_GPGSCM], [test "x$build_gpgscm" != xno])
#
# Add -Werror to CFLAGS. This hack can be used to avoid problems with
# misbehaving autoconf tests in case the user supplied -Werror.
#
AC_ARG_ENABLE(werror,
AC_HELP_STRING([--enable-werror],
[append -Werror to CFLAGS]),
[if test $enableval = yes ; then
CFLAGS="$CFLAGS -Werror"
fi])
#
# Provide information about the build.
#
BUILD_REVISION="mym4_revision"
AC_SUBST(BUILD_REVISION)
AC_DEFINE_UNQUOTED(BUILD_REVISION, "$BUILD_REVISION",
[GIT commit id revision used to build this package])
changequote(,)dnl
BUILD_VERSION=`echo "$PACKAGE_VERSION"|sed 's/\([0-9.]*\).*/\1./'`
changequote([,])dnl
BUILD_VERSION="${BUILD_VERSION}0.mym4_revision_dec"
BUILD_FILEVERSION=`echo "${BUILD_VERSION}" | tr . ,`
AC_SUBST(BUILD_VERSION)
AC_SUBST(BUILD_FILEVERSION)
AC_ARG_ENABLE([build-timestamp],
AC_HELP_STRING([--enable-build-timestamp],
[set an explicit build timestamp for reproducibility.
(default is the current time in ISO-8601 format)]),
[if test "$enableval" = "yes"; then
BUILD_TIMESTAMP=`date -u +%Y-%m-%dT%H:%M+0000 2>/dev/null || date`
else
BUILD_TIMESTAMP="$enableval"
fi],
[BUILD_TIMESTAMP=""])
AC_SUBST(BUILD_TIMESTAMP)
AC_DEFINE_UNQUOTED(BUILD_TIMESTAMP, "$BUILD_TIMESTAMP",
[The time this package was configured for a build])
AC_ARG_ENABLE(languages, AC_HELP_STRING([--disable-languages],
[do not build support for other languages than C]))
AM_CONDITIONAL([LANGUAGES_SOME], [test "x$enable_languages" != xno])
build_doc=yes
AC_ARG_ENABLE([doc], AC_HELP_STRING([--disable-doc],
[do not build the documentation]),
build_doc=$enableval, build_doc=yes)
AM_CONDITIONAL([BUILD_DOC], [test "x$build_doc" != xno])
build_tests=yes
AC_ARG_ENABLE([tests], AC_HELP_STRING([--disable-tests],
[do not build the tests]),
build_tests=$enableval, build_tests=yes)
AM_CONDITIONAL([BUILD_TESTS], [test "x$build_tests" != xno])
#
# Substitution
#
AC_CONFIG_FILES([Makefile])
AC_CONFIG_FILES([doc/Makefile po/Makefile.in m4/Makefile])
AC_CONFIG_FILES([src/Makefile tests/Makefile])
AC_CONFIG_FILES([lang/Makefile lang/cl/Makefile lang/cl/gpg-error.asd])
AC_CONFIG_FILES([src/versioninfo.rc src/gpg-error.w32-manifest])
AC_CONFIG_FILES([src/gpg-error.pc])
AC_CONFIG_FILES([src/gpg-error-config], [chmod +x src/gpg-error-config])
+AC_CONFIG_FILES([src/gpg-error-config-new], [chmod +x src/gpg-error-config-new])
AC_OUTPUT
tmp=
if test "$have_w32_system" != yes; then
if test x"$gl_use_threads" = xno; then
tmp=" NO-THREADS"
fi
fi
echo "
$PACKAGE_NAME v$PACKAGE_VERSION has been configured as follows:
Revision: mym4_revision (mym4_revision_dec)
Platform: $host$tmp
"
if test "$gcry_cv_gcc_attribute_aligned" != "yes" ; then
cat <"
-#
-get_var () {
- local name=$1
-
- eval echo \$VAR_$name
-}
-
-#
-# get_attr: Get the attribute value of KEY
-#
-# Attributes are recorded in the shell variables named "ATTR_"
-#
-get_attr () {
- local name=$1
-
- eval echo \$ATTR_$name
-}
-
-# Remove ${varname} part in the beginning of a string.
-remove_var_expr () {
- local varname=$1
- shift
-
- eval echo \"\${@#\\\$\\\{$varname\\\}}\"
-}
-
-# Given a string, substitute variables.
-substitute_vars () {
- local string="$1"
- local line
- local varname
- local result
-
- while [ -n "$string" ]; do
- case "$string" in
- \$\$*)
- result="$result\$"
- string="${string#\$\$}"
- ;;
- \${*}*)
- varname="${string#\$\{}"
- varname="${varname%%\}*}"
- result="$result$(get_var ${varname})"
- string=$(remove_var_expr ${varname} ${string})
- ;;
- *)
- result="${result}$(printf %c "$string")"
- string="${string#$(printf %c "$string")}"
- ;;
- esac
- done
-
- echo "$result"
-}
-
-#
-# Read a config from stdin
-#
-# Variables:
-# For VAR=VALUE, value is stored in the shell variable VAR_*.
-#
-# Attributes:
-# For KEY: VALUE, value is stored in the shell variable ATTR_*.
-#
-read_config_from_stdin () {
- local filename=$1
- local line
- local varname
- local value
- local key
- local reading_attrs
-
- while read line; do
- if [ -z "$line" ]; then
- reading_attrs=yes
- continue
- elif [ -z "$reading_attrs" ]; then
- case "$line" in
- *=*)
- varname="${line%%=*}"
- value="${line#*=}"
- VAR_list="$VAR_list VAR_$varname"
- read VAR_$varname <&2
- exit 1
- ;;
- esac
- fi
- done
-}
-
-
-find_file_in_path () {
- local f=$1
- local p=$2
- local IFS=":" # On Windows it should be ";"???
-
- for d in $p; do
- if [ -r $d/$f ]; then
- RESULT="$d/$f"
- return 0
- fi
- done
- RESULT=""
- return 1
-}
-
-read_config_file () {
- local config_file
- local RESULT
-
- if find_file_in_path $1.pc $2; then
- config_file=$RESULT
- else
- echo "Can't find $1.pc" 1>&2
- exit 1
- fi
- read_config_from_stdin $config_file < $config_file
-}
-
-cleanup_vars_attrs () {
- eval unset $VAR_list VAR_list
- eval unset $ATTR_list ATTR_list
-}
-
-not_listed_yet () {
- local m=$1
- local arg
- shift
-
- for arg; do
- if [ $m = $arg ]; then
- return 1
- fi
- done
-
- return 0
-}
-
-list_only_once () {
- local result=""
- local arg
-
- for arg; do
- if not_listed_yet $arg $result; then
- result="$result $arg"
- fi
- done
-
- echo $result
-}
+exec_prefix=@exec_prefix@
+includedir=@includedir@
+libdir=@libdir@
+isubdirafter="@GPG_ERROR_CONFIG_ISUBDIRAFTER@"
-list_only_once_for_libs () {
- local result=""
- local rev_list=""
- local arg
-
- # Scan the list and eliminate duplicates for non-"-lxxx"
- # the resulted list is in reverse order
- for arg; do
- case "$arg" in
- -l*)
- # As-is
- rev_list="$arg $rev_list"
- ;;
- *)
- if not_listed_yet $arg $rev_list; then
- rev_list="$arg $rev_list"
- fi
- ;;
- esac
- done
-
- # Scan again
- for arg in $rev_list; do
- case "$arg" in
- -l*)
- if not_listed_yet $arg $result; then
- result="$arg $result"
- fi
- ;;
- *)
- # As-is
- result="$arg $result"
- ;;
- esac
- done
-
- echo $result
-}
-
-arg1_is_same () {
- [ "$1" = "=" -o "$1" = ">=" -o "$1" = "<=" ]
-}
-
-arg1_is_less () {
- [ "$1" = "!=" -o "$1" = "<" -o "$1" = "<=" ]
-}
-
-arg1_is_great () {
- [ "$1" = "!=" -o "$1" = ">" -o "$1" = ">=" ]
-}
-
-#
-# Evaluate comparison between versions in RPM way
-#
-eval_compare_version () {
- local str1="$1"
- local cmp="$2"
- local str2="$3"
- local char1 char2
- local chunk1 chunk2
-
- while [ -n "$str1" -a -n "$str2" ]; do
- # Trim anything that's not alnum or tilde from the front
- str1="$(expr "$str1" : '[^0-9A-Za-z~]*\(.*\)')"
- str2="$(expr "$str2" : '[^0-9A-Za-z~]*\(.*\)')"
-
- # Get the first character
- char1=${str1%${str1#?}}
- char2=${str2%${str2#?}}
-
- if [ "$char1" = ~ -o "$char2" = ~ ]; then
- if [ "$char1" != ~ ]; then
- arg1_is_great $cmp
- return
- fi
- if [ "$char2" != ~ ]; then
- arg1_is_less $cmp
- return
- fi
- str1=${str1#~}
- str2=${str2#~}
- continue
- fi
-
- if [ -z "$char1" -o -z "$char2" ]; then
- break
- fi
-
- case "$char1$char2" in
- [0-9][A-Za-z])
- arg1_is_great $cmp
- return
- ;;
- [A-Za-z][0-9])
- arg1_is_less $cmp
- return
- ;;
- [0-9][0-9])
- chunk1="$(expr "$str1" : '\([0-9]*\)')"
- chunk2="$(expr "$str2" : '\([0-9]*\)')"
- ;;
- [A-Za-z][A-Za-z])
- chunk1="$(expr "$str1" : '\([A-Za-z]*\)')"
- chunk2="$(expr "$str2" : '\([A-Za-z]*\)')"
- ;;
- esac
-
- # Compare chunks numerically if digits, or lexicographically
- if expr "$chunk1" "!=" "$chunk2" >/dev/null; then
- if expr "$chunk1" ">" "$chunk2" >/dev/null; then
- arg1_is_great $cmp
- return
- else
- arg1_is_less $cmp
- return
- fi
- fi
-
- # Remove the chunk
- str1="${str1#$chunk1}"
- str2="${str2#$chunk2}"
- done
-
- # Either STR1, STR2 or both is empty here
- if [ -n "$str1" ]; then
- case "$str1" in
- ~*) arg1_is_less $cmp ;;
- *) arg1_is_great $cmp ;;
- esac
- elif [ -n "$str2" ]; then
- case "$str2" in
- ~*) arg1_is_great $cmp ;;
- *) arg1_is_less $cmp ;;
- esac
- else
- arg1_is_same $cmp
- fi
-}
-
-#
-# Recursively solve package dependencies
-#
-# Result is in the pkg_list variable
-#
-all_required_config_files () {
- local list
- local all_list
- local new_list
- local p pkg cmp ver
-
- list=$*
- while [ -n "$list" ]; do
- for p in $list; do
- if [ -z "$pkg" ]; then
- pkg=$p
- elif [ -z "$cmp" ]; then
- case "$p" in
- "="|"!="|"<"|">"|"<="|">=") cmp=$p ;;
- *)
- read_config_file $pkg $PKG_CONFIG_PATH
- all_list="$all_list $pkg"
- new_list="$new_list${new_list:+ }$(get_attr Requires)"
- cleanup_vars_attrs
- pkg=$p
- ;;
- esac
- else
- read_config_file $pkg $PKG_CONFIG_PATH
- if ! eval_compare_version "$(get_attr Version)" $cmp $p; then
- echo "Version mismatch for $pkg $cmp $p: $(get_attr Version)" 1>&2
- exit 1
- fi
- all_list="$all_list $pkg"
- new_list="$new_list${new_list:+ }$(get_attr Requires)"
- cleanup_vars_attrs
- pkg=
- cmp=
- fi
- done
- if [ -n "$cmp" ]; then
- echo "No version after comparison operator ($cmp): $pkg" 1>&2
- exit 1
- elif [ -n "$pkg" ]; then
- read_config_file $pkg $PKG_CONFIG_PATH
- all_list="$all_list $pkg"
- new_list="$new_list${new_list:+ }$(get_attr Requires)"
- cleanup_vars_attrs
- fi
-
- list="$new_list"
- new_list=""
- done
-
- pkg_list=$(list_only_once $all_list)
-}
-
-#### end of pkgconf-funcs
-
-myname=${0##*/}
-if [ $myname = gpgrt-config ]; then
+if echo "$0" | grep gpg-error-config 2>/dev/null >/dev/null; then
myname="gpg-error-config"
+else
+ myname="gpgrt-config"
fi
+output=""
+mt=no
+
usage()
{
cat <&2
fi
-if [ "$1" != "--mt" ]; then
- mt=no
-else
- # In future, use --variable=mtcflags or --variable=mtlibs
- mt=yes
- shift
-fi
-
-modules=""
-want_var=""
-want_attr=""
-want_cflags=""
-want_libs=""
-
-cflags=""
-libs=""
-mtcflags=""
-mtlibs=""
-
-delimiter=" "
-output=""
-
while test $# -gt 0; do
- case $1 in
- --prefix)
- # In future, use --variable=prefix instead.
- want_var=prefix
+ case "$1" in
+ -*=*)
+ optarg=`echo "$1" | sed 's/[-_a-zA-Z0-9]*=//'`
;;
- --exec-prefix)
- # In future, use --variable=exec_prefix instead.
- want_var=exec_prefix
- ;;
- --version)
- # In future, use --modversion instead.
- want_attr=Version
- delimiter="
-"
- ;;
- --modversion)
- want_attr=Version
- delimiter="
-"
- ;;
- --cflags)
- want_cflags=yes
+ *)
+ optarg=
;;
- --libs)
- want_libs=yes
+ esac
+
+ case $1 in
+ --mt)
+ mt=yes
+ ;;
+ --prefix)
+ output="$output $prefix"
;;
- --variable=*)
- want_var=${1#*=}
+ --exec-prefix)
+ output="$output $exec_prefix"
;;
- --host)
- # In future, use --variable=host instead.
- want_var=host
+ --version)
+ echo "@PACKAGE_VERSION@"
+ exit 0
;;
- --help)
- usage 0
+ --cflags)
+ if test "x$includedir" != "x/usr/include" -a "x$includedir" != "x/include"; then
+ output="$output -I$includedir"
+ fi
+ # Note: -idirafter is a gcc extension. It is only used on
+ # systems where gcc is the only compiler we support (WindowsCE).
+ for i in $isubdirafter; do
+ output="$output -idirafter ${includedir}/${i}"
+ done
+ output="$output @GPG_ERROR_CONFIG_CFLAGS@"
+ if test $mt = yes ; then
+ output="$output @GPG_ERROR_CONFIG_MT_CFLAGS@"
+ fi
;;
- --*)
- usage 1 1>&2
+ --libs)
+ case "$libdir" in
+ /usr/lib|/usr/lib64|/lib|/lib64) ;;
+ *)
+ output="$output -L$libdir"
+ ;;
+ esac
+ output="$output @GPG_ERROR_CONFIG_LIBS@"
+ if test $mt = yes ; then
+ output="$output @GPG_ERROR_CONFIG_MT_LIBS@"
+ fi
;;
+ --host)
+ echo "@GPG_ERROR_CONFIG_HOST@"
+ exit 0
+ ;;
*)
- # Modules
- modules="$modules${modules:+ }$1"
+ usage 1 1>&2
;;
esac
-
shift
done
-
-if [ -z "$modules" ]; then
- modules=${myname%-config}
-elif expr match "$modules" "=\|!=\|<\|>\|<=\|>=" >/dev/null; then
- modules="${myname%-config} $modules"
-fi
-
-all_required_config_files $modules
-
-for p in $pkg_list; do
- read_config_file $p $PKG_CONFIG_PATH
- if [ -n "$want_var" ]; then
- output="$output${output:+$delimiter}$(get_var $want_var)"
- elif [ -n "$want_attr" ]; then
- output="$output${output:+$delimiter}$(get_attr $want_attr)"
- else
- cflags="$cflags${cflags:+ }$(get_attr Cflags)"
- libs="$libs${libs:+ }$(get_attr Libs)"
-
- if [ $p = "gpg-error" ]; then
- mtcflags="$(get_var mtcflags)"
- mtlibs="$(get_var mtlibs)"
- fi
- fi
- cleanup_vars_attrs
-done
-
-if [ -z "$want_var" -a -z "$want_attr" ]; then
- if [ -n "$want_cflags" ]; then
- output="$output${output:+ }$(list_only_once $cflags)"
- # Backward compatibility to old gpg-error-config
- if [ $mt = yes ]; then
- output="$output $mtcflags"
- fi
- fi
- if [ -n "$want_libs" ]; then
- output="$output${output:+ }$(list_only_once_for_libs $libs)"
- # Backward compatibility to old gpg-error-config
- if [ $mt = yes ]; then
- output="$output $mtlibs"
- fi
- fi
-fi
-
-echo "$output"
+echo $output