Skip to content
Snippets Groups Projects
configure.ac 114 KiB
Newer Older
  • Learn to ignore specific revisions
  • Alexandre Julliard's avatar
    Alexandre Julliard committed
    dnl Process this file with autoconf to produce a configure script.
    
    dnl Original author: Michael Patra
    dnl See ChangeLog file for detailed change history.
    
    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],[http://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], ["http://www.winehq.org"], [Define to the home page for this package.])
       AC_SUBST([PACKAGE_URL], ["http://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(maintainer-mode, AS_HELP_STRING([--enable-maintainer-mode],[enable maintainer-specific build rules]))
    
    AC_ARG_WITH(alsa,      AS_HELP_STRING([--without-alsa],[do not use the Alsa sound support]),
                [if test "x$withval" = "xno"; then ac_cv_header_sys_asoundlib_h=no; ac_cv_header_alsa_asoundlib_h=no; fi])
    AC_ARG_WITH(capi,      AS_HELP_STRING([--without-capi],[do not use CAPI (ISDN support)]),
                [if test "x$withval" = "xno"; then ac_cv_header_capi20_h=no; ac_cv_header_linux_capi_h=no; fi])
    AC_ARG_WITH(cms,       AS_HELP_STRING([--without-cms],[do not use CMS (color management support)]),
                [if test "x$withval" = "xno"; then ac_cv_header_lcms_h=no; ac_cv_header_lcms_lcms_h=no; fi])
    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(curses,    AS_HELP_STRING([--without-curses],[do not use (n)curses]),
                [if test "x$withval" = "xno"; then ac_cv_header_ncurses_h=no; ac_cv_header_curses_h=no; fi])
    
    AC_ARG_WITH(dbus,      AS_HELP_STRING([--without-dbus],[do not use DBus (dynamic device support)]))
    
    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(glu,       AS_HELP_STRING([--without-glu],[do not use the GLU library]),
                [if test "x$withval" = "xno"; then ac_cv_header_GL_glu_h=no; fi])
    
    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(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(jpeg,      AS_HELP_STRING([--without-jpeg],[do not use JPEG]),
                [if test "x$withval" = "xno"; then ac_cv_header_jpeglib_h=no; fi])
    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(mpg123,    AS_HELP_STRING([--without-mpg123],[do not use the mpg123 library]),
                [if test "x$withval" = "xno"; then ac_cv_header_mpg123_h=no; fi])
    
    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(openssl,   AS_HELP_STRING([--without-openssl],[do not use OpenSSL]),
                [if test "x$withval" = "xno"; then ac_cv_header_openssl_err_h=no; ac_cv_header_openssl_ssl_h=no; fi])
    
    AC_ARG_WITH(oss,       AS_HELP_STRING([--without-oss],[do not use the OSS sound support]))
    
    AC_ARG_WITH(png,       AS_HELP_STRING([--without-png],[do not use PNG]),
                [if test "x$withval" = "xno"; then ac_cv_header_png_h=no; fi])
    
    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(sane,      AS_HELP_STRING([--without-sane],[do not use SANE (scanner support)]))
    
    AC_ARG_WITH(tiff,       AS_HELP_STRING([--without-tiff],[do not use TIFF]),
                [if test "x$withval" = "xno"; then ac_cv_header_tiffio_h=no; fi])
    
    AC_ARG_WITH(v4l,       AS_HELP_STRING([--without-v4l],[do not use v4l1 (v4l support)]))
    
    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(xinerama,  AS_HELP_STRING([--without-xinerama],[do not use Xinerama (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 (resolution changes)]),
                [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(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(zlib,      AS_HELP_STRING([--without-zlib],[do not use Zlib (data compression)]),
                [if test "x$withval" = "xno"; then ac_cv_header_zlib_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 out of tree build with unclean source tree
    case "$srcdir" in
     .) ;;
     *) if test -f "$srcdir/Makefile" -o -f "$srcdir/include/config.h"; then
          AC_MSG_ERROR([you are building out of the source tree, but the source tree contains object files.
    You need to run 'make distclean' in the source tree first.])
        fi ;;
    esac
    
    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.])
    
        then
          CC="$CC -m64"
          CXX="$CXX -m64"
          host_cpu="x86_64"
          notice_platform="64-bit "
          AC_SUBST(TARGETFLAGS,"-m64")
        else
          CC="$CC -m32"
          CXX="$CXX -m32"
          host_cpu="i386"
          notice_platform="32-bit "
          AC_SUBST(TARGETFLAGS,"-m32")
          enable_win16=${enable_win16:-yes}
        fi
    
        if test "x$enable_win64" != "xyes" -a "$cross_compiling" != "yes"
    
          CC="$CC -m32"
          CXX="$CXX -m32"
          AC_MSG_CHECKING([whether $CC works])
    
          AC_LINK_IFELSE([AC_LANG_PROGRAM()],AC_MSG_RESULT([yes]),
    
                         [AC_MSG_RESULT([no])
                          AC_MSG_ERROR([Cannot build a 32-bit program, you need to install 32-bit development libraries.])])
    
          host_cpu="i386"
    
          enable_win16=${enable_win16:-yes}
    
          if test "x${GCC}" = "xyes"
          then
            AC_MSG_CHECKING([whether $CC supports __builtin_ms_va_list])
            AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <stdarg.h>]], [[void func(__builtin_ms_va_list *args);]])],
                              [AC_MSG_RESULT([yes])],
                              [AC_MSG_RESULT([no])
                               AC_MSG_ERROR([You need gcc >= 4.4 to build Wine as 64-bit.])])
          fi
    
        AC_MSG_CHECKING([whether $CC supports Thumb])
        WINE_TRY_ASM_LINK([".thumb\nblx ac_test\n.arm"],[int ac_test(int i) { return i; }], [if (ac_test(1)) return 1],
    
                          [AC_MSG_RESULT([yes])],
                          [AC_MSG_RESULT([no])
    
                           AC_MSG_ERROR([You need a target with Thumb support to build Wine for ARM.])])
    
      *-mingw32*|*-cygwin*)
    
        enable_win16=${enable_win16:-no}
    
        CFLAGS="$CFLAGS -D_WIN32"
    
        ;;
      i[[3456789]]86*)
        enable_win16=${enable_win16:-yes}
        ;;
    
    dnl enable_win16 defaults to yes on x86, to no on other CPUs
    
    enable_win16=${enable_win16:-no}
    
    enable_win64=${enable_win64:-no}
    
    dnl Disable winetest too if tests are disabled
    enable_winetest=${enable_winetest:-$enable_tests}
    
    
    dnl Some special cases for the wow64 build
    if test -n "$with_wine64"
    then
        if test "x$enable_win64" = "xyes"
        then
            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
    
        enable_fonts=${enable_fonts:-no}
        enable_server=${enable_server:-no}
        enable_tools=${enable_tools:-no}
    
    elif test "x$enable_win64" = "xyes"
    then
        test "x$libdir" != "x\${exec_prefix}/lib" || libdir="\${exec_prefix}/lib64"
    
    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"
    
       fi
       if test -z "$wine_cv_toolsdir"; then
    
       elif test -d "$wine_cv_toolsdir/tools/winebuild"; then
         case "$wine_cv_toolsdir" in
           /*) ;;
    
           *)  wine_cv_toolsdir="\$(top_builddir)/$wine_cv_toolsdir" ;;
    
         AC_MSG_ERROR([could not find Wine tools in $wine_cv_toolsdir])
    
       fi])
    AC_SUBST(TOOLSDIR,$wine_cv_toolsdir)
    
    if test -n "$host_alias" -a "$host_alias" != "$build_alias"
    
    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_MSG_CHECKING([whether flex is recent enough])
    cat >conftest.l <<EOF
    %top{
    #include "prediluvian.h"
    }
    %%
    EOF
    
    if $FLEX -t conftest.l >/dev/null 2>&AS_MESSAGE_LOG_FD
    
    then
      AC_MSG_RESULT([yes])
    else
      AC_MSG_RESULT([no])
      AC_MSG_ERROR([Your flex version is too old. Please install flex version 2.5.33 or newer.])
    fi
    
    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_SUBST(ARFLAGS,rc)
    
    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_PROG_INSTALL
    dnl Prepend src dir to install path dir if it's a relative path
    case "$INSTALL" in
    
      [[\\/$]]* | ?:[[\\/]]* ) ;;
    
    Alexandre Julliard's avatar
    Alexandre Julliard committed
    
    
    dnl Check for lint
    AC_CHECK_PROGS(LINT, lclint lint)
    if test "$LINT" = "lint"
    then
      LINTFLAGS="$LINTFLAGS -errchk=%all,no%longptr64 -errhdr=%user -Ncheck=macro -Nlevel=4"
      dnl LINTFLAGS='-D_SIZE_T "-Dsize_t=unsigned long" -errchk=longptr64'
    fi
    AC_SUBST(LINTFLAGS)
    
    
    dnl Check for various programs
    AC_CHECK_PROGS(FONTFORGE, fontforge, false)
    
    AC_CHECK_PROGS(PKG_CONFIG, pkg-config, false)
    
    AC_CHECK_PROGS(RSVG, rsvg, false)
    
    AC_CHECK_PROGS(CONVERT, convert, false)
    
    AC_CHECK_PROGS(ICOTOOL, icotool, false)
    
    AC_CHECK_PROGS(MSGFMT, msgfmt, false)
    
    if test "x$enable_maintainer_mode" != "xyes"
    
      if test "$FONTFORGE" = "false"; then AC_MSG_ERROR([You need fontforge to rebuild fonts in maintainer mode.]); fi
      if test "$RSVG" = "false"; then AC_MSG_ERROR([You need rsvg to rebuild icons in maintainer mode.]); fi
    
    
      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
      AS_UNSET(ac_cv_header_gettext_po_h)
    
    test "x$with_gettext" != xno || MSGFMT=false
    
    if test "$MSGFMT" != "false"
    then
      AC_MSG_CHECKING([whether msgfmt supports 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
        AC_MSG_RESULT([yes])
      else
        AC_MSG_RESULT([no])
        MSGFMT=false
      fi
    fi
    
    WINE_WARNING_WITH(gettext,[test "$MSGFMT" = false],
    
                      [gettext tools not found (or too old), translations won't be built.])
    
    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
    
    Alexandre Julliard's avatar
    Alexandre Julliard committed
    AC_CHECK_LIB(i386,i386_set_ldt)
    
    dnl Check for -lossaudio for NetBSD
    AC_CHECK_LIB(ossaudio,_oss_ioctl)
    
    AC_SUBST(XLIB,"")
    AC_SUBST(OPENGL_LIBS,"")
    
    test "x$with_fontconfig" != "xno" || ac_cv_header_fontconfig_fontconfig_h=no
    
    
    	AL/al.h \
    
    	ApplicationServices/ApplicationServices.h \
    
    	AudioToolbox/AudioConverter.h \
    
    	AudioUnit/AudioUnit.h \
    
    	AudioUnit/AudioComponent.h \
    
    	CoreAudio/CoreAudio.h \
    
    	DiskArbitration/DiskArbitration.h \
    
    	IOKit/hid/IOHIDLib.h \
    
    	Security/Security.h \
    
    	asm/types.h \
    
    	fontconfig/fontconfig.h \
    	getopt.h \
    
    	link.h \
    	linux/cdrom.h \
    	linux/compiler.h \
    	linux/hdreg.h \
    	linux/input.h \
    	linux/ioctl.h \
    	linux/joystick.h \
    	linux/major.h \
    	linux/param.h \
    	linux/serial.h \
    
    	linux/types.h \
    
    	mach-o/loader.h \
    
    	mach/machine.h \
    
    	machine/limits.h \
    
    	machine/sysarch.h \
    
    	netdb.h \
    	netinet/in.h \
    	netinet/in_systm.h \
    	netinet/tcp.h \
    	netinet/tcp_fsm.h \
    
    	poll.h \
    
    	process.h \
    	pthread.h \
    	pwd.h \
    	sched.h \
    	scsi/scsi.h \
    	scsi/scsi_ioctl.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/vm86.h \
    	sys/wait.h \
    	syscall.h \
    	termios.h \
    
    	valgrind/memcheck.h \
    
    dnl **** Checks for headers that depend on other ones ****
    
    
    AC_CHECK_HEADERS([sys/mount.h sys/statfs.h sys/sysctl.h sys/user.h sys/vfs.h],,,
    
    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/types.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],,,
    
        [#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([mach-o/dyld_images.h],,,
        [#ifdef HAVE_STDBOOL_H
         # include <stdbool.h>
         #endif
         #ifdef HAVE_STDINT_H
         # include <stdint.h>
         #endif])
    
    
    AC_CHECK_HEADERS([resolv.h],,,
        [#include <sys/types.h>
    
    AC_CHECK_HEADERS([ifaddrs.h],,,[#include <sys/types.h>])
    
    
    AC_CHECK_HEADERS(ucontext.h,,,[#include <signal.h>])
    
    
    AC_CHECK_HEADERS([sys/thr.h],,,
    [#include <sys/types.h>
    
    AC_CHECK_HEADERS([pthread_np.h],,,
    [#ifdef HAVE_PTHREAD_H
    #include <pthread.h>
    #endif])
    
    
    AC_CHECK_HEADERS([linux/videodev.h 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])
    
    
    dnl Check for broken kernel header that doesn't define __user
    AC_CHECK_HEADERS([linux/capi.h],,,[#define __user])
    
    
    dnl **** Check for working dll ****
    
    AC_SUBST(DLLEXT,"")
    AC_SUBST(DLLFLAGS,"-D_REENTRANT")
    AC_SUBST(LDSHARED,"")
    AC_SUBST(LDDLLFLAGS,"")
    AC_SUBST(LIBEXT,"so")
    AC_SUBST(IMPLIBEXT,"def")
    AC_SUBST(LDRPATH_INSTALL,"")
    AC_SUBST(LDRPATH_LOCAL,"")
    
    WINE_PATH_LDD
    
    case $host_os in
      cygwin*|mingw32*)
        AC_CHECK_TOOL(DLLTOOL,dlltool,false)
        AC_CHECK_TOOL(DLLWRAP,dllwrap,false)
        if test "$DLLWRAP" = "false"; then
          LIBEXT="a"
        else
          dnl FIXME - check whether dllwrap works correctly...
          LIBEXT="dll"
        fi
        IMPLIBEXT="a"
    
        dnl Disable modules that can't be used on Windows
        enable_iphlpapi=${enable_iphlpapi:-no}
        enable_kernel32=${enable_kernel32:-no}
        enable_msvcrt=${enable_msvcrt:-no}
        enable_ntdll=${enable_ntdll:-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}
    
        ;;
      darwin*|macosx*)
        DLLEXT=".so"
        LIBEXT="dylib"
        DLLFLAGS="$DLLFLAGS -fPIC"
        LDDLLFLAGS="-bundle -multiply_defined suppress"
        LIBWINE_LDFLAGS="-multiply_defined suppress"
        LDSHARED="\$(CC) -dynamiclib"
    
        LDRPATH_LOCAL="&& install_name_tool -change @executable_path/\`\$(RELPATH) \$(bindir) \$(libdir)\`/libwine.1.dylib @executable_path/\$(top_builddir)/libs/wine/libwine.1.dylib \$@ || \$(RM) \$@"
    
        dnl declare needed frameworks
        AC_SUBST(COREFOUNDATIONLIB,"-framework CoreFoundation")
        AC_SUBST(IOKITLIB,"-framework IOKit -framework CoreFoundation")
    
        AC_SUBST(APPLICATIONSERVICESLIB,"-framework ApplicationServices")
    
        AC_SUBST(CORESERVICESLIB,"-framework CoreServices")
    
        case $host_os in
          darwin11*)
            AC_SUBST(LDEXECFLAGS,["-image_base 0x7bf00000 -Wl,-macosx_version_min,10.6,-segaddr,WINE_DOS,0x00001000,-segaddr,WINE_SHAREDHEAP,0x7f000000"]) ;;
          *)
            AC_SUBST(LDEXECFLAGS,["-image_base 0x7bf00000 -Wl,-segaddr,WINE_DOS,0x00001000,-segaddr,WINE_SHAREDHEAP,0x7f000000"]) ;;
        esac
    
        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(DISKARBITRATIONLIB,"-framework DiskArbitration -framework CoreFoundation")
        fi
    
        if test "$ac_cv_header_Security_Security_h" = "yes"
        then
            AC_SUBST(SECURITYLIB,"-framework Security -framework CoreFoundation")
    
            dnl Check for the SSLCopyPeerCertificates function
            ac_save_LIBS="$LIBS"
            LIBS="$LIBS $SECURITYLIB"
            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,"-framework CoreFoundation -framework CoreAudio -framework AudioUnit -framework AudioToolbox -framework CoreMIDI")
            else
                dnl CoreServices needed by AudioUnit
                AC_SUBST(COREAUDIO,"-framework CoreAudio -framework AudioUnit -framework CoreServices -framework AudioToolbox -framework CoreMIDI")
            fi
    
            dnl Check for the AUGraphAddNode function
            ac_save_LIBS="$LIBS"
            LIBS="$LIBS $COREAUDIO"
            AC_CHECK_FUNCS(AUGraphAddNode)
            LIBS="$ac_save_LIBS"
    
        if test "$ac_cv_header_OpenAL_al_h" = "yes"
        then
    
            AC_SUBST(FRAMEWORK_OPENAL,"-framework OpenAL")
            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_SUBST(LIBOPENCL,"-framework OpenCL")
            ac_cv_lib_OpenCL_clGetPlatformInfo=yes
        fi
    
        if test "$ac_cv_header_IOKit_hid_IOHIDLib_h" = "yes"
        then
            ac_save_LIBS="$LIBS"
            LIBS="$LIBS $IOKITLIB"
            AC_CHECK_FUNCS(IOHIDManagerCreate)
            LIBS="$ac_save_LIBS"
        fi
    
        case $host_cpu in
          *powerpc*)
            LDDLLFLAGS="$LDDLLFLAGS -read_only_relocs warning"  dnl FIXME
            ;;
        esac
    
        if test "$ac_cv_header_QuickTime_ImageCompression_h" = "yes"
        then
            AC_SUBST(QUICKTIMELIB,"-framework QuickTime -framework ApplicationServices -framework CoreVideo")
            enable_wineqtdecoder=${enable_wineqtdecoder:-yes}
        else
            WINE_NOTICE([QuickTime ${notice_platform}development files not found, video decoding won't be supported.])
        fi
    
        dnl Enable quartz driver on Mac OS X
        if test "$ac_cv_header_Carbon_Carbon_h" = "yes"
        then
            AC_SUBST(CARBONLIB,"-framework Carbon")
    
            enable_winequartz_drv=${enable_winequartz_drv:-yes}
    
        dnl Check for Xcode 3.x broken 16-bit support
        if test "x$enable_win16" = "xyes"
        then
            AC_MSG_CHECKING([whether 16-bit code can be built correctly])
    
            AC_RUN_IFELSE([AC_LANG_PROGRAM([[asm(".text\n"
    
                                                "bad:\tnop;nop\n"
                                                "good:\tnop;nop\n\t"
                                                ".globl _testfunc\n"
                                                "_testfunc:\tcallw good");
                                            extern void testfunc();]],
                                          [[unsigned short *p = (unsigned short *)testfunc;
    
                                            return p[0] != 0xe866 || p[1] != 0xfffa]])],
    
                                          AC_MSG_RESULT(yes),
                                          [AC_MSG_RESULT(no)
                                           AC_MSG_ERROR([Xcode 3.x cannot build 16-bit code correctly. Use --disable-win16 if you don't need 16-bit support.])],
                                           AC_MSG_RESULT([[cross-compiling, assuming yes]]))
        fi
    
        ;;
      *)
        DLLFLAGS="$DLLFLAGS -fPIC"
        DLLEXT=".so"
        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
          LDSHARED="\$(CC) -shared"
          LDDLLFLAGS="-shared -Wl,-Bsymbolic"
          WINE_TRY_CFLAGS([-fPIC -shared -Wl,-soname,confest.so.1],
                          [LDSHARED="\$(CC) -shared \$(SONAME:%=-Wl,-soname,%)"],
                          [WINE_TRY_CFLAGS([-fPIC -shared -Wl,-h,confest.so.1],
                                           [LDSHARED="\$(CC) -shared \$(SONAME:%=-Wl,-h,%)"])])
    
          WINE_TRY_CFLAGS([-fPIC -shared -Wl,-Bsymbolic,-z,defs], [LDDLLFLAGS="$LDDLLFLAGS,-z,defs"])
    
          WINE_TRY_CFLAGS([-fPIC -shared -Wl,-Bsymbolic,-init,__wine_spec_init,-fini,__wine_spec_fini],
                          [LDDLLFLAGS="$LDDLLFLAGS,-init,__wine_spec_init,-fini,__wine_spec_fini"])
    
          echo '{ global: *; };' >conftest.map
          WINE_TRY_CFLAGS([-fPIC -shared -Wl,--version-script=conftest.map],
                          [LDSHARED="$LDSHARED \$(VERSCRIPT:%=-Wl,--version-script=%)"])
          rm -f conftest.map
    
          WINE_TRY_CFLAGS([-fPIC -Wl,--export-dynamic],
                          [AC_SUBST(LDEXECFLAGS,["-Wl,--export-dynamic"])])
    
          WINE_TRY_CFLAGS([-fPIC -Wl,--rpath,\$ORIGIN/../lib],
                          [LDRPATH_INSTALL="-Wl,--rpath,\\\$\$ORIGIN/\`\$(RELPATH) \$(bindir) \$(libdir)\`"
    
                           LDRPATH_LOCAL="-Wl,--rpath,\\\$\$ORIGIN/\$(top_builddir)/libs/wine"],
    
              [WINE_TRY_CFLAGS([-fPIC -Wl,-R,\$ORIGIN/../lib],
                               [LDRPATH_INSTALL="-Wl,-R,\\\$\$ORIGIN/\`\$(RELPATH) \$(bindir) \$(libdir)\`"
    
                                LDRPATH_LOCAL="-Wl,-R,\\\$\$ORIGIN/\$(top_builddir)/libs/wine"])])
    
          WINE_TRY_CFLAGS([-Wl,--enable-new-dtags],
                          [LDRPATH_INSTALL="$LDRPATH_INSTALL -Wl,--enable-new-dtags"])
    
    
          case $host_cpu in
            *i[[3456789]]86* | x86_64)
              WINE_TRY_CFLAGS([-Wl,--section-start,.interp=0x7bf00400],
    
                               freebsd* | kfreebsd*-gnu) LDEXECFLAGS="$LDEXECFLAGS -Wl,--section-start,.interp=0x60000400" ;;
    
                               *) LDEXECFLAGS="$LDEXECFLAGS -Wl,--section-start,.interp=0x7bf00400" ;;
                               esac
                              ])
    
              AC_PATH_PROG(PRELINK, prelink, false, [/sbin /usr/sbin $PATH])
              if test "x$PRELINK" = xfalse
              then
                  WINE_WARNING([prelink not found, base address of core dlls won't be set correctly.])
              fi
    
              ;;
          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
            LDSHARED="\$(CC) -Wl,-G \$(SONAME:%=-Wl,-h,%)"
            LDDLLFLAGS="-Wl,-G,-B,symbolic"
    
          else
            AC_CACHE_CHECK(whether we can build an HP-UX dll, ac_cv_c_dll_hpux,
              [WINE_TRY_SHLIB_FLAGS([-shared], ac_cv_c_dll_hpux="yes", ac_cv_c_dll_hpux="no")])
            if test "$ac_cv_c_dll_hpux" = "yes"
            then
              LIBEXT="sl"
              DLLEXT=".sl"
              LDDLLFLAGS="-shared -fPIC"
              LDSHARED="\$(CC) -shared"
            fi
          fi
        fi
        ;;
    esac
    
    
    enable_wineqtdecoder=${enable_wineqtdecoder:-no}
    
    enable_winequartz_drv=${enable_winequartz_drv:-no}
    
    
    if test "$LIBEXT" = "a"; then
      AC_MSG_ERROR(
    [could not find a way to build shared libraries.
    It is currently not possible to build Wine without shared library
    (.so) support to allow transparent switch between .so and .dll files.
    If you are using Linux, you will need a newer binutils.]
    )
    fi
    
    
    dnl Check for cross compiler to build test programs
    
    AC_SUBST([CROSSTEST_DISABLE],[\#])
    if test "$cross_compiling" = "no" -a "x$enable_tests" != xno -a "$LIBEXT" != "dll"
    
    then
        WINE_CHECK_MINGW_PROG(CROSSCC,gcc,false)
        if test "$CROSSCC" != "false"
        then
    
            ac_save_CC="$CC"
            CC="$CROSSCC"
            AC_MSG_CHECKING([whether $CROSSCC works])
    
            AC_COMPILE_IFELSE([AC_LANG_PROGRAM([])],
    
                              [AC_MSG_RESULT([yes])
                               set x $CROSSCC
                               shift
                               target=""
                               while test $# -ge 1
                               do
                                   case "$1" in
                                     *-gcc) target=`expr "$1" : '\(.*\)-gcc'` ;;
                                   esac
                                   shift
                               done
                               if test -n "$target"
                               then
                                   CROSSTEST_DISABLE=""
                                   AC_SUBST(CROSSTARGET,"$target")
                               fi],
                              [AC_MSG_RESULT([no])])
            CC="$ac_save_CC"
    
    dnl **** Check for pthread ****
    
    if test "$ac_cv_header_pthread_h" = "yes"
    then
        AC_CHECK_LIB(pthread,pthread_create,[AC_SUBST(LIBPTHREAD,"-lpthread")])
    fi
    WINE_ERROR_WITH(pthread,[test "x$LIBPTHREAD" = "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,[XLIB="-lXext $XLIB"],,[$X_LIBS -lX11 $X_EXTRA_LIBS])
    
        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/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 $XLIB $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 $XLIB $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