| m4_define([poppler_version_major],[0]) |
| m4_define([poppler_version_minor],[56]) |
| m4_define([poppler_version_micro],[0]) |
| m4_define([poppler_version],[poppler_version_major.poppler_version_minor.poppler_version_micro]) |
| |
| AC_PREREQ(2.59) |
| AC_INIT([poppler],[poppler_version],[https://bugs.freedesktop.org/enter_bug.cgi?product=poppler]) |
| AC_CONFIG_MACRO_DIR([m4]) |
| AM_INIT_AUTOMAKE([1.7 foreign]) |
| m4_ifdef([AM_SILENT_RULES],[AM_SILENT_RULES([yes])]) |
| AC_CONFIG_HEADERS([config.h poppler/poppler-config.h]) |
| AC_C_BIGENDIAN |
| |
| dnl ##### Initialize libtool. |
| AC_LIBTOOL_WIN32_DLL |
| define([AC_LIBTOOL_LANG_F77_CONFIG], [:]) |
| AC_PROG_LIBTOOL |
| |
| dnl ##### Checks for programs. |
| AC_PROG_CC |
| AC_PROG_CXX |
| AC_ISC_POSIX |
| AC_PROG_CC_STDC |
| #if test -z "$CXX" -a "$CC" = "gcc"; then |
| # CXX="gcc" |
| #fi |
| AC_PROG_CXX |
| AC_PROG_INSTALL |
| CXXFLAGS="$CXXFLAGS -std=c++11" |
| |
| dnl ##### Check for pkgconfig |
| PKG_PROG_PKG_CONFIG |
| |
| dnl ##### Export the version |
| AC_DEFINE_UNQUOTED([POPPLER_VERSION], ["poppler_version"], [Defines the poppler version]) |
| |
| dnl Enable these unconditionally. |
| AC_DEFINE([OPI_SUPPORT], [1], [Generate OPI comments in PS output.]) |
| AC_DEFINE([MULTITHREADED], [1], [Enable multithreading support.]) |
| AC_DEFINE([TEXTOUT_WORD_LIST], [1], [Enable word list support.]) |
| |
| dnl Check for OS specific flags |
| win32_libs="" |
| create_shared_lib="" |
| auto_import_flags="" |
| case "$host_os" in |
| cygwin*) |
| create_shared_lib="-no-undefined" |
| ;; |
| mingw*) |
| os_win32=yes |
| win32_libs="-lgdi32 -lwinspool -lcomdlg32" |
| create_shared_lib="-no-undefined" |
| auto_import_flags="-Wl,--enable-auto-import" |
| |
| # Use mingw's ansi stdio extensions |
| CXXFLAGS="$CXXFLAGS -D__USE_MINGW_ANSI_STDIO=1" |
| ;; |
| esac |
| |
| AC_SUBST(win32_libs) |
| AC_SUBST(create_shared_lib) |
| AC_SUBST(auto_import_flags) |
| |
| AX_PTHREAD() |
| |
| dnl Install xpdf headers |
| AC_ARG_ENABLE(xpdf-headers, |
| AC_HELP_STRING([--enable-xpdf-headers], |
| [Install unsupported xpdf headers.]), |
| enable_xpdf_headers=$enableval, |
| enable_xpdf_headers="no") |
| AM_CONDITIONAL(ENABLE_XPDF_HEADERS, test x$enable_xpdf_headers = xyes) |
| |
| dnl ##### Emulate cmake -DCMAKE_BUILD_TYPE=Release using options from cmake/modules/PopplerMacros.cmake |
| |
| AC_ARG_ENABLE(build-type, |
| AC_HELP_STRING([--enable-build-type=@<:@relwithdebinfo/release/debug/debugfull/profile@:>@], |
| [Build with options similar to 'cmake -DCMAKE_BUILD_TYPE=' values.]), |
| [enable_build_type=no; |
| case "$enableval" in |
| relwithdebinfo|release|debug|debugfull|profile) enable_build_type="$enableval" ;; |
| *) AC_MSG_ERROR([bad value $enableval for --enable-build-type option. |
| Options are relwithdebinfo, release, debug, debugfull, and profile.]) ;; |
| esac], |
| enable_build_type=no) |
| |
| if test "x$GCC" = "xyes"; then |
| case "$enable_build_type" in |
| relwithdebinfo) |
| CFLAGS="-O2 -g $CFLAGS" |
| CXXFLAGS="-O2 -g $CXXFLAGS" |
| ;; |
| release) |
| CFLAGS="-O2 $CFLAGS -g0 -DNDEBUG" |
| CXXFLAGS="-O2 $CXXFLAGS -g0 -DNDEBUG" |
| ;; |
| debug) |
| CFLAGS="-O2 -g $CFLAGS -fno-reorder-blocks -fno-schedule-insns -fno-inline" |
| CXXFLAGS="-O2 -g $CXXFLAGS -fno-reorder-blocks -fno-schedule-insns -fno-inline" |
| ;; |
| debugfull) |
| CFLAGS="$CFLAGS -g3 -fno-inline" |
| CXXFLAGS="$CXXFLAGS -g3 -fno-inline" |
| ;; |
| profile) |
| CFLAGS="$CFLAGS -g3 -fno-inline -ftest-coverage -fprofile-arcs" |
| CXXFLAGS="$CXXFLAGS -g3 -fno-inline -ftest-coverage -fprofile-arcs" |
| LDFLAGS="$LDFLAGS -fprofile-arcs -ftest-coverage -lgcov" |
| ;; |
| *) |
| enable_build_type=no |
| ;; |
| esac |
| else |
| case "$enable_build_type" in |
| relwithdebinfo|release|debug|debugfull|profile) |
| echo " Warning: --enable-build-type ignored for non-gcc compiler." |
| ;; |
| esac |
| enable_build_type=no |
| fi |
| |
| AC_ARG_ENABLE(single-precision, |
| [ --enable-single-precision use single precision arithmetic (instead of double precision) in the Splash backend], |
| AC_DEFINE(USE_FLOAT, [1], [Use single precision arithmetic in the Splash backend])) |
| |
| AC_ARG_ENABLE(fixedpoint, |
| [ --enable-fixedpoint use fixed point (instead of double precision) arithmetic in the Splash backend], |
| AC_DEFINE(USE_FIXEDPOINT, [1], [Use fixed point arithmetic in the Splash backend])) |
| |
| AC_ARG_ENABLE(cmyk, |
| [ --enable-cmyk Include support for CMYK rasterization], |
| AC_DEFINE(SPLASH_CMYK, [1], [Include support for CMYK rasterization])) |
| |
| dnl Relocation support |
| AC_ARG_ENABLE(relocatable, |
| AC_HELP_STRING([--disable-relocatable], |
| [Hardcode the poppler library location (on Windows).]), |
| enable_relocatable=$enableval, |
| [if test x$os_win32 = xyes; then |
| # default to yes on native Windows. |
| enable_relocatable="yes" |
| else |
| # default to no everywhere else. |
| enable_relocatable="no" |
| fi |
| ] |
| ) |
| |
| if test x$enable_relocatable = xyes; then |
| if test x$os_win32 = xyes; then |
| AC_DEFINE([ENABLE_RELOCATABLE], |
| [1],[Do not hardcode the library location]) |
| else |
| AC_MSG_ERROR( |
| [Invalid setting for relocatable, only supported on windows]) |
| |
| fi |
| fi |
| |
| dnl ##### Check for installed poppler-data. Use the same datarootdir as default otherwise. |
| PKG_CHECK_EXISTS(poppler-data, |
| [POPPLER_DATADIR=`$PKG_CONFIG --variable=poppler_datadir poppler-data` |
| AC_DEFINE_DIR(POPPLER_DATADIR, "{POPPLER_DATADIR}", [Poppler data dir])], |
| [AC_DEFINE_DIR(POPPLER_DATADIR, "{datarootdir}/poppler", [Poppler data dir])] |
| ) |
| |
| dnl ##### Checks for header files. |
| AC_PATH_XTRA |
| AC_HEADER_DIRENT |
| AC_CHECK_HEADERS([stdint.h]) |
| |
| dnl ##### Switch over to C++. This will make the checks below a little |
| dnl ##### bit stricter (requiring function prototypes in include files). |
| dnl ##### (99% of xpdf is written in C++.) |
| AC_LANG_CPLUSPLUS |
| |
| AC_CHECK_DECL(gettimeofday, [AC_CHECK_FUNC(gettimeofday, AC_DEFINE(HAVE_GETTIMEOFDAY, 1, [Defines if gettimeofday is available on your system]))],[],[#include <sys/time.h>]) |
| AC_CHECK_FUNC(localtime_r, AC_DEFINE(HAVE_LOCALTIME_R, 1, [Defines if localtime_r is available on your system])) |
| AC_CHECK_FUNC(gmtime_r, AC_DEFINE(HAVE_GMTIME_R, 1, [Defines if gmtime_r is available on your system])) |
| AC_CHECK_FUNC(timegm, AC_DEFINE(HAVE_TIMEGM, 1, [Defines if timegm is available on your system])) |
| AC_CHECK_FUNC(rand_r, AC_DEFINE(HAVE_RAND_R, 1, [Defines if rand_r is available on your system])) |
| |
| dnl ##### Check for extra libraries needed by X. (LynxOS needs this.) |
| AC_CHECK_FUNC(nanosleep,,) |
| dnl try in librt if not found in current LIBS |
| if test x$ac_cv_func_nanosleep = xno |
| then |
| AC_CHECK_LIB(rt,nanosleep, X_EXTRA_LIBS="$X_EXTRA_LIBS -lrt") |
| fi |
| |
| dnl try in libposix4, if not found so far |
| if test x$ac_cv_func_nanosleep = xno && test x$ac_cv_lib_rt_nanosleep = xno |
| then |
| AC_CHECK_LIB(posix4,nanosleep, X_EXTRA_LIBS="$X_EXTRA_LIBS -lposix4") |
| fi |
| |
| |
| dnl ##### Test for libopenjpeg. Versions prior to 1.4 do not provide a pkgconfig file. |
| openjpeg1="no" |
| openjpeg2="no" |
| AC_ARG_ENABLE(libopenjpeg, |
| AC_HELP_STRING([--enable-libopenjpeg=@<:@auto/openjpeg1/openjpeg2/unmaintained/none@:>@], |
| [Use openjpeg for JPEG2000 images. 'auto' prefers openjpeg2 over openjpeg1 if both are available. 'unmaintained' gives you the internal unmaintained decoder. Use at your own risk. 'none' compiles no JPX decoder at all. [[default=auto]]]), |
| [enable_libopenjpeg=$enableval], |
| [enable_libopenjpeg="auto"]) |
| |
| openjpeg_header=yes |
| |
| dnl test for libopenjpeg2 |
| if test x$enable_libopenjpeg = xopenjpeg2 || test x$enable_libopenjpeg = xauto; then |
| PKG_CHECK_MODULES(LIBOPENJPEG, libopenjp2, |
| [openjpeg2=yes],[openjpeg2=no]) |
| fi |
| |
| dnl test for libopenjpeg1 |
| if test x$openjpeg2 = xno; then |
| if test x$enable_libopenjpeg = xopenjpeg1 || test x$enable_libopenjpeg = xauto; then |
| PKG_CHECK_MODULES(LIBOPENJPEG, libopenjpeg, |
| [openjpeg1="yes"], |
| [AC_CHECK_LIB([openjpeg], [opj_cio_open], |
| [openjpeg1="yes" |
| LIBOPENJPEG_LIBS="-lopenjpeg"],[openjpeg_header=no]) |
| AC_CHECK_HEADERS([openjpeg.h],, |
| [openjpeg_header="no"])]) |
| fi |
| fi |
| |
| |
| if test x$enable_libopenjpeg = xopenjpeg1 && test x$openjpeg1 = xno; then |
| if test x$openjpeg_header = xno; then |
| AC_MSG_ERROR("*** libopenjpeg headers not found ***") |
| else |
| AC_MSG_ERROR("*** libopenjpeg library not found ***") |
| fi |
| fi |
| |
| if test x$enable_libopenjpeg = xopenjpeg2 && test x$openjpeg2 = xno; then |
| AC_MSG_ERROR("*** libopenjp2 library not found ***") |
| fi |
| |
| if test x$openjpeg1 = xyes || test x$openjpeg2 = xyes; then |
| enable_libopenjpeg=yes |
| if test x$openjpeg1 = xyes; then |
| AC_DEFINE(USE_OPENJPEG1, 1, [Defined if using openjpeg1]) |
| fi |
| if test x$openjpeg2 = xyes; then |
| AC_DEFINE(USE_OPENJPEG2, 1, [Defined if using openjpeg2]) |
| fi |
| |
| AC_SUBST(LIBOPENJPEG_CFLAGS) |
| AC_SUBST(LIBOPENJPEG_LIBS) |
| AC_DEFINE(ENABLE_LIBOPENJPEG) |
| PKG_CHECK_EXISTS(libopenjpeg >= 1.5, |
| [AC_DEFINE(WITH_OPENJPEG_IGNORE_PCLR_CMAP_CDEF_FLAG, 1, [OpenJPEG with the OPJ_DPARAMETERS_IGNORE_PCLR_CMAP_CDEF_FLAG flag.])], |
| [PKG_CHECK_EXISTS(libopenjpeg1 >= 1.5, |
| [AC_DEFINE(WITH_OPENJPEG_IGNORE_PCLR_CMAP_CDEF_FLAG, 1, [OpenJPEG with the OPJ_DPARAMETERS_IGNORE_PCLR_CMAP_CDEF_FLAG flag.])], |
| []) |
| ]) |
| have_jpx_decoder=yes |
| AC_DEFINE(HAVE_JPX_DECODER) |
| else |
| if test x$enable_libopenjpeg = xunmaintained; then |
| enable_libopenjpeg=no |
| have_jpx_decoder=yes |
| AC_DEFINE(HAVE_JPX_DECODER) |
| elif test x$enable_libopenjpeg = xnone; then |
| enable_libopenjpeg=no |
| have_jpx_decoder=no |
| else |
| if test x$enable_libopenjpeg = xopenjpeg2 || test x$enable_libopenjpeg = xopenjpeg1 || test x$enable_libopenjpeg = xauto; then |
| AC_MSG_ERROR([Install libopenjpeg2 or libopenjpeg1 before trying to build poppler. You can also decide to use the internal unmaintained JPX decoder or none at all. See --help.]) |
| else |
| AC_MSG_ERROR([Invalid --enable-libopenjpeg value. See --help.]) |
| fi |
| fi |
| fi |
| |
| AH_TEMPLATE([HAVE_JPX_DECODER], [Do we have any JPX decoder?.]) |
| |
| dnl Test for NSS |
| AC_ARG_ENABLE(libnss, |
| AC_HELP_STRING([--disable-libnss], |
| [Do not build against libnss3.]), |
| enable_libnss=$enableval, |
| enable_libnss="try") |
| |
| if test x$enable_libnss != xno; then |
| PKG_CHECK_MODULES(NSS3, nss, [enable_nss="yes"], |
| [enable_nss="no"]) |
| fi |
| |
| if test x$enable_nss = xyes; then |
| AC_DEFINE(ENABLE_NSS3, 1, [Build against NSS.]) |
| fi |
| |
| AM_CONDITIONAL(BUILD_LIBOPENJPEG, test x$openjpeg1 = xyes || test x$openjpeg2 = xyes) |
| AH_TEMPLATE([ENABLE_LIBOPENJPEG], |
| [Use libopenjpeg instead of builtin jpeg2000 decoder.]) |
| |
| AM_CONDITIONAL(BUILD_NSS, test x$enable_nss = xyes) |
| AH_TEMPLATE([ENABLE_NSS3], [Build Poppler against NSS for digital signature support.]) |
| |
| dnl ##### Test for libtiff |
| AC_ARG_ENABLE(libtiff, |
| AC_HELP_STRING([--disable-libtiff], |
| [Don't build against libtiff.]), |
| enable_libtiff=$enableval, |
| enable_libtiff="try") |
| |
| AC_ARG_VAR([LIBTIFF_CFLAGS], [C compiler flags for LIBTIFF]) |
| AC_ARG_VAR([LIBTIFF_LIBS], [linker flags to link LIBTIFF (default is -ltiff)]) |
| ac_save_CPPFLAGS="$CPPFLAGS" |
| ac_save_CXXFLAGS="$CXXFLAGS" |
| ac_save_LIBS="$LDFLAGS" |
| CPPFLAGS="$CPPFLAGS $LIBTIFF_CFLAGS" |
| CXXFLAGS="$CXXFLAGS $LIBTIFF_CFLAGS" |
| LIBS="$LIBS $LIBTIFF_LIBS" |
| if test x$enable_libtiff = xyes; then |
| if test x"$LIBTIFF_LIBS" != x; then |
| AC_CHECK_FUNC([TIFFOpen],, |
| AC_MSG_ERROR("*** libtiff library not found ***")) |
| else |
| AC_CHECK_LIB([tiff], [TIFFOpen],, |
| AC_MSG_ERROR("*** libtiff library not found ***")) |
| fi |
| AC_CHECK_HEADERS([tiffio.h],, |
| AC_MSG_ERROR("*** libtiff headers not found ***")) |
| elif test x$enable_libtiff = xtry; then |
| if test x"$LIBTIFF_LIBS" != x; then |
| AC_CHECK_FUNC([TIFFOpen], |
| [enable_libtiff="yes"], |
| [enable_libtiff="no"]) |
| else |
| AC_CHECK_LIB([tiff], [TIFFOpen], |
| [enable_libtiff="yes"], |
| [enable_libtiff="no"]) |
| fi |
| AC_CHECK_HEADERS([tiffio.h],, |
| [enable_libtiff="no"]) |
| fi |
| CPPFLAGS="$ac_save_CPPFLAGS" |
| CXXFLAGS="$ac_save_CXXFLAGS" |
| LIBS="$ac_save_LIBS" |
| |
| if test x$enable_libtiff = xyes; then |
| if test x"$LIBTIFF_LIBS" = x; then |
| LIBTIFF_LIBS="-ltiff" |
| fi |
| AC_SUBST(LIBTIFF_CFLAGS) |
| AC_SUBST(LIBTIFF_LIBS) |
| AC_DEFINE(ENABLE_LIBTIFF) |
| fi |
| |
| AM_CONDITIONAL(BUILD_LIBTIFF, test x$enable_libtiff = xyes) |
| AH_TEMPLATE([ENABLE_LIBTIFF], [Build against libtiff.]) |
| if test x$enable_libtiff = xyes; then |
| AC_DEFINE(ENABLE_LIBTIFF, 1, [Build against libtiff.]) |
| fi |
| |
| dnl ##### Checks for library functions. |
| AC_CHECK_FUNCS(popen mkstemp mkstemps) |
| AC_CHECK_FUNCS(strcpy_s strcat_s) |
| |
| dnl ##### Back to C for the library tests. |
| AC_LANG_C |
| |
| dnl ##### Check for fseeko/ftello or fseek64/ftell64 |
| dnl The LARGEFILE and FSEEKO macros have to be called in C, not C++, mode. |
| AC_SYS_LARGEFILE |
| AC_FUNC_FSEEKO |
| AC_CHECK_FUNCS(fseek64, xpdf_cv_func_fseek64=yes, xpdf_cv_func_fseek64=no) |
| AC_CHECK_FUNCS(ftell64, xpdf_cv_func_ftell64=yes, xpdf_cv_func_ftell64=no) |
| if test "$xpdf_cv_func_fseek64" = yes -a "$xpdf_cv_func_ftell64" = yes; then |
| AC_DEFINE(HAVE_FSEEK64) |
| fi |
| AC_CHECK_FUNCS(pread64 lseek64) |
| |
| dnl Test for zlib |
| AC_ARG_ENABLE(zlib, |
| AC_HELP_STRING([--disable-zlib], |
| [Don't build against zlib.]), |
| enable_zlib=$enableval, |
| enable_zlib="try") |
| |
| AC_ARG_ENABLE([zlib_uncompress], |
| AS_HELP_STRING([--enable-zlib-uncompress], |
| [Use zlib to uncompress flate streams (not totally safe)]), |
| enable_zlib_uncompress=$enableval, |
| enable_zlib_uncompress="no") |
| |
| if test x$enable_zlib = xyes; then |
| AC_CHECK_LIB([z], [inflate],, |
| AC_MSG_ERROR("*** zlib library not found ***")) |
| AC_CHECK_HEADERS([zlib.h],, |
| AC_MSG_ERROR("*** zlib headers not found ***")) |
| elif test x$enable_zlib = xtry; then |
| AC_CHECK_LIB([z], [inflate], |
| [enable_zlib="yes"], |
| [enable_zlib="no"]) |
| AC_CHECK_HEADERS([zlib.h],, |
| [enable_zlib="no"]) |
| fi |
| |
| if test x$enable_zlib = xyes; then |
| ZLIB_LIBS="-lz" |
| AC_SUBST(ZLIB_LIBS) |
| AC_DEFINE(ENABLE_ZLIB, 1, [Build against zlib.]) |
| |
| if test x$enable_zlib_uncompress = xyes; then |
| AC_DEFINE(ENABLE_ZLIB_UNCOMPRESS, 1, |
| [Use zlib instead of builtin zlib decoder to uncompress flate streams.]) |
| fi |
| else |
| if test x$enable_zlib_uncompress = xyes; then |
| echo " Warning: --enable-zlib-uncompress is incompatible with --disable-zlib." |
| fi |
| enable_zlib_uncompress="no" |
| fi |
| |
| AM_CONDITIONAL(BUILD_ZLIB, test x$enable_zlib = xyes) |
| AH_TEMPLATE([ENABLE_ZLIB], |
| [Build against zlib.]) |
| AM_CONDITIONAL(BUILD_ZLIB_UNCOMPRESS, test x$enable_zlib_uncompress = xyes) |
| AH_TEMPLATE([ENABLE_ZLIB_UNCOMPRESS], |
| [Use zlib instead of builtin zlib decoder to uncompress flate streams.]) |
| |
| dnl Test for libcurl |
| AC_ARG_ENABLE(libcurl, |
| AC_HELP_STRING([--enable-libcurl], |
| [Build with libcurl based HTTP support.]), |
| enable_libcurl=$enableval, |
| enable_libcurl="no") |
| |
| if test x$enable_libcurl = xyes; then |
| PKG_CHECK_MODULES(LIBCURL, libcurl) |
| AC_DEFINE(ENABLE_LIBCURL, 1, [Build against libcurl.]) |
| AC_DEFINE(POPPLER_HAS_CURL_SUPPORT, 1, |
| [Support for curl based doc builder is compiled in.]) |
| fi |
| |
| AM_CONDITIONAL(BUILD_LIBCURL, test x$enable_libcurl = xyes) |
| |
| dnl Test for dct decoder |
| AC_ARG_ENABLE(dctdecoder, |
| AC_HELP_STRING([--enable-dctdecoder=@<:@libjpeg/unmaintained/none@:>@], |
| [Decides which DCT decoder to use. 'libjpeg' will use libjpeg if available or fail if not. 'unmaintained' gives you the internal unmaintained decoder. Use at your own risk. 'none' compiles no DCT decoder at all. [[default=libjpeg]]]), |
| [dctdecoder=$enableval], |
| [dctdecoder="libjpeg"]) |
| |
| AC_ARG_VAR([LIBJPEG_CFLAGS], [C compiler flags for LIBJPEG]) |
| if test x$dctdecoder = x"libjpeg"; then |
| |
| dnl |
| dnl POPPLER_FIND_JPEG uses "USER_INCLUDES" and "USER_LIBS" |
| dnl to receive the flags for header and library directories. |
| dnl |
| ac_save_USER_INCLUDES="$USER_INCLUDES" |
| ac_save_USER_LDFLAGS="$USER_LDFLAGS" |
| USER_INCLUDES="$USER_INCLUDES $LIBJPEG_CFLAGS" |
| USER_LDFLAGS="$USER_LDFLAGS $LIBJPEG_CFLAGS" |
| POPPLER_FIND_JPEG |
| |
| dnl check INT16, INT32 typedef conflict in jmorecfg.h |
| ac_save_CPPFLAGS="$CPPFLAGS" |
| ac_save_CFLAGS="$CFLAGS" |
| CPPFLAGS="$CPPFLAGS $LIBJPEG_CFLAGS" |
| CFLAGS="$CFLAGS $LIBJPEG_CFLAGS" |
| AC_MSG_CHECKING([libjpeg.h works correctly]) |
| AC_COMPILE_IFELSE([ |
| AC_LANG_PROGRAM([ |
| #ifdef _WIN32 |
| #include <windows.h> |
| #endif |
| #include <sys/types.h> |
| #include <stdio.h> |
| #include <jpeglib.h> |
| ],[{return 0;}])],[ |
| AC_MSG_RESULT([ok]) |
| ],[ |
| AC_MSG_RESULT([no]) |
| AC_MSG_CHECKING([libjpeg.h problem can be fixed by XMD_H macro]) |
| CPPFLAGS="$CPPFLAGS -DXMD_H" |
| CFLAGS="$CFLAGS -DXMD_H" |
| AC_COMPILE_IFELSE([ |
| AC_LANG_PROGRAM([ |
| #ifdef _WIN32 |
| #include <windows.h> |
| #endif |
| #include <sys/types.h> |
| #include <stdio.h> |
| #include <jpeglib.h> |
| ],[{return 0;}])],[ |
| AC_MSG_RESULT([ok, -DXMD_H is added to LIBJPEG_CFLAGS]) |
| LIBJPEG_CFLAGS="$LIBJPEG_CFLAGS -DXMD_H" |
| ],[ |
| AC_MSG_RESULT([no, disable libjpeg]) |
| enable_libjpeg="no" |
| ]) |
| ]) |
| CPPFLAGS="$ac_save_CPPFLAGS" |
| CFLAGS="$ac_save_CFLAGS" |
| |
| dnl POPPLER_FIND_JPEG sets LIBJPEG_LIBS |
| AC_SUBST(LIBJPEG_CFLAGS) |
| USER_INCLUDES="$ac_save_USER_INCLUDES" |
| USER_LDFLAGS="$ac_save_USER_LDFLAGS" |
| |
| if test x$enable_libjpeg != x"yes"; then |
| AC_MSG_ERROR([Install libjpeg before trying to build poppler. You can also decide to use the internal unmaintained DCT decoder or none at all. See --help.]) |
| fi |
| have_dct_decoder="yes" |
| AC_DEFINE(HAVE_DCT_DECODER) |
| elif test x$dctdecoder = x"unmaintained"; then |
| enable_libjpeg="no" |
| have_dct_decoder="yes" |
| AC_DEFINE(HAVE_DCT_DECODER) |
| elif test x$dctdecoder = x"none"; then |
| enable_libjpeg="no" |
| have_dct_decoder="no" |
| else |
| AC_MSG_ERROR([Invalid --enable-dctdecoder value. See --help.]) |
| fi |
| |
| AH_TEMPLATE([HAVE_DCT_DECODER], [Do we have any DCT decoder?.]) |
| |
| AM_CONDITIONAL(BUILD_LIBJPEG, test x$enable_libjpeg = xyes) |
| AH_TEMPLATE([ENABLE_LIBJPEG], |
| [Use libjpeg instead of builtin unmaintained jpeg decoder.]) |
| |
| dnl Test for libpng |
| AC_ARG_ENABLE(libpng, |
| AC_HELP_STRING([--disable-libpng], |
| [Do not build against libpng.]), |
| enable_libpng=$enableval, |
| enable_libpng="try") |
| |
| if test x$enable_libpng != xno; then |
| PKG_CHECK_MODULES(LIBPNG, libpng, [enable_libpng="yes"], |
| [enable_libpng="no"]) |
| fi |
| |
| if test x$enable_libpng = xyes; then |
| AC_DEFINE(ENABLE_LIBPNG, 1, [Build against libpng.]) |
| fi |
| |
| AM_CONDITIONAL(BUILD_LIBPNG, test x$enable_libpng = xyes) |
| |
| dnl Check for freetype headers |
| |
| PKG_CHECK_MODULES(FREETYPE, freetype2, |
| [freetype_pkgconfig=yes], [freetype_pkgconfig=no]) |
| |
| if test "x$freetype_pkgconfig" = "xyes"; then |
| |
| AC_DEFINE(HAVE_FREETYPE_H, 1, [Have FreeType2 include files]) |
| |
| else |
| |
| FREETYPE_LIBS= |
| FREETYPE_CFLAGS= |
| |
| AC_PATH_PROG(FREETYPE_CONFIG, freetype-config, no) |
| if test "x$FREETYPE_CONFIG" != "xno" ; then |
| |
| FREETYPE_CFLAGS=`$FREETYPE_CONFIG --cflags` |
| FREETYPE_LIBS=`$FREETYPE_CONFIG --libs` |
| AC_DEFINE(HAVE_FREETYPE_H, 1, [Have FreeType2 include files]) |
| |
| fi |
| |
| fi |
| |
| AC_SUBST(FREETYPE_CFLAGS) |
| AC_SUBST(FREETYPE_LIBS) |
| |
| AC_MSG_CHECKING([which font configuration to use]) |
| AC_ARG_WITH([font_configuration], |
| [AS_HELP_STRING([--with-font-configuration=fontconfig|win32], |
| [Select font configuration backend])], |
| [], |
| [if test x$os_win32 = xyes; then |
| # default to win32 on native Windows. |
| with_font_configuration=win32 |
| else |
| # default to fontconig everywhere else. |
| with_font_configuration=fontconfig |
| fi |
| ] |
| ) |
| AC_MSG_RESULT([$with_font_configuration]) |
| |
| case $with_font_configuration in |
| win32) |
| AC_DEFINE([WITH_FONTCONFIGURATION_WIN32], |
| [1],[Use win32 font configuration backend]) |
| # Set the minimum required Internet Explorer version to 5.0 |
| CPPFLAGS="$CPPFLAGS -D_WIN32_IE=0x0500" |
| ;; |
| fontconfig) |
| AC_DEFINE([WITH_FONTCONFIGURATION_FONTCONFIG], |
| [1],[Use fontconfig font configuration backend]) |
| PKG_CHECK_MODULES(FONTCONFIG, fontconfig >= 2.0.0) |
| ;; |
| *) |
| AC_MSG_ERROR( |
| [Invalid font configuration setting: $with_font_configuration]) |
| ;; |
| esac |
| |
| AM_CONDITIONAL(BUILD_WITH_WIN32_FONTCONFIGURATION, |
| test x$with_font_configuration = xwin32) |
| |
| AC_ARG_ENABLE(splash-output, |
| AC_HELP_STRING([--disable-splash-output], |
| [Don't build the Splash graphics backend.]),, |
| enable_splash_output="yes") |
| AM_CONDITIONAL(BUILD_SPLASH_OUTPUT, test x$enable_splash_output = xyes) |
| AH_TEMPLATE([HAVE_SPLASH], [Use splash for rendering.]) |
| if test x$enable_splash_output = xyes; then |
| AC_DEFINE(HAVE_SPLASH) |
| fi |
| |
| CAIRO_VERSION="1.10.0" |
| AC_SUBST(CAIRO_VERSION) |
| CAIRO_DEPS="cairo >= $CAIRO_VERSION cairo-ft >= $CAIRO_VERSION" |
| AC_ARG_ENABLE(cairo-output, |
| AC_HELP_STRING([--disable-cairo-output], |
| [Don't build the cairo graphics backend.]), |
| enable_cairo_output=$enableval, |
| enable_cairo_output="try") |
| use_cairo="" |
| if test x$enable_cairo_output = xyes; then |
| PKG_CHECK_MODULES(CAIRO, $CAIRO_DEPS) |
| elif test x$enable_cairo_output = xtry; then |
| PKG_CHECK_MODULES(CAIRO, $CAIRO_DEPS, |
| [enable_cairo_output="yes"], |
| [enable_cairo_output="no" |
| use_cairo="no (requires cairo >= $CAIRO_VERSION)"]) |
| fi |
| if test "x$use_cairo" = "x"; then |
| use_cairo=$enable_cairo_output |
| fi |
| |
| AC_SUBST(CAIRO_CFLAGS) |
| AC_SUBST(CAIRO_LIBS) |
| |
| AM_CONDITIONAL(BUILD_CAIRO_OUTPUT, test x$enable_cairo_output = xyes) |
| AH_TEMPLATE([HAVE_CAIRO], [Use cairo for rendering.]) |
| if test x$enable_cairo_output = xyes; then |
| PDFTOCAIRO_DEPS="cairo cairo-ft" |
| dnl Check for optional cairo backends used by pdftocairo |
| PKG_CHECK_EXISTS(cairo-pdf, [PDFTOCAIRO_DEPS="$PDFTOCAIRO_DEPS cairo-pdf"], []) |
| PKG_CHECK_EXISTS(cairo-ps, [PDFTOCAIRO_DEPS="$PDFTOCAIRO_DEPS cairo-ps"], []) |
| PKG_CHECK_EXISTS(cairo-svg, [PDFTOCAIRO_DEPS="$PDFTOCAIRO_DEPS cairo-svg"], []) |
| |
| PKG_CHECK_MODULES(PDFTOCAIRO, $PDFTOCAIRO_DEPS) |
| AC_SUBST(PDFTOCAIRO_CFLAGS) |
| AC_SUBST(PDFTOCAIRO_LIBS) |
| |
| AC_DEFINE(HAVE_CAIRO) |
| CAIRO_FEATURE="#define POPPLER_HAS_CAIRO 1" |
| CAIRO_REQ="cairo" |
| AC_CHECK_HEADERS(fcntl.h sys/mman.h sys/stat.h) |
| else |
| CAIRO_FEATURE="#undef POPPLER_HAS_CAIRO" |
| CAIRO_REQ="" |
| fi |
| AC_SUBST(CAIRO_FEATURE) |
| AC_SUBST(CAIRO_REQ) |
| |
| use_glib="" |
| found_introspection=no |
| if test x$enable_cairo_output = xyes; then |
| POPPLER_GLIB_DISABLE_DEPRECATED="" |
| POPPLER_GLIB_DISABLE_SINGLE_INCLUDES="" |
| |
| GLIB_REQUIRED=2.41 |
| AC_SUBST(GLIB_REQUIRED) |
| AC_ARG_ENABLE(poppler-glib, |
| AC_HELP_STRING([--disable-poppler-glib], |
| [Don't compile poppler glib wrapper.]), |
| enable_poppler_glib=$enableval, |
| enable_poppler_glib="try") |
| if test x$enable_poppler_glib = xyes; then |
| PKG_CHECK_MODULES(POPPLER_GLIB, glib-2.0 >= $GLIB_REQUIRED gobject-2.0 >= $GLIB_REQUIRED gio-2.0 >= $GLIB_REQUIRED cairo >= $CAIRO_VERSION) |
| elif test x$enable_poppler_glib = xtry; then |
| PKG_CHECK_MODULES(POPPLER_GLIB, glib-2.0 >= $GLIB_REQUIRED gobject-2.0 >= $GLIB_REQUIRED gio-2.0 >= $GLIB_REQUIRED cairo >= $CAIRO_VERSION, |
| [enable_poppler_glib="yes"], |
| [enable_poppler_glib="no" |
| use_glib="no (requires glib-2.0 >= $GLIB_REQUIRED gobject-2.0 >= $GLIB_REQUIRED gio-2.0 >= $GLIB_REQUIRED cairo >= $CAIRO_VERSION)"]) |
| fi |
| if test x$enable_poppler_glib = xyes; then |
| # Check for introspection |
| GOBJECT_INTROSPECTION_CHECK([0.6.7]) |
| |
| AC_PATH_PROG([GLIB_MKENUMS],[glib-mkenums]) |
| POPPLER_GLIB_DISABLE_DEPRECATED="$POPPLER_GLIB_DISABLE_DEPRECATED -DG_DISABLE_DEPRECATED" |
| POPPLER_GLIB_DISABLE_SINGLE_INCLUDES="$POPPLER_GLIB_DISABLE_SINGLE_INCLUDES -DG_DISABLE_SINGLE_INCLUDES" |
| fi |
| else |
| if test x$enable_poppler_glib = xyes; then |
| AC_MSG_ERROR("Cairo output is required to build glib frontend") |
| fi |
| use_glib="no (requires cairo output)" |
| enable_poppler_glib="no" |
| fi |
| if test x"$use_glib" = x; then |
| use_glib="$enable_poppler_glib" |
| fi |
| AM_CONDITIONAL(BUILD_POPPLER_GLIB, test x$enable_poppler_glib = xyes) |
| AM_CONDITIONAL(HAVE_INTROSPECTION, test "x$found_introspection" = "xyes") |
| AC_SUBST(GLIB_REQ) |
| AC_SUBST(POPPLER_GLIB_DISABLE_DEPRECATED) |
| AC_SUBST(POPPLER_GLIB_DISABLE_SINGLE_INCLUDES) |
| |
| GTK_DOC_CHECK([1.14],[--flavour no-tmpl]) |
| |
| dnl |
| dnl Try Qt4 |
| dnl |
| |
| AC_ARG_ENABLE(poppler-qt4, |
| AC_HELP_STRING([--disable-poppler-qt4], |
| [Don't compile poppler Qt4 wrapper.]), |
| enable_poppler_qt4=$enableval, |
| enable_poppler_qt4="try") |
| if test x$enable_poppler_qt4 = xyes; then |
| PKG_CHECK_MODULES(POPPLER_QT4, |
| QtCore >= 4.7.0 QtGui >= 4.7.0 QtXml >= 4.7.0) |
| PKG_CHECK_MODULES(POPPLER_QT4_TEST, |
| QtTest >= 4.7.0) |
| elif test x$enable_poppler_qt4 = xtry; then |
| PKG_CHECK_MODULES(POPPLER_QT4, |
| QtCore >= 4.7.0 QtGui >= 4.7.0 QtXml >= 4.7.0, |
| [enable_poppler_qt4="yes"], |
| [enable_poppler_qt4="no"]) |
| if test x$enable_poppler_qt4 = xyes; then |
| PKG_CHECK_MODULES(POPPLER_QT4_TEST, |
| QtTest >= 4.7.0, |
| [enable_poppler_qt4="yes"], |
| [enable_poppler_qt4="no"]) |
| fi |
| fi |
| |
| AC_SUBST(POPPLER_QT4_CXXFLAGS) |
| AC_SUBST(POPPLER_QT4_LIBS) |
| AC_SUBST(POPPLER_QT4_TEST_LIBS) |
| |
| if test x$enable_poppler_qt4 = xyes; then |
| AC_CHECK_TOOL(MOCQT4, moc) |
| AC_MSG_CHECKING([for Qt4 moc]) |
| mocversion=`$MOCQT4 -v 2>&1` |
| mocversiongrep=`echo $mocversion | grep "Qt 4"` |
| if test x"$mocversiongrep" != x"$mocversion"; then |
| AC_MSG_RESULT([no]) |
| # moc was not the qt4 one, try with moc-qt4 |
| AC_CHECK_TOOL(MOCQT42, moc-qt4) |
| AC_MSG_CHECKING([for Qt4 moc-qt4]) |
| mocversion=`$MOCQT42 -v 2>&1` |
| mocversiongrep=`echo $mocversion | grep "Qt 4"` |
| if test x"$mocversiongrep" != x"$mocversion"; then |
| # no valid moc found |
| enable_poppler_qt4=no; |
| MOCQT4="not found" |
| else |
| MOCQT4=$MOCQT42 |
| fi |
| fi |
| AC_SUBST(MOCQT4) |
| AC_MSG_RESULT([$MOCQT4]) |
| fi |
| |
| AM_CONDITIONAL(BUILD_POPPLER_QT4, test "x$enable_poppler_qt4" = "xyes") |
| |
| dnl |
| dnl Try Qt5 |
| dnl |
| |
| AC_ARG_ENABLE(poppler-qt5, |
| AC_HELP_STRING([--disable-poppler-qt5], |
| [Don't compile poppler Qt5 wrapper.]), |
| enable_poppler_qt5=$enableval, |
| enable_poppler_qt5="try") |
| if test x$enable_poppler_qt5 = xyes; then |
| PKG_CHECK_MODULES(POPPLER_QT5, |
| Qt5Core >= 5.0.0 Qt5Gui >= 5.0.0 Qt5Xml >= 5.0.0 Qt5Widgets >= 5.0.0) |
| PKG_CHECK_MODULES(POPPLER_QT5_TEST, |
| Qt5Test >= 5.0.0 ) |
| elif test x$enable_poppler_qt5 = xtry; then |
| PKG_CHECK_MODULES(POPPLER_QT5, |
| Qt5Core >= 5.0.0 Qt5Gui >= 5.0.0 Qt5Xml >= 5.0.0 Qt5Widgets >= 5.0.0, |
| [enable_poppler_qt5="yes"], |
| [enable_poppler_qt5="no"]) |
| if test x$enable_poppler_qt5 = xyes; then |
| PKG_CHECK_MODULES(POPPLER_QT5_TEST, |
| Qt5Test >= 5.0.0, |
| [enable_poppler_qt5="yes"], |
| [enable_poppler_qt5="no"]) |
| fi |
| fi |
| |
| AC_SUBST(POPPLER_QT5_CXXFLAGS) |
| AC_SUBST(POPPLER_QT5_LIBS) |
| AC_SUBST(POPPLER_QT5_TEST_LIBS) |
| |
| if test x$enable_poppler_qt5 = xyes; then |
| AC_CHECK_TOOL(MOCQT5, moc) |
| AC_MSG_CHECKING([for Qt5 moc]) |
| mocversion=`$MOCQT5 -v 2>&1` |
| mocversiongrep=`echo $mocversion | grep -E "Qt 5|moc 5"` |
| if test x"$mocversiongrep" != x"$mocversion"; then |
| AC_MSG_RESULT([no]) |
| # moc was not the qt5 one, try with moc-qt5 |
| AC_CHECK_TOOL(MOCQT52, moc-qt5) |
| AC_MSG_CHECKING([for Qt5 moc-qt5]) |
| mocversion=`$MOCQT52 -v 2>&1` |
| mocversiongrep=`echo $mocversion | grep -E "Qt 5|moc-qt5 5|moc 5"` |
| if test x"$mocversiongrep" != x"$mocversion"; then |
| AC_CHECK_TOOL(QTCHOOSER, qtchooser) |
| AC_MSG_CHECKING([for qtchooser]) |
| qt5tooldir=`QT_SELECT=qt5 qtchooser -print-env | grep QTTOOLDIR | cut -d '=' -f 2 | cut -d \" -f 2` |
| mocversion=`$qt5tooldir/moc -v 2>&1` |
| mocversiongrep=`echo $mocversion | grep -E "Qt 5|moc 5"` |
| if test x"$mocversiongrep" != x"$mocversion"; then |
| # no valid moc found |
| enable_poppler_qt5=no; |
| MOCQT5="not found" |
| else |
| MOCQT5=$qt5tooldir/moc |
| fi |
| else |
| MOCQT5=$MOCQT52 |
| fi |
| fi |
| AC_SUBST(MOCQT5) |
| AC_MSG_RESULT([$MOCQT5]) |
| fi |
| |
| AM_CONDITIONAL(BUILD_POPPLER_QT5, test "x$enable_poppler_qt5" = "xyes") |
| |
| dnl |
| dnl CPP frontend |
| dnl |
| |
| AC_ARG_ENABLE(poppler-cpp, |
| AC_HELP_STRING([--disable-poppler-cpp], |
| [Don't compile poppler cpp wrapper.]), |
| enable_poppler_cpp=$enableval, |
| enable_poppler_cpp="yes") |
| if test x$enable_poppler_cpp = xyes; then |
| AM_ICONV() |
| if test x$am_func_iconv != xyes; then |
| enable_poppler_cpp=no |
| fi |
| fi |
| |
| AM_CONDITIONAL(BUILD_POPPLER_CPP, test "x$enable_poppler_cpp" = "xyes") |
| |
| |
| GTK_TEST_DEPS='gtk+-3.0 >= 3.8 gdk-pixbuf-2.0' |
| if test x$enable_cairo_output = xyes; then |
| GTK_TEST_DEPS="$GTK_TEST_DEPS $CAIRO_DEPS" |
| fi |
| AC_ARG_ENABLE(gtk-test, |
| AC_HELP_STRING([--disable-gtk-test], |
| [Don't compile GTK+ test program.]), |
| enable_gtk_test=$enableval, |
| enable_gtk_test="try") |
| if test x$enable_gtk_test = xyes; then |
| PKG_CHECK_MODULES(GTK_TEST, $GTK_TEST_DEPS) |
| elif test x$enable_gtk_test = xtry; then |
| PKG_CHECK_MODULES(GTK_TEST, $GTK_TEST_DEPS, |
| [enable_gtk_test="yes"], |
| [enable_gtk_test="no"]) |
| fi |
| AM_CONDITIONAL(BUILD_GTK_TEST, test x$enable_gtk_test = xyes -a x$enable_poppler_glib = xyes) |
| |
| AC_ARG_ENABLE(utils, |
| AC_HELP_STRING([--disable-utils], |
| [Don't compile poppler command line utils.]), |
| enable_utils=$enableval, |
| enable_utils="yes") |
| AM_CONDITIONAL(BUILD_UTILS, test x$enable_utils = xyes) |
| |
| AC_ARG_ENABLE(compile-warnings, |
| AC_HELP_STRING([--enable-compile-warnings=@<:@no/yes/kde@:>@], |
| [Turn on compiler warnings.]),, |
| [enable_compile_warnings="yes"]) |
| |
| dnl |
| dnl Color Management |
| dnl |
| |
| AC_ARG_ENABLE(cms, |
| AC_HELP_STRING([--enable-cms=@<:@auto/lcms1/lcms2/none@:>@], |
| [Use color management system. 'auto' prefers lcms2 over lcms1 if both are available [[default=auto]]]), |
| [enable_cms=$enableval], |
| [enable_cms="auto"]) |
| if test x$enable_cms = xauto; then |
| PKG_CHECK_MODULES(LCMS, lcms2, [lcms2=yes], [lcms2=no]) |
| if test x$lcms2 = xno; then |
| PKG_CHECK_MODULES(LCMS, lcms, [lcms1=yes], [lcms1=no]) |
| fi |
| elif test x$enable_cms = xlcms1; then |
| PKG_CHECK_MODULES(LCMS, lcms, [lcms1=yes], [lcms1=no]) |
| elif test x$enable_cms = xlcms2; then |
| PKG_CHECK_MODULES(LCMS, lcms2, [lcms2=yes], [lcms2=no]) |
| fi |
| |
| if test x$lcms1 = xyes || test x$lcms2 = xyes; then |
| enable_cms=yes |
| AC_DEFINE(USE_CMS, 1, [Defines if use cms]) |
| if test x$lcms1 = xyes; then |
| lcms1=yes; |
| AC_DEFINE(USE_LCMS1, 1, [Defines if use lcms1]) |
| fi |
| else |
| enable_cms=no |
| fi |
| |
| AM_CONDITIONAL(USE_CMS, test x$enable_cms = xyes) |
| AM_CONDITIONAL(USE_LCMS1, test x$lcms1 = xyes) |
| |
| AC_ARG_WITH([testdatadir], |
| [AS_HELP_STRING([--with-testdatadir=/path/to/testdatadir], |
| [Specify test data dir])], |
| [case $withval in |
| [[\\/]]* | ?:[[\\/]]* ) # Absolute name. |
| TESTDATADIR=$withval ;; |
| *) # Relative name. |
| TESTDATADIR=$ac_pwd/$withval ;; |
| esac |
| ], |
| [case $srcdir in |
| [[\\/]]* | ?:[[\\/]]* ) # Absolute name. |
| TESTDATADIR=$srcdir/../test ;; |
| *) # Relative name. |
| TESTDATADIR=$ac_pwd/$srcdir/../test ;; |
| esac |
| ] |
| ) |
| AC_MSG_CHECKING([for test data in $TESTDATADIR]) |
| if test -d $TESTDATADIR && test -f $TESTDATADIR/test-poppler.c; then |
| AC_MSG_RESULT([yes]) |
| else |
| AC_MSG_RESULT([no]) |
| AC_MSG_WARN([ |
| No test data found in $TESTDATADIR. |
| You will not be able to run 'make check' successfully. |
| |
| The test data is not included in the source packages |
| and is also not part of the main git repository. Instead, |
| you can checkout the test data from its own git |
| repository with: |
| |
| git clone git://git.freedesktop.org/git/poppler/test |
| |
| You should checkout the test data as a sibling of your |
| poppler source folder or specify the location of your |
| checkout with --with-testdatadir=/path/to/checkoutdir/test. |
| ]) |
| fi |
| AC_SUBST(TESTDATADIR) |
| |
| # some compilers do not support this flag (see bug #76963) |
| fno_check_new= |
| AC_MSG_CHECKING([for -fno-check-new compiler flag]) |
| AC_LANG_PUSH([C++]) |
| saved_CXXFLAGS=$CXXFLAGS |
| CXXFLAGS="-fno-check-new $CXXFLAGS" |
| AC_TRY_COMPILE([], [], |
| [AC_MSG_RESULT([yes]) |
| fno_check_new="-fno-check-new"], |
| AC_MSG_RESULT([no]) |
| ) |
| CXXFLAGS=$saved_CXXFLAGS |
| AC_LANG_POP |
| |
| if test "x$GCC" != xyes; then |
| enable_compile_warnings=no |
| fi |
| case "$enable_compile_warnings" in |
| no) ;; |
| yes) CXXFLAGS="-Wall -Woverloaded-virtual -Wnon-virtual-dtor -Wcast-align -fno-exceptions $fno_check_new -fno-common $CXXFLAGS"; |
| CFLAGS="-Wall $CFLAGS" ;; |
| kde) CXXFLAGS="-Wnon-virtual-dtor -Wno-long-long -Wundef \ |
| -D_XOPEN_SOURCE=600 -D_BSD_SOURCE -Wcast-align \ |
| -Wconversion -Wall -W -Wpointer-arith \ |
| -Wwrite-strings -O2 -Wformat-security \ |
| -Wmissing-format-attribute -fno-exceptions $fno_check_new \ |
| -fno-common $CXXFLAGS" ;; |
| esac |
| |
| case "$host_os" in |
| mingw*|cygwin*) |
| # mingw and cygwin print "warning: -fPIC ignored for target (all code is position independent)" |
| # for every file |
| ;; |
| *) |
| CXXFLAGS="-fPIC $CXXFLAGS"; |
| ;; |
| esac |
| |
| |
| case `$PKG_CONFIG --version` in |
| 0.?|0.1[0-7]) |
| PC_REQUIRES_PRIVATE=""; |
| PC_REQUIRES="poppler = $VERSION";; |
| *) |
| PC_REQUIRES_PRIVATE="Requires.private: poppler = $VERSION"; |
| PC_REQUIRES="";; |
| esac |
| |
| AC_SUBST(PC_REQUIRES) |
| AC_SUBST(PC_REQUIRES_PRIVATE) |
| |
| AC_SUBST([POPPLER_MAJOR_VERSION],[poppler_version_major]) |
| AC_SUBST([POPPLER_MINOR_VERSION],[poppler_version_minor]) |
| AC_SUBST([POPPLER_MICRO_VERSION],[poppler_version_micro]) |
| AC_SUBST([POPPLER_VERSION],[poppler_version]) |
| |
| AC_OUTPUT([ |
| Makefile |
| goo/Makefile |
| fofi/Makefile |
| splash/Makefile |
| poppler/Makefile |
| utils/Makefile |
| glib/Makefile |
| glib/poppler-features.h |
| glib/reference/Makefile |
| glib/reference/version.xml |
| glib/demo/Makefile |
| test/Makefile |
| qt4/Makefile |
| qt4/src/Makefile |
| qt4/tests/Makefile |
| qt4/demos/Makefile |
| qt5/Makefile |
| qt5/src/Makefile |
| qt5/tests/Makefile |
| qt5/demos/Makefile |
| cpp/Makefile |
| cpp/poppler-version.h |
| cpp/tests/Makefile |
| poppler.pc |
| poppler-uninstalled.pc |
| poppler-cairo.pc |
| poppler-cairo-uninstalled.pc |
| poppler-splash.pc |
| poppler-splash-uninstalled.pc |
| poppler-glib.pc |
| poppler-glib-uninstalled.pc |
| poppler-qt4.pc |
| poppler-qt4-uninstalled.pc |
| poppler-qt5.pc |
| poppler-qt5-uninstalled.pc |
| poppler-cpp.pc |
| poppler-cpp-uninstalled.pc]) |
| |
| |
| echo "" |
| echo "Building poppler with support for:" |
| echo " font configuration: $with_font_configuration" |
| echo " splash output: $enable_splash_output" |
| if test x$enable_cmyk = xyes;then |
| echo " with CMYK support" |
| fi |
| echo " cairo output: $use_cairo" |
| echo " qt4 wrapper: $enable_poppler_qt4" |
| echo " qt5 wrapper: $enable_poppler_qt5" |
| echo " glib wrapper: $use_glib" |
| echo " introspection: $found_introspection" |
| echo " cpp wrapper: $enable_poppler_cpp" |
| echo " use gtk-doc: $enable_gtk_doc" |
| echo " use libjpeg: $enable_libjpeg" |
| echo " use libpng: $enable_libpng" |
| echo " use libtiff: $enable_libtiff" |
| echo " use zlib compress: $enable_zlib" |
| echo " use zlib uncompress: $enable_zlib_uncompress" |
| echo " use nss: $enable_nss" |
| echo " use libcurl: $enable_libcurl" |
| echo " use libopenjpeg: $enable_libopenjpeg" |
| if test x$enable_libopenjpeg = xyes;then |
| if test x$openjpeg1 = xyes;then |
| echo " with openjpeg1" |
| else |
| echo " with openjpeg2" |
| fi |
| fi |
| echo " use cms: $enable_cms" |
| if test x$enable_cms = xyes;then |
| if test x$lcms1 = xyes;then |
| echo " with lcms1" |
| else |
| echo " with lcms2" |
| fi |
| fi |
| if test x$enable_build_type != xno;then |
| echo " build type: $enable_build_type" |
| fi |
| echo " command line utils: $enable_utils" |
| echo " test data dir: $TESTDATADIR" |
| echo "" |
| |
| if test x$enable_splash_output = xno -a x$enable_cairo_output = xno; then |
| echo " Warning: There is no rendering backend enabled" |
| fi |
| |
| if test x$enable_single_precision = xyes -a x$enable_fixedpoint = xyes; then |
| echo " Warning: Single precision and fixed point options should not be enabled at the same time" |
| fi |
| |
| if test x$enable_libjpeg != xyes -a x$have_dct_decoder = xyes; then |
| echo " Warning: Using libjpeg is recommended. The internal DCT decoder is unmaintained." |
| fi |
| |
| if test x$have_dct_decoder = xno; then |
| echo " Warning: You're not compiling any DCT decoder. Some files will fail to display properly." |
| fi |
| |
| if test x$enable_zlib_uncompress != xno; then |
| echo " Warning: Using zlib for decompression is not totally safe" |
| fi |
| |
| if test x$enable_libopenjpeg != xyes -a x$have_jpx_decoder = xyes; then |
| echo " Warning: Using libopenjpeg2 is recommended. The internal JPX decoder is unmaintained." |
| fi |
| |
| if test x$have_jpx_decoder = xno; then |
| echo " Warning: You're not compiling any JPX decoder. Some files will fail to display properly." |
| fi |