Skip to content
Snippets Groups Projects
configure.ac 163 KiB
Newer Older
Alexandre Julliard's avatar
Alexandre Julliard committed
dnl Process this file with autoconf to produce a configure script.
dnl Original author: Michael Patra
dnl For detailed change history, see the git commit logs.

m4_define(WINE_VERSION,regexp(m4_include(VERSION),[version \([-.0-9A-Za-z]+\)],[\1]))

dnl autoconf versions before 2.62 don't handle source dir symlinks correctly
AC_PREREQ(2.62)
AC_INIT([Wine],[WINE_VERSION],[wine-devel@winehq.org],[wine],[https://www.winehq.org])
AC_CONFIG_SRCDIR(server/atom.c)
AC_CONFIG_HEADERS(include/config.h)
Alexandre Julliard's avatar
Alexandre Julliard committed
AC_CONFIG_AUX_DIR(tools)
Alexandre Julliard's avatar
Alexandre Julliard committed

dnl autoconf versions before 2.63b don't have AS_VAR_APPEND or AS_VAR_IF
m4_ifdef([AS_VAR_APPEND],,[as_fn_append () { eval $[1]=\$$[1]\$[2]; }
AC_DEFUN([AS_VAR_APPEND],[as_fn_append $1 $2])])dnl
m4_ifdef([AS_VAR_IF],,[AC_DEFUN([AS_VAR_IF],
[AS_LITERAL_IF([$1],
  [AS_IF([test "x$$1" = x""$2], [$3], [$4])],
  [eval as_val=\$$1
   AS_IF([test "x$as_val" = x""$2], [$3], [$4])])])])dnl
dnl autoconf versions before 2.64 don't have AC_PACKAGE_URL
m4_ifdef([AC_PACKAGE_URL],,
  [AC_DEFINE([PACKAGE_URL], ["https://www.winehq.org"], [Define to the home page for this package.])
   AC_SUBST([PACKAGE_URL], ["https://www.winehq.org"])])dnl
Alexandre Julliard's avatar
Alexandre Julliard committed
dnl **** Command-line arguments ****

AC_ARG_ENABLE(win16, AS_HELP_STRING([--disable-win16],[do not include Win16 support]))
AC_ARG_ENABLE(win64, AS_HELP_STRING([--enable-win64],[build a Win64 emulator on AMD64 (won't run Win32 binaries)]))
AC_ARG_ENABLE(tests, AS_HELP_STRING([--disable-tests],[do not build the regression tests]))
AC_ARG_ENABLE(build-id, AS_HELP_STRING([--enable-build-id],[include .buildid section in output objects]))
AC_ARG_ENABLE(maintainer-mode, AS_HELP_STRING([--enable-maintainer-mode],[enable maintainer-specific build rules]))
AC_ARG_ENABLE(silent-rules, AS_HELP_STRING([--enable-silent-rules],[use silent build rules (override: "make V=1")]))
AC_ARG_ENABLE(werror, AS_HELP_STRING([--enable-werror],[treat compilation warnings as errors]))
AC_ARG_WITH(alsa,      AS_HELP_STRING([--without-alsa],[do not use the Alsa sound support]))
AC_ARG_WITH(capi,      AS_HELP_STRING([--without-capi],[do not use CAPI (ISDN support)]))
AC_ARG_WITH(cms,       AS_HELP_STRING([--without-cms],[do not use CMS (color management support)]))
AC_ARG_WITH(coreaudio, AS_HELP_STRING([--without-coreaudio],[do not use the CoreAudio sound support]),
            [if test "x$withval" = "xno"; then ac_cv_header_CoreAudio_CoreAudio_h=no; fi])
AC_ARG_WITH(cups,      AS_HELP_STRING([--without-cups],[do not use CUPS]))
AC_ARG_WITH(dbus,      AS_HELP_STRING([--without-dbus],[do not use DBus (dynamic device support)]))
AC_ARG_WITH(faudio,    AS_HELP_STRING([--without-faudio],[do not use FAudio (XAudio2 support)]))
AC_ARG_WITH(float-abi, AS_HELP_STRING([--with-float-abi=abi],[specify the ABI (soft|softfp|hard) for ARM platforms]))
AC_ARG_WITH(fontconfig,AS_HELP_STRING([--without-fontconfig],[do not use fontconfig]))
AC_ARG_WITH(freetype,  AS_HELP_STRING([--without-freetype],[do not use the FreeType library]))
AC_ARG_WITH(gettext,   AS_HELP_STRING([--without-gettext],[do not use gettext]))
AC_ARG_WITH(gettextpo, AS_HELP_STRING([--with-gettextpo],[use the GetTextPO library to rebuild po files]),
            [if test "x$withval" = "xno"; then ac_cv_header_gettext_po_h=no; fi])
AC_ARG_WITH(gphoto,    AS_HELP_STRING([--without-gphoto],[do not use gphoto (Digital Camera support)]))
AC_ARG_WITH(gnutls,    AS_HELP_STRING([--without-gnutls],[do not use GnuTLS (schannel support)]))
AC_ARG_WITH(gsm,       AS_HELP_STRING([--without-gsm],[do not use libgsm (GSM 06.10 codec support)]),
            [if test "x$withval" = "xno"; then ac_cv_header_gsm_h=no; ac_cv_header_gsm_gsm_h=no; fi])
AC_ARG_WITH(gssapi,    AS_HELP_STRING([--without-gssapi],[do not use GSSAPI (Kerberos SSP support)]))
AC_ARG_WITH(gstreamer, AS_HELP_STRING([--without-gstreamer],[do not use GStreamer (codecs support)]))
AC_ARG_WITH(hal,       AS_HELP_STRING([--without-hal],[do not use HAL (dynamic device support)]))
AC_ARG_WITH(inotify,   AS_HELP_STRING([--without-inotify],[do not use inotify (filesystem change notifications)]))
AC_ARG_WITH(jpeg,      AS_HELP_STRING([--without-jpeg],[do not use JPEG]))
AC_ARG_WITH(jxrlib,    AS_HELP_STRING([--without-jxrlib],[do not use JPEG-XR]))
AC_ARG_WITH(krb5,      AS_HELP_STRING([--without-krb5],[do not use krb5 (Kerberos)]))
AC_ARG_WITH(ldap,      AS_HELP_STRING([--without-ldap],[do not use LDAP]),
            [if test "x$withval" = "xno"; then ac_cv_header_ldap_h=no; ac_cv_header_lber_h=no; fi])
AC_ARG_WITH(mingw,     AS_HELP_STRING([--without-mingw],[do not use the MinGW cross-compiler]))
AC_ARG_WITH(mpg123,    AS_HELP_STRING([--without-mpg123],[do not use the mpg123 library]))
AC_ARG_WITH(netapi,    AS_HELP_STRING([--without-netapi],[do not use the Samba NetAPI library]))
AC_ARG_WITH(openal,    AS_HELP_STRING([--without-openal],[do not use OpenAL]),
            [if test "x$withval" = "xno"; then ac_cv_header_AL_al_h=no; ac_cv_header_OpenAL_al_h=no; fi])
AC_ARG_WITH(opencl,    AS_HELP_STRING([--without-opencl],[do not use OpenCL]),
            [if test "x$withval" = "xno"; then ac_cv_header_CL_cl_h=no; ac_cv_header_OpenCL_opencl_h=no; fi])
AC_ARG_WITH(opengl,    AS_HELP_STRING([--without-opengl],[do not use OpenGL]))
AC_ARG_WITH(osmesa,     AS_HELP_STRING([--without-osmesa],[do not use the OSMesa library]))
AC_ARG_WITH(oss,       AS_HELP_STRING([--without-oss],[do not use the OSS sound support]))
AC_ARG_WITH(pcap,      AS_HELP_STRING([--without-pcap],[do not use the Packet Capture library]),
            [if test "x$withval" = "xno"; then ac_cv_header_pcap_pcap_h=no; fi])
AC_ARG_WITH(png,       AS_HELP_STRING([--without-png],[do not use PNG]))
AC_ARG_WITH(pthread,   AS_HELP_STRING([--without-pthread],[do not use the pthread library]),
            [if test "x$withval" = "xno"; then ac_cv_header_pthread_h=no; fi])
AC_ARG_WITH(pulse,     AS_HELP_STRING([--without-pulse],[do not use PulseAudio sound support]))
AC_ARG_WITH(quicktime, AS_HELP_STRING([--without-quicktime],[do not use QuickTime support]))
AC_ARG_WITH(sane,      AS_HELP_STRING([--without-sane],[do not use SANE (scanner support)]))
AC_ARG_WITH(sdl,       AS_HELP_STRING([--without-sdl],[do not use SDL]))
AC_ARG_WITH(tiff,      AS_HELP_STRING([--without-tiff],[do not use TIFF]))
AC_ARG_WITH(udev,      AS_HELP_STRING([--without-udev],[do not use udev (plug and play support)]))
AC_ARG_WITH(unwind,    AS_HELP_STRING([--without-unwind],[do not use the libunwind library (exception handling)]))
AC_ARG_WITH(usb,       AS_HELP_STRING([--without-usb],[do not use the libusb library]))
Zebediah Figura's avatar
Zebediah Figura committed
AC_ARG_WITH(v4l2,      AS_HELP_STRING([--without-v4l2],[do not use v4l2 (video capture)]))
AC_ARG_WITH(vkd3d,     AS_HELP_STRING([--without-vkd3d],[do not use vkd3d (Direct3D 12 support)]))
AC_ARG_WITH(vulkan,    AS_HELP_STRING([--without-vulkan],[do not use Vulkan]))
AC_ARG_WITH(xcomposite,AS_HELP_STRING([--without-xcomposite],[do not use the Xcomposite extension]),
            [if test "x$withval" = "xno"; then ac_cv_header_X11_extensions_Xcomposite_h=no; fi])
AC_ARG_WITH(xcursor,   AS_HELP_STRING([--without-xcursor],[do not use the Xcursor extension]),
            [if test "x$withval" = "xno"; then ac_cv_header_X11_Xcursor_Xcursor_h=no; fi])
AC_ARG_WITH(xfixes,  AS_HELP_STRING([--without-xfixes],[do not use Xfixes for clipboard change notifications]),
            [if test "x$withval" = "xno"; then ac_cv_header_X11_extensions_Xfixes_h=no; fi])
AC_ARG_WITH(xinerama,  AS_HELP_STRING([--without-xinerama],[do not use Xinerama (legacy multi-monitor support)]),
            [if test "x$withval" = "xno"; then ac_cv_header_X11_extensions_Xinerama_h=no; fi])
AC_ARG_WITH(xinput,    AS_HELP_STRING([--without-xinput],[do not use the Xinput extension]),
            [if test "x$withval" = "xno"; then ac_cv_header_X11_extensions_XInput_h=no; fi])
AC_ARG_WITH(xinput2,   AS_HELP_STRING([--without-xinput2],[do not use the Xinput 2 extension]),
            [if test "x$withval" = "xno"; then ac_cv_header_X11_extensions_XInput2_h=no; fi])
AC_ARG_WITH(xml,       AS_HELP_STRING([--without-xml],[do not use XML]))
AC_ARG_WITH(xrandr,    AS_HELP_STRING([--without-xrandr],[do not use Xrandr (multi-monitor support)]),
            [if test "x$withval" = "xno"; then ac_cv_header_X11_extensions_Xrandr_h=no; fi])
AC_ARG_WITH(xrender,   AS_HELP_STRING([--without-xrender],[do not use the Xrender extension]),
            [if test "x$withval" = "xno"; then ac_cv_header_X11_extensions_Xrender_h=no; fi])
AC_ARG_WITH(xshape,    AS_HELP_STRING([--without-xshape],[do not use the Xshape extension]),
            [if test "x$withval" = "xno"; then ac_cv_header_X11_extensions_shape_h=no; fi])
AC_ARG_WITH(xshm,      AS_HELP_STRING([--without-xshm],[do not use XShm (shared memory extension)]),
            [if test "x$withval" = "xno"; then ac_cv_header_X11_extensions_XShm_h=no; fi])
AC_ARG_WITH(xslt,      AS_HELP_STRING([--without-xslt],[do not use XSLT]))
AC_ARG_WITH(xxf86vm,   AS_HELP_STRING([--without-xxf86vm],[do not use XFree video mode extension]),
            [if test "x$withval" = "xno"; then ac_cv_header_X11_extensions_xf86vmode_h=no; ac_cv_header_X11_extensions_xf86vmproto_h=no; fi])

AC_ARG_WITH(wine-tools,AS_HELP_STRING([--with-wine-tools=DIR],[use Wine tools from directory DIR]))
AC_ARG_WITH(wine64,    AS_HELP_STRING([--with-wine64=DIR],[use the 64-bit Wine in DIR for a Wow64 build]))
Alexandre Julliard's avatar
Alexandre Julliard committed


dnl **** Check for some programs ****

AC_PROG_MAKE_SET
AC_PROG_CC
AC_PROG_CXX
dnl We can't use AC_PROG_CPP for winegcc, it uses by default $(CC) -E
AC_CHECK_TOOL(CPPBIN,cpp,cpp)
AC_DEFINE_UNQUOTED(EXEEXT,["$ac_exeext"],[Define to the file extension for executables.])
AC_CHECK_TOOL(LD,ld)
  *-mingw32*|*-cygwin*)
    enable_win16=${enable_win16:-no}
    if test "x$enable_win64" != "xyes" -a "$cross_compiling" != "yes"
      AC_CACHE_CHECK([whether $CC works], wine_cv_cc_m32,
          [AC_LINK_IFELSE([AC_LANG_PROGRAM()],[wine_cv_cc_m32=yes],[wine_cv_cc_m32=no])])
      test $wine_cv_cc_m32 != no || AC_MSG_ERROR([Cannot build a 32-bit program, you need to install 32-bit development libraries.])
      host_cpu="i386"
      TARGETFLAGS="$TARGETFLAGS -m32"
      PKG_CONFIG_PATH=${PKG_CONFIG_PATH:-/usr/lib/i386-linux-gnu/pkgconfig:/usr/lib32/pkgconfig:/usr/lib/pkgconfig}
      enable_win16=${enable_win16:-yes}
      with_unwind=${with_unwind:-no}
        AC_CACHE_CHECK([whether $CC supports __builtin_ms_va_list],wine_cv_builtin_ms_va_list,
            [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <stdarg.h>]], [[void func(__builtin_ms_va_list *args);]])],
                          [wine_cv_builtin_ms_va_list=yes],[wine_cv_builtin_ms_va_list=no])])
        test $wine_cv_builtin_ms_va_list != no || AC_MSG_ERROR([You need gcc >= 4.4 or clang >= 3.8 to build Wine as 64-bit.])
      host_cpu="x86_64"
      TARGETFLAGS="$TARGETFLAGS -m64"
      enable_wow64cpu=${enable_wow64cpu:-yes}
    AC_CACHE_CHECK([whether $CC supports Thumb-2],wine_cv_thumb2,
        [WINE_TRY_ASM_LINK([".syntax unified\n\t.thumb\n\tldm r0,{r0-r8}"],,,
                           [wine_cv_thumb2=yes],[wine_cv_thumb2=no])])
    if test x"$wine_cv_thumb2" = xyes
    then
        CFLAGS="$CFLAGS -mthumb"
        TARGETFLAGS="$TARGETFLAGS -mthumb"
    else
        CFLAGS="$CFLAGS -marm"
        TARGETFLAGS="$TARGETFLAGS -marm"
    case $with_float_abi in
      soft|softfp|hard)
        float_abi=$with_float_abi ;;
      *)
        case $host_os in
          *eabihf)
            float_abi=hard ;;
          *)
            float_abi=softfp
            saved_CFLAGS=$CFLAGS
            CFLAGS="$CFLAGS -mfloat-abi=$float_abi"
            AC_CACHE_CHECK([whether $CC supports -mfloat-abi=$float_abi],wine_cv_float_abi,
                [WINE_TRY_ASM_LINK(["vmrs r2,fpscr"],,,[wine_cv_float_abi=yes],[wine_cv_float_abi=no])])
            if test $wine_cv_float_abi = no
            then
                float_abi=soft
                WINE_WARNING([Floating point is not supported for this target. The resulting build won't be compatible with Windows ARM binaries.])
            fi
    CFLAGS="$CFLAGS -mfloat-abi=$float_abi"
    TARGETFLAGS="$TARGETFLAGS -mfloat-abi=$float_abi"
    AC_CACHE_CHECK([whether $CC supports __builtin_ms_va_list],wine_cv_builtin_ms_va_list,
        [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <stdarg.h>]], [[void func(__builtin_ms_va_list *args);]])],
                      [wine_cv_builtin_ms_va_list=yes],[wine_cv_builtin_ms_va_list=no])])
    test $wine_cv_builtin_ms_va_list != no || AC_MSG_ERROR([You need clang >= 5.0 to build Wine for arm64.])
  i[[3456789]]86*)
    enable_win16=${enable_win16:-yes}
    with_unwind=${with_unwind:-no}
dnl enable_win16 defaults to yes on x86, to no on other CPUs
enable_win16=${enable_win16:-no}
enable_win64=${enable_win64:-no}
Zebediah Figura's avatar
Zebediah Figura committed
enable_wow64cpu=${enable_wow64cpu:-no}
dnl Disable winetest too if tests are disabled
enable_winetest=${enable_winetest:-$enable_tests}

dnl Some special cases for the 64-bit build
if test "x$enable_win64" = "xyes"
    test -z "$with_wine64" || AC_MSG_ERROR([--enable-win64 and --with-wine64 are mutually exclusive.
--enable-win64 should be used in the 64-bit build tree, --with-wine64 in the 32-bit Wow64 build tree.])
fi

dnl Normalize CPU architecture
case $host_cpu in
  *i[[3456789]]86*) AC_SUBST(ARCH,"i386") ;;
  *x86_64*)         AC_SUBST(ARCH,"x86_64") ;;
  *aarch64*)        AC_SUBST(ARCH,"aarch64") ;;
  *arm*)            AC_SUBST(ARCH,"arm") ;;
  *)                AC_SUBST(ARCH,"") ;;
esac

AC_CACHE_CHECK([for the directory containing the Wine tools], wine_cv_toolsdir,
  [wine_cv_toolsdir="$with_wine_tools"
   if test -z "$with_wine_tools"; then
     if test "$cross_compiling" = "yes"; then
       AC_MSG_ERROR([you must use the --with-wine-tools option when cross-compiling.])
     elif test -n "$with_wine64"; then
       wine_cv_toolsdir="$with_wine64"
if test -z "$wine_cv_toolsdir"; then
    wine_makedep=tools/makedep
elif test -d "$wine_cv_toolsdir/tools/winebuild"; then
    wine_makedep=$wine_cv_toolsdir/tools/makedep
    enable_tools=${enable_tools:-no}
    test -f "$wine_makedep" || AC_MSG_ERROR([the Wine tools have not yet been built in $wine_cv_toolsdir])
else
    AC_MSG_ERROR([could not find Wine tools in $wine_cv_toolsdir])
fi
if test -n "$host_alias" -a "$host_alias" != "$build_alias"
    TARGETFLAGS="-b $host_alias $TARGETFLAGS"
dnl Check for flex
AC_CHECK_PROGS(FLEX,flex,none)
if test "$FLEX" = "none"
  AC_MSG_ERROR([no suitable flex found. Please install the 'flex' package.])
AC_CACHE_CHECK([whether flex is recent enough],wine_cv_recent_flex,
    [cat >conftest.l <<EOF
%top{
#include "prediluvian.h"
}
%%
EOF
    if $FLEX -t conftest.l >/dev/null 2>&AS_MESSAGE_LOG_FD
    then
      wine_cv_recent_flex=yes
    else
      wine_cv_recent_flex=no
    fi])
test $wine_cv_recent_flex != no || AC_MSG_ERROR([Your flex version is too old. Please install flex version 2.5.33 or newer.])
dnl Check for bison
AC_CHECK_PROGS(BISON,bison,none)
if test "$BISON" = "none"
then
  AC_MSG_ERROR([no suitable bison found. Please install the 'bison' package.])
fi
AC_CACHE_CHECK([whether bison is recent enough],wine_cv_recent_bison,
    [cat >conftest.y <<EOF
%define parse.error verbose
%%
empty: ;
EOF
    if $BISON conftest.y >/dev/null 2>&AS_MESSAGE_LOG_FD
    then
      wine_cv_recent_bison=yes
    else
      wine_cv_recent_bison=no
    fi])
test $wine_cv_recent_bison != no || AC_MSG_ERROR([Your bison version is too old. Please install bison version 3.0 or newer.])
AC_CHECK_TOOL(STRIP,strip,strip)
Alexandre Julliard's avatar
Alexandre Julliard committed
AC_PROG_RANLIB
Alexandre Julliard's avatar
Alexandre Julliard committed
AC_PROG_LN_S
AC_PATH_PROG(LDCONFIG, ldconfig, true, [/sbin /usr/sbin $PATH])
AC_CHECK_PROGS(MSGFMT, msgfmt, false)
WINE_PATH_PKG_CONFIG
if test "x$enable_maintainer_mode" != "xyes"
  FONTFORGE=""
  RSVG=""
  CONVERT=""
  ICOTOOL=""
  test "$srcdir" = . || AC_MSG_ERROR([Maintainer mode cannot work out of tree.])
  AC_CHECK_PROGS(FONTFORGE, fontforge, false)
  AC_CHECK_PROGS(RSVG, rsvg-convert rsvg, false)
  AC_CHECK_PROGS(CONVERT, convert, false)
  AC_CHECK_PROGS(ICOTOOL, icotool, false)
  test "$FONTFORGE" != "false" || AC_MSG_ERROR([You need fontforge to rebuild fonts in maintainer mode.])
  test "$RSVG" != "false" || AC_MSG_ERROR([You need rsvg to rebuild icons in maintainer mode.])

  dnl Check the imagemagick version
  if test "$CONVERT" = false
  then
    AC_MSG_ERROR([You need imagemagick to rebuild icons in maintainer mode.])
  else
    AC_MSG_CHECKING([for recent enough imagemagick])
    convert_version=`convert --version | head -n1`
    if test "x$convert_version" != "x"
    then
      convert_version_major=`expr "$convert_version" : '.* \([[0-9]]*\)\.[[0-9]]*'`
      convert_version_minor=`expr "$convert_version" : '.* [[0-9]]*\.\([[0-9]]*\)'`
      if test "$convert_version_major" -eq 6 -a "$convert_version_minor" -lt 6
      then
        CONVERT=false
      fi
    fi
    if test "$CONVERT" = false
    then
      AC_MSG_RESULT([no ($convert_version_major.$convert_version_minor)])
      AC_MSG_ERROR([You need imagemagick version 6.6 or newer to rebuild icons in maintainer mode.])
    else
      AC_MSG_RESULT([yes ($convert_version_major.$convert_version_minor)])
    fi
  fi

  dnl Check the icotool version
  if test "$ICOTOOL" = false
  then
    AC_MSG_ERROR([You need icotool to rebuild icons in maintainer mode.])
  else
    AC_MSG_CHECKING([for recent enough icotool])
    icotool_version=`icotool --version | head -n1`
    if test "x$icotool_version" != "x"
    then
      icotool_version_major=`expr "$icotool_version" : '.* \([[0-9]]*\)\.[[0-9]]*'`
      icotool_version_minor=`expr "$icotool_version" : '.* [[0-9]]*\.\([[0-9]]*\)'`
      if test "$icotool_version_major" -eq 0 -a "$icotool_version_minor" -lt 29
      then
        ICOTOOL=false
        WINE_WARNING([icotool version 0.29.0 or newer is needed to rebuild icons.])
      fi
    fi
    if test "$ICOTOOL" = false
    then
      AC_MSG_RESULT([no ($icotool_version_major.$icotool_version_minor)])
      AC_MSG_ERROR([You need icotool version 0.29.0 or newer to rebuild icons in maintainer mode.])
    else
      AC_MSG_RESULT([yes ($icotool_version_major.$icotool_version_minor)])
    fi
  fi

  dnl Maintainer mode requires gettext
  with_gettext=yes
  with_gettextpo=yes

  dnl Maintainer mode wants -Werror
  enable_werror=yes
test "x$with_gettext" != xno || MSGFMT=false
  AC_CACHE_CHECK([whether msgfmt supports contexts],wine_cv_msgfmt_contexts,
  [cat >conftest.po <<EOF
# comment
msgctxt "ctxt"
msgid "id"
msgstr "str"
EOF
  if $MSGFMT -o /dev/null conftest.po 2>&AS_MESSAGE_LOG_FD
  then
    wine_cv_msgfmt_contexts=yes
    wine_cv_msgfmt_contexts=no
  fi])
  test $wine_cv_msgfmt_contexts != no || MSGFMT=false
WINE_WARNING_WITH(gettext,[test "$MSGFMT" = false],
                  [gettext tools not found (or too old), translations won't be built.],
                  [enable_po])
Alexandre Julliard's avatar
Alexandre Julliard committed
dnl **** Check for some libraries ****

Alexandre Julliard's avatar
Alexandre Julliard committed
dnl Check for -li386 for NetBSD and OpenBSD
AC_CHECK_LIB(i386,i386_set_ldt,[AC_SUBST(I386_LIBS, "-li386")])
AC_SUBST(OPENGL_LIBS,"")
	AL/al.h \
	ApplicationServices/ApplicationServices.h \
	AudioToolbox/AudioConverter.h \
	AudioUnit/AudioUnit.h \
	AudioUnit/AudioComponent.h \
	CommonCrypto/CommonCryptor.h \
	CoreAudio/CoreAudio.h \
	DiskArbitration/DiskArbitration.h \
	IOKit/hid/IOHIDLib.h \
	Security/Security.h \
	SystemConfiguration/SCDynamicStoreCopyDHCPInfo.h \
	SystemConfiguration/SCNetworkConfiguration.h \
	asm/types.h \
	linux/input.h \
	linux/ioctl.h \
	linux/joystick.h \
	linux/major.h \
	linux/param.h \
	linux/serial.h \
	linux/types.h \
	lwp.h \
	mach-o/loader.h \
	machine/sysarch.h \
	mntent.h \
	netdb.h \
	netinet/in.h \
	netinet/in_systm.h \
	netinet/tcp.h \
	netinet/tcp_fsm.h \
	pcap/pcap.h \
	poll.h \
	sched.h \
	scsi/scsi.h \
	scsi/scsi_ioctl.h \
	sys/filio.h \
	sys/ioctl.h \
	sys/ipc.h \
	sys/link.h \
	sys/mman.h \
	sys/modem.h \
	sys/msg.h \
	sys/scsiio.h \
	sys/shm.h \
	sys/signal.h \
	sys/socket.h \
	sys/sockio.h \
	sys/statvfs.h \
	sys/strtio.h \
	sys/syscall.h \
	sys/vnode.h \
	sys/wait.h \
	syscall.h \
	termios.h \
	unistd.h \
	utime.h \
	valgrind/memcheck.h \
	valgrind/valgrind.h
dnl **** Checks for headers that depend on other ones ****

AC_CHECK_HEADERS([sys/conf.h sys/mount.h sys/statfs.h sys/user.h sys/vfs.h],,,
dnl check for broken Linux sysctl.h that causes deprecation warnings
saved_sysctl_h_CFLAGS=$CFLAGS
test "x${GCC}" != xyes || CFLAGS="$CFLAGS -Werror"
AC_CHECK_HEADERS([sys/sysctl.h],,,
    [#include <sys/types.h>
     #ifdef HAVE_SYS_PARAM_H
     # include <sys/param.h>
     #endif])
CFLAGS=$saved_sysctl_h_CFLAGS

AC_CHECK_HEADERS(\
	netinet/ip.h \
	net/if.h \
	net/if_arp.h \
	net/if_dl.h \
	net/if_types.h \
	net/route.h \
	netinet/if_ether.h \
	netinet/if_inarp.h \
	netinet/in_pcb.h \
	netinet/ip_icmp.h \
	netinet/ip_var.h \
	netinet/udp.h \
	netipx/ipx.h \
     # include <sys/socketvar.h>
     #ifdef HAVE_NET_ROUTE_H
     # include <net/route.h>
     #endif
     #ifdef HAVE_NETINET_IN_SYSTM_H
     # include <netinet/in_systm.h>
     #endif
     #ifdef HAVE_NET_IF_H
     # include <net/if.h>
     #endif
     #ifdef HAVE_NETINET_IP_H
     # include <netinet/ip.h>
AC_CHECK_HEADERS([netinet/tcp_timer.h netinet/udp_var.h netinet/icmp_var.h netinet/tcp_var.h ],,,
    [#include <sys/types.h>
     #ifdef HAVE_ALIAS_H
     # include <alias.h>
     #endif
     # include <sys/socket.h>
     #endif
     # include <sys/socketvar.h>
     #endif
     #ifdef HAVE_SYS_TIMEOUT_H
     # include <sys/timeout.h>
     #endif
     # include <netinet/in.h>
     #endif
     #ifdef HAVE_NETINET_IN_SYSTM_H
     # include <netinet/in_systm.h>
     #endif
     #ifdef HAVE_NETINET_IP_H
     # include <netinet/ip.h>
     #endif
     #ifdef HAVE_NETINET_IP_VAR_H
     # include <netinet/ip_var.h>
     #endif
     #ifdef HAVE_NETINET_IP_ICMP_H
     # include <netinet/ip_icmp.h>
     #endif
     #ifdef HAVE_NETINET_UDP_H
     # include <netinet/udp.h>
     #endif
     #ifdef HAVE_NETINET_TCP_H
     # include <netinet/tcp.h>
     #endif
     #ifdef HAVE_NETINET_TCP_TIMER_H
     #include <netinet/tcp_timer.h>
AC_CHECK_HEADERS([linux/ipx.h linux/irda.h linux/rtnetlink.h],,,
    [#include <sys/types.h>
     #ifdef HAVE_ASM_TYPES_H
     # include <asm/types.h>
     #endif
     # include <sys/socket.h>
     #endif
     #ifdef HAVE_LINUX_TYPES_H
     # include <linux/types.h>
AC_CHECK_HEADERS([resolv.h],,,
    [#include <sys/types.h>
AC_CHECK_HEADERS([ifaddrs.h],,,[#include <sys/types.h>])

AC_CHECK_HEADERS(sys/ucontext.h,,,[#include <signal.h>])
AC_CHECK_HEADERS([sys/thr.h],,,
[#include <sys/types.h>
#ifdef HAVE_SYS_UCONTEXT_H
#include <sys/ucontext.h>
AC_CHECK_HEADERS([pthread_np.h],,,
[#ifdef HAVE_PTHREAD_H
#include <pthread.h>
#endif])

Zebediah Figura's avatar
Zebediah Figura committed
AC_CHECK_HEADERS([linux/videodev2.h],,,
[#ifdef HAVE_SYS_TIME_H
#include <sys/time.h>
#endif
#include <sys/types.h>
#ifdef HAVE_ASM_TYPES_H
#include <asm/types.h>
#endif])

AC_CHECK_HEADERS([libprocstat.h],,,
[#ifdef HAVE_SYS_PARAM_H
#include <sys/param.h>
#endif
#ifdef HAVE_SYS_QUEUE_H
#include <sys/queue.h>
#endif
#ifdef HAVE_SYS_SOCKET_H
#include <sys/socket.h>
#endif])

dnl **** Check for working dll ****

AC_SUBST(DLLFLAGS,"-D_REENTRANT")
AC_SUBST(LDDLLFLAGS,"")
AC_SUBST(TOP_INSTALL_LIB,"")
AC_SUBST(TOP_INSTALL_DEV,"")
AC_SUBST(WINEPRELOADER_LDFLAGS,"")
wine_binary="wine"
test "x$enable_win64" != "xyes" || wine_binary="wine64"
AC_SUBST(WINELOADER_PROGRAMS,"$wine_binary")
libwine_soversion=`expr $libwine_version : '\([[0-9]]*\)\..*'`
case $host_os in
  cygwin*|mingw32*)
    AC_CHECK_TOOL(DLLTOOL,dlltool,false)
    dnl Disable stdcall fixups to catch prototype mismatches
    case $host_cpu in
      *i[[3456]]86*) WINE_TRY_CFLAGS([-Wl,--disable-stdcall-fixup],
                                     [LDDLLFLAGS="-Wl,--disable-stdcall-fixup"]) ;;
    dnl Disable modules that can't be used on Windows
    enable_iphlpapi=${enable_iphlpapi:-no}
    enable_ws2_32=${enable_ws2_32:-no}
    enable_loader=${enable_loader:-no}
    enable_server=${enable_server:-no}
    dnl Disable dependencies that are not useful on Windows
    with_x=${with_x:-no}
    with_pthread=${with_pthread:-no}
    AC_LANG_PUSH([Objective C])
        AC_CHECK_HEADERS(Metal/Metal.h)
    AC_LANG_POP([Objective C])
    AC_SUBST(COREFOUNDATION_LIBS,"-framework CoreFoundation")
    AC_SUBST(IOKIT_LIBS,"-framework IOKit -framework CoreFoundation")
    AC_SUBST(FORCEFEEDBACK_LIBS,"-framework ForceFeedback -framework CoreFoundation")
    AC_SUBST(APPLICATIONSERVICES_LIBS,"-framework ApplicationServices")
    AC_SUBST(CORESERVICES_LIBS,"-framework CoreServices")
    AC_SUBST(APPKIT_LIBS,"-framework AppKit")
    AC_SUBST(SYSTEMCONFIGURATION_LIBS,"-framework SystemConfiguration")
    WINELOADER_LDFLAGS="-Wl,-pie,-pagezero_size,0x1000,-sectcreate,__TEXT,__info_plist,loader/wine_info.plist"
    WINEPRELOADER_LDFLAGS="-nostartfiles -nodefaultlibs -e _start -ldylib1.o -Wl,-image_base,0x7d400000,-pagezero_size,0x1000,-sectcreate,__TEXT,__info_plist,loader/wine_info.plist,-segaddr,WINE_4GB_RESERVE,0x100000000"
    WINE_TRY_CFLAGS([-Wl,-no_new_main -e _main],
                    [WINEPRELOADER_LDFLAGS="-Wl,-no_new_main $WINEPRELOADER_LDFLAGS"
                     WINE_TRY_CFLAGS([-Wl,-no_new_main -e _main -nostartfiles -nodefaultlibs],,
                        [WINE_TRY_CFLAGS([-Wl,-no_new_main -e _main -mmacosx-version-min=10.7 -nostartfiles -nodefaultlibs],
                                         [WINEPRELOADER_LDFLAGS="-mmacosx-version-min=10.7 $WINEPRELOADER_LDFLAGS"],
                                         [wine_can_build_preloader=no])])],
                    [WINE_TRY_CFLAGS([-nostartfiles -nodefaultlibs],,
                        [WINE_TRY_CFLAGS([-mmacosx-version-min=10.7 -nostartfiles -nodefaultlibs],
                                         [WINEPRELOADER_LDFLAGS="-mmacosx-version-min=10.7 $WINEPRELOADER_LDFLAGS"],
                                         [wine_can_build_preloader=no])])])
    if test "$wine_can_build_preloader" = "yes"
    then
        WINE_TRY_CFLAGS([-Wl,-no_pie],
                        [WINEPRELOADER_LDFLAGS="-Wl,-no_pie $WINEPRELOADER_LDFLAGS"])
        test "$wine_binary" = wine || WINE_IGNORE_FILE("loader/wine-preloader")
        WINELOADER_PROGRAMS="$WINELOADER_PROGRAMS $wine_binary-preloader"
    else
        WINE_WARNING([can't build Wine preloader; many programs won't work])
    fi
    if test "$ac_cv_header_DiskArbitration_DiskArbitration_h" = "yes"
    then
        dnl DiskArbitration API is not public on Darwin < 8.0, use it only if header found
        AC_SUBST(DISKARBITRATION_LIBS,"-framework DiskArbitration -framework CoreFoundation")
    if test "$ac_cv_header_Security_Security_h" = "yes"
    then
        AC_SUBST(SECURITY_LIBS,"-framework Security -framework CoreFoundation")
        dnl Check for the SSLCopyPeerCertificates function
        ac_save_LIBS="$LIBS"
        AC_CHECK_FUNCS(SSLCopyPeerCertificates)
        LIBS="$ac_save_LIBS"
    if test "$ac_cv_header_CoreAudio_CoreAudio_h" = "yes" -a "$ac_cv_header_AudioUnit_AudioUnit_h" = "yes"
    then
        if test "$ac_cv_header_AudioUnit_AudioComponent_h" = "yes"
        then
            AC_SUBST(COREAUDIO_LIBS,"-framework CoreFoundation -framework CoreAudio -framework AudioUnit -framework AudioToolbox -framework CoreMIDI")
        else
            dnl CoreServices needed by AudioUnit
            AC_SUBST(COREAUDIO_LIBS,"-framework CoreAudio -framework AudioUnit -framework CoreServices -framework AudioToolbox -framework CoreMIDI")
        enable_winecoreaudio_drv=${enable_winecoreaudio_drv:-yes}
        dnl Check for the AUGraphAddNode function
        ac_save_LIBS="$LIBS"
        AC_CHECK_FUNCS(AUGraphAddNode)
        LIBS="$ac_save_LIBS"
    if test "$ac_cv_header_OpenAL_al_h" = "yes"
    then
        AC_DEFINE_UNQUOTED(HAVE_OPENAL,1,[Define to 1 if OpenAL is available])
        ac_cv_lib_openal=yes
    if test "$ac_cv_header_OpenCL_opencl_h" = "yes"
    then
        ac_cv_lib_OpenCL_clGetPlatformInfo=yes
    fi
    if test "$ac_cv_header_IOKit_hid_IOHIDLib_h" = "yes"
    then
        ac_save_LIBS="$LIBS"
        AC_CHECK_FUNCS(IOHIDManagerCreate)
        LIBS="$ac_save_LIBS"
    fi

    dnl *** Check for QuickTime ***
    if test "x$with_quicktime" != "xno"
        if test "$ac_cv_header_QuickTime_ImageCompression_h" = "yes"
        then
            dnl Make sure we can actually use the QuickTime framework
            ac_save_LIBS="$LIBS"
            LIBS="-framework QuickTime -framework ApplicationServices -framework CoreVideo $LIBS"
            AC_MSG_CHECKING([for the QuickTime framework])
            AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <QuickTime/ImageCompression.h>]],[[CodecManagerVersion(NULL);]])],
                           [AC_MSG_RESULT([yes])
                            AC_SUBST(QUICKTIME_LIBS,"-framework QuickTime -framework ApplicationServices -framework CoreVideo")
                            enable_wineqtdecoder=${enable_wineqtdecoder:-yes}],
                           [AC_MSG_RESULT([no])
                            ac_cv_header_QuickTime_ImageCompression_h=no])
            LIBS="$ac_save_LIBS"
        fi
    WINE_NOTICE_WITH(quicktime,[test "$ac_cv_header_QuickTime_ImageCompression_h" != "yes"],
                     [QuickTime ${notice_platform}development files not found, video decoding won't be supported.])

    if test "$ac_cv_header_Metal_Metal_h" = "yes"
    then
        AC_SUBST(METAL_LIBS,"-framework Metal -framework QuartzCore")
    fi
    dnl Check for MTLDevice registryID property
    if test "$ac_cv_header_Metal_Metal_h" = "yes"
    then
        AC_MSG_CHECKING([whether MTLDevice protocol supports registryID property])
        AC_LANG_PUSH([Objective C])
        AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <Metal/Metal.h>]], [[id<MTLDevice> device; device.registryID;]])],
                              [AC_MSG_RESULT(yes)
                               AC_DEFINE(HAVE_MTLDEVICE_REGISTRYID, 1, [Define if MTLDevice protocol has registryID property.])],
                              [AC_MSG_RESULT(no)])
        AC_LANG_POP([Objective C])
    fi

    dnl Enable Mac driver on Mac OS X 10.6 or later
    if test "$ac_cv_header_ApplicationServices_ApplicationServices_h" = "yes"
    then
        ac_save_LIBS="$LIBS"
        AC_CHECK_FUNC(CGDisplayModeGetWidth,enable_winemac_drv=${enable_winemac_drv:-yes})
        LIBS="$ac_save_LIBS"
    fi

    AC_SUBST(LIBWINE_SHAREDLIB,"libwine.$libwine_version.dylib")
    AC_SUBST(LIBWINE_LDFLAGS,["-dynamiclib -install_name @rpath/libwine.$libwine_soversion.dylib -Wl,-rpath,@loader_path/ -compatibility_version $libwine_soversion -current_version $libwine_version"])
    AC_SUBST(WINELOADER_DEPENDS,"wine_info.plist")
    TOP_INSTALL_LIB="$TOP_INSTALL_LIB libs/wine/libwine.$libwine_version.dylib libs/wine/libwine.$libwine_soversion.dylib"
  linux-android*)
    DLLFLAGS="$DLLFLAGS -fPIC"
    LDEXECFLAGS="-Wl,-pie"
    enable_wineandroid_drv=${enable_wineandroid_drv:-yes}
    WINE_TRY_CFLAGS([-fPIC -Wl,--export-dynamic],
                    [WINELOADER_LDFLAGS="-Wl,--export-dynamic"])
    WINEPRELOADER_LDFLAGS="-static -nostartfiles -nodefaultlibs -Wl,-Ttext=0x7d400000"
    WINE_CHECK_SONAME(EGL,eglGetProcAddress)
    WINE_CHECK_SONAME(GLESv2,glFlush)

    if test "x$exec_prefix" = xNONE
    then
      case $host_cpu in
        *i[[3456]]86*) exec_prefix='${prefix}/x86' ;;
        *x86_64*)      exec_prefix='${prefix}/x86_64' ;;
        *arm*)         exec_prefix='${prefix}/armeabi-v7a' ;;
        *aarch64*)     exec_prefix='${prefix}/arm64-v8a' ;;
      esac
    fi
    case $host_cpu in
      *i[[3456789]]86*)
        DLLFLAGS="$DLLFLAGS -fno-PIC"
        LDDLLFLAGS="-fno-PIC"
        WINE_TRY_CFLAGS([-fno-PIC -Wl,-z,notext],[LDDLLFLAGS="$LDDLLFLAGS -Wl,-z,notext"])
        ;;
        DLLFLAGS="$DLLFLAGS -fPIC"
        LDDLLFLAGS="-fPIC" ;;
    AC_CACHE_CHECK([whether we can build a GNU style ELF dll], ac_cv_c_dll_gnuelf,
        [WINE_TRY_SHLIB_FLAGS([-fPIC -shared -Wl,-Bsymbolic],
                              ac_cv_c_dll_gnuelf="yes",ac_cv_c_dll_gnuelf="no")])
    if test "$ac_cv_c_dll_gnuelf" = "yes"
    then
      WINE_TRY_CFLAGS([-shared -Wl,-soname,confest.so.1],
                      [LIBWINE_LDFLAGS="-shared -Wl,-soname,libwine.so.$libwine_soversion"],
                      [WINE_TRY_CFLAGS([-shared -Wl,-h,confest.so.1],
                                       [LIBWINE_LDFLAGS="-shared -Wl,-h,libwine.so.$libwine_soversion"])])
      WINE_TRY_CFLAGS([-shared -Wl,--version-script=conftest.map],
                      [LIBWINE_LDFLAGS="$LIBWINE_LDFLAGS -Wl,--version-script=\$(srcdir)/wine.map"])
      WINE_TRY_CFLAGS([-Wl,--export-dynamic],
                      [WINELOADER_LDFLAGS="-Wl,--export-dynamic"])
      WINEPRELOADER_LDFLAGS="-static -nostartfiles -nodefaultlibs -Wl,-Ttext=0x7d400000"
        *i[[3456789]]86* | x86_64 | *aarch64*)
          WINE_TRY_CFLAGS([-Wl,-Ttext-segment=0x7bc00000],
                           freebsd* | kfreebsd*-gnu) WINELOADER_LDFLAGS="$WINELOADER_LDFLAGS -Wl,-Ttext-segment=0x60000000" ;;
                           *) WINELOADER_LDFLAGS="$WINELOADER_LDFLAGS -Wl,-Ttext-segment=0x7d000000" ;;
                          [WINE_TRY_CFLAGS([-Wl,--section-start,.interp=0x7d000400],
                                              freebsd* | kfreebsd*-gnu) WINELOADER_LDFLAGS="$WINELOADER_LDFLAGS -Wl,--section-start,.interp=0x60000400" ;;
                                              *) WINELOADER_LDFLAGS="$WINELOADER_LDFLAGS -Wl,--section-start,.interp=0x7d000400" ;;
                                           esac])
                           AC_PATH_PROG(PRELINK, prelink, false, [/sbin /usr/sbin $PATH])
                           if test "x$PRELINK" = xfalse
                           then
                               WINE_WARNING([prelink not found and linker does not support relocation, base address of core dlls won't be set correctly.])
                           fi])
          WINE_TRY_CFLAGS([-Wl,-z,max-page-size=0x1000],
                          [WINELOADER_LDFLAGS="$WINELOADER_LDFLAGS -Wl,-z,max-page-size=0x1000"])
          ;;
      esac

    else
      AC_CACHE_CHECK(whether we can build a UnixWare (Solaris) dll, ac_cv_c_dll_unixware,
          [WINE_TRY_SHLIB_FLAGS([-fPIC -Wl,-G,-h,conftest.so.1.0,-B,symbolic],
                                ac_cv_c_dll_unixware="yes",ac_cv_c_dll_unixware="no")])
      if test "$ac_cv_c_dll_unixware" = "yes"
      then
        LIBWINE_LDFLAGS="-Wl,-G,-h,libwine.so.$libwine_soversion"
    AC_SUBST(LIBWINE_SHAREDLIB,"libwine.so.$libwine_version")
    AC_SUBST(LIBWINE_DEPENDS,"wine.map")
    TOP_INSTALL_LIB="$TOP_INSTALL_LIB libs/wine/libwine.so.$libwine_version libs/wine/libwine.so.$libwine_soversion"
enable_winecoreaudio_drv=${enable_winecoreaudio_drv:-no}
enable_wineqtdecoder=${enable_wineqtdecoder:-no}
enable_wineandroid_drv=${enable_wineandroid_drv:-no}
enable_winemac_drv=${enable_winemac_drv:-no}
test "$ac_cv_header_linux_joystick_h" = "yes" -o "$ac_cv_header_IOKit_hid_IOHIDLib_h" = "yes" || enable_winejoystick_drv=${enable_winejoystick_drv:-no}
dnl Check for cross compiler to build test programs
    case "x$with_mingw" in
      x|xyes) WINE_CHECK_MINGW_PROG(CROSSCC,false) ;;
      *) CROSSCC=$with_mingw ;;
    esac
        AC_SUBST(CROSSCFLAGS,${CROSSCFLAGS:-"-g -O2"})
        AC_SUBST(EXTRACROSSCFLAGS,"-DWINE_CROSS_PE -Wall")
        AC_SUBST(CROSSLDFLAGS)
        AC_CACHE_CHECK([whether $CROSSCC works], wine_cv_crosscc,
            [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([])],[wine_cv_crosscc=yes],[wine_cv_crosscc=no])])
        if test $wine_cv_crosscc = yes
        then
            set x $CROSSCC
            shift
            while test $# -ge 1
            do
                case "$1" in
                    *-gcc) CROSSTARGET=`expr "$1" : '\(.*\)-gcc'` ;;
                    *-clang) CROSSTARGET=`expr "$1" : '\(.*\)-clang'` ;;
                esac
                shift
            done

            dnl Check if cross compiler supports -target argument
            llvm_target=$CROSSTARGET
            if test -z "$llvm_target"
            then
                case $host_cpu in
                *i[[3456789]]86*) llvm_target=i686-windows ;;
                *) llvm_target=$host_cpu-windows ;;
            case $llvm_target in
            *windows) llvm_cflags="$llvm_cflags -Wl,-subsystem:console" ;;
            esac
            WINE_TRY_CROSSCFLAGS([-target $llvm_target $llvm_cflags],
                                 [CROSSTARGET=$llvm_target
                                  EXTRACROSSCFLAGS="$EXTRACROSSCFLAGS -target $CROSSTARGET"
                                  CFLAGS="$CFLAGS $llvm_cflags"])
        WINE_TRY_CROSSCFLAGS([-fno-strict-aliasing])
        dnl clang needs to be told to fail on unknown options
        WINE_TRY_CROSSCFLAGS([-Werror=unknown-warning-option],[CFLAGS="$CFLAGS -Werror=unknown-warning-option"])
        WINE_TRY_CROSSCFLAGS([-Werror=ignored-optimization-argument],[CFLAGS="$CFLAGS -Werror=ignored-optimization-argument"])
        WINE_TRY_CROSSCFLAGS([-Wdeclaration-after-statement])
        WINE_TRY_CROSSCFLAGS([-Wempty-body])
        WINE_TRY_CROSSCFLAGS([-Wignored-qualifiers])
        WINE_TRY_CROSSCFLAGS([-Winit-self])
        WINE_TRY_CROSSCFLAGS([-Wpacked-not-aligned],[EXTRACROSSCFLAGS="$EXTRACROSSCFLAGS -Wno-packed-not-aligned"])
        WINE_TRY_CROSSCFLAGS([-Wpragma-pack],[EXTRACROSSCFLAGS="$EXTRACROSSCFLAGS -Wno-pragma-pack"])
        WINE_TRY_CROSSCFLAGS([-Wshift-overflow=2])
        WINE_TRY_CROSSCFLAGS([-Wstrict-prototypes])
        WINE_TRY_CROSSCFLAGS([-Wtype-limits])
        WINE_TRY_CROSSCFLAGS([-Wunused-but-set-parameter])
        WINE_TRY_CROSSCFLAGS([-Wvla])
        WINE_TRY_CROSSCFLAGS([-Wwrite-strings])
        WINE_TRY_CROSSCFLAGS([-Wpointer-arith])
        WINE_TRY_CROSSCFLAGS([-Wlogical-op])
        WINE_TRY_CROSSCFLAGS([-Wabsolute-value])

        case $host_cpu in
          *i[[3456789]]86*) WINE_TRY_CROSSCFLAGS([-fno-omit-frame-pointer]) ;;
          x86_64) WINE_TRY_CROSSCFLAGS([-Wno-format])
                  WINE_TRY_CROSSCFLAGS([-Wformat-overflow])
                  WINE_TRY_CROSSCFLAGS([-Wnonnull])
                  WINE_TRY_CROSSCFLAGS([-mcx16]) ;;
          aarch64) WINE_TRY_CROSSCFLAGS([-Wno-format]) ;;
        dnl Determine debug info format
        AC_SUBST(CROSSDEBUG)
        if test -z "$CROSSDEBUG"
        then
          for ac_flag in $CROSSCFLAGS; do
            case $ac_flag in
             -gdwarf*)    CROSSDEBUG=dwarf ;;
             -gcodeview)  CROSSDEBUG=pdb ;;
             -g)          CROSSDEBUG=${CROSSDEBUG:-dwarf} ;;
            esac
          done
        fi
        case $CROSSDEBUG in
          *dwarf)  WINE_TRY_CROSSCFLAGS([-gdwarf-2])
                   WINE_TRY_CROSSCFLAGS([-gstrict-dwarf]) ;;
          pdb)     WINE_TRY_CROSSCFLAGS([-gcodeview]) ;;
        esac
        WINE_TRY_CROSSCFLAGS([-fexcess-precision=standard],[AC_SUBST(EXCESS_PRECISION_CFLAGS,"-fexcess-precision=standard")])

        if test "x$enable_werror" = "xyes"
        if test "x$enable_build_id" = "xyes"
        then
            WINE_TRY_CROSSCFLAGS([-Wl,--build-id], [CROSSCFLAGS="$CROSSCFLAGS -Wl,--build-id"
                            CROSSLDFLAGS="$CROSSLDFLAGS -Wl,--build-id"])
        fi
WINE_NOTICE_WITH(mingw,[test "x$CROSSTARGET" = "x"],
                 [MinGW compiler not found, cross-compiling PE files won't be supported.])
dnl **** Check for pthread ****

if test "$ac_cv_header_pthread_h" = "yes"
then
    AC_CHECK_FUNC(pthread_create,,[AC_CHECK_LIB(pthread,pthread_create,[AC_SUBST(PTHREAD_LIBS,"-lpthread")])])
WINE_ERROR_WITH(pthread,[test "x$ac_cv_func_pthread_create" != xyes -a "x$PTHREAD_LIBS" = x],
[pthread ${notice_platform}development files not found.
Wine cannot support threads without libpthread.])

    ac_save_CPPFLAGS="$CPPFLAGS"
    CPPFLAGS="$CPPFLAGS $X_CFLAGS"
    WINE_CHECK_SONAME(X11,XCreateWindow,,,[$X_LIBS $X_EXTRA_LIBS])
    WINE_CHECK_SONAME(Xext,XextCreateExtension,[X_LIBS="$X_LIBS -lXext"],,[$X_LIBS -lX11 $X_EXTRA_LIBS])
    X_LIBS="$X_LIBS -lX11"
    dnl *** All of the following tests require X11/Xlib.h
    AC_CHECK_HEADERS([X11/Xlib.h \
                      X11/XKBlib.h \
                      X11/Xutil.h \
                      X11/Xcursor/Xcursor.h \
                      X11/extensions/shape.h \
                      X11/extensions/XInput.h \
                      X11/extensions/XInput2.h \
                      X11/extensions/Xcomposite.h \
                      X11/extensions/Xfixes.h \
                      X11/extensions/Xinerama.h \
                      X11/extensions/Xrandr.h \
                      X11/extensions/Xrender.h \
                      X11/extensions/xf86vmode.h \
                      X11/extensions/xf86vmproto.h],,,
[#ifdef HAVE_X11_XLIB_H
# include <X11/Xlib.h>
#endif
#ifdef HAVE_X11_XUTIL_H
# include <X11/Xutil.h>
#endif])
        dnl *** Check for X keyboard extension
        if test "$ac_cv_header_X11_XKBlib_h" = "yes"
        then
              AC_CHECK_LIB(X11, XkbQueryExtension,
              AC_DEFINE(HAVE_XKB, 1, [Define if you have the XKB extension]),,[$X_LIBS $X_EXTRA_LIBS])
        dnl *** Check for X cursor
        if test "$ac_cv_header_X11_Xcursor_Xcursor_h" = "yes"
        then
            WINE_CHECK_SONAME(Xcursor,XcursorImageLoadCursor,,,[$X_LIBS $X_EXTRA_LIBS])
        WINE_NOTICE_WITH(xcursor,[test "x$ac_cv_lib_soname_Xcursor" = "x"],
                         [libxcursor ${notice_platform}development files not found, the Xcursor extension won't be supported.])
        dnl *** Check for X input extension
        if test "$ac_cv_header_X11_extensions_XInput_h" = "yes"
        then
            WINE_CHECK_SONAME(Xi,XOpenDevice,,,[$X_LIBS $X_EXTRA_LIBS])
        WINE_NOTICE_WITH(xinput,[test "x$ac_cv_lib_soname_Xi" = "x"],
                         [libxi ${notice_platform}development files not found, the Xinput extension won't be supported.])
        dnl *** Check for X input 2 extension
        if test "x$ac_cv_lib_soname_Xi" != x
        then
            WINE_NOTICE_WITH(xinput2,[test "$ac_cv_header_X11_extensions_XInput2_h" != "yes"],
                             [XInput2 headers not found, the XInput 2 extension won't be supported.])
        fi

        dnl *** Check for X Shm extension
        if test "$ac_cv_header_X11_extensions_XShm_h" = "yes"
        then
              AC_CHECK_LIB(Xext, XShmQueryExtension,
              AC_DEFINE(HAVE_LIBXXSHM, 1, [Define if you have the X Shm extension]),,[$X_LIBS $X_EXTRA_LIBS])
        fi
        WINE_NOTICE_WITH(xshm,[test "$ac_cv_lib_Xext_XShmQueryExtension" != "yes"],
                         [XShm ${notice_platform}development files not found, X Shared Memory won't be supported.])

        dnl *** Check for X shape extension
        if test "$ac_cv_header_X11_extensions_shape_h" = "yes"
        then
              AC_CHECK_LIB(Xext,XShapeQueryExtension,
	      AC_DEFINE(HAVE_LIBXSHAPE, 1, [Define if you have the X Shape extension]),,[$X_LIBS $X_EXTRA_LIBS])
        WINE_NOTICE_WITH(xshape,[test "$ac_cv_lib_Xext_XShapeQueryExtension" != "yes"],
                         [XShape ${notice_platform}development files not found, XShape won't be supported.])
        dnl *** Check for XFree86 VMODE extension
        if test "$ac_cv_header_X11_extensions_xf86vmode_h" = "yes" -o "$ac_cv_header_X11_extensions_xf86vmproto_h" = "yes"
            WINE_CHECK_SONAME(Xxf86vm,XF86VidModeQueryExtension,,,[$X_LIBS $X_EXTRA_LIBS])
        WINE_NOTICE_WITH(xxf86vm,[test "x$ac_cv_lib_soname_Xxf86vm" = "x"],
                         [libXxf86vm ${notice_platform}development files not found, XFree86 Vidmode won't be supported.])
        dnl *** Check for Transform functions in Xrender
        if test "$ac_cv_header_X11_extensions_Xrender_h" = "yes" -a "x$ac_cv_lib_soname_X11" != "x"
            WINE_CHECK_SONAME(Xrender,XRenderQueryExtension,
              [AC_CHECK_LIB(Xrender,XRenderSetPictureTransform,
                [AC_DEFINE(HAVE_XRENDERSETPICTURETRANSFORM, 1,
                 [Define if Xrender has the XRenderSetPictureTransform function])],,[$X_LIBS $X_EXTRA_LIBS])
               AC_CHECK_LIB(Xrender,XRenderCreateLinearGradient,
                [AC_DEFINE(HAVE_XRENDERCREATELINEARGRADIENT, 1,
                 [Define if Xrender has the XRenderCreateLinearGradient function])],,[$X_LIBS $X_EXTRA_LIBS])],,[$X_LIBS $X_EXTRA_LIBS])
        WINE_WARNING_WITH(xrender,[test "x$ac_cv_lib_soname_Xrender" = "x"],
                         [libxrender ${notice_platform}development files not found, XRender won't be supported.])

        dnl *** Check for X RandR extension
        if test "$ac_cv_header_X11_extensions_Xrandr_h" = "yes" -a "x$ac_cv_lib_soname_Xrender" != "x"
        then
                AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <X11/Xlib.h>
#include <X11/extensions/Xrandr.h>]], [[static typeof(XRRSetScreenConfigAndRate) * func; if (func) return 0;]])],
                  [WINE_CHECK_SONAME(Xrandr,XRRQueryExtension,
                    [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <X11/Xlib.h>
#include <X11/extensions/Xrandr.h>]], [[static typeof(XRRGetProviderResources) *f; if (f) return 0;]])],
                      [AC_DEFINE(HAVE_XRRGETPROVIDERRESOURCES, 1,
                        [Define if Xrandr has the XRRGetProviderResources function])],
                      [WINE_NOTICE([libxrandr ${notice_platform}development files too old, XRandR display device handler won't be supported.])])],,[$X_LIBS $X_EXTRA_LIBS])])
        WINE_NOTICE_WITH(xrandr,[test "x$ac_cv_lib_soname_Xrandr" = "x"],
                         [libxrandr ${notice_platform}development files not found, XRandr won't be supported.])
        dnl *** Check for Xfixes extension
        if test "$ac_cv_header_X11_extensions_Xfixes_h" = "yes"
        then
                AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <X11/Xlib.h>
#include <X11/extensions/Xfixes.h>]], [[static typeof(XFixesQueryVersion) * func; if (func) return 0;]])],
                  [WINE_CHECK_SONAME(Xfixes,XFixesQueryVersion,,,[$X_LIBS $X_EXTRA_LIBS])])
        fi
        WINE_NOTICE_WITH(xfixes,[test "x$ac_cv_lib_soname_Xfixes" = "x"],
                         [libxfixes ${notice_platform}development files not found, Xfixes won't be supported.])

        dnl *** Check for Xinerama extension
        if test "$ac_cv_header_X11_extensions_Xinerama_h" = "yes"
        then
                AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <X11/Xlib.h>
#include <X11/extensions/Xinerama.h>]], [[static typeof(XineramaQueryScreens) * func; if (func) return 0;]])],
                  [WINE_CHECK_SONAME(Xinerama,XineramaQueryScreens,,,[$X_LIBS $X_EXTRA_LIBS])])
        WINE_NOTICE_WITH(xinerama,[test "x$ac_cv_lib_soname_Xinerama" = "x"],
                         [libxinerama ${notice_platform}development files not found, multi-monitor setups won't be supported.])
        dnl *** Check for X Composite extension
        if test "$ac_cv_header_X11_extensions_Xcomposite_h" = "yes"
        then
            WINE_CHECK_SONAME(Xcomposite,XCompositeRedirectWindow,,,[$X_LIBS $X_EXTRA_LIBS])
        WINE_NOTICE_WITH(xcomposite,[test "x$ac_cv_lib_soname_Xcomposite" = "x"],
                         [libxcomposite ${notice_platform}development files not found, Xcomposite won't be supported.])
        dnl *** Check for XICCallback struct
        AC_CHECK_MEMBERS([XICCallback.callback, XEvent.xcookie],,,
[#ifdef HAVE_X11_XLIB_H
#include <X11/Xlib.h>
#endif])

Lionel Ulmer's avatar
Lionel Ulmer committed
    dnl Check for the presence of OpenGL
    if test "x$with_opengl" != "xno"
	WINE_CHECK_SONAME(GL,glXCreateContext,
		     [OPENGL_LIBS="-lGL"],
                     [WINE_CHECK_SONAME(GL,glXCreateContext,
			    [OPENGL_LIBS="-Xlinker -dylib_file -Xlinker /System/Library/Frameworks/OpenGL.framework/Versions/A/Libraries/libGL.dylib:/System/Library/Frameworks/OpenGL.framework/Versions/A/Libraries/libGL.dylib -lGL"],
			    [if test -f /usr/X11R6/lib/libGL.a
                            then
	                        opengl_msg="/usr/X11R6/lib/libGL.a is present on your system.
This probably prevents linking to OpenGL. Try deleting the file and restarting configure."
                            else
                                opengl_msg="No OpenGL library found on this system."
                            fi],
			    $X_LIBS -lm $X_EXTRA_LIBS -dylib_file /System/Library/Frameworks/OpenGL.framework/Versions/A/Libraries/libGL.dylib:/System/Library/Frameworks/OpenGL.framework/Versions/A/Libraries/libGL.dylib)],
		     $X_LIBS -lm $X_EXTRA_LIBS)
            WINE_CHECK_SONAME(OSMesa,OSMesaGetProcAddress,,,[$X_LIBS -lm $X_EXTRA_LIBS])
            WINE_NOTICE_WITH(osmesa,[test "x$ac_cv_lib_soname_OSMesa" = "x"],
                             [libOSMesa ${notice_platform}development files not found (or too old), OpenGL rendering in bitmaps won't be supported.])
        fi
    WINE_WARNING_WITH(opengl,[test -n "$opengl_msg"],[$opengl_msg
OpenGL and Direct3D won't be supported.])
    CPPFLAGS="$ac_save_CPPFLAGS"
if test "$enable_wineandroid_drv$enable_winemac_drv" = "nono"
then
    WINE_ERROR_WITH(x,[test "x$X_LIBS" = "x"],
[X ${notice_platform}development files not found. Wine will be built
without X support, which probably isn't what you want. You will need
to install ${notice_platform}development packages of Xlib at the very least.],
                    [enable_winex11_drv])
else
    WINE_NOTICE_WITH(x,[test "x$X_LIBS" = "x"],
                     [X ${notice_platform}development files not found, the X11 driver won't be supported.],
                     [enable_winex11_drv])
fi
dnl **** Check for OpenCL ****
if test "$ac_cv_header_CL_cl_h" = "yes"
    AC_CHECK_LIB(OpenCL,clGetPlatformInfo,[AC_SUBST(OPENCL_LIBS,["-lOpenCL"])])
fi
WINE_NOTICE_WITH(opencl,[test "x$ac_cv_lib_OpenCL_clGetPlatformInfo" != xyes],
                 [OpenCL ${notice_platform}development files not found, OpenCL won't be supported.],
                 [enable_opencl])
dnl **** Check for libpcap ****
if test "$ac_cv_header_pcap_pcap_h" = "yes"
then
    AC_CHECK_LIB(pcap,pcap_create,[AC_SUBST(PCAP_LIBS,["-lpcap"])])
fi
WINE_NOTICE_WITH(pcap,[test "x$ac_cv_lib_pcap_pcap_create" != xyes],
                 [pcap ${notice_platform}development files not found, wpcap won't be supported.],
                 [enable_wpcap])
dnl **** Check for libxml2 ****

    WINE_PACKAGE_FLAGS(XML2,[libxml-2.0],[-lxml2],
                       [`${XML2_CONFIG:-xml2-config} --cflags 2>/dev/null`],[`${XML2_CONFIG:-xml2-config} --libs 2>/dev/null`],
        [AC_CHECK_HEADERS([libxml/parser.h libxml/xmlsave.h libxml/SAX2.h])
        if test "$ac_cv_header_libxml_parser_h" = "yes" -a "$ac_cv_header_libxml_xmlsave_h" = "yes" -a "$ac_cv_header_libxml_SAX2_h" = "yes"
        then
            AC_CHECK_LIB(xml2, xmlParseMemory,
                [AC_DEFINE(HAVE_LIBXML2, 1, [Define if you have the libxml2 library])],[XML2_LIBS=""],[$XML2_LIBS])
            AC_CHECK_LIB(xml2, xmlReadMemory,
                [AC_DEFINE(HAVE_XMLREADMEMORY,1,[Define if libxml2 has the xmlReadMemory function])],,[$XML2_LIBS])
            AC_CHECK_LIB(xml2, xmlNewDocPI,
                [AC_DEFINE(HAVE_XMLNEWDOCPI,1,[Define if libxml2 has the xmlNewDocPI function])],,[$XML2_LIBS])
            AC_CHECK_LIB(xml2, xmlSchemaSetParserStructuredErrors,
                [AC_DEFINE(HAVE_XMLSCHEMASSETPARSERSTRUCTUREDERRORS,1,[Define if libxml2 has the xmlSchemaSetParserStructuredErrors function])],,[$XML2_LIBS])
            AC_CHECK_LIB(xml2, xmlSchemaSetValidStructuredErrors,
                [AC_DEFINE(HAVE_XMLSCHEMASSETVALIDSTRUCTUREDERRORS,1,[Define if libxml2 has the xmlSchemaSetValidStructuredErrors function])],,[$XML2_LIBS])
            AC_CHECK_LIB(xml2, xmlFirstElementChild,
                [AC_DEFINE(HAVE_XMLFIRSTELEMENTCHILD,1,[Define if libxml2 has the xmlFirstElementChild function])],,[$XML2_LIBS])
            AC_CHECK_TYPE([xmlDocProperties],
                [AC_DEFINE(HAVE_XMLDOC_PROPERTIES,1,[Define if libxml2 has the xmlDocProperties enum])],,[[#include <libxml/tree.h>]])
        else
            XML2_CFLAGS=""
            XML2_LIBS=""
        fi])
WINE_WARNING_WITH(xml,[test "$ac_cv_lib_xml2_xmlParseMemory" != "yes"],
                 [libxml2 ${notice_platform}development files not found (or too old), XML won't be supported.])
    WINE_PACKAGE_FLAGS(XSLT,[libxslt],[-lxml2],
                       [`${XSLT_CONFIG:-xslt-config} --cflags 2>/dev/null`],[`${XSLT_CONFIG:-xslt-config} --libs 2>/dev/null`],
        [AC_CHECK_HEADERS([libxslt/pattern.h libxslt/transform.h],,,
        [#ifdef HAVE_LIBXSLT_PATTERN_H
# include <libxslt/pattern.h>
#endif])
        if test "$ac_cv_header_libxslt_transform_h" = "yes"
        then
            WINE_CHECK_SONAME(xslt,xsltCompilePattern,,,[$XSLT_LIBS])
        else
            XSLT_CFLAGS=""
        fi])
WINE_WARNING_WITH(xslt,[test "x$ac_cv_lib_soname_xslt" = "x"],
                 [libxslt ${notice_platform}development files not found, xslt won't be supported.])
dnl **** Check for inotify ****
if test "x$with_inotify" != "xno"
then
    WINE_PACKAGE_FLAGS(INOTIFY,[libinotify],,,,
        [AC_CHECK_HEADERS([sys/inotify.h])
         AC_CHECK_LIB(inotify,inotify_add_watch,[:],[INOTIFY_LIBS=""],[$INOTIFY_LIBS])])
fi
WINE_NOTICE_WITH(inotify,[test "$ac_cv_header_sys_inotify_h" != "yes"],
                 [libinotify ${notice_platform}development files not found (or too old), filesystem change notifications won't be supported.])

dnl **** Check for libdbus ****
if test "x$with_dbus" != "xno"
then
    WINE_PACKAGE_FLAGS(DBUS,[dbus-1],,,,
        [AC_CHECK_HEADER([dbus/dbus.h],
            [WINE_CHECK_SONAME(dbus-1, dbus_connection_close,,[DBUS_CFLAGS=""],[$DBUS_LIBS])],
            [DBUS_CFLAGS=""])])
fi
WINE_NOTICE_WITH(dbus,[test "x$ac_cv_lib_soname_dbus_1" = "x" -a \
                            "x$ac_cv_header_DiskArbitration_DiskArbitration_h" != "xyes"],
                 [libdbus ${notice_platform}development files not found, no dynamic device support.])

dnl **** Check for libhal ****
if test "x$with_hal" != "xno" -a "x$ac_cv_lib_soname_dbus_1" != x
    WINE_PACKAGE_FLAGS(HAL,[hal],[-ldbus-1],,,
        [AC_CHECK_HEADER([hal/libhal.h],
            [WINE_CHECK_SONAME(hal, libhal_ctx_new,,[HAL_CFLAGS=""],[$HAL_LIBS])],
            [HAL_CFLAGS=""])])
    WINE_NOTICE_WITH(hal,[test "x$ac_cv_lib_soname_hal" = "x" -a \
                               "x$ac_cv_header_DiskArbitration_DiskArbitration_h" != "xyes"],
                     [libhal ${notice_platform}development files not found, no legacy dynamic device support.])
dnl **** Check for libgnutls ****
    WINE_PACKAGE_FLAGS(GNUTLS,[gnutls],[-lgnutls],,,
        [AC_CHECK_HEADER(gnutls/gnutls.h,
            [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <gnutls/gnutls.h>
#include <gnutls/crypto.h>]], [[static typeof(gnutls_mac_get_key_size) *func; if (func) return 0;]])],
                [WINE_CHECK_SONAME(gnutls,gnutls_global_init,,[GNUTLS_CFLAGS=""],[$GNUTLS_LIBS],[[libgnutls\\(-deb0\\)\\{0,1\\}]])
                 WINE_CHECK_LIB_FUNCS(gnutls_cipher_init,[$GNUTLS_LIBS],,
                                      [WINE_NOTICE([libgnutls ${notice_platform}development files too old, bcrypt encryption won't be supported.])])])],
WINE_WARNING_WITH(gnutls,[test "x$ac_cv_lib_soname_gnutls" = "x"],
                 [libgnutls ${notice_platform}development files not found, no schannel support.])
dnl **** Check for SANE ****
    WINE_PACKAGE_FLAGS(SANE,[sane-backends],,[`${SANE_CONFIG:-sane-config} --cflags 2>/dev/null`],[`${SANE_CONFIG:-sane-config} --ldflags 2>/dev/null`],
        [AC_CHECK_HEADER(sane/sane.h,
            [WINE_CHECK_SONAME(sane,sane_init,,[SANE_CFLAGS=""],[$SANE_LIBS])],
            [SANE_CFLAGS=""])])
WINE_NOTICE_WITH(sane,[test "x$ac_cv_lib_soname_sane" = "x"],
                 [libsane ${notice_platform}development files not found, scanners won't be supported.])
dnl **** Check for libusb ****
if test "x$with_usb" != "xno"
then
    WINE_PACKAGE_FLAGS(USB,[libusb-1.0],[-lusb-1.0],,,
        [AC_CHECK_HEADER([libusb.h],
            [AC_CHECK_LIB(usb-1.0,libusb_interrupt_event_handler,[:],[USB_LIBS=""],[$USB_LIBS])],
            [USB_LIBS=""])])
fi
WINE_NOTICE_WITH(usb,[test "$ac_cv_lib_usb_1_0_libusb_interrupt_event_handler" != "yes"],
                 [libusb-1.0 ${notice_platform}development files not found (or too old), USB devices won't be supported.],
                 [enable_wineusb_sys])

Zebediah Figura's avatar
Zebediah Figura committed
dnl **** Check for libv4l2 ****
if test "x$with_v4l2" != "xno"
Zebediah Figura's avatar
Zebediah Figura committed
    WINE_CHECK_SONAME(v4l2,v4l2_open)
Zebediah Figura's avatar
Zebediah Figura committed
WINE_NOTICE_WITH(v4l2,[test "x$ac_cv_lib_soname_v4l2" = "x"],
                 [libv4l2 ${notice_platform}development files not found.])
    WINE_PACKAGE_FLAGS(GPHOTO2,[libgphoto2],[-lgphoto2],
                       [`${GPHOTO2_CONFIG:-gphoto2-config} --cflags 2>/dev/null`],[`${GPHOTO2_CONFIG:-gphoto2-config} --libs 2>/dev/null`],
        [AC_CHECK_HEADER(gphoto2-camera.h,
                        [AC_CHECK_LIB(gphoto2,gp_camera_new,
                                      [AC_DEFINE(HAVE_GPHOTO2, 1, [Define if we have the libgphoto2 development environment])],
                                      [GPHOTO2_LIBS=""; GPHOTO2_CFLAGS=""],
                                      [$GPHOTO2_LIBS])],
                        [GPHOTO2_LIBS=""; GPHOTO2_CFLAGS=""])])
    WINE_PACKAGE_FLAGS(GPHOTO2_PORT,[libgphoto2_port],[-lgphoto2_port],
                       [`${GPHOTO2_PORT_CONFIG:-gphoto2-port-config} --cflags 2>/dev/null`],
                       [`${GPHOTO2_PORT_CONFIG:-gphoto2-port-config} --libs 2>/dev/null`],
        [AC_CHECK_HEADER(gphoto2-port.h,
                        [AC_CHECK_LIB(gphoto2_port,gp_port_info_list_new,
                                      [AC_DEFINE(HAVE_GPHOTO2_PORT, 1, [Define if we have the libgphoto2_port development environment])],
                                      [GPHOTO2_PORT_LIBS=""; GPHOTO2_PORT_CFLAGS=""],
                                      [$GPHOTO2_PORT_LIBS])],
                        [GPHOTO2_PORT_LIBS=""; GPHOTO2_PORT_CFLAGS=""])])
WINE_NOTICE_WITH(gphoto,[test "$ac_cv_lib_gphoto2_gp_camera_new" != "yes"],
                 [libgphoto2 ${notice_platform}development files not found, digital cameras won't be supported.])
WINE_NOTICE_WITH(gphoto,[test "$ac_cv_lib_gphoto2_port_gp_port_info_list_new" != "yes"],
                 [libgphoto2_port ${notice_platform}development files not found, digital cameras won't be auto-detected.])
dnl **** Check for resolver library ***
if test "$ac_cv_header_resolv_h" = "yes"
then
    AC_CACHE_CHECK([for resolver library], ac_cv_have_resolv,
      [ac_save_LIBS="$LIBS"
       for lib in '' -lresolv
       do
         LIBS="$lib $ac_save_LIBS"
         AC_LINK_IFELSE([AC_LANG_PROGRAM([[#ifdef HAVE_NETINET_IN_H
#include <netinet/in.h>
#endif
#include <resolv.h>]],[[if (!(_res.options & RES_INIT)) res_init(); res_query("foo",ns_c_in,0,0,0)]])],
           [ac_cv_have_resolv=${lib:-"none required"}],[ac_cv_have_resolv="not found"])
         test "x$ac_cv_have_resolv" = "xnot found" || break
       done
       LIBS="$ac_save_LIBS"])

    case "$ac_cv_have_resolv" in
      "not found") ;;
      "none required")
        AC_DEFINE(HAVE_RESOLV, 1, [Define if you have the resolver library and header]) ;;
      *)
        AC_DEFINE(HAVE_RESOLV, 1)
        AC_SUBST(RESOLV_LIBS,$ac_cv_have_resolv) ;;
    esac

    if test "x$ac_cv_have_resolv" != "xnot found"
    then
        AC_CACHE_CHECK([for res_getservers], ac_cv_have_res_getservers,
                       [ac_save_LIBS="$LIBS"
                        LIBS="$RESOLV_LIBS $LIBS"
                        AC_LINK_IFELSE([AC_LANG_PROGRAM(
        [[#include <resolv.h>]],[[res_getservers(NULL, NULL, 0);]])],[ac_cv_have_res_getservers=yes],[ac_cv_have_res_getservers=no])
	                 LIBS="$ac_save_LIBS"])
        if test "$ac_cv_have_res_getservers" = "yes"
        then
          AC_DEFINE(HAVE_RES_GETSERVERS, 1, [Define to 1 if you have the `res_getservers' function.])
        fi
    fi
dnl **** Check for LittleCMS ***
if test "x$with_cms" != "xno"
    WINE_PACKAGE_FLAGS(LCMS2,[lcms2],[-llcms2],,,
        [AC_CHECK_HEADERS([lcms2.h])
        if test "$ac_cv_header_lcms2_h" = "yes"
        then
            AC_CHECK_LIB(lcms2, cmsOpenProfileFromFile,
                [AC_DEFINE(HAVE_LCMS2, 1, [Define if you have the LittleCMS development environment])],[LCMS2_LIBS=""],[$LCMS2_LIBS])
Hans Leidekker's avatar
Hans Leidekker committed
WINE_NOTICE_WITH(cms,[test "$ac_cv_lib_lcms2_cmsOpenProfileFromFile" != "yes"],
                 [liblcms2 ${notice_platform}development files not found, Color Management won't be supported.])
dnl **** Check for FreeType 2 ****
    WINE_PACKAGE_FLAGS(FREETYPE,[freetype2],[-lfreetype],
                       [`(${FREETYPE_CONFIG:-freetype-config} --cflags || ${FREETYPE2_CONFIG:-freetype2-config} --cflags) 2>/dev/null`],
                       [`(${FREETYPE_CONFIG:-freetype-config} --libs || ${FREETYPE2_CONFIG:-freetype2-config} --libs) 2>/dev/null`],
        [AC_CHECK_HEADERS([ft2build.h])
        if test "$ac_cv_header_ft2build_h" = "yes"
            WINE_CHECK_SONAME(freetype,FT_Init_FreeType,
                [AC_DEFINE(HAVE_FREETYPE, 1, [Define if FreeType 2 is installed])
                 AC_CHECK_TYPES(FT_TrueTypeEngineType,,,[#include <ft2build.h>
#include FT_MODULE_H])],
                [FREETYPE_LIBS=""],[$FREETYPE_LIBS])
WINE_ERROR_WITH(freetype,[test "x$ac_cv_lib_soname_freetype" = x],
                [FreeType ${notice_platform}development files not found. Fonts will not be built.],
                [enable_fonts])
dnl **** Check for pthread functions ****
        pthread_getthreadid_np,
dnl **** Check for gettextpo ****
if test "x$enable_tools" != xno -a "x$with_gettextpo" = xyes
then
    if test "$ac_cv_header_gettext_po_h" = "yes"
    then
        AC_CHECK_LIB(gettextpo,po_message_msgctxt,
                     [AC_DEFINE(HAVE_LIBGETTEXTPO,1,[Define to 1 if you have the `gettextpo' library (-lgettextpo).])
    WINE_NOTICE_WITH(gettextpo,[test "x$GETTEXTPO_LIBS" = "x"],
      [GetText ${notice_platform}development files not found (or too old), po files can't be rebuilt.])
    WINE_NOTICE_WITH(gettextpo,[test "$srcdir" != .],
      [Rebuilding po files is not supported for out of tree builds.])
dnl **** Check for PulseAudio ****
if test "x$with_pulse" != "xno";
then
    WINE_PACKAGE_FLAGS(PULSE,[libpulse],,,,
        [AC_CHECK_HEADERS(pulse/pulseaudio.h,
            [AC_CHECK_LIB(pulse, pa_stream_is_corked,[:],[PULSE_LIBS=""],[$PULSE_LIBS])],
            [PULSE_LIBS=""])])
WINE_NOTICE_WITH(pulse, [test -z "$PULSE_LIBS"],
        [libpulse ${notice_platform}development files not found or too old, Pulse won't be supported.],
        [enable_winepulse_drv])
dnl **** Check for gstreamer ****
if test "x$with_gstreamer" != "xno"
then
    WINE_PACKAGE_FLAGS(GSTREAMER,[gstreamer-1.0 gstreamer-video-1.0 gstreamer-audio-1.0],,,,
            [AC_MSG_CHECKING([whether gint64 defined by gst/gst.h is indeed 64-bit])
              AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <gst/gst.h>]],
                                                 [[static int a[sizeof(gint64) > 4 ? 1 : -1]; if (a[0]) return 0;]])],
                [AC_MSG_RESULT([yes])
                 AC_CHECK_LIB(gstreamer-1.0,gst_pad_new,[:],,[$GSTREAMER_LIBS])],
                [AC_MSG_RESULT([no])
                 ac_glib2_broken=yes
                 WINE_NOTICE([glib-2.0 pkgconfig configuration is for the wrong architecture, winegstreamer won't be built.])])])])
if test "x$with_gstreamer" = xyes -o "x$with_quicktime" = xno -o "x$ac_cv_header_QuickTime_ImageCompression_h" != xyes
then
    WINE_NOTICE_WITH(gstreamer,[test "x$ac_glib2_broken" != xyes -a "x$ac_cv_lib_gstreamer_1_0_gst_pad_new" != xyes],
                     [gstreamer-1.0 base plugins ${notice_platform}development files not found, GStreamer won't be supported.])
fi
test "x$ac_cv_lib_gstreamer_1_0_gst_pad_new" = xyes || enable_winegstreamer=${enable_winegstreamer:-no}
dnl **** Check for ALSA 1.x ****
if test "x$with_alsa" != "xno"
    AC_CHECK_LIB(asound,snd_pcm_hw_params_get_access_mask,
        [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <alsa/asoundlib.h>]], [[snd_pcm_hw_params_get_access_mask(NULL, NULL)]])],
test -n "$ALSA_LIBS" || enable_winealsa_drv=${enable_winealsa_drv:-no}
dnl **** Check for OSSv4 ****
if test "x$with_oss" != xno
    ac_save_CPPFLAGS="$CPPFLAGS"
    if test -f /etc/oss.conf
    then
        . /etc/oss.conf
    fi
    ac_oss_incl="-I${OSSLIBDIR:-/usr/lib/oss}/include"
    CPPFLAGS="$CPPFLAGS $ac_oss_incl"
    AC_CHECK_HEADER([sys/soundcard.h],
        [AC_CHECK_MEMBERS([oss_sysinfo.numaudioengines],
            [AC_SUBST(OSS4_CFLAGS,"$ac_oss_incl")
             AC_CHECK_LIB(ossaudio,_oss_ioctl,
                 [AC_SUBST(OSS4_LIBS,"-lossaudio")])],,
            [#include <sys/soundcard.h>])])
    CPPFLAGS="$ac_save_CPPFLAGS"
WINE_NOTICE_WITH(oss,[test "x$ac_cv_member_oss_sysinfo_numaudioengines" != xyes],
                 [OSS sound system found but too old (OSSv4 needed), OSS won't be supported.],
                 [enable_wineoss_drv])
dnl **** Check for libudev ****
if test "x$with_udev" != "xno"
then
    WINE_PACKAGE_FLAGS(UDEV,[libudev],[-ludev],,,
        [AC_CHECK_HEADERS(libudev.h,
            [AC_CHECK_LIB(udev,udev_new,
                AC_DEFINE(HAVE_UDEV,1,[Define to 1 if you have the `udev' library (-ludev).]),
                [UDEV_LIBS=""],[$UDEV_LIBS])],
            [UDEV_LIBS=""])])
fi
WINE_NOTICE_WITH(udev,[test "x$UDEV_LIBS" = "x"],
                 [libudev ${notice_platform}development files not found, plug and play won't be supported.])

dnl **** Check for libunwind ****
if test "x$with_unwind" != xno
then
    WINE_PACKAGE_FLAGS(UNWIND,[libunwind],[-lunwind],,,
       [AC_CACHE_CHECK([for unw_step],wine_cv_have_unw_step,
           [AC_LINK_IFELSE([AC_LANG_PROGRAM([[#define UNW_LOCAL_ONLY
#include <libunwind.h>]],
                [[unw_cursor_t cursor; unw_step( &cursor );]])],
                [wine_cv_have_unw_step="yes"],[wine_cv_have_unw_step="no"])])
        if test "$wine_cv_have_unw_step" = no -a -n "$UNWIND_LIBS"
            dnl Force static libgcc, libunwind breaks libgcc_s unwinding
            UNWIND_LIBS="-static-libgcc $UNWIND_LIBS"
            AC_CACHE_CHECK([for unw_step in libunwind],wine_cv_have_libunwind_unw_step,
               [AC_LINK_IFELSE([AC_LANG_PROGRAM([[#define UNW_LOCAL_ONLY
#include <libunwind.h>]],
                    [[unw_cursor_t cursor; unw_step( &cursor );]])],
                    [wine_cv_have_libunwind_unw_step="yes"],
                    [wine_cv_have_libunwind_unw_step="no"])])
        test "$wine_cv_have_libunwind_unw_step" = yes || UNWIND_LIBS=""
        if test "x$wine_cv_have_unw_step$wine_cv_have_libunwind_unw_step" != xnono
        then
            AC_DEFINE(HAVE_LIBUNWIND,1,[Define to 1 if you have the `unwind' library (-lunwind).])
        fi])
fi
case $host in
  aarch64*|*-darwin*)
    WINE_NOTICE_WITH(unwind,[test "x$wine_cv_have_unw_step$wine_cv_have_libunwind_unw_step" = xnono],
                     [libunwind ${notice_platform}development files not found, stack unwinding won't work.]) ;;
esac

dnl **** Check for libSDL2 ****
if test "x$with_sdl" != "xno"
then
    WINE_PACKAGE_FLAGS(SDL2,[sdl2],[-lSDL2],,,
        [AC_CHECK_HEADERS([SDL.h],
            [WINE_CHECK_SONAME(SDL2,SDL_Init,,,[$SDL2_LIBS],[[libSDL2-2.0*]])])])
WINE_NOTICE_WITH(sdl,[test "x$ac_cv_lib_soname_SDL2" = "x"],
                 [libSDL2 ${notice_platform}development files not found, SDL2 won't be supported.])

dnl **** Check for FAudio ****
if test "x$with_faudio" != "xno"
then
    WINE_PACKAGE_FLAGS(FAUDIO,[FAudio],[-lFAudio],,,
        [AC_CHECK_HEADERS([FAudio.h],
            [WINE_CHECK_SONAME(FAudio,FAudioCreate,,,[$FAUDIO_LIBS],[[libFAudio*]])])
             WINE_CHECK_LIB_FUNCS([FAudio_CommitOperationSet \
                                   FAudioLinkedVersion \
                                   FAudioCreateReverb9WithCustomAllocatorEXT], [$FAUDIO_LIBS])
fi
WINE_NOTICE_WITH(faudio,[test "x$ac_cv_lib_soname_FAudio" = "x"],
                 [libFAudio ${notice_platform}development files not found, XAudio2 won't be supported.])

dnl **** Check for capi4linux ****
if test "x$with_capi" != "xno"
    WINE_PACKAGE_FLAGS(CAPI20,[capi20],,,,
     dnl Check for broken kernel header that doesn't define __user
    [AC_CHECK_HEADERS([capi20.h linux/capi.h],,,[#define __user])
    if test "$ac_cv_header_capi20_h" = "yes" -a "$ac_cv_header_linux_capi_h" = "yes"
    then
        WINE_CHECK_SONAME(capi20,capi20_register,,,[$CAPI20_LIBS])
    fi])
WINE_NOTICE_WITH(capi,[test "x$ac_cv_lib_soname_capi20" = "x"],
                 [libcapi20 ${notice_platform}development files not found, ISDN won't be supported.])
if test "x$with_cups" != "xno"
    WINE_PACKAGE_FLAGS(CUPS,[cups],[-lcups],
                       [`${CUPS_CONFIG:-cups-config} --cflags 2>/dev/null`],
                       [`${CUPS_CONFIG:-cups-config} --libs 2>/dev/null`],
                       [AC_CHECK_HEADERS(cups/cups.h cups/ppd.h)
                        if test "$ac_cv_header_cups_cups_h" = "yes"
                        then
                            WINE_CHECK_SONAME(cups,cupsGetDefault,,[CUPS_LIBS=""],[$CUPS_LIBS])
                        else
                            CUPS_CFLAGS=""
                            CUPS_LIBS=""
                        fi])
WINE_NOTICE_WITH(cups,[test "x$ac_cv_lib_soname_cups" = "x"],
                 [libcups ${notice_platform}development files not found, CUPS won't be supported.])
if test "x$with_fontconfig" != "xno"
    WINE_PACKAGE_FLAGS(FONTCONFIG,[fontconfig],,[$X_CFLAGS],[$X_LIBS],
        [AC_CHECK_HEADERS([fontconfig/fontconfig.h])
        if test "$ac_cv_header_fontconfig_fontconfig_h" = "yes"
        then
            WINE_CHECK_SONAME(fontconfig,FcInit,,[FONTCONFIG_CFLAGS=""],[$FONTCONFIG_LIBS])
        else
            FONTCONFIG_CFLAGS=""
        fi])
WINE_NOTICE_WITH(fontconfig,[test "x$ac_cv_lib_soname_fontconfig" = "x"],
                 [fontconfig ${notice_platform}development files not found, fontconfig won't be supported.])
dnl **** Check for gsm codec ****
if test "$ac_cv_header_gsm_h" = "yes" -o "$ac_cv_header_gsm_gsm_h" = "yes"
then
    WINE_CHECK_SONAME(gsm,gsm_create)
fi
WINE_NOTICE_WITH(gsm,[test "x$ac_cv_lib_soname_gsm" = "x"],
                 [libgsm ${notice_platform}development files not found, gsm 06.10 codec won't be supported.])

dnl **** Check for krb5 ****
if test "x$with_krb5" != "xno"
then
    WINE_PACKAGE_FLAGS(KRB5,[krb5],,
                       [`${KRB5_CONFIG:-krb5-config} --cflags 2>/dev/null`],
                       [`${KRB5_CONFIG:-krb5-config} --libs 2>/dev/null`],
        [AC_CHECK_HEADERS([krb5/krb5.h])
         if test "$ac_cv_header_krb5_krb5_h" = "yes"
         then
             WINE_CHECK_SONAME(krb5,krb5_is_config_principal,,[KRB5_CFLAGS=""],[$KRB5_LIBS])
         else
             KRB5_CFLAGS=""
         fi])
fi
WINE_NOTICE_WITH(krb5,[test "x$ac_cv_lib_soname_krb5" = "x"],
                 [libkrb5 ${notice_platform}development files not found (or too old), Kerberos won't be supported.])
test "x$ac_cv_lib_soname_krb5" != "x" || with_gssapi=${with_gssapi:-no}
dnl **** Check for gssapi ****
if test "x$with_gssapi" != "xno"
then
    WINE_PACKAGE_FLAGS(GSSAPI,[krb5-gssapi],,
                       [`${KRB5_CONFIG:-krb5-config} --cflags gssapi 2>/dev/null`],
                       [`${KRB5_CONFIG:-krb5-config} --libs gssapi 2>/dev/null`],
        [AC_CHECK_HEADERS([gssapi/gssapi.h gssapi/gssapi_ext.h])
        if test "$ac_cv_header_gssapi_gssapi_h" = "yes" -a "$ac_cv_header_gssapi_gssapi_ext_h" = "yes"
        then
            WINE_CHECK_SONAME(gssapi_krb5, gss_init_sec_context,,[GSSAPI_CFLAGS=""],[$GSSAPI_LIBS])
        else
            GSSAPI_CFLAGS=""
        fi])
fi
WINE_NOTICE_WITH(gssapi,[test "x$ac_cv_lib_soname_gssapi_krb5" = "x"],
                 [libgssapi_krb5 ${notice_platform}development files not found (or too old), no Kerberos SSP support.])

if test "x$with_jpeg" != "xno"
    WINE_PACKAGE_FLAGS(JPEG,[libjpeg],,,,
        [AC_CHECK_HEADERS([jpeglib.h])
        if test "$ac_cv_header_jpeglib_h" = "yes"
        then
            WINE_CHECK_SONAME(jpeg,jpeg_start_decompress,,[JPEG_CFLAGS=""],[$JPEG_LIBS])
        else
            JPEG_CFLAGS=""
        fi])
WINE_WARNING_WITH(jpeg,[test "x$ac_cv_lib_soname_jpeg" = "x"],
                 [libjpeg ${notice_platform}development files not found, JPEG won't be supported.])
dnl **** Check for libjxrglue ****
if test "x$with_jxrlib" != "xno"
then
    WINE_PACKAGE_FLAGS(JXRLIB,[jxrlib],,[${JXRLIB_CFLAGS:--I/usr/include/jxrlib}],,
        [AC_CHECK_HEADERS([JXRGlue.h],,,[#define FAR])
        if test "$ac_cv_header_JXRGlue_h" = "yes"
        then
            WINE_CHECK_SONAME(jxrglue,PKImageDecode_Create_WMP,,[JXRLIB_CFLAGS=""],[$JXRLIB_LIBS])
        else
            JXRLIB_CFLAGS=""
        fi])
fi
WINE_NOTICE_WITH(jxrlib,[test "x$ac_cv_lib_soname_jxrglue" = "x"],
                 [jxrlib ${notice_platform}development files not found, JPEG-XR won't be supported.])

dnl **** Check for libpng ****
if test "x$with_png" != "xno"
    WINE_PACKAGE_FLAGS(PNG,[libpng],,[$X_CFLAGS],[$X_LIBS],
        [AC_CHECK_HEADERS([png.h])
        if test "$ac_cv_header_png_h" = "yes"
        then
            WINE_CHECK_SONAME(png,png_create_read_struct,,
                [PNG_CFLAGS=""],[$PNG_LIBS -lm -lz],[[libpng[[0-9]]*]])
        else
            PNG_CFLAGS=""
        fi])
WINE_WARNING_WITH(png,[test "x$ac_cv_lib_soname_png" = "x"],
                 [libpng ${notice_platform}development files not found, PNG won't be supported.])
dnl **** Check for libtiff ****
if test "x$with_tiff" != "xno"
    WINE_PACKAGE_FLAGS(TIFF,[libtiff-4],,,,
        [AC_CHECK_HEADERS([tiffio.h])
        if test "$ac_cv_header_tiffio_h" = "yes"
        then
            WINE_CHECK_SONAME(tiff,TIFFClientOpen,,,[$TIFF_LIBS])
        fi])
fi
WINE_NOTICE_WITH(tiff,[test "x$ac_cv_lib_soname_tiff" = "x"],
                 [libtiff ${notice_platform}development files not found, TIFF won't be supported.])

dnl **** Check for mpg123 ****
if test "x$with_mpg123" != "xno"
    WINE_PACKAGE_FLAGS(MPG123,[libmpg123],[-lmpg123],,,
        [AC_CHECK_HEADERS([mpg123.h])
        if test "$ac_cv_header_mpg123_h" = "yes"
        then
            AC_CHECK_LIB(mpg123,mpg123_feed,[:],[MPG123_LIBS=""],[$MPG123_LIBS])
        else
            MPG123_CFLAGS=""
            MPG123_LIBS=""
        fi])
WINE_NOTICE_WITH(mpg123,[test "x$ac_cv_lib_mpg123_mpg123_feed" != xyes -a x"$ac_cv_header_CoreAudio_CoreAudio_h" != xyes],
                 [libmpg123 ${notice_platform}development files not found (or too old), mp3 codec won't be supported.],
                 [enable_l3codeca_acm])
test "x$ac_cv_lib_mpg123_mpg123_feed" = xyes || enable_mp3dmod=${enable_mp3dmod:-no}
dnl **** Check for OpenAL 1.1 ****
if test "$ac_cv_header_AL_al_h" = "yes"
then
    WINE_CHECK_SONAME(openal,alGetSource3i,[AC_SUBST(OPENAL_LIBS,"-lopenal")
                      ac_cv_lib_openal=yes
                      AC_DEFINE_UNQUOTED(HAVE_OPENAL,1,[Define to 1 if OpenAL is available])],,)
WINE_NOTICE_WITH(openal,[test "x$ac_cv_lib_openal" != xyes],
                 [libopenal ${notice_platform}development files not found (or too old), OpenAL won't be supported.],
if test "x$ac_cv_lib_soname_FAudio" = "x"
    enable_x3daudio1_0=${enable_x3daudio1_0:-no}
    enable_x3daudio1_1=${enable_x3daudio1_1:-no}
    enable_x3daudio1_2=${enable_x3daudio1_2:-no}
    enable_x3daudio1_3=${enable_x3daudio1_3:-no}
    enable_x3daudio1_4=${enable_x3daudio1_4:-no}
    enable_x3daudio1_5=${enable_x3daudio1_5:-no}
    enable_x3daudio1_6=${enable_x3daudio1_6:-no}
    enable_x3daudio1_7=${enable_x3daudio1_7:-no}
    enable_xactengine2_0=${enable_xactengine2_0:-no}
    enable_xactengine2_4=${enable_xactengine2_4:-no}
    enable_xactengine2_7=${enable_xactengine2_7:-no}
    enable_xactengine2_9=${enable_xactengine2_9:-no}
    enable_xactengine3_0=${enable_xactengine3_0:-no}
    enable_xactengine3_1=${enable_xactengine3_1:-no}
    enable_xactengine3_2=${enable_xactengine3_2:-no}
    enable_xactengine3_3=${enable_xactengine3_3:-no}
    enable_xactengine3_4=${enable_xactengine3_4:-no}
    enable_xactengine3_5=${enable_xactengine3_5:-no}
    enable_xactengine3_6=${enable_xactengine3_6:-no}
    enable_xactengine3_7=${enable_xactengine3_7:-no}
    enable_xapofx1_1=${enable_xapofx1_1:-no}
    enable_xapofx1_2=${enable_xapofx1_2:-no}
    enable_xapofx1_3=${enable_xapofx1_3:-no}
    enable_xapofx1_4=${enable_xapofx1_4:-no}
    enable_xapofx1_5=${enable_xapofx1_5:-no}
    enable_xaudio2_0=${enable_xaudio2_0:-no}
    enable_xaudio2_1=${enable_xaudio2_1:-no}
    enable_xaudio2_2=${enable_xaudio2_2:-no}
    enable_xaudio2_3=${enable_xaudio2_3:-no}
    enable_xaudio2_4=${enable_xaudio2_4:-no}
    enable_xaudio2_5=${enable_xaudio2_5:-no}
    enable_xaudio2_6=${enable_xaudio2_6:-no}
    enable_xaudio2_7=${enable_xaudio2_7:-no}
    enable_xaudio2_8=${enable_xaudio2_8:-no}
Andrew Eikum's avatar
Andrew Eikum committed
    enable_xaudio2_9=${enable_xaudio2_9:-no}
dnl **** Check for libkstat ****
if test "$ac_cv_header_kstat_h" = "yes"
then
    AC_CHECK_LIB(kstat,kstat_open,
                 [AC_DEFINE(HAVE_LIBKSTAT, 1, [Define to 1 if you have the `kstat' library (-lkstat).])
dnl **** Check for libprocstat ****
if test "$ac_cv_header_libprocstat_h" = "yes"
then
    AC_CHECK_LIB(procstat,procstat_open_sysctl,
                 [AC_DEFINE(HAVE_LIBPROCSTAT, 1, [Define to 1 if you have the `procstat' library (-lprocstat).])
dnl **** Check for libodbc ****
WINE_CHECK_SONAME(odbc,SQLConnect,,[AC_DEFINE_UNQUOTED(SONAME_LIBODBC,["libodbc.$LIBEXT"])])

dnl **** Check for libnetapi ****
if test "x$with_netapi" != "xno"
then
    WINE_PACKAGE_FLAGS(NETAPI,[netapi],,,,
      [WINE_CHECK_SONAME(netapi,libnetapi_init,,[AC_DEFINE_UNQUOTED(SONAME_LIBNETAPI,["libnetapi.$LIBEXT"])],[$NETAPI_LIBS])])
if test "x$enable_winealsa_drv$enable_winecoreaudio_drv$enable_winepulse_drv$enable_wineoss_drv$enable_wineandroid_drv" = xnonononono -a \
        "x$with_alsa$with_coreaudio$with_oss$with_pulse" != xnononono
then
    WINE_WARNING([No sound system was found. Windows applications will be silent.])
fi
dnl *** Check for Vulkan ***
if test "x$with_vulkan" != "xno"
then
    WINE_CHECK_SONAME(vulkan, vkGetInstanceProcAddr)
    if test "x$ac_cv_lib_soname_vulkan" = "x"
    then
        WINE_CHECK_SONAME(MoltenVK, vkGetInstanceProcAddr)
    fi
WINE_NOTICE_WITH(vulkan,[test "x$ac_cv_lib_soname_vulkan" = "x" -a "x$ac_cv_lib_soname_MoltenVK" = "x"],
                 [libvulkan and libMoltenVK ${notice_platform}development files not found, Vulkan won't be supported.])
dnl **** Check for vkd3d ****
if test "x$with_vkd3d" != "xno"
then
    WINE_PACKAGE_FLAGS(VKD3D,[libvkd3d],,,,
        [WINE_CHECK_SONAME(vkd3d,vkd3d_serialize_versioned_root_signature,,,[$VKD3D_LIBS])])
    WINE_PACKAGE_FLAGS(VKD3D_SHADER,[libvkd3d-shader],,,,
        [WINE_CHECK_SONAME(vkd3d-shader,vkd3d_shader_compile,,,[$VKD3D_SHADER_LIBS])])
fi
WINE_NOTICE_WITH(vkd3d,[test "x$ac_cv_lib_soname_vkd3d" = "x"],
                 [vkd3d ${notice_platform}development files not found (or too old), Direct3D 12 won't be supported.])
test "x$ac_cv_lib_soname_vkd3d" != "x" || enable_d3d12=${enable_d3d12:-no}

dnl **** Check for gcc specific options ****
Alexandre Julliard's avatar
Alexandre Julliard committed
if test "x${GCC}" = "xyes"
then
  EXTRACFLAGS="-Wall -pipe"
  dnl Check for some compiler flags
  dnl clang needs to be told to fail on unknown options
  saved_CFLAGS=$CFLAGS
  WINE_TRY_CFLAGS([-Werror=unknown-warning-option],[CFLAGS="$CFLAGS -Werror=unknown-warning-option"])
  WINE_TRY_CFLAGS([-Werror=unused-command-line-argument],[CFLAGS="$CFLAGS -Werror=unused-command-line-argument"])
  WINE_TRY_CFLAGS([-Werror=ignored-optimization-argument],[CFLAGS="$CFLAGS -Werror=ignored-optimization-argument"])
  WINE_TRY_CFLAGS([-fcf-protection=none])
  WINE_TRY_CFLAGS([-fno-stack-protector])
  WINE_TRY_CFLAGS([-fno-strict-aliasing])
  WINE_TRY_CFLAGS([-Wdeclaration-after-statement])
  WINE_TRY_CFLAGS([-Wempty-body])
  WINE_TRY_CFLAGS([-Wignored-qualifiers])
  WINE_TRY_CFLAGS([-Winit-self])
  WINE_TRY_CFLAGS([-Wpacked-not-aligned],[EXTRACFLAGS="$EXTRACFLAGS -Wno-packed-not-aligned"])
  WINE_TRY_CFLAGS([-Wpragma-pack],[EXTRACFLAGS="$EXTRACFLAGS -Wno-pragma-pack"])
  WINE_TRY_CFLAGS([-Wshift-overflow=2])
  WINE_TRY_CFLAGS([-Wstrict-prototypes])
  WINE_TRY_CFLAGS([-Wtype-limits])
  WINE_TRY_CFLAGS([-Wunused-but-set-parameter])
  WINE_TRY_CFLAGS([-Wvla])
  WINE_TRY_CFLAGS([-Wwrite-strings])
  if test -z "$CROSSTARGET"
  then
    WINE_TRY_CFLAGS([-fexcess-precision=standard],[AC_SUBST(EXCESS_PRECISION_CFLAGS,"-fexcess-precision=standard")])
  fi

  dnl Check for noisy string.h
  WINE_TRY_CFLAGS([-Wpointer-arith],
     [saved_string_h_CFLAGS=$CFLAGS
      CFLAGS="$CFLAGS -Wpointer-arith -Werror"
      AC_CACHE_CHECK([for broken string.h that generates warnings with -Wpointer-arith], ac_cv_c_string_h_warnings,
          AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <string.h>]])],[ac_cv_c_string_h_warnings=no],[ac_cv_c_string_h_warnings=yes]))
      test "$ac_cv_c_string_h_warnings" = yes || EXTRACFLAGS="$EXTRACFLAGS -Wpointer-arith"
      CFLAGS=$saved_string_h_CFLAGS])

  dnl Check for noisy string.h on logical ops
  WINE_TRY_CFLAGS([-Wlogical-op],
     [saved_string_h_CFLAGS=$CFLAGS
      CFLAGS="$CFLAGS -Wlogical-op -Werror"
      AC_CACHE_CHECK([for broken string.h that generates warnings with -Wlogical-op], ac_cv_c_logicalop_noisy,
          AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <string.h>
char*f(const char *h,char n) {return strchr(h,n);}]])],[ac_cv_c_logicalop_noisy=no],[ac_cv_c_logicalop_noisy=yes]))
      CFLAGS=$saved_string_h_CFLAGS
      test "$ac_cv_c_logicalop_noisy" = yes || EXTRACFLAGS="$EXTRACFLAGS -Wlogical-op"])

  dnl Check for 64-bit compare-and-swap
  AC_CACHE_CHECK([for flags needed for 64-bit compare-and-swap support], wine_cv_64bit_compare_swap,
      [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#ifndef __GCC_HAVE_SYNC_COMPARE_AND_SWAP_8
#error no
#endif]])],
          [wine_cv_64bit_compare_swap="none needed"],
          [case $host_cpu in
            *i[[3456]]86*) wine_cv_64bit_compare_swap="-march=i586" ;;
            *arm*)         wine_cv_64bit_compare_swap="-march=armv7-a" ;;
            *)             wine_cv_64bit_compare_swap="unknown" ;;
           esac
           if test "x$wine_cv_64bit_compare_swap" != xunknown
           then
               dnl try with the new flags
               CFLAGS="$CFLAGS $wine_cv_64bit_compare_swap"
               AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#ifndef __GCC_HAVE_SYNC_COMPARE_AND_SWAP_8
#error no
#endif]])],,[wine_cv_64bit_compare_swap="unknown"])
               CFLAGS=$saved_CFLAGS
           fi])])
  case "$wine_cv_64bit_compare_swap" in
      unknown) AC_MSG_ERROR([gcc doesn't support 64-bit compare-and-swap on this platform]) ;;
      "none needed") ;;
      *) EXTRACFLAGS="$EXTRACFLAGS $wine_cv_64bit_compare_swap" ;;
  esac

  dnl Default to dwarf-2 debug info
  for ac_flag in $CFLAGS; do
    case $ac_flag in
      -g) WINE_TRY_CFLAGS([-gdwarf-2])
          WINE_TRY_CFLAGS([-gstrict-dwarf]) ;;
  dnl Disable gcc builtins except for Mingw
    mingw32*)  dnl Check for delayload linker support
       WINE_TRY_CFLAGS([-Wl,-delayload,autoconftest.dll],[AC_SUBST(DELAYLOADFLAG,["-Wl,-delayload,"])]) ;;
    *) WINE_TRY_CFLAGS([-fno-builtin],[MSVCRTFLAGS="$MSVCRTFLAGS -fno-builtin"])
       WINE_TRY_CFLAGS([-fshort-wchar],[MSVCRTFLAGS="$MSVCRTFLAGS -fshort-wchar"]) ;;
    dnl gcc-4.6+ omits frame pointers by default, breaking some copy protections
    *i[[3456789]]86*) WINE_TRY_CFLAGS([-fno-omit-frame-pointer]) ;;
    *x86_64*)
      case $host_os in
        dnl Mingw uses Windows 64-bit types, not Unix ones
        cygwin*|mingw32*) WINE_TRY_CFLAGS([-Wno-format]) ;;
        dnl Default to ms_abi on 64-bit
        *) WINE_TRY_CFLAGS([-mabi=ms],[MSVCRTFLAGS="$MSVCRTFLAGS -mabi=ms"]) ;;
      esac ;;
  dnl Enable -Werror
  if test "x$enable_werror" = "xyes"
  then
      WINE_TRY_CFLAGS([-Werror])
  fi
  if test "x$enable_build_id" = "xyes"
  then
      WINE_TRY_CFLAGS([-Wl,--build-id], [CFLAGS="$CFLAGS -Wl,--build-id"
                      LDFLAGS="$LDFLAGS -Wl,--build-id"])
  fi
dnl **** Disable Fortify, it has too many false positives

AC_CACHE_CHECK([for the need to disable Fortify], ac_cv_c_fortify_enabled,
    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <string.h>]],
[[#if (defined(__USE_FORTIFY_LEVEL) && __USE_FORTIFY_LEVEL > 0) || (defined(_FORTIFY_SOURCE) && _FORTIFY_SOURCE > 0)
#error Fortify enabled
#endif]])],
        [ac_cv_c_fortify_enabled=no],[ac_cv_c_fortify_enabled=yes]))
if test "$ac_cv_c_fortify_enabled" = yes
then
    CFLAGS="$CFLAGS -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=0"
dnl **** Check for CFI directives support ****
AC_CACHE_CHECK([whether CFI directives are supported in assembly code], ac_cv_c_cfi_support,
    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[asm(".text\nac_test:\t.cfi_startproc\n\t.long 0\n\t.cfi_endproc");]])],
                      ac_cv_c_cfi_support="yes",ac_cv_c_cfi_support="no"))
if test "$ac_cv_c_cfi_support" = "yes"
then
   DLLFLAGS="$DLLFLAGS -fasynchronous-unwind-tables"
   LDDLLFLAGS="$LDDLLFLAGS -fasynchronous-unwind-tables"
   if test "x$enable_win64" = "xyes"
   then
      WINE_WARNING([building 64-bit Wine without support for CFI directives; exception handling will not work properly.])
   fi
case $host_os in
  linux*)
    case $host_cpu in
      *i[[3456789]]86*|x86_64*|*aarch64*)
        test "$wine_binary" = wine || WINE_IGNORE_FILE("loader/wine-preloader")
        WINELOADER_PROGRAMS="$WINELOADER_PROGRAMS $wine_binary-preloader"
        ;;
dnl **** Check for functions ****

ac_save_CFLAGS="$CFLAGS"
CFLAGS="$CFLAGS $BUILTINFLAG"
        __res_get_state \
        __res_getservers \
	fstatfs \
Loading
Loading full blame...