configure.ac

dnl Process this file with autoconf to produce a configure script.
dnl This config.in requires autoconf 2.5 or greater.

AC_PREREQ([2.68])
AC_INIT([qpdf],[10.5.0])

AC_CONFIG_MACRO_DIR([m4])
AC_CONFIG_FILES([autoconf.mk])
AC_CONFIG_FILES([libqpdf.pc])
AC_CONFIG_FILES([libqpdf.map])
AC_CONFIG_HEADERS([libqpdf/qpdf/qpdf-config.h])

AC_SUBST(MAINTAINER_MODE)
AC_ARG_ENABLE(maintainer-mode,
   AS_HELP_STRING([--enable-maintainer-mode],
		  [turn on features intended for maintainers that may change generated files and require additional tools; implies enable-doc-maintenances]),
   [if test "$enableval" = "no"; then
      MAINTAINER_MODE=0
    else
      MAINTAINER_MODE=1
    fi],
   [MAINTAINER_MODE=0])

AC_ARG_ENABLE(check-autofiles,
   AS_HELP_STRING([--enable-check-autofiles],
		  [if specified, verify checksums on automatically generated files (default=yes); package maintainers may want to disable this]),
   [if test "$enableval" = "no"; then
      CHECK_AUTOFILES=0
    else
      CHECK_AUTOFILES=1
    fi],
   [CHECK_AUTOFILES=1])

# Check to see if automatically generated files are outdated and if we
# can update them.
AC_CHECK_PROG(AUTOCONF,autoconf,1,0)
AC_CHECK_PROG(AUTOHEADER,autoheader,1,0)
AC_CHECK_PROG(ACLOCAL,aclocal,1,0)
AC_CHECK_PROG(SHA256SUM,sha256sum,1,0)
if test "$CHECK_AUTOFILES$AUTOCONF$AUTOHEADER$ACLOCAL$SHA256SUM" = "11111"; then
   if ! sha256sum -c autofiles.sums; then
       AC_MSG_ERROR(autofiles are outdated; rerun autogen.sh)
   fi
fi

AC_PROG_CC
AC_PROG_CC_C99
AC_PROG_CXX
AX_CXX_COMPILE_STDCXX([14], [noext], [mandatory])
AC_HEADER_STDC
LT_INIT([win32-dll])

# * If any interfaces have been removed or changed, or if any private
#   member variables or virtual functions have been added to any
#   class, we are not binary compatible. Increment LT_CURRENT, and set
#   LT_AGE and LT_REVISION to 0.
#
# * Otherwise, if any interfaces have been added since the last public
#   release, then increment LT_CURRENT and LT_AGE, and set LT_REVISION
#   to 0.
#
# * Otherwise, increment LT_REVISION

# LT = libtool
LT_CURRENT=33
LT_AGE=5
LT_REVISION=0
AC_SUBST(LT_CURRENT)
AC_SUBST(LT_REVISION)
AC_SUBST(LT_AGE)
LT_SONAME=$(expr $LT_CURRENT - $LT_AGE)
AC_SUBST(LT_SONAME)

AC_MSG_CHECKING(for whether to use -rpath)
AC_ARG_ENABLE(rpath,
   AS_HELP_STRING([--enable-rpath],
                  [whether to pass -rpath to the linker when building libraries]),
   [if test "$enableval" = "yes"; then
      qpdf_USE_RPATH=1;
    else
      qpdf_USE_RPATH=0;
    fi], [qpdf_USE_RPATH=1])
if test "$qpdf_USE_RPATH" = "1"; then
   AC_MSG_RESULT(yes)
   RPATH='-rpath $(libdir)'
else
   AC_MSG_RESULT(no)
fi
AC_SUBST(RPATH)

AC_MSG_CHECKING(for -fvisibility=hidden)
try_flags=-fvisibility=hidden
oCXXFLAGS=$CXXFLAGS
CXXFLAGS="$CXXFLAGS $try_flags"
AC_LANG_PUSH([C++])
AC_LINK_IFELSE([AC_LANG_PROGRAM(
    [[class X
{
  public:
    __attribute__ ((visibility ("default")))
    X() {}
    __attribute__ ((visibility ("default")))
    void f() {}
};
   ]],[[X x; x.f();]])],
   [qpdf_VISIBILITY_HIDDEN=1],
   [qpdf_VISIBILITY_HIDDEN=0])
AC_LANG_POP
if test "$qpdf_VISIBILITY_HIDDEN" = "0"; then
   AC_MSG_RESULT(no)
   CXXFLAGS=$oCXXFLAGS
else
   AC_MSG_RESULT(yes)
   CFLAGS="$CFLAGS $try_flags"
fi

AC_MSG_CHECKING(whether to use insecure random numbers)
AC_ARG_ENABLE(insecure-random,
   AS_HELP_STRING([--enable-insecure-random],
                  [whether to use stdlib's random number generator (default is no)]),
   [if test "$enableval" = "yes"; then
      qpdf_INSECURE_RANDOM=1;
    else
      qpdf_INSECURE_RANDOM=0;
    fi], [qpdf_INSECURE_RANDOM=0])
if test "$qpdf_INSECURE_RANDOM" = "1"; then
   AC_MSG_RESULT(yes)
   AC_DEFINE([USE_INSECURE_RANDOM], [1], [Whether to use insecure random numbers])
else
   AC_MSG_RESULT(no)
fi

AC_MSG_CHECKING(whether to use OS-provided secure random numbers)
AC_ARG_ENABLE(os-secure-random,
   AS_HELP_STRING([--enable-os-secure-random],
                  [whether to try to use OS-provided secure random numbers (default is yes)]),
   [if test "$enableval" = "yes"; then
      qpdf_OS_SECURE_RANDOM=1;
    else
      qpdf_OS_SECURE_RANDOM=0;
    fi], [qpdf_OS_SECURE_RANDOM=1])
if test "$qpdf_OS_SECURE_RANDOM" = "1"; then
   AC_MSG_RESULT(yes)
else
   AC_MSG_RESULT(no)
   AC_DEFINE([SKIP_OS_SECURE_RANDOM], [1], [Whether to suppress use of OS-provided secure random numbers])
fi

AX_RANDOM_DEVICE

AC_MSG_CHECKING(whether to avoid Windows HANDLE type)
AC_ARG_ENABLE(avoid-windows-handle,
   AS_HELP_STRING([--enable-avoid-windows-handle],
                  [whether to avoid use of HANDLE, useful for some embedded Windows builds (default is no)]),
   [if test "$enableval" = "yes"; then
      qpdf_AVOID_HANDLE=1;
    else
      qpdf_AVOID_HANDLE=0;
    fi], [qpdf_AVOID_HANDLE=0])
if test "$qpdf_AVOID_HANDLE" = "1"; then
   AC_MSG_RESULT(yes)
   AC_DEFINE([AVOID_WINDOWS_HANDLE], [1], [Whether to avoid use of HANDLE in Windows])
else
   AC_MSG_RESULT(no)
fi

USE_EXTERNAL_LIBS=0
AC_MSG_CHECKING(for whether to use external libraries distribution)
AC_ARG_ENABLE(external-libs,
   AS_HELP_STRING([--enable-external-libs],
		  [whether to use external libraries distribution]),
   [if test "$enableval" = "yes"; then
      USE_EXTERNAL_LIBS=1;
    else
      USE_EXTERNAL_LIBS=0;
    fi], [BUILD_INTERNAL_LIBS=0])
if test "$BUILD_INTERNAL_LIBS" = "0"; then
   AC_MSG_RESULT(no)
else
   AC_MSG_RESULT(yes)
fi

AC_CHECK_SIZEOF([size_t])
if test "$ac_cv_sizeof_size_t" = "4"; then
   IS_32BIT=1
   WINDOWS_WORDSIZE=32
else
   IS_32BIT=0
   WINDOWS_WORDSIZE=64
fi
AC_SUBST(IS_32BIT)
AC_SUBST(WINDOWS_WORDSIZE)

PKG_PROG_PKG_CONFIG
if test "$BUILD_INTERNAL_LIBS" = "0"; then
    if test "$PKG_CONFIG" != ""; then
       PKG_CHECK_MODULES([pc_zlib], [zlib],
         [CFLAGS="$CFLAGS $pc_zlib_CFLAGS"
          CXXFLAGS="$CXXFLAGS $pc_zlib_CFLAGS $pc_zlib_CXXFLAGS"
          LIBS="$LIBS $pc_zlib_LIBS"
         ], [:])
       PKG_CHECK_MODULES([pc_libjpeg], [libjpeg],
         [CFLAGS="$CFLAGS $pc_libjpeg_CFLAGS"
          CXXFLAGS="$CXXFLAGS $pc_libjpeg_CFLAGS $pc_libjpeg_CXXFLAGS"
          LIBS="$LIBS $pc_libjpeg_LIBS"
         ],[:])
    fi
    if test "$pc_zlib_LIBS" = ""; then
        AC_CHECK_HEADER(zlib.h,,[MISSING_ZLIB_H=1; MISSING_ANY=1])
        AC_SEARCH_LIBS(deflate,z zlib,,[MISSING_ZLIB=1; MISSING_ANY=1])
    fi
    if test "$pc_libjpeg_LIBS" = ""; then
        AC_CHECK_HEADER(jpeglib.h,,[MISSING_JPEG_H=1; MISSING_ANY=1])
        AC_SEARCH_LIBS(jpeg_destroy,jpeg,,[MISSING_JPEG=1; MISSING_ANY=1])
    fi
    if test "$LIBS" != ""; then
        nLIBS=""
        for x in $LIBS; do
            if echo $x | grep -q '^-L'; then
                LDFLAGS="$LDFLAGS $x"
            else
                nLIBS="$nLIBS $x"
            fi
            LIBS=$nLIBS
        done
    fi
fi

qpdf_USE_WMAIN=0
AC_LANG_PUSH([C++])
AC_SUBST(WINDOWS_WMAIN_COMPILE)
AC_SUBST(WINDOWS_WMAIN_LINK)
for i in 0 1; do
  if test "$qpdf_USE_WMAIN" = "0"; then
    oLDFLAGS="$LDFLAGS"
    if test "$i" = "1"; then
      nLDFLAGS="-municode"
      LDFLAGS="$LDFLAGS $nLDFLAGS"
      msg="checking for wmain with $nLDFLAGS"
    else
      nLDFLAGS=
      msg="checking for wmain"
    fi
    AC_MSG_CHECKING($msg)
    AC_LINK_IFELSE([AC_LANG_SOURCE(
      [[#include <windows.h>
       #include <string.h>
       #include <stdio.h>
       extern "C"
       int wmain(int argc, wchar_t* argv[])
       {
           size_t x = wcslen(argv[0]);
           return 0;
       }
       ]])],
       [qpdf_USE_WMAIN=1],
       [qpdf_USE_WMAIN=0])
    LDFLAGS="$oLDFLAGS"
    if test "$qpdf_USE_WMAIN" = "1"; then
      AC_MSG_RESULT(yes)
      WINDOWS_WMAIN_COMPILE="-DWINDOWS_WMAIN $nLDFLAGS"
      WINDOWS_WMAIN_LINK="$nLDFLAGS"
    else
      AC_MSG_RESULT(no)
    fi
  fi
done
AC_LANG_POP

AC_LANG_PUSH([C++])
AC_MSG_CHECKING(whether to use -latomic)
dnl On some platforms with some versions of gcc, you have to link with
dnl -latomic in order for std::atomic to work. Passing --as-needed
dnl prevents unnecessary linking with -latomic.
oLDFLAGS="$LDFLAGS"
LDFLAGS="$LDFLAGS -Wl,--as-needed -latomic"
AC_LINK_IFELSE([AC_LANG_SOURCE(
  [[#include <atomic>
    int main()
    {
        static std::atomic<int> a{0};
        a = a.fetch_add(1);
        return 0;
    }
   ]])],
   [qpdf_USE_ATOMIC=1],
   [qpdf_USE_ATOMIC=0])
if test "$qpdf_USE_ATOMIC" = "1"; then
  AC_MSG_RESULT(yes)
else
  AC_MSG_RESULT(no)
  LDFLAGS="$oLDFLAGS"
fi
AC_LANG_POP

if test "x$qpdf_OS_SECURE_RANDOM" = "x1"; then
  OLIBS=$LIBS
  LIBS="$LIBS Advapi32.lib"
  AC_MSG_CHECKING(for Advapi32 library)
  AC_LINK_IFELSE([AC_LANG_PROGRAM(
    [[#pragma comment(lib, "crypt32.lib")
     #include <windows.h>
     #include <wincrypt.h>
     HCRYPTPROV cp;]],
     [CryptAcquireContext(&cp, NULL, NULL, PROV_RSA_FULL, 0);]
     )],
     [AC_MSG_RESULT(yes)
      LIBS="$OLIBS -lAdvapi32"],
     [AC_MSG_RESULT(no)
      LIBS=$OLIBS])
fi

QPDF_LARGE_FILE_TEST_PATH=
AC_SUBST(QPDF_LARGE_FILE_TEST_PATH)
AC_ARG_WITH(large-file-test-path,
   AS_HELP_STRING([--with-large-file-test-path=path],
		  [To enable testing of files > 4GB, give the path to a directory with at least 11 GB free.  The test suite will write temporary files to this directory.  Alternatively, just set the QPDF_LARGE_FILE_TEST_PATH environment variable to the path before running the test suite.]),
   [QPDF_LARGE_FILE_TEST_PATH=$withval],
   [QPDF_LARGE_FILE_TEST_PATH=])

AC_SYS_LARGEFILE
AC_FUNC_FSEEKO
AC_CHECK_FUNCS([fseeko64 random localtime_r])

# Check if LD supports linker scripts, and define conditional
# HAVE_LD_VERSION_SCRIPT if so.  This functionality is currently
# constrained to compilers using GNU ld on ELF systems or systems
# which provide an adequate emulation thereof.
AC_ARG_ENABLE([ld-version-script],
  AS_HELP_STRING([--enable-ld-version-script],
    [enable linker version script (default is enabled)]),
    [have_ld_version_script=$enableval], [have_ld_version_script=yes])
if test "$have_ld_version_script" != no; then
  AC_MSG_CHECKING([if LD -Wl,--version-script works])
  save_LDFLAGS="$LDFLAGS"
  LDFLAGS="$LDFLAGS -Wl,--version-script=conftest.map"
  cat > conftest.map <<EOF
VERS_1 {
        global: sym;
};

VERS_2 {
        global: sym;
} VERS_1;
EOF
  AC_LINK_IFELSE([AC_LANG_PROGRAM([], [])],
                 [have_ld_version_script=yes], [have_ld_version_script=no])
  rm -f conftest.map
  LDFLAGS="$save_LDFLAGS"
  AC_MSG_RESULT($have_ld_version_script)
fi
if test "$have_ld_version_script" = "yes"; then
  HAVE_LD_VERSION_SCRIPT=1
else
  HAVE_LD_VERSION_SCRIPT=0
fi
AC_SUBST(HAVE_LD_VERSION_SCRIPT)

make_okay=0
for make_prog in make gmake; do
  this_make_okay=0
  AC_MSG_CHECKING(for gnu make >= 3.81 ($make_prog))
  if $make_prog --version >/dev/null 2>&1; then
    v=`$make_prog --version | grep 'GNU Make' | sed -e 's/.*Make //'`
    maj=`echo $v | cut -d. -f 1`
    min=`echo $v | cut -d. -f 2`
    if test $maj -gt 3 -o '(' $maj -eq 3 -a $min -ge 81 ')'; then
       this_make_okay=1
       make_okay=1
    fi
  fi
  if test "$this_make_okay" = "1"; then
    AC_MSG_RESULT(yes)
  else
    AC_MSG_RESULT(no)
  fi
done

if test "$make_okay" = "0"; then
  dnl Don't set MISSING_ANY=1 -- maybe user calls make something else
  MISSING_MAKE_381=1
  ISSUE_WARNINGS=1
fi

AC_SUBST(GENDEPS)
GENDEPS=0
AC_MSG_CHECKING(for whether $CC supports -MD -MF x.dep -MP)
oCFLAGS=$CFLAGS
rm -f x.dep
CFLAGS="$CFLAGS -MD -MF x.dep -MP"
AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
                    [[#include <stdio.h>]], [[FILE* a = stdout]]
                  )],
                  [qpdf_DEPFLAGS=yes],
                  [qpdf_DEPFLAGS=no])
CFLAGS=$oCFLAGS
if test "$qpdf_DEPFLAGS" = "yes"; then
   if ! grep stdio.h x.dep >/dev/null 2>&1; then
      qpdf_DEPFLAGS=no
   fi
fi
rm -f x.dep
if test "$qpdf_DEPFLAGS" = "yes"; then
   AC_MSG_RESULT(yes)
   GENDEPS=1
else
   AC_MSG_RESULT(no)
fi

AC_MSG_CHECKING(which build rules to use)
AC_SUBST(BUILDRULES)
AC_ARG_WITH(buildrules,
   AS_HELP_STRING([--with-buildrules=rules],
		  [which build rules to use; see README.md]),
   [BUILDRULES=$withval],
   [BUILDRULES=libtool])
AC_MSG_RESULT($BUILDRULES)

AC_SUBST(WFLAGS)
AC_SUBST(CXXWFLAGS)
qpdf_USE_EXTRA_WARNINGS=0
if test "$BUILDRULES" = "msvc"; then
   dnl /w14996 makes warning 4996 a level 1 warning.  This warning
   dnl reports on functions that Microsoft considers unsafe or
   dnl deprecated.  Removing these warnings helps people who want to
   dnl write applications based on qpdf that can be Windows 8
   dnl certified.
   try_flags="-w14996"
else
   try_flags="-Wall"
fi
AC_MSG_CHECKING(for whether $CC supports $try_flags)
oCFLAGS=$CFLAGS
CFLAGS="$CFLAGS $try_flags"
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[int a = 1; int b = a; a = b;]])],
                  [qpdf_USE_EXTRA_WARNINGS=1],[qpdf_USE_EXTRA_WARNINGS=0])
CFLAGS=$oCFLAGS
if test "$qpdf_USE_EXTRA_WARNINGS" = "1"; then
   AC_MSG_RESULT(yes)
   WFLAGS="$try_flags"
else
   AC_MSG_RESULT(no)
fi
if test "$BUILDRULES" != "msvc"; then
   qpdf_USE_EXTRA_WARNINGS=0
   try_flags="-Wold-style-cast"
   AC_MSG_CHECKING(for whether $CXX supports $try_flags)
   oCXXFLAGS=$CXXFLAGS
   CXXFLAGS="$CXXFLAGS $try_flags"
   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[int a = 1; int b = a; a = b;]])],
                     [qpdf_USE_EXTRA_WARNINGS=1],[qpdf_USE_EXTRA_WARNINGS=0])
   CXXFLAGS=$oCXXFLAGS
   if test "$qpdf_USE_EXTRA_WARNINGS" = "1"; then
      AC_MSG_RESULT(yes)
      CXXWFLAGS="$try_flags"
   else
      AC_MSG_RESULT(no)
   fi
fi

if test "$BUILDRULES" = "msvc"; then
   try_flags=-FS
   AC_MSG_CHECKING(for whether $CC supports $try_flags)
   oCFLAGS=$CFLAGS
   CFLAGS="$CFLAGS $try_flags"
   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[int a = 1; int b = a; a = b;]])],
                     [qpdf_USE_FS=1],[qpdf_USE_FS=0])
   if test "$qpdf_USE_FS" = "1"; then
      AC_MSG_RESULT(yes)
      CXXFLAGS="$CXXFLAGS $try_flags"
   else
      AC_MSG_RESULT(no)
      CFLAGS=$oCFLAGS
   fi
fi

if test "$BUILDRULES" = "msvc"; then
   try_flags="-WX"
else
   try_flags="-Werror"
fi
AC_MSG_CHECKING(for whether to use $try_flags)
AC_ARG_ENABLE(werror,
   AS_HELP_STRING([--enable-werror],
                  [whether to treat warnings as errors (default is no)]),
   [if test "$enableval" = "yes"; then
      qpdf_USE_WERROR=1;
    else
      qpdf_USE_WERROR=0;
    fi], [qpdf_USE_WERROR=0])
if test "$qpdf_USE_WERROR" = "1"; then
   AC_MSG_RESULT(yes)
   WFLAGS="$WFLAGS $try_flags"
else
   AC_MSG_RESULT(no)
fi

if test "$BUILDRULES" = "msvc"; then
   try_flags="-W3"
else
   try_flags="-Wconversion -Wsign-conversion"
fi
oCFLAGS=$CFLAGS
CFLAGS="$CFLAGS $try_flags"
AC_MSG_CHECKING(for whether to use $try_flags)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[int a = 1; int b = a; a = b;]])],
                  [qpdf_INT_WARNINGS=1],[qpdf_INT_WARNINGS=0])
if test "$qpdf_INT_WARNINGS" = "1"; then
   AC_MSG_RESULT(yes)
   CXXFLAGS="$CXXFLAGS $try_flags"
else
   AC_MSG_RESULT(no)
   CFLAGS=$oCFLAGS
fi

if test "$BUILDRULES" != "msvc"; then
   try_flags="-Wshadow=local"
   oCFLAGS=$CFLAGS
   CFLAGS="$CFLAGS $try_flags -Werror"
   AC_MSG_CHECKING(for whether to use $try_flags)
   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[int a = 1; int b = a; a = b;]])],
                     [qpdf_SHADOW_WARNINGS=1],[qpdf_SHADOW_WARNINGS=0])
   if test "$qpdf_SHADOW_WARNINGS" = "1"; then
      AC_MSG_RESULT(yes)
      CFLAGS="$oCFLAGS $try_flags"
      CXXFLAGS="$CXXFLAGS $try_flags"
   else
      AC_MSG_RESULT(no)
      CFLAGS=$oCFLAGS
   fi
fi

AC_MSG_CHECKING(for tm_gmtoff in struct tm)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
      #include <time.h>
   ]],[[
      struct tm tm;
      tm.tm_gmtoff = 1;
   ]])], [qpdf_TM_GMTOFF=1], [qpdf_TM_GMTOFF=0])
if test "$qpdf_TM_GMTOFF" = "1"; then
   AC_MSG_RESULT(yes)
   AC_DEFINE([HAVE_TM_GMTOFF], [1], [Whether struct tm has tm_gmtoff])
else
   AC_MSG_RESULT(no)
fi

AC_MSG_CHECKING(for extern long timezone)
AC_LINK_IFELSE([AC_LANG_PROGRAM([[
      #include <time.h>
      #include <stdio.h>
   ]],[[
      tzset();
      printf("%ld\n", timezone);
   ]])], [qpdf_EXTERN_LONG_TIMEZONE=1], [qpdf_EXTERN_LONG_TIMEZONE=0])
if test "$qpdf_EXTERN_LONG_TIMEZONE" = "1"; then
   AC_MSG_RESULT(yes)
   AC_DEFINE([HAVE_EXTERN_LONG_TIMEZONE], [1], [Whether extern long timezone is available])
else
   AC_MSG_RESULT(no)
fi

LL_FMT=""
oCFLAGS=$CFLAGS
CFLAGS="$WFLAGS $CFLAGS"
for fmt in "%lld" "%I64d" "%I64lld"; do
  if test "$LL_FMT" = ""; then
    AC_MSG_CHECKING(printf format for long long: $fmt)
    AC_RUN_IFELSE([AC_LANG_PROGRAM(
     [[
        #define _CRT_SECURE_NO_WARNINGS
        #include <stdio.h>
        #include <string.h>
     ]],
     [[
        long long int a = 123456789012345ll;
        char s[30];
        sprintf(s, "]$fmt[", a);
        return (strcmp(s, "123456789012345") == 0) ? 0 : 1
     ]]
     )],
     [LL_FMT=$fmt],[],[LL_FMT="%lld"])
    if test "$LL_FMT" != ""; then
       AC_MSG_RESULT(yes)
    else
       AC_MSG_RESULT(no)
    fi
  fi
done
CFLAGS=$oCFLAGS
if test "LL_FMT" = ""; then
  LL_FMT="%lld%"
fi
AC_DEFINE_UNQUOTED([LL_FMT], ["$LL_FMT"], [printf format for long long])

AC_SUBST(WINDOWS_WMAIN_XLINK_FLAGS)
AC_SUBST(WINDOWS_MAIN_XLINK_FLAGS)
if test "$BUILDRULES" = "msvc"; then
  WINDOWS_WMAIN_XLINK_FLAGS="-link wsetargv.obj"
  WINDOWS_MAIN_XLINK_FLAGS="-link setargv.obj"
fi

dnl BEGIN CRYPTO

dnl By default, we build in support for every crypto provider that we
dnl can. If implicit crypto is disabled, we don't build support for
dnl any crypto that is not explicitly enabled. Test for various crypto
dnl providers in increasing order of priority. The last one found
dnl becomes the default unless a default is explicitly specified.

AC_MSG_CHECKING(for whether to use implicit crypto)
AC_ARG_ENABLE(implicit-crypto,
   AS_HELP_STRING([--enable-implicit-crypto],
		  [whether to enable available crypto providers that are not explicitly requested; true by default]),
   [if test "$enableval" = "yes"; then
      IMPLICIT_CRYPTO=1
    else
      IMPLICIT_CRYPTO=0
    fi],
   [IMPLICIT_CRYPTO=1])
if test "$IMPLICIT_CRYPTO" = "1"; then
   AC_MSG_RESULT(yes)
else
   AC_MSG_RESULT(no)
fi

dnl Native crypto is always available unless explicitly disabled.

AC_SUBST(USE_CRYPTO_NATIVE)
AC_ARG_ENABLE(crypto-native,
   AS_HELP_STRING([--enable-crypto-native],
                  [whether to include support for native crypto provider]),
   [if test "$enableval" = "yes"; then
      USE_CRYPTO_NATIVE=1
    else
      USE_CRYPTO_NATIVE=0
    fi],
   [USE_CRYPTO_NATIVE=$IMPLICIT_CRYPTO])
if test "$USE_CRYPTO_NATIVE" = "1"; then
  AC_DEFINE([USE_CRYPTO_NATIVE], 1, [Whether to use the native crypto provider])
  DEFAULT_CRYPTO=native
fi

dnl If the openssl/BoringSSL provider is explicitly requested, require openssl.
dnl If the openssl provider is not explicitly disabled, enable it if
dnl openssl is available. If the openssl provider is explicitly
dnl disabled, do not link with openssl even if present.

if test "$USE_EXTERNAL_LIBS" = "1"; then
  OPENSSL_FOUND=1
else
  PKG_CHECK_MODULES([pc_openssl], [openssl >= 1.1.0],
                    [OPENSSL_FOUND=1], [OPENSSL_FOUND=0])
fi

dnl Override pkg-config if headers and libraries are present.
AS_IF([test "$OPENSSL_FOUND" = "0"],
      [AC_CHECK_HEADER(
       [openssl/evp.h],
       [AC_SEARCH_LIBS(EVP_MD_CTX_new,crypto,[OPENSSL_FOUND=1])])
      ])

IMPLICIT_OPENSSL=0
USE_CRYPTO_OPENSSL=0
AC_SUBST(USE_CRYPTO_OPENSSL)
AC_ARG_ENABLE(crypto-openssl,
   AS_HELP_STRING([--enable-crypto-openssl],
                  [whether to include support for the openssl crypto provider]),
   [if test "$enableval" = "yes"; then
      USE_CRYPTO_OPENSSL=1
    else
      USE_CRYPTO_OPENSSL=0
    fi],
   [IMPLICIT_OPENSSL=$IMPLICIT_CRYPTO])

if test "$IMPLICIT_OPENSSL" = "1"; then
  USE_CRYPTO_OPENSSL=$OPENSSL_FOUND
  if test "$USE_CRYPTO_OPENSSL" = "1"; then
    AC_MSG_NOTICE(enabling openssl crypto provider since openssl is available)
  else
    AC_MSG_NOTICE(not enabling openssl crypto provider since openssl was not found)
  fi
fi

if test "$USE_CRYPTO_OPENSSL" = "1" -a "$OPENSSL_FOUND" = "0"; then
  AC_MSG_ERROR(unable to use requested openssl crypto provider without openssl)
fi

if test "$USE_CRYPTO_OPENSSL" = "1"; then
  CFLAGS="$CFLAGS $pc_openssl_CFLAGS"
  CXXFLAGS="$CXXFLAGS $pc_openssl_CFLAGS $pc_openssl_CXXFLAGS"
  LIBS="$LIBS $pc_openssl_LIBS"
  AC_DEFINE([USE_CRYPTO_OPENSSL], 1, [Whether to use the openssl crypto provider])
  DEFAULT_CRYPTO=openssl
elif test "$OPENSSL_FOUND" = "1"; then
  AC_MSG_NOTICE(not linking with openssl even though it is available)
fi

dnl If the gnutls provider is explicitly requested, require gnutls. If
dnl the gnutls provider is not explicitly disabled, enable it if
dnl gnutls is available. If the gnutls provider is explicitly
dnl disabled, do not link with gnutls even if present.

PKG_CHECK_MODULES([pc_gnutls], [gnutls], [GNUTLS_FOUND=1], [GNUTLS_FOUND=0])
if test "$GNUTLS_FOUND" = "0"; then
  AC_CHECK_HEADER(gnutls/gnutls.h,[GNUTLS_FOUND=1],[GNUTLS_FOUND=0])
  AC_SEARCH_LIBS(gnutls_hash_init,gnutls,[GNUTLS_FOUND=1],[GNUTLS_FOUND=0])
fi

IMPLICIT_GNUTLS=0
USE_CRYPTO_GNUTLS=0
AC_SUBST(USE_CRYPTO_GNUTLS)
AC_ARG_ENABLE(crypto-gnutls,
   AS_HELP_STRING([--enable-crypto-gnutls],
                  [whether to include support for gnutls crypto provider]),
   [if test "$enableval" = "yes"; then
      USE_CRYPTO_GNUTLS=1
    else
      USE_CRYPTO_GNUTLS=0
    fi],
   [IMPLICIT_GNUTLS=$IMPLICIT_CRYPTO])

if test "$IMPLICIT_GNUTLS" = "1"; then
  USE_CRYPTO_GNUTLS=$GNUTLS_FOUND
  if test "$USE_CRYPTO_GNUTLS" = "1"; then
    AC_MSG_NOTICE(enabling gnutls crypto provider since gnutls is available)
  else
    AC_MSG_NOTICE(not enabling gnutls crypto provider since gnutls was not found)
  fi
fi

if test "$USE_CRYPTO_GNUTLS" = "1" -a "$GNUTLS_FOUND" = "0"; then
  AC_MSG_ERROR(unable to use requested gnutls crypto provider without gnutls)
fi

if test "$USE_CRYPTO_GNUTLS" = "1"; then
  CFLAGS="$CFLAGS $pc_gnutls_CFLAGS"
  CXXFLAGS="$CXXFLAGS $pc_gnutls_CFLAGS $pc_gnutls_CXXFLAGS"
  LIBS="$LIBS $pc_gnutls_LIBS"
  AC_DEFINE([USE_CRYPTO_GNUTLS], 1, [Whether to use the gnutls crypto provider])
  DEFAULT_CRYPTO=gnutls
elif test "$GNUTLS_FOUND" = "1"; then
  AC_MSG_NOTICE(not linking with gnutls even though it is available)
fi

dnl Allow the default crypto provider to be specified explicitly.

AC_MSG_CHECKING(which crypto to use by default)
AC_SUBST(DEFAULT_CRYPTO)
AC_ARG_WITH(default-crypto,
   AS_HELP_STRING([--with-default-crypto=provider],
		  [which crypto provider to use by default; see README.md]),
   [DEFAULT_CRYPTO=$withval],
   [])
AC_MSG_RESULT($DEFAULT_CRYPTO)
AC_DEFINE_UNQUOTED([DEFAULT_CRYPTO], "$DEFAULT_CRYPTO", [Default crypto provider])

dnl Make sure the default crypto provider is actually being built.

bad_crypto=0
case "$DEFAULT_CRYPTO" in
  "native")
    if test "$USE_CRYPTO_NATIVE" != "1"; then
      bad_crypto=1
    fi
  ;;
  "openssl")
    if test "$USE_CRYPTO_OPENSSL" != "1"; then
      bad_crypto=1
    fi
  ;;
  "gnutls")
    if test "$USE_CRYPTO_GNUTLS" != "1"; then
      bad_crypto=1
    fi
  ;;
  *)
    bad_crypto=1
  ;;
esac
if test "$bad_crypto" = "1"; then
  AC_MSG_ERROR(Unsupported default crypto: $DEFAULT_CRYPTO)
fi

dnl END CRYPTO

AC_SUBST(QPDF_SKIP_TEST_COMPARE_IMAGES)
AC_ARG_ENABLE(test-compare-images,
   AS_HELP_STRING([--enable-test-compare-images],
		  [whether to compare images in test suite; disabled by default, enabling requires ghostscript and tiffcmp to be available]),
   [if test "$enableval" = "no"; then
      QPDF_SKIP_TEST_COMPARE_IMAGES=1
    else
      QPDF_SKIP_TEST_COMPARE_IMAGES=0
    fi],
   [QPDF_SKIP_TEST_COMPARE_IMAGES=1])

AC_SUBST(SHOW_FAILED_TEST_OUTPUT)
AC_ARG_ENABLE(show-failed-test-output,
   AS_HELP_STRING([--enable-show-failed-test-output],
		  [if specified, write failed test output to the console; useful for building on build servers where you can't easily open the test output files]),
   [if test "$enableval" = "no"; then
      SHOW_FAILED_TEST_OUTPUT=0
    else
      SHOW_FAILED_TEST_OUTPUT=1
    fi],
   [SHOW_FAILED_TEST_OUTPUT=0])

AC_CHECK_PROG(LATEX,latex,latex,[])
AC_CHECK_PROG(PDFLATEX,pdflatex,pdflatex,[])
AC_CHECK_PROG(LATEXMK,latexmk,latexmk,[])
AC_CHECK_PROG(SPHINX,sphinx-build,sphinx-build,[])

AC_ARG_ENABLE(doc-maintenance,
   AS_HELP_STRING([--enable-doc-maintenance],
		  [if set, enables all documentation options; also turned on by maintainer mode]),
   [if test "$enableval" = "yes"; then
      doc_default=1;
    else
      doc_default=0;
    fi],
   [doc_default=$MAINTAINER_MODE])

BUILD_HTML=0
AC_SUBST(BUILD_HTML)
AC_ARG_ENABLE(html-doc,
   AS_HELP_STRING([--enable-html-doc],
		  [whether to build HTML documents]),
   [if test "$enableval" = "yes"; then
      BUILD_HTML=1;
    else
      BUILD_HTML=0;
    fi],
   [BUILD_HTML=$doc_default])
BUILD_PDF=0
AC_SUBST(BUILD_PDF)
AC_ARG_ENABLE(pdf-doc,
   AS_HELP_STRING([--enable-pdf-doc],
		  [whether to build PDF documents]),
   [if test "$enableval" = "yes"; then
      BUILD_PDF=1;
    else
      BUILD_PDF=0;
    fi],
   [BUILD_PDF=$doc_default])

AC_SUBST(OSS_FUZZ)
AC_ARG_ENABLE(oss-fuzz,
   AS_HELP_STRING([--enable-oss-fuzz],
		  [if set, build static fuzzers for oss-fuzz]),
   [if test "$enableval" = "yes"; then
      OSS_FUZZ=1;
    else
      OSS_FUZZ=0;
    fi],
   [OSS_FUZZ=0])

if test "$BUILD_HTML" = "1"; then
   if test "$SPHINX" = ""; then
      MISSING_SPHINX=1
      MISSING_ANY=1
   fi
fi
if test "$BUILD_PDF" = "1"; then
   if test "$SPHINX" = ""; then
      MISSING_SPHINX=1
      MISSING_ANY=1
   fi
   if test "$LATEX" = ""; then
      MISSING_LATEX=1
      MISSING_ANY=1
   fi
   if test "$LATEXMK" = ""; then
      MISSING_LATEXMK=1
      MISSING_ANY=1
   fi
   if test "$PDFLATEX" = ""; then
      MISSING_PDFLATEX=1
      MISSING_ANY=1
   fi
fi

if test "$MISSING_ANY" = "1"; then
  ISSUE_WARNINGS=1
fi
if test "$ISSUE_WARNINGS" = "1"; then
  echo ""
  echo ""
fi

if test "$MISSING_MAKE_381" = "1"; then
  AC_MSG_WARN(gnu make >= 3.81 is required)
fi

if test "$MISSING_ZLIB_H" = "1"; then
  AC_MSG_WARN(unable to find required header zlib.h)
fi

if test "$MISSING_ZLIB" = "1"; then
  AC_MSG_WARN(unable to find required library z (or zlib))
fi

if test "$MISSING_JPEG_H" = "1"; then
  AC_MSG_WARN(unable to find required header jpeglib.h)
fi

if test "$MISSING_JPEG" = "1"; then
  AC_MSG_WARN(unable to find required library jpeg)
fi

if test "$MISSING_LATEX" = "1"; then
  AC_MSG_WARN(latex is required to build PDF documentation)
fi

if test "$MISSING_LATEXMK" = "1"; then
  AC_MSG_WARN(latexmk is required to build PDF documentation)
fi

if test "$MISSING_PDFLATEX" = "1"; then
  AC_MSG_WARN(pdflatex is required to build PDF documentation)
fi

if test "$MISSING_SPHINX" = "1"; then
  AC_MSG_WARN(sphinx-build is required to build documentation)
fi

if test "$ISSUE_WARNINGS" = "1"; then
  echo ""
  echo ""
fi

if test "$MISSING_ANY" = "1"; then
  AC_MSG_ERROR(some required prerequisites were not found)
fi

# Do this last so it doesn't interfere with other tests.
if test "$USE_EXTERNAL_LIBS" = "1"; then
   # Don't actually check for the presence of this -- we document that
   # the user can run this and then edit autoconf.mk if they have too
   # much trouble getting it to work with a different compiler.
   CPPFLAGS="$CPPFLAGS -Iexternal-libs/include"
   LDFLAGS="$LDFLAGS -Lexternal-libs/lib-$BUILDRULES$WINDOWS_WORDSIZE"
   LIBS="$LIBS -lz -ljpeg -lssl -lcrypto -lmsvcrt -lws2_32 -lshell32 -ladvapi32 -lgdi32 -luser32 -lcrypt32"
fi

AC_OUTPUT