Bochs/bochs/configure.in

dnl // Process this file with autoconf to produce a configure script.

AC_PREREQ(2.50)
AC_INIT(bochs.h)
AC_REVISION([[$Id: configure.in,v 1.382 2009-01-18 13:11:27 vruppert Exp $]])
AC_CONFIG_HEADER(config.h)
AC_CONFIG_HEADER(ltdlconf.h)

dnl // Put Bochs version information right here so that it gets substituted
dnl // into all the right places.
VERSION="2.3.7.cvs"
VER_STRING="2.3.7.cvs"
dnl // WIN_VER_STRING format is "a, b, c, d"
dnl // d should be 0 for release and 1 for cvs version
WIN_VER_STRING="2, 3, 7, 1"
REL_STRING="Build from CVS snapshot, after release 2.3.7"

changequote(<<, >>)
changequote([, ])

dnl Detect host and target
AC_CANONICAL_HOST
AC_CANONICAL_TARGET

AC_MSG_CHECKING(if you are configuring for another platform)
if test "$cross_compiling" = yes -o "$target_os" = "windows"; then
  AC_MSG_RESULT(yes)
  cross_configure=1
else
  AC_MSG_RESULT(no)
  cross_configure=0
fi

# this case statement defines the compile flags which are needed to
# compile bochs on a platform.  Don't put things like optimization settings
# into the configure.in file, since people will want to be able to change
# those settings by defining CFLAGS and CXXFLAGS before running configure.
NO_LT=0
need_dlcompat_for_plugins=0
case "$target" in
  *-pc-windows* | *-pc-winnt*)
    DEFAULT_GUI=win32                 # default to win32 gui
    ;;
  *-pc-cygwin* | *-pc-mingw32*)
    NO_LT=1   # do not use libtool at all on cygwin
    if test "$with_term" = yes; then
      # ncurses won't compile with -mno-cygwin or -DWIN32
      # also, I can't get it to link without this -DBROKEN_LINKER=1 hack.
      # see /usr/include/curses.h for details.
      ADD_FLAGS="-DBROKEN_LINKER=1"
    else
      # default case
      ADD_FLAGS="-mno-cygwin -DWIN32"   # required for cygwin compile+win32 gui
      DEFAULT_GUI=win32                 # default to win32 gui
    fi
    ;;
  *-macosx* | *-darwin*)
    ADD_FLAGS="-fpascal-strings -fno-common -Wno-four-char-constants -Wno-unknown-pragmas -Dmacintosh"      # required for macosx compile
    DEFAULT_GUI=carbon                # default to carbon
    need_dlcompat_for_plugins=1
    ;;
  *-macos*)
    DEFAULT_GUI=macos                 # macos defaults to macos
    ;;
  *-beos*)
    ADD_FLAGS="-Wno-multichar"
    DEFAULT_GUI=beos                  # beos defaults to beos
    ;;
  *-amigaos* | *-morphos*)
    DEFAULT_GUI=amigaos               # amigaos or morphos defaults to amigaos gui
    ;;
  *-solaris*)
    ADD_FLAGS="-D_XOPEN_SOURCE_EXTENDED=1 -D__EXTENSIONS__"      # required for correct function prototypes
    LIBS="$LIBS -lsocket -lnsl"
    DEFAULT_GUI=x11
    ;;
  *)
    DEFAULT_GUI=x11
    ;;
esac
if test "${ADD_FLAGS:+set}" = set; then
      CFLAGS="$CFLAGS $ADD_FLAGS"
      CXXFLAGS="$CXXFLAGS $ADD_FLAGS"
      CPPFLAGS="$CPPFLAGS $ADD_FLAGS"
fi

AC_MSG_CHECKING(for standard CFLAGS on this platform)
AC_MSG_RESULT($ADD_FLAGS)

dnl // make sure X Windows is default if no other chosen
if (test "$with_sdl" != yes) && \
   (test "$with_svga" != yes) && \
   (test "$with_x11" != yes) && \
   (test "$with_beos" != yes) && \
   (test "$with_win32" != yes) && \
   (test "$with_nogui" != yes) && \
   (test "$with_term" != yes) && \
   (test "$with_rfb" != yes) && \
   (test "$with_amigaos" != yes) && \
   (test "$with_carbon" != yes) && \
   (test "$with_wx" != yes) && \
   (test "$with_macos" != yes); then
  # use DEFAULT_GUI.  Set the appropriate variable.
  # DEFAULT_GUI must be set to one of the names above.  Otherwise, no
  # valid $with_* variable will be set and who knows what will happen?
  eval "with_${DEFAULT_GUI}=yes"
fi

AC_PROG_CC
AC_PROG_CXX
AC_PROG_MAKE_SET

dnl------------ libtool configuration
dnl Configure libtool, and default to shared libraries.  Libtool will only be
dnl used for compiling and linking plugins.
AC_DISABLE_STATIC
dnl Check for dlopen support
AC_LIBTOOL_DLOPEN
dnl Configure libtool
AC_PROG_LIBTOOL
dnl Configure the ltdl library.  This must go after AC_PROG_LIBTOOL or
dnl else it disables shared libraries somehow.  The values from this macro
dnl are written to ltdlconf.h.
AC_LIB_LTDL

AC_PATH_XTRA

AC_C_BIGENDIAN
AC_C_INLINE
AC_CHECK_SIZEOF(unsigned char)
AC_CHECK_SIZEOF(unsigned short)
AC_CHECK_SIZEOF(unsigned int)
AC_CHECK_SIZEOF(unsigned long)
AC_CHECK_SIZEOF(unsigned long long)
AC_CHECK_SIZEOF(int *)
AC_CHECK_FUNCS(getenv, AC_DEFINE(BX_HAVE_GETENV))
AC_CHECK_FUNCS(setenv, AC_DEFINE(BX_HAVE_SETENV))
AC_CHECK_FUNCS(select, AC_DEFINE(BX_HAVE_SELECT))
AC_CHECK_FUNCS(snprintf, AC_DEFINE(BX_HAVE_SNPRINTF))
AC_CHECK_FUNCS(vsnprintf, AC_DEFINE(BX_HAVE_VSNPRINTF))
AC_CHECK_FUNCS(strtoull, AC_DEFINE(BX_HAVE_STRTOULL))
AC_CHECK_FUNCS(strtouq, AC_DEFINE(BX_HAVE_STRTOUQ))
AC_CHECK_FUNCS(strdup, AC_DEFINE(BX_HAVE_STRDUP))
AC_CHECK_FUNCS(strrev, AC_DEFINE(BX_HAVE_STRREV))
AC_CHECK_FUNCS(sleep, AC_DEFINE(BX_HAVE_SLEEP))
AC_CHECK_FUNCS(usleep, AC_DEFINE(BX_HAVE_USLEEP))
AC_CHECK_FUNCS(nanosleep, AC_DEFINE(BX_HAVE_NANOSLEEP))
AC_CHECK_FUNCS(abort, AC_DEFINE(BX_HAVE_ABORT))
AC_CHECK_FUNCS(gettimeofday, AC_DEFINE(BX_HAVE_GETTIMEOFDAY))
AC_CHECK_TYPE(socklen_t, AC_DEFINE(BX_HAVE_SOCKLEN_T), , [#include <sys/types.h>
#include <sys/socket.h>])
AC_CHECK_MEMBER(struct sockaddr_in.sin_len, AC_DEFINE(BX_HAVE_SOCKADDR_IN_SIN_LEN), , [#include <sys/socket.h>
#include <netinet/in.h> ])
AC_CHECK_FUNCS(mkstemp, AC_DEFINE(BX_HAVE_MKSTEMP))
AC_CHECK_HEADER(sys/mman.h, AC_DEFINE(BX_HAVE_SYS_MMAN_H))
AC_CHECK_FUNCS(timelocal, AC_DEFINE(BX_HAVE_TIMELOCAL))
AC_CHECK_FUNCS(gmtime, AC_DEFINE(BX_HAVE_GMTIME))
AC_CHECK_FUNCS(mktime, AC_DEFINE(BX_HAVE_MKTIME))

dnl As of autoconf 2.53, the standard largefile test fails for Linux/gcc.
dnl It does not put the largefiles arguments into CFLAGS, even though Linux/gcc
dnl does need them.  Since wxWidgets had already solved this exact problem,
dnl Bryce asked Vadim Zeitlin of the wxWidgets project if Bochs could grab
dnl their largefile test, and he said it was fine.  The re-implemented
dnl AC_SYS_LARGEFILE test can be found in aclocal.m4.
AC_SYS_LARGEFILE

dnl This logic came from wxWidgets as well.  Bryce added the CFLAGS and
dnl CXXFLAGS lines, since Bochs makefiles don't use CPPFLAGS at all.
dnl
dnl we need to define _FILE_OFFSET_BITS or _LARGE_FILES on the compiler command
dnl line because otherwise the system headers risk being included before
dnl config.h which defines these constants leading to inconsistent
dnl sizeof(off_t) in different source files of the same program and linking
dnl problems
if test "x$wx_largefile" = "xyes"; then
    if test "x$ac_cv_sys_file_offset_bits" = "x64"; then
        BX_LARGEFILE_FLAGS="-D_FILE_OFFSET_BITS=64 -D_LARGE_FILES"
    else
        BX_LARGEFILE_FLAGS="-D_LARGE_FILES"
    fi
    CPPFLAGS="$CPPFLAGS $BX_LARGEFILE_FLAGS"
    CFLAGS="$CFLAGS $BX_LARGEFILE_FLAGS"
    CXXFLAGS="$CXXFLAGS $BX_LARGEFILE_FLAGS"
fi
dnl ---end of largefile tests

dnl Add the -lm library if math functions cannot be used without it.
dnl This check is important on cygwin because of the bizarre way that they
dnl have organized functions into libraries.  On cygwin, both libc.a and
dnl libm.a are symbolic links to a single lib libcygwin.a.  This means that
dnl   1) linking with -lm is not necessary, and
dnl   2) linking with -lm is dangerous if the order of libraries is wrong
dnl In particular, if you compile any program with -mno-cygwin and link with
dnl -lm, it will crash instantly when it is run.  This happens because the
dnl linker incorrectly links the Cygwin libm.a (==libcygwin.a), which replaces
dnl the ___main function instead of allowing it to be defined by
dnl /usr/lib/mingw/libmingw32.a as it should be.
dnl
dnl On MacOS X, this test will find that -lm is unnecessary and leave it out.
dnl
dnl Just check a few math functions. If they are all found without
dnl -lm, then we must not need -lm.
have_cos=0
have_floor=0
AC_CHECK_FUNCS(cos, have_cos=1)
AC_CHECK_FUNCS(floor, have_floor=1)
AC_MSG_CHECKING(if math functions link without -lm)
if test "$have_cos" = 1 -a "$have_floor" = 1; then
    AC_MSG_RESULT(yes)
else
    AC_MSG_RESULT(no)
    LIBS="$LIBS -lm"
    # use different functions to bypass configure caching
    have_sin=0
    have_ceil=0
    AC_CHECK_FUNCS(sin, have_sin=1)
    AC_CHECK_FUNCS(ceil, have_ceil=1)
    AC_MSG_CHECKING(if math functions link with -lm)
    if test "$have_sin" = 1 -a "$have_ceil" = 1; then
        AC_MSG_RESULT(yes)
    else
        AC_MSG_RESULT(no)
        # not sure we should warn the user, crash, etc.
	# expect link failure
    fi
fi

AC_MSG_CHECKING(for struct timeval)
AC_TRY_COMPILE([#include <sys/time.h>],
    [struct timeval x;],
    [
      AC_MSG_RESULT(yes)
      AC_DEFINE(BX_HAVE_STRUCT_TIMEVAL, 1)
    ],
    AC_MSG_RESULT(no))

AC_MSG_CHECKING(if compiler allows empty structs)
AC_TRY_COMPILE([], [typedef struct { } junk;],
    AC_MSG_RESULT(yes),
    [
      AC_DEFINE(BX_NO_EMPTY_STRUCTS)
      AC_MSG_RESULT(no)
    ])

AC_MSG_CHECKING(if compiler allows __attribute__)
AC_TRY_COMPILE([], [typedef struct { } __attribute__ ((packed)) junk;],
    AC_MSG_RESULT(yes),
    [
      AC_MSG_RESULT(no)
      AC_DEFINE(BX_NO_ATTRIBUTES)
    ])

AC_LANG_SAVE
AC_LANG_CPLUSPLUS
AC_MSG_CHECKING(for hash_map)
AC_TRY_COMPILE([#include <hash_map>], [],
   [
     AC_MSG_RESULT(yes)
     AC_DEFINE(BX_HAVE_HASH_MAP)
   ], AC_MSG_RESULT(no))
AC_MSG_CHECKING(for hash_map.h)
AC_TRY_COMPILE([#include <hash_map.h>], [],
   [
     AC_MSG_RESULT(yes)
     AC_DEFINE(BX_HAVE_HASH_MAP_H)
   ], AC_MSG_RESULT(no))
AC_MSG_CHECKING(for set)
AC_TRY_COMPILE([#include <set>], [],
   [
     AC_MSG_RESULT(yes)
     AC_DEFINE(BX_HAVE_SET)
   ], AC_MSG_RESULT(no))
AC_MSG_CHECKING(for set.h)
AC_TRY_COMPILE([#include <set.h>], [],
   [
     AC_MSG_RESULT(yes)
     AC_DEFINE(BX_HAVE_SET_H)
   ], AC_MSG_RESULT(no))
AC_LANG_RESTORE

dnl Implement a check for each gui library to see if has a chance of compiling.
if test "$with_all_libs" = yes; then
  if test "$cross_configure" = 1; then
    AC_MSG_WARN([[Using --with-all-libs while cross configuring is very unlikely to be what you want.  You should specify the --with-* args yourself.]])
  fi
  if test "$with_beos" != yes; then
    can_compile_beos=1
    AC_CHECK_HEADER([app/Application.h], [], [ can_compile_beos=0 ])
    AC_CHECK_HEADER([interface/Window.h], [], [ can_compile_beos=0 ])
    AC_CHECK_HEADER([interface/View.h], [], [ can_compile_beos=0 ])
    if test $can_compile_beos = 1; then
      with_beos=yes
    fi
  fi

  if test "$with_amigaos" != yes; then
    can_compile_amigaos=1
    AC_CHECK_HEADER([proto/intuition.h], [], [ can_compile_amigaos=0 ])
    AC_CHECK_HEADER([intuition/intuitionbase.h], [], [ can_compile_amigaos=0 ])
    AC_CHECK_HEADER([cybergraphx/cybergraphics.h], [], [ can_compile_amigaos=0 ])
    AC_CHECK_HEADER([devices/trackdisk.h], [], [ can_compile_amigaos=0 ])
    if test $can_compile_amigaos = 1; then
      with_amigaos=yes
    fi
  fi

  if test "$with_macos" != yes; then
    can_compile_macos=1
    AC_CHECK_HEADER([Quickdraw.h], [], [ can_compile_macos=0 ])
    AC_CHECK_HEADER([Dialogs.h], [], [ can_compile_macos=0 ])
    if test $can_compile_macos = 1; then
      with_macos=yes
    fi
  fi

  if test "$with_carbon" != yes; then
    can_compile_carbon=1
    AC_CHECK_HEADER([Carbon.h], [], [ can_compile_carbon=0 ])
    AC_CHECK_HEADER([ApplicationServices/ApplicationServices.h], [], [ can_compile_carbon=0 ])
    if test $can_compile_carbon = 1; then
      with_carbon=yes
    fi
  fi

  if test "$with_win32" != yes; then
    can_compile_win32=1
    AC_CHECK_HEADER([windows.h], [], [ can_compile_win32=0 ])
    AC_CHECK_HEADER([commctrl.h], [], [ can_compile_win32=0 ])
    if test $can_compile_win32 = 1; then
      with_win32=yes
    fi
  fi

  if test "$with_sdl" != yes; then
    can_compile_sdl=1
    AC_CHECK_HEADER([SDL/SDL.h], [], [ can_compile_sdl=0 ])
    AC_CHECK_HEADER([SDL/SDL_main.h], [], [ can_compile_sdl=0 ])
    if test $can_compile_sdl = 1; then
      with_sdl=yes
    fi
  fi

  if test "$with_svga" != yes; then
    can_compile_svga=1
    AC_CHECK_HEADER([vga.h], [], [ can_compile_svga=0 ])
    AC_CHECK_HEADER([vgagl.h], [], [ can_compile_svga=0 ])
    if test $can_compile_svga = 1; then
      with_svga=yes
    fi
  fi

  if test "$with_x11" != yes; then
    can_compile_x11=1
    AC_CHECK_HEADER([X11/Xlib.h], [], [ can_compile_x11=0 ])
    AC_CHECK_HEADER([X11/Xutil.h], [], [ can_compile_x11=0 ])
    if test $can_compile_x11 = 1; then
      with_x11=yes
    fi
  fi

  if test "$with_rfb" != yes; then
    can_compile_rfb=1
    case $target in
      *-pc-windows* | *-pc-winnt* | *-pc-cygwin* | *-pc-mingw32*)
	AC_CHECK_HEADER([winsock.h], [], [ can_compile_rfb=0 ])
	AC_CHECK_HEADER([process.h], [], [ can_compile_rfb=0 ])
        ;;
      *)
	AC_CHECK_HEADER([sys/socket.h], [], [ can_compile_rfb=0 ])
	AC_CHECK_HEADER([netinet/tcp.h], [], [ can_compile_rfb=0 ])
	AC_CHECK_HEADER([pthread.h], [], [ can_compile_rfb=0 ])
	;;
    esac
    if test $can_compile_rfb = 1; then
      with_rfb=yes
    fi
  fi

  if test "$with_term" != yes; then
    can_compile_term=1
    AC_CHECK_HEADER([curses.h], [], [ can_compile_term=0 ])
    AC_CHECK_HEADER([signal.h], [], [ can_compile_term=0 ])
    if test $can_compile_term = 1; then
      with_term=yes
    fi
  fi

  if test "$with_nogui" != yes; then
    with_nogui=yes
  fi
fi    # end of if $with_all_libs = yes

AC_MSG_CHECKING(for idle hack)
AC_ARG_ENABLE(idle-hack,
  [  --enable-idle-hack                use Roland Mainz's idle hack],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_USE_IDLE_HACK, 1)
   else
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_USE_IDLE_HACK, 0)
   fi],
  [
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_USE_IDLE_HACK, 0)
    ]
  )
AC_SUBST(BX_USE_IDLE_HACK)

AC_CHECK_HEADER(dlfcn.h, AC_DEFINE(BX_HAVE_DLFCN_H, 1))
AC_CHECK_HEADER(assert.h, AC_DEFINE(HAVE_ASSERT_H, 1))

AC_MSG_CHECKING(for plugins support)
AC_ARG_ENABLE(plugins,
  [  --enable-plugins                  enable plugins],
  [if test "$enableval" = yes; then
     bx_plugins=1
   else
     bx_plugins=0
   fi],
  [
    bx_plugins=0
    ]
  )

if test "$bx_plugins" = 1; then
  AC_MSG_RESULT(yes)
  AC_DEFINE(BX_PLUGINS, 1)
  GUI_NON_PLUGIN_OBJS='$(OBJS_THAT_CANNOT_BE_PLUGINS)'
  GUI_PLUGIN_OBJS='$(OBJS_THAT_CAN_BE_PLUGINS)'
  DEFINE_PLUGIN_PATH='-DBX_PLUGIN_PATH="\"${plugdir}\""'
  # and the $(OBJS_THAT_SUPPORT_OTHER_PLUGINS) will be built and linked
  # by special link rules for the plugins that they support.
  LIBS="$LIBS $LIBADD_DL"
  PLUGIN_VAR='ltdl.o'
  PLUGIN_TARGET=bochs_plugins
  INSTALL_PLUGINS_VAR=install_libtool_plugins
  NONPLUGIN_GUI_LINK_OPTS=''
else
  AC_MSG_RESULT(no)
  bx_plugins=0
  AC_DEFINE(BX_PLUGINS, 0)
  GUI_NON_PLUGIN_OBJS='$(OBJS_THAT_CANNOT_BE_PLUGINS) $(OBJS_THAT_CAN_BE_PLUGINS) $(OBJS_THAT_SUPPORT_OTHER_PLUGINS)'
  GUI_PLUGIN_OBJS=''
  NONPLUGIN_GUI_LINK_OPTS='$(GUI_LINK_OPTS)'
fi
AC_SUBST(DEFINE_PLUGIN_PATH)
AC_SUBST(NONPLUGIN_GUI_LINK_OPTS)

# copy gui variables into iodev variables.  Later, we will add to the gui
# objs list, according to which display libraries are enabled.
IODEV_NON_PLUGIN_OBJS=$GUI_NON_PLUGIN_OBJS
IODEV_PLUGIN_OBJS=$GUI_PLUGIN_OBJS

# on MacOSX if they enabled plugins, make sure that dlopen() was found.
# It is provided by a library called dlcompat.
if test "$bx_plugins" = 1 -a "$need_dlcompat_for_plugins" = 1; then
  have_dlopen=0
  AC_CHECK_LIB(dl, dlopen, [have_dlopen=1])
  AC_MSG_CHECKING(if you have dlcompat, required for MacOSX plugins)
  if test "$have_dlopen" = 0; then
    AC_MSG_RESULT(no)
    AC_MSG_ERROR([To use plugins on MacOSX you must use a library called dlcompat.  The configure script was not able to find dlcompat.  If it is already installed then you must set up your environment variables to point to it, as is done in .conf.macosx.  If you cannot resolve this, you should turn off plugins.])
  else
    AC_MSG_RESULT(yes)
  fi
fi

AC_MSG_CHECKING(if compiler allows blank labels)
AC_TRY_COMPILE([], [ { label1: } ],
    AC_MSG_RESULT(yes),
    [
      AC_MSG_RESULT(no)
      AC_DEFINE(BX_NO_BLANK_LABELS)
    ])

AC_MSG_CHECKING(if compiler allows LL for 64-bit constants)
AC_TRY_COMPILE([], [ { 42LL; } ],
    AC_MSG_RESULT(yes),
    [
      AC_MSG_RESULT(no)
      AC_DEFINE(BX_64BIT_CONSTANTS_USE_LL, 0)
    ])

use_x86_64=0
AC_MSG_CHECKING(for x86-64 support)
AC_ARG_ENABLE(x86-64,
  [  --enable-x86-64                   compile in support for x86-64 instructions],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    OBJS64='$(OBJS64)'
    AC_DEFINE(BX_SUPPORT_X86_64, 1)
    use_x86_64=1
   else
    AC_MSG_RESULT(no)
    OBJS64=''
    AC_DEFINE(BX_SUPPORT_X86_64, 0)
   fi
   ],
  [
    AC_MSG_RESULT(no)
    OBJS64=''
    AC_DEFINE(BX_SUPPORT_X86_64, 0)
    ]
  )
AC_SUBST(OBJS64)

use_smp=0
AC_MSG_CHECKING(for SMP support)
AC_ARG_ENABLE(smp,
  [  --enable-smp                      compile in support for SMP configurations],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_SUPPORT_SMP, 1)
    AC_DEFINE(BX_USE_CPU_SMF, 0)
    use_smp=1
   else
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SUPPORT_SMP, 0)
   fi
   ],
  [
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SUPPORT_SMP, 0)
    ]
  )

AC_MSG_CHECKING(for cpu level)
AC_ARG_ENABLE(cpu-level,
  [  --enable-cpu-level                select cpu level (3,4,5,6)],
  [case "$enableval" in
     3)
       AC_MSG_RESULT(3)
       AC_DEFINE(BX_CPU_LEVEL, 3)
       AC_DEFINE(BX_CPU_LEVEL_HACKED, 3)
       ;;
     4)
       AC_MSG_RESULT(4)
       AC_DEFINE(BX_CPU_LEVEL, 4)
       AC_DEFINE(BX_CPU_LEVEL_HACKED, 4)
       ;;
     5)
       AC_MSG_RESULT(5)
       AC_DEFINE(BX_CPU_LEVEL, 5)
       AC_DEFINE(BX_CPU_LEVEL_HACKED, 5)
       ;;
     6)
       AC_MSG_RESULT(6)
       AC_DEFINE(BX_CPU_LEVEL, 6)
       AC_DEFINE(BX_CPU_LEVEL_HACKED, 6)
       ;;
     *)
       echo " "
       echo "ERROR: you must supply a valid CPU level to --enable-cpu-level"
       exit 1
       ;;
   esac
   bx_cpu_level=$enableval
   if test "$use_smp" = 1 -a "$enableval" -lt 6; then
     echo "ERROR: with >1 processor, use --enable-cpu-level=6"
     exit 1
   fi
  ],
  [
    # for multiprocessors or x86-64, cpu level must be 6
    if test "$use_smp" = 1 -o "$use_x86_64" = 1; then
      AC_MSG_RESULT(6)
      AC_DEFINE(BX_CPU_LEVEL, 6)
      AC_DEFINE(BX_CPU_LEVEL_HACKED, 6)
      bx_cpu_level=6
    else
      AC_MSG_RESULT(5)
      AC_DEFINE(BX_CPU_LEVEL, 5)
      AC_DEFINE(BX_CPU_LEVEL_HACKED, 5)
      bx_cpu_level=5
    fi
  ]
  )


AC_MSG_CHECKING(for APIC support)
AC_ARG_ENABLE(apic,
  [  --enable-apic                     enable APIC support],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_SUPPORT_APIC, 1)
    IOAPIC_OBJS='ioapic.o'
   else
    AC_MSG_RESULT(no)
    if test "$use_smp" = 1; then
      echo "ERROR: With SMP configuration you must use --enable-apic"
      exit 1
    fi
    AC_DEFINE(BX_SUPPORT_APIC, 0)
    IOAPIC_OBJS=''
   fi
   ],
  [
    if test "$use_smp" = 1 -o "$bx_cpu_level" -gt 5; then
      # enable APIC by default, if SMP configuration or if cpulevel>5
      AC_MSG_RESULT(yes)
      AC_DEFINE(BX_SUPPORT_APIC, 1)
      IOAPIC_OBJS='ioapic.o'
    else
      AC_MSG_RESULT(no)
      AC_DEFINE(BX_SUPPORT_APIC, 0)
      IOAPIC_OBJS=''
     fi
   ]
  )
AC_SUBST(IOAPIC_OBJS)

AC_CHECK_HEADER(zlib.h, [AC_CHECK_LIB(z, gzopen, AC_DEFINE(BX_HAVE_ZLIB,1))] )

AC_MSG_CHECKING(for compressed hard disk image support)
AC_ARG_ENABLE(compressed-hd,
  [  --enable-compressed-hd            allows compressed (zlib) hard disk image (not implemented yet)],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_COMPRESSED_HD_SUPPORT, 1)
    LIBS="$LIBS -lz"
   else
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_COMPRESSED_HD_SUPPORT, 0)
   fi],
  [
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_COMPRESSED_HD_SUPPORT, 0)
    ]
  )
AC_SUBST(BX_COMPRESSED_HD_SUPPORT)

AC_MSG_CHECKING(for NE2000 support)
AC_ARG_ENABLE(ne2000,
  [  --enable-ne2000                   enable limited ne2000 support],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_SUPPORT_NE2K, 1)
    NE2K_OBJS='ne2k.o'
    networking=yes
   else
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SUPPORT_NE2K, 0)
    NE2K_OBJS=''
    networking=no
   fi],
  [
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SUPPORT_NE2K, 0)
    NE2K_OBJS=''
    networking=no
    ]
  )
AC_SUBST(NE2K_OBJS)

AC_MSG_CHECKING(for ACPI support)
AC_ARG_ENABLE(acpi,
  [  --enable-acpi                     enable ACPI support],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_SUPPORT_ACPI, 1)
   else
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SUPPORT_ACPI, 0)
   fi],
  [
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SUPPORT_ACPI, 0)
    ]
  )
AC_SUBST(BX_SUPPORT_ACPI)

AC_MSG_CHECKING(for i440FX PCI support)
AC_ARG_ENABLE(pci,
  [  --enable-pci                      enable limited i440FX PCI support],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_SUPPORT_PCI, 1)
    pci=1
    PCI_OBJ='pci.o pci2isa.o pci_ide.o pcivga.o acpi.o'
   else
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SUPPORT_PCI, 0)
    pci=0
    PCI_OBJ=''
   fi],
  [
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SUPPORT_PCI, 0)
    pci=0
    PCI_OBJ=''
    ]
  )
AC_SUBST(PCI_OBJ)

#
# PCI host device support
#
AC_MSG_CHECKING(for PCI host device mapping support)
AC_ARG_ENABLE(pcidev,
  [  --enable-pcidev                   enable PCI host device mapping support (linux host only)],
  [
    if test "$enableval" = "yes"; then
      AC_MSG_RESULT(yes)
      if test "$pci" != "1"; then
        AC_MSG_ERROR([PCI host device mapping requires PCI support])
      fi
      case "$target" in
        *-linux*)
          AC_MSG_NOTICE([Linux detected as host for PCI host device mapping])
          linux_version=`uname -r`
	  case "$linux_version" in
		2.4*)
	  		PCIDEV_MODULE_MAKE_ALL="all-kernel24"
			KERNEL_MODULE_SUFFIX="o"
          	;;
		2.6*)
	  		PCIDEV_MODULE_MAKE_ALL="all-kernel26"
			KERNEL_MODULE_SUFFIX="ko"
		;;
		*)
			AC_MSG_ERROR([Linux kernel 2.4 or 2.6 is required])
		;;
	  esac
	  KERNELDIR="/lib/modules/$linux_version/build"
	  LSMOD="lsmod"
	  INSMOD="insmod"
	  RMMOD="rmmod"
	  DEPMOD="depmod"
	  AC_SUBST(KERNELDIR)
	  AC_SUBST(LSMOD)
	  AC_SUBST(INSMOD)
	  AC_SUBST(RMMOD)
	  AC_SUBST(DEPMOD)
	  AC_SUBST(PCIDEV_MODULE_MAKE_ALL)
	  AC_SUBST(KERNEL_MODULE_SUFFIX)
        ;;
        *)
          AC_MSG_ERROR([PCI host device mapping requires Linux as host])
        ;;
      esac
      AC_DEFINE(BX_SUPPORT_PCIDEV, 1)
      PCI_OBJ="$PCI_OBJ pcidev.o"
    else
      AC_MSG_RESULT(no)
      AC_DEFINE(BX_SUPPORT_PCIDEV, 0)
    fi
  ],
  [
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SUPPORT_PCIDEV, 0)
  ]
)

USBDEV_OBJS=''
SCSI_OBJS=''
AC_MSG_CHECKING(for limited USB support)
AC_ARG_ENABLE(usb,
  [  --enable-usb                      enable limited USB support],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_SUPPORT_PCIUSB, 1)
    PCI_OBJ="$PCI_OBJ pciusb.o"
    USBDEV_OBJS="usb_common.o usb_hid.o usb_msd.o"
    SCSI_OBJS="scsi_device.o"
   else
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SUPPORT_PCIUSB, 0)
   fi],
  [
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SUPPORT_PCIUSB, 0)
    ]
  )

AC_SUBST(USBDEV_OBJS)
AC_SUBST(SCSI_OBJS)

AC_MSG_CHECKING(for PCI pseudo NIC support)
AC_ARG_ENABLE(pnic,
  [  --enable-pnic                     enable PCI pseudo NIC support],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_SUPPORT_PCIPNIC, 1)
    PCI_OBJ="$PCI_OBJ pcipnic.o"
    networking=yes
   else
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SUPPORT_PCIPNIC, 0)
   fi],
  [
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SUPPORT_PCIPNIC, 0)
    ]
  )

NETLOW_OBJS=''
if test "$networking" = yes; then
  NETLOW_OBJS='eth.o eth_null.o eth_vnet.o'
  AC_CHECK_HEADER(net/bpf.h, NETLOW_OBJS="$NETLOW_OBJS eth_fbsd.o")
  AC_CHECK_HEADER(netpacket/packet.h, NETLOW_OBJS="$NETLOW_OBJS eth_linux.o")
  case "$target" in
    *-pc-windows* | *-pc-winnt* | *-pc-cygwin* | *-pc-mingw32*)
    NETLOW_OBJS="$NETLOW_OBJS eth_win32.o"
    ;;
    *-macosx* | *-darwin*)
    NETLOW_OBJS="$NETLOW_OBJS eth_tuntap.o"
    AC_DEFINE(HAVE_TUNTAP, 1)
    ;;
    *)
    AC_CHECK_HEADER(net/if.h, [
        use_ethertap=yes
        AC_DEFINE(BX_HAVE_NET_IF_H, 1)
      ], [],
      [
      #include <sys/types.h>
      #include <sys/socket.h>
    ])
    AC_CHECK_HEADER(linux/netlink.h, [
        use_ethertap=yes
      ], [],
      [
      #include <asm/types.h>
      #include <sys/socket.h>
    ])

    if test "$use_ethertap" = yes; then
      NETLOW_OBJS="$NETLOW_OBJS eth_tap.o eth_vde.o"
      AC_DEFINE(HAVE_ETHERTAP, 1)
      AC_DEFINE(HAVE_VDE, 1)
    fi

    AC_CHECK_HEADER(net/if_tun.h, [
        use_tuntap=yes
      ], [],
      [
      #include <sys/types.h>
      #include <sys/socket.h>
      #include <net/if.h>
    ])
    AC_CHECK_HEADER(linux/if_tun.h, [
        use_tuntap=yes
      ], [],
      [
      #include <asm/types.h>
      #include <sys/socket.h>
    ])
    if test "$use_tuntap" = yes; then
      NETLOW_OBJS="$NETLOW_OBJS eth_tuntap.o"
      AC_DEFINE(HAVE_TUNTAP, 1)
    fi

    ;;
  esac
  AC_DEFINE(BX_NETWORKING, 1)
else
  AC_DEFINE(BX_NETWORKING, 0)
fi

AC_SUBST(NETLOW_OBJS)


AC_MSG_CHECKING(for large pages support)
AC_ARG_ENABLE(large-pages,
  [  --enable-large-pages               support for large pages (2M/4M pages)],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_SUPPORT_LARGE_PAGES, 1)
    support_large_pages=1
   else
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SUPPORT_LARGE_PAGES, 0)
    support_large_pages=0
   fi],
  [
    if test "$bx_cpu_level" -gt 4; then
      AC_MSG_RESULT(yes)
      AC_DEFINE(BX_SUPPORT_LARGE_PAGES, 1)
      support_large_pages=1
    else
      AC_MSG_RESULT(no)
      AC_DEFINE(BX_SUPPORT_LARGE_PAGES, 0)
      support_large_pages=0
    fi
    ]
  )


AC_MSG_CHECKING(for PAE support)
AC_ARG_ENABLE(pae,
  [  --enable-pae                      support Physical Address Extensions],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_SUPPORT_PAE, 1)
    support_pae=1
   else
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SUPPORT_PAE, 0)
    support_pae=0
   fi],
  [
    if test "$bx_cpu_level" -gt 5; then
      AC_MSG_RESULT(yes)
      AC_DEFINE(BX_SUPPORT_PAE, 1)
      support_pae=1
    else
      AC_MSG_RESULT(no)
      AC_DEFINE(BX_SUPPORT_PAE, 0)
      support_pae=0
    fi
    ]
  )

AC_MSG_CHECKING(for global pages support)
AC_ARG_ENABLE(global-pages,
  [  --enable-global-pages             support for global pages in PDE/PTE],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_SUPPORT_GLOBAL_PAGES, 1)
    support_global_pages=1
   else
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SUPPORT_GLOBAL_PAGES, 0)
    support_global_pages=0
   fi],
  [
    if test "$bx_cpu_level" -gt 5; then
      # enable by default
      AC_MSG_RESULT(yes)
      AC_DEFINE(BX_SUPPORT_GLOBAL_PAGES, 1)
      support_global_pages=1
    else
      AC_MSG_RESULT(no)
      AC_DEFINE(BX_SUPPORT_GLOBAL_PAGES, 0)
      support_global_pages=0
    fi
    ]
  )

AC_MSG_CHECKING(for long mode 1G pages support)
AC_ARG_ENABLE(1g-pages,
  [  --enable-1g-pages                 support for 1G pages in long mode],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_SUPPORT_1G_PAGES, 1)
    support_1g_pages=1
   else
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SUPPORT_1G_PAGES, 0)
    support_1g_pages=0
   fi],
  [
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SUPPORT_1G_PAGES, 0)
    support_1g_pages=0
    ]
  )

if test "$support_1g_pages" = 1 -a "$use_x86_64" = 0; then
  AC_MSG_ERROR([x86-64 mode is required for 1G pages support])
fi

if test "$bx_cpu_level" -lt 4 -a "$support_large_pages" = 1; then
  AC_MSG_ERROR([for large paging support the CPU level must be >= 4])
fi

if test "$bx_cpu_level" -lt 5 -a "$support_pae" = 1; then
  AC_MSG_ERROR([for PAE support the CPU level must be >= 5])
fi

if test "$bx_cpu_level" -lt 5 -a "$support_global_pages" = 1; then
  AC_MSG_ERROR([for Global Pages support the CPU level must be >= 5])
fi

AC_MSG_CHECKING(for MTRRs support)
AC_ARG_ENABLE(mtrr,
  [  --enable-mtrr                     support for MTRRs],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_SUPPORT_MTRR, 1)
   else
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SUPPORT_MTRR, 0)
   fi],
  [
    if test "$bx_cpu_level" -gt 5; then
      # enable by default
      AC_MSG_RESULT(yes)
      AC_DEFINE(BX_SUPPORT_MTRR, 1)
    else
      AC_MSG_RESULT(no)
      AC_DEFINE(BX_SUPPORT_MTRR, 0)
    fi
    ]
  )

AC_MSG_CHECKING(for repeated IO and mem copy speedups)
AC_ARG_ENABLE(repeat-speedups,
  [  --enable-repeat-speedups          support repeated IO and mem copy speedups],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    speedup_repeat=1
   else
    AC_MSG_RESULT(no)
    speedup_repeat=0
   fi],
  [
    AC_MSG_RESULT(no)
    speedup_repeat=0
    ]
  )

AC_MSG_CHECKING(for instruction trace cache support)
AC_ARG_ENABLE(trace-cache,
  [  --enable-trace-cache              support instruction trace cache],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    speedup_TraceCache=1
   else
    AC_MSG_RESULT(no)
    speedup_TraceCache=0
   fi],
  [
    if test "$speedup_TraceCache " = 1; then
      AC_MSG_RESULT(yes)
      speedup_TraceCache=1
    else
      AC_MSG_RESULT(no)
      speedup_TraceCache=0
    fi
    ]
  )

AC_MSG_CHECKING(for instruction cache support)
AC_ARG_ENABLE(icache,
  [  --enable-icache                   support instruction cache],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    speedup_iCache=1
   else
    AC_MSG_RESULT(no)
    speedup_iCache=0
   fi],
  [
    AC_MSG_RESULT(no)
    speedup_iCache=0
    ]
  )

AC_MSG_CHECKING(for gcc fast function calls optimization)
AC_ARG_ENABLE(fast-function-calls,
  [  --enable-fast-function-calls      support for fast function calls (gcc on x86 only)],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    speedup_fastcall=1
   else
    AC_MSG_RESULT(no)
    speedup_fastcall=0
   fi],
  [
    AC_MSG_RESULT(no)
    speedup_fastcall=0
    ]
  )

AC_MSG_CHECKING(for host specific inline assembly accelerations)
AC_ARG_ENABLE(host-specific-asms,
  [  --enable-host-specific-asms       support for host specific inline assembly],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    speedup_host_specific_asms=1
   else
    AC_MSG_RESULT(no)
    speedup_host_specific_asms=0
   fi],
  [
    AC_MSG_RESULT(no)
    speedup_host_specific_asms=0
    ]
  )

AC_MSG_CHECKING(support for configurable MSR registers)
AC_ARG_ENABLE(configurable-msrs,
  [  --enable-configurable-msrs        support for configurable MSR registers],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_CONFIGURE_MSRS, 1)
   else
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_CONFIGURE_MSRS, 0)
   fi],
  [
    if test "$bx_cpu_level" -ge 5; then
      AC_MSG_RESULT(yes)
      AC_DEFINE(BX_CONFIGURE_MSRS, 1)
    else
      AC_MSG_RESULT(no)
      AC_DEFINE(BX_CONFIGURE_MSRS, 0)
    fi
    ]
  )

AC_MSG_CHECKING(whether to ignore bad MSR references)
AC_ARG_ENABLE(ignore-bad-msr,
  [  --enable-ignore-bad-msr           ignore bad MSR references],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_IGNORE_BAD_MSR, 1)
   else
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_IGNORE_BAD_MSR, 0)
   fi],
  [
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_IGNORE_BAD_MSR, 1)
    ]
  )

AC_MSG_CHECKING(for port e9 hack)
AC_ARG_ENABLE(port-e9-hack,
  [  --enable-port-e9-hack             writes to port e9 go to console],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_PORT_E9_HACK, 1)
   else
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_PORT_E9_HACK, 0)
   fi],
  [
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_PORT_E9_HACK, 1)
    ]
  )

AC_MSG_CHECKING(show IPS)
AC_ARG_ENABLE(show-ips,
  [  --enable-show-ips                 show IPS in Bochs log file],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_SHOW_IPS, 1)
   else
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SHOW_IPS, 0)
   fi],
  [
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SHOW_IPS, 0)
    ]
  )

AC_MSG_CHECKING(for use of .cpp as suffix)
AC_ARG_ENABLE(cpp,
  [  --enable-cpp                      use .cpp as C++ suffix],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    SUFFIX_LINE='.SUFFIXES: .cpp'
    CPP_SUFFIX='cpp'
   else
    AC_MSG_RESULT(no)
    SUFFIX_LINE='.SUFFIXES: .cc'
    CPP_SUFFIX='cc'
   fi],
  [
    AC_MSG_RESULT(no)
    SUFFIX_LINE='.SUFFIXES: .cc'
    CPP_SUFFIX='cc'
    ]
  )
AC_SUBST(SUFFIX_LINE)
AC_SUBST(CPP_SUFFIX)

if test "$enable_cpp" = yes; then
  echo "moving .cc source files to .cpp"
  sourcefiles=`find . -name "*.cc" -print`
  if test "$sourcefiles" != ""; then
    for ccname in $sourcefiles
    do
      cppname=`echo $ccname | sed -e "s/\.cc$/.cpp/"`
      echo "mv $ccname $cppname"
      mv   $ccname $cppname
    done
  else
    echo "no more .cc source files to rename"
  fi
fi



AC_MSG_CHECKING(for Bochs internal debugger support)
AC_ARG_ENABLE(debugger,
  [  --enable-debugger                 compile in support for Bochs internal debugger],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_DEBUGGER, 1)
    DEBUGGER_VAR='$(DEBUGGER_LIB)'
    bx_debugger=1
   else
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_DEBUGGER, 0)
    DEBUGGER_VAR=''
    bx_debugger=0
   fi
   ],
  [
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_DEBUGGER, 0)
    DEBUGGER_VAR=''
    bx_debugger=0
    ]
  )
AC_SUBST(DEBUGGER_VAR)

AC_MSG_CHECKING(for disassembler support)
AC_ARG_ENABLE(disasm,
  [  --enable-disasm                   compile in support for disassembler],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_DISASM, 1)
    DISASM_VAR='$(DISASM_LIB)'
   else
    AC_MSG_RESULT(no)
    if test "$bx_debugger" = 1; then
      echo "ERROR: debugger is enabled, so --enable-disasm is required"
      exit 1
    fi
    AC_DEFINE(BX_DISASM, 0)
    DISASM_VAR=''
   fi],
  [
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_DISASM, 1)
    DISASM_VAR='$(DISASM_LIB)'
  ])
AC_SUBST(DISASM_VAR)

AC_MSG_CHECKING(enable Bochs internal debugger GUI)
AC_ARG_ENABLE(debugger-gui,
  [  --enable-debugger-gui             compile in support for Bochs internal debugger GUI],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_DEBUGGER_GUI, 1)
   else
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_DEBUGGER_GUI, 0)
   fi],
  [
    if test "$bx_debugger" = 1; then
      AC_MSG_RESULT(yes)
      AC_DEFINE(BX_DEBUGGER_GUI, 1)
    else
      AC_MSG_RESULT(no)
      AC_DEFINE(BX_DEBUGGER_GUI, 0)
    fi
    ]
  )


AC_MSG_CHECKING(for ALL optimizations enabled)
AC_ARG_ENABLE(all-optimizations,
  [  --enable-all-optimizations        compile in all possible optimizations],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    speedups_all=1
   else
    AC_MSG_RESULT(no)
    speedups_all=0
   fi
   ],
  [
    AC_MSG_RESULT(no)
    speedups_all=0
    ]
  )

#
# Optimizations section.  Decide what the status of various optimizations
# should be based on configure choices and other factors.
#

if test "$speedups_all" = 1; then
  # Configure requested to force all options enabled.
  speedup_repeat=1
  speedup_iCache=1
  speedup_TraceCache=1
  speedup_fastcall=1
fi

if test "$speedup_iCache" = 0 -a "$speedup_TraceCache" = 1; then
  AC_MSG_ERROR([iCache is required to compile with trace cache optimization])
fi

if test "$speedup_repeat" = 1; then
  AC_DEFINE(BX_SupportRepeatSpeedups, 1)
else
  AC_DEFINE(BX_SupportRepeatSpeedups, 0)
fi

if test "$speedup_iCache" = 1; then
  AC_DEFINE(BX_SUPPORT_ICACHE, 1)
else
  AC_DEFINE(BX_SUPPORT_ICACHE, 0)
fi

if test "$speedup_host_specific_asms" = 1; then
  AC_DEFINE(BX_SupportHostAsms, 1)
else
  AC_DEFINE(BX_SupportHostAsms, 0)
fi

if test "$speedup_fastcall" = 1; then
  AC_DEFINE(BX_FAST_FUNC_CALL, 1)
else
  AC_DEFINE(BX_FAST_FUNC_CALL, 0)
fi

if test "$speedup_TraceCache" = 1; then
  AC_DEFINE(BX_SUPPORT_TRACE_CACHE, 1)
else
  AC_DEFINE(BX_SUPPORT_TRACE_CACHE, 0)
fi


READLINE_LIB=""
rl_without_curses_ok=no
rl_with_curses_ok=no

AC_MSG_CHECKING(whether user wants readline)
AC_ARG_ENABLE(readline,
  [  --enable-readline                 use readline library, if available],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
     want_readline=yes
   else
     AC_MSG_RESULT(no)
     want_readline=no
   fi],
  [
    AC_MSG_RESULT(yes)
    want_readline=yes
    ]
 )

use_readline=0
AC_MSG_CHECKING(whether to use readline)
if test "$want_readline" = yes; then
  if test "$bx_debugger" = 1; then

    AC_MSG_CHECKING(if readline works without -lcurses)
    OLD_LIBS=$LIBS
    LIBS="$LIBS -lreadline"
    AC_TRY_RUN([
      #include <stdio.h>
      #include <readline/readline.h>
      int main() { rl_initialize(); exit(0); }
      ],
      [ AC_MSG_RESULT(yes)
        rl_without_curses_ok=yes ],
      [ AC_MSG_RESULT(no) ]
    )
    AC_MSG_CHECKING(if readline works with -lcurses)
    LIBS="$LIBS -lcurses"
    AC_TRY_RUN([
      #include <stdio.h>
      #include <readline/readline.h>
      int main() { rl_initialize(); exit(0); }
      ],
      [AC_MSG_RESULT(yes)
       rl_with_curses_ok=yes ],
      [ AC_MSG_RESULT(no) ]
    )
    LIBS=$OLD_LIBS

    if test "$rl_without_curses_ok" = yes; then
      AC_MSG_RESULT(yes)
      AC_DEFINE(HAVE_LIBREADLINE, 1)
      READLINE_LIB="-lreadline"
      use_readline=1
    elif test "$rl_with_curses_ok" = yes; then
      AC_MSG_RESULT(yes)
      AC_DEFINE(HAVE_LIBREADLINE, 1)
      READLINE_LIB="-lreadline -lcurses"
      use_readline=1
    else
      AC_MSG_RESULT(no)
      echo WARNING: The readline library was disabled because it was not found.
    fi
  else
    AC_MSG_RESULT(no)
  fi
else
  AC_MSG_RESULT(no)
fi
AC_SUBST(READLINE_LIB)

AC_CHECK_HEADER(readline/history.h,
  AC_DEFINE(HAVE_READLINE_HISTORY_H)
  )

INSTRUMENT_DIR='instrument/stubs'

AC_MSG_CHECKING(for instrumentation support)
AC_ARG_ENABLE(instrumentation,
  [  --enable-instrumentation          compile in support for instrumentation],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_INSTRUMENTATION, 1)
    INSTRUMENT_VAR='$(INSTRUMENT_LIB)'
   elif test "$enableval" = no; then
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_INSTRUMENTATION, 0)
    INSTRUMENT_VAR=''
   else
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_INSTRUMENTATION, 1)
    INSTRUMENT_DIR=$enableval
    INSTRUMENT_VAR='$(INSTRUMENT_LIB)'
   fi],
  [
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_INSTRUMENTATION, 0)
    INSTRUMENT_VAR=''
    ]
  )
AC_SUBST(INSTRUMENT_DIR)
AC_SUBST(INSTRUMENT_VAR)

dnl // serial mode 'socket' needs wsock32.dll in non-plugin mode
if test "$bx_plugins" = 0; then
  case $target in
    *-pc-windows*)
      DEVICE_LINK_OPTS="$DEVICE_LINK_OPTS wsock32.lib"
      ;;
    *-cygwin* | *-mingw32*)
      DEVICE_LINK_OPTS="$DEVICE_LINK_OPTS -lwsock32"
      ;;
  esac
fi

AC_MSG_CHECKING(enable logging)
AC_ARG_ENABLE(logging,
  [  --enable-logging                  enable logging],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_NO_LOGGING, 0)
   else
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_NO_LOGGING, 1)
   fi],
  [
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_NO_LOGGING, 0)
    ]
  )

AC_MSG_CHECKING(enable assert checks)
AC_ARG_ENABLE(assert-checks,
  [  --enable-assert-checks            enable BX_ASSERT checks],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_ASSERT_ENABLE, 1)
   else
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_ASSERT_ENABLE, 0)
   fi],
  [
    if test "$bx_debugger" = 1; then
      AC_MSG_RESULT(yes)
      AC_DEFINE(BX_ASSERT_ENABLE, 1)
    else
      AC_MSG_RESULT(no)
      AC_DEFINE(BX_ASSERT_ENABLE, 0)
    fi
    ]
  )

AC_MSG_CHECKING(for raw serial support)
AC_ARG_ENABLE(raw-serial,
  [  --enable-raw-serial               use raw serial port access],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(USE_RAW_SERIAL, 1)
   else
    AC_MSG_RESULT(no)
    AC_DEFINE(USE_RAW_SERIAL, 0)
   fi],
  [
    AC_MSG_RESULT(no)
    AC_DEFINE(USE_RAW_SERIAL, 0)
    ]
  )

AC_MSG_CHECKING(for VESA BIOS extensions)
AC_ARG_ENABLE(vbe,
  [  --enable-vbe                      use VESA BIOS extensions],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_SUPPORT_VBE, 1)
    if test "$pci" = 1; then
      AC_DEFINE(BX_SUPPORT_PCIVGA, 1)
    fi
   else
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SUPPORT_VBE, 0)
   fi],
  [
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_SUPPORT_VBE, 1)
    if test "$pci" = 1; then
      AC_DEFINE(BX_SUPPORT_PCIVGA, 1)
    fi
    ]
  )

AC_MSG_CHECKING(for CLGD54XX emulation)
AC_ARG_ENABLE(clgd54xx,
  [  --enable-clgd54xx                 enable CLGD54XX emulation],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_SUPPORT_CLGD54XX, 1)
   else
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SUPPORT_CLGD54XX, 0)
   fi],
  [
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SUPPORT_CLGD54XX, 0)
    ]
  )

support_fpu=1
AC_MSG_CHECKING(for FPU emulation)
FPU_VAR=''
AC_ARG_ENABLE(fpu,
  [  --enable-fpu                      compile in FPU emulation],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_SUPPORT_FPU, 1)
    FPU_VAR='$(FPU_LIB)'
   elif test "$enableval" = no; then
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SUPPORT_FPU, 0)
    support_fpu=0
   else
    echo " "
    echo "ERROR: --enable-fpu does not accept a path"
    exit 1
   fi
   ],
  [
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_SUPPORT_FPU, 1)
    FPU_VAR='$(FPU_LIB)'
    ]
  )
AC_SUBST(FPU_VAR)

AC_MSG_CHECKING(for VME support)
AC_ARG_ENABLE(vme,
  [  --enable-vme                      virtual 8086 mode extensions],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_SUPPORT_VME, 1)
   elif test "$enableval" = no; then
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SUPPORT_VME, 0)
   fi
   ],
  [
    if test "$bx_cpu_level" -ge 5; then
      AC_MSG_RESULT(yes)
      AC_DEFINE(BX_SUPPORT_VME, 1)
    else
      AC_MSG_RESULT(no)
      AC_DEFINE(BX_SUPPORT_VME, 0)
    fi
    ]
  )

support_mmx=1
AC_MSG_CHECKING(for MMX support)
AC_ARG_ENABLE(mmx,
  [  --enable-mmx                      MMX support],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_SUPPORT_MMX, 1)
   elif test "$enableval" = no; then
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SUPPORT_MMX, 0)
    support_mmx=0
   fi
   ],
  [
    if test "$bx_cpu_level" -ge 5; then
      AC_MSG_RESULT(yes)
      AC_DEFINE(BX_SUPPORT_MMX, 1)
    else
      AC_MSG_RESULT(no)
      AC_DEFINE(BX_SUPPORT_MMX, 0)
    fi
    ]
  )

AC_MSG_CHECKING(for 3DNow! support)
AC_ARG_ENABLE(3dnow,
  [  --enable-3dnow                    3DNow! support (incomplete)],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_SUPPORT_3DNOW, 1)
   elif test "$enableval" = no; then
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SUPPORT_3DNOW, 0)
   fi
   ],
  [
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SUPPORT_3DNOW, 0)
  ]
  )

support_sse=0
AC_MSG_CHECKING(for SSE support)
AC_ARG_ENABLE(sse,
  [  --enable-sse                      SSE support (--enable-sse=[no|1|2|3|4])],
  [case "$enableval" in
    no | 0)
      support_sse=0
      AC_MSG_RESULT(no)
      ;;
    yes | 1)
      support_sse=1
      AC_MSG_RESULT(SSE1)
      ;;
    2)
      support_sse=2
      AC_MSG_RESULT(SSE2)
      ;;
    3)
      support_sse=3
      AC_MSG_RESULT(SSE3)
      ;;
    4)
      support_sse=4
      AC_MSG_RESULT(SSE4)
      ;;
    *)
      echo "ERROR: --enable-sse=$enableval not understood. Use --enable-sse=[no|1|2|3|4]"
      exit 1
      ;;
   esac
   ],
  [
    if test "$use_x86_64" = 1; then
      support_sse=2
      AC_MSG_RESULT(SSE2)
    else
      AC_MSG_RESULT(no)
    fi
  ]
  )

if test "$support_sse" -gt 0 -a "$bx_cpu_level" -lt 6; then
  AC_MSG_ERROR([for SSE support the CPU level must be set to 6])
fi

if test "$support_sse" -lt 2 -a "$use_x86_64" = 1; then
  AC_MSG_ERROR([x86-64 needs SSE2 support])
fi

if test "$support_sse" = 4; then
  AC_DEFINE(BX_SUPPORT_SSE,  4)
elif test "$support_sse" = 3; then
  AC_DEFINE(BX_SUPPORT_SSE,  3)
elif test "$support_sse" = 2; then
  AC_DEFINE(BX_SUPPORT_SSE,  2)
elif test "$support_sse" = 1; then
  AC_DEFINE(BX_SUPPORT_SSE,  1)
else
  AC_DEFINE(BX_SUPPORT_SSE,  0)
fi

support_sse_extensions=0
AC_MSG_CHECKING(for SSE extensions support)
AC_ARG_ENABLE(sse-extension,
  [  --enable-sse-extension            support for SSE extensions],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_SUPPORT_SSE_EXTENSION, 1)
    support_sse_extensions=1
   elif test "$enableval" = no; then
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SUPPORT_SSE_EXTENSION, 0)
   fi
   ],
  [
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SUPPORT_SSE_EXTENSION, 0)
  ]
  )

AC_MSG_CHECKING(for DAZ support)
AC_ARG_ENABLE(daz,
  [  --enable-daz                      denormals-are-zeroes support],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_SUPPORT_DAZ, 1)
   elif test "$enableval" = no; then
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SUPPORT_DAZ, 0)
   fi
   ],
  [
    if test "$support_sse" -ge 2; then
      AC_MSG_RESULT(yes)
      AC_DEFINE(BX_SUPPORT_DAZ, 1)
    else
      AC_MSG_RESULT(no)
      AC_DEFINE(BX_SUPPORT_DAZ, 0)
    fi
    ]
  )

use_xsave=0
AC_MSG_CHECKING(for XSAVE/XRSTOR support)
AC_ARG_ENABLE(xsave,
  [  --enable-xsave                    support for XSAVE/XRSTOR extensions],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_SUPPORT_XSAVE, 1)
    use_xsave=1
   elif test "$enableval" = no; then
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SUPPORT_XSAVE, 0)
   fi
   ],
  [
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SUPPORT_XSAVE, 0)
  ]
  )

if test "$support_sse" -lt 1 -a "$use_xsave" = 1; then
  AC_MSG_ERROR([XSAVE requires SSE support!])
fi

use_aes=0
AC_MSG_CHECKING(for AES instructions support)
AC_ARG_ENABLE(aes,
  [  --enable-aes                      support for AES instructions],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_SUPPORT_AES, 1)
    use_aes=1
   elif test "$enableval" = no; then
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SUPPORT_AES, 0)
   fi
   ],
  [
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SUPPORT_AES, 0)
  ]
  )

if test "$support_sse" -lt 1 -a "$use_aes" = 1; then
  AC_MSG_ERROR([AES requires SSE support!])
fi

AC_MSG_CHECKING(for alignment check support)
AC_ARG_ENABLE(alignment-check,
  [  --enable-alignment-check          alignment check (#AC) support],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_SUPPORT_ALIGNMENT_CHECK, 1)
   elif test "$enableval" = no; then
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SUPPORT_ALIGNMENT_CHECK, 0)
   fi
   ],
  [
    if test "$bx_cpu_level" -gt 3; then
      AC_MSG_RESULT(yes)
      AC_DEFINE(BX_SUPPORT_ALIGNMENT_CHECK, 1)
    else
      AC_MSG_RESULT(no)
      AC_DEFINE(BX_SUPPORT_ALIGNMENT_CHECK, 0)
    fi
    ]
  )

AC_MSG_CHECKING(for misaligned SSE support)
AC_ARG_ENABLE(misaligned-sse,
  [  --enable-misaligned-sse           misaligned SSE support],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_SUPPORT_MISALIGNED_SSE, 1)
   elif test "$enableval" = no; then
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SUPPORT_MISALIGNED_SSE, 0)
   fi
   ],
  [
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SUPPORT_MISALIGNED_SSE, 0)
    ]
  )

AC_MSG_CHECKING(for SEP support)
AC_ARG_ENABLE(sep,
  [  --enable-sep                      SYSENTER/SYSEXIT support],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_SUPPORT_SEP, 1)
   elif test "$enableval" = no; then
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SUPPORT_SEP, 0)
   fi
   ],
  [
    if test "$bx_cpu_level" -ge 6 -a "$support_mmx" = 1; then
      AC_MSG_RESULT(yes)
      AC_DEFINE(BX_SUPPORT_SEP, 1)
    else
      AC_MSG_RESULT(no)
      AC_DEFINE(BX_SUPPORT_SEP, 0)
    fi
    ]
  )

AC_MSG_CHECKING(for POPCNT instruction support)
AC_ARG_ENABLE(popcnt,
  [  --enable-popcnt                   support for POPCNT instruction],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_SUPPORT_POPCNT, 1)
   elif test "$enableval" = no; then
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SUPPORT_POPCNT, 0)
   fi
   ],
  [
    if test "$support_sse" -ge 4 -a "$support_sse_extensions" = 1; then
      AC_MSG_RESULT(yes)
      AC_DEFINE(BX_SUPPORT_POPCNT, 1)
    else
      AC_MSG_RESULT(no)
      AC_DEFINE(BX_SUPPORT_POPCNT, 0)
    fi
    ]
  )

AC_MSG_CHECKING(for MOVBE instruction support)
AC_ARG_ENABLE(movbe,
  [  --enable-movbe                    support for MOVBE Intel Atom(R) instruction],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_SUPPORT_MOVBE, 1)
   elif test "$enableval" = no; then
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SUPPORT_MOVBE, 0)
   fi
   ],
  [
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SUPPORT_MOVBE, 0)
  ]
  )

AC_MSG_CHECKING(for MONITOR/MWAIT instructions support (experimental))
AC_ARG_ENABLE(monitor_mwait,
  [  --enable-monitor-mwait            support for MONITOR/MWAIT instructions (experimental)],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_SUPPORT_MONITOR_MWAIT, 1)
   elif test "$enableval" = no; then
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SUPPORT_MONITOR_MWAIT, 0)
   fi
   ],
  [
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SUPPORT_MONITOR_MWAIT, 0)
  ]
  )

AC_MSG_CHECKING(for x86 debugger support)
AC_ARG_ENABLE(x86-debugger,
  [  --enable-x86-debugger             x86 debugger support],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_X86_DEBUGGER, 1)
   elif test "$enableval" = no; then
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_X86_DEBUGGER, 0)
   fi
   ],
  [
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_X86_DEBUGGER, 0)
    ]
  )

AC_CHECK_HEADER(IOKit/storage/IOCDMedia.h,
  can_use_osx_cdrom=yes
  )

AC_MSG_CHECKING(for CDROM support)
AC_ARG_ENABLE(cdrom,
  [  --enable-cdrom                    CDROM support],
  [if test "$enableval" = no; then
     bx_cdrom=0
   else
     bx_cdrom=1
   fi],
  [ bx_cdrom=1 ]
  )

if test "$bx_cdrom" = 1; then
    AC_MSG_RESULT(yes)
    CDROM_OBJS='cdrom.o'
    if test "$with_amigaos" = yes; then
      # use the amiga cdrom file instead.
      CDROM_OBJS="cdrom_amigaos.o"
    elif test "$can_use_osx_cdrom" = yes; then
      # use cdrom_osx
      AC_MSG_RESULT(Using OSX IOKit CD Interface)
      CDROM_OBJS="cdrom.o"
      EXTRA_LINK_OPTS="${EXTRA_LINK_OPTS} -framework IOKit -framework CoreFoundation "'$(GUI_LINK_OPTS)'
    fi
    case $target in
      *-beos*)
	# use the beos cdrom file instead
	CDROM_OBJS="$CDROM_OBJS cdrom_beos.o"
    esac
    AC_DEFINE(BX_SUPPORT_CDROM, 1)
else
    AC_MSG_RESULT(no)
    CDROM_OBJS=''
    AC_DEFINE(BX_SUPPORT_CDROM, 0)
fi

AC_SUBST(CDROM_OBJS)


bx_have_alsa=0
AC_CHECK_HEADER([alsa/asoundlib.h], [bx_have_alsa=1])

AC_MSG_CHECKING(for Sound Blaster 16 support)
SB16_OBJS=''
SOUNDLOW_OBJS=''
GAME_OBJS=''
gameport_present=0
AC_ARG_ENABLE(sb16,
  [  --enable-sb16=xxx                 Sound Blaster 16 Support (xxx=dummy|win|linux|freebsd|osx)],
  [if test "$enableval" = no; then
     AC_MSG_RESULT(no)
     AC_DEFINE(BX_SUPPORT_SB16, 0)
   else
     case "$enableval" in
       dummy)
         SOUNDLOW_OBJS=''
         AC_DEFINE(BX_SOUND_OUTPUT_C, bx_sound_output_c)
         AC_MSG_RESULT(dummy)
         ;;
       freebsd|linux)
         SOUNDLOW_OBJS='soundlnx.o'
         AC_DEFINE(BX_SOUND_OUTPUT_C, bx_sound_linux_c)
         if test "$bx_have_alsa" = 1; then
           AC_DEFINE(BX_HAVE_ALSASOUND, 1)
           if test "$bx_plugins" = 1; then
             SOUND_LINK_OPTS="$SOUND_LINK_OPTS -lasound"
           else
             DEVICE_LINK_OPTS="$DEVICE_LINK_OPTS -lasound"
           fi
         fi
         AC_MSG_RESULT(linux)
         ;;
       win)
         SOUNDLOW_OBJS='soundwin.o'
         AC_DEFINE(BX_SOUND_OUTPUT_C, bx_sound_windows_c)
         AC_MSG_RESULT(win)
         case $target in
           *-pc-windows*)
             DEVICE_LINK_OPTS="$DEVICE_LINK_OPTS winmm.lib"
             ;;
           *)
             DEVICE_LINK_OPTS="$DEVICE_LINK_OPTS -lwinmm"
             ;;
         esac
         ;;
       osx)
         SOUNDLOW_OBJS='soundosx.o'
         AC_DEFINE(BX_SOUND_OUTPUT_C, bx_sound_osx_c)
         AC_MSG_RESULT(osx)
         DEVICE_LINK_OPTS="$DEVICE_LINK_OPTS -framework AudioUnit -framework AudioToolbox"
         ;;
       yes)
         case "$target" in
           *-linux* | *-freebsd*)
             SOUNDLOW_OBJS='soundlnx.o'
             AC_DEFINE(BX_SOUND_OUTPUT_C, bx_sound_linux_c)
             if test "$bx_have_alsa" = 1; then
               AC_DEFINE(BX_HAVE_ALSASOUND, 1)
               if test "$bx_plugins" = 1; then
                 SOUND_LINK_OPTS="$SOUND_LINK_OPTS -lasound"
               else
                 DEVICE_LINK_OPTS="$DEVICE_LINK_OPTS -lasound"
               fi
             fi
             AC_MSG_RESULT(linux)
             ;;
           *-pc-windows*)
             SOUNDLOW_OBJS='soundwin.o'
             AC_DEFINE(BX_SOUND_OUTPUT_C, bx_sound_windows_c)
             AC_MSG_RESULT(win)
             DEVICE_LINK_OPTS="$DEVICE_LINK_OPTS winmm.lib"
             ;;
           *-cygwin* | *-mingw32*)
             SOUNDLOW_OBJS='soundwin.o'
             AC_DEFINE(BX_SOUND_OUTPUT_C, bx_sound_windows_c)
             AC_MSG_RESULT(win)
             DEVICE_LINK_OPTS="$DEVICE_LINK_OPTS -lwinmm"
             ;;
           *-macosx* | *-macos*)
             SOUNDLOW_OBJS='soundosx.o'
             AC_DEFINE(BX_SOUND_OUTPUT_C, bx_sound_osx_c)
             AC_MSG_RESULT(osx)
             DEVICE_LINK_OPTS="$DEVICE_LINK_OPTS -framework AudioUnit -framework AudioToolbox"
             ;;
           *)
             SOUNDLOW_OBJS=''
             AC_DEFINE(BX_SOUND_OUTPUT_C, bx_sound_output_c)
             AC_MSG_RESULT(dummy)
             ;;
         esac
         ;;
       *)
         echo " "
         echo \!\!\!Error\!\!\!
         echo "You must pass one of dummy, linux, win, freebsd, osx to --enable-sb16"
         exit 1 ;;
     esac
     SB16_OBJS='sb16.o'
     AC_DEFINE(BX_SUPPORT_SB16, 1)
     GAME_OBJS='gameport.o'
     gameport_present=1
   fi],

  [
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SUPPORT_SB16, 0)
    ]
  )
AC_SUBST(SB16_OBJS)
AC_SUBST(SOUNDLOW_OBJS)
AC_SUBST(SOUND_LINK_OPTS)


AC_MSG_CHECKING(for standard PC gameport support)
AC_ARG_ENABLE(gameport,
  [  --enable-gameport                 enable standard PC gameport support],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_SUPPORT_GAMEPORT, 1)
    if test "$gameport_present" = 0; then
      GAME_OBJS='gameport.o'
      case $target in
        *-cygwin* | *-mingw32*)
           DEVICE_LINK_OPTS="$DEVICE_LINK_OPTS -lwinmm"
           ;;
      esac
    fi
   else
    AC_MSG_RESULT(no)
    GAME_OBJS=''
    AC_DEFINE(BX_SUPPORT_GAMEPORT, 0)
   fi],
  [
    if test "$gameport_present" = 1; then
      AC_DEFINE(BX_SUPPORT_GAMEPORT, 1)
      AC_MSG_RESULT(yes)
    else
      AC_DEFINE(BX_SUPPORT_GAMEPORT, 0)
      AC_MSG_RESULT(no)
    fi]
  )
AC_SUBST(GAME_OBJS)


AC_MSG_CHECKING(for gdb stub enable)
AC_ARG_ENABLE(gdb-stub,
  [  --enable-gdb-stub                 enable gdb stub support],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_GDBSTUB, 1)
    GDBSTUB_VAR='$(GDBSTUB_OBJS)'
    if test "$bx_debugger" = 1; then
      AC_MSG_ERROR([[--enable-debugger and --enable-gdb-stub are mutually exclusive]])
    fi
   else
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_GDBSTUB, 0)
    GDBSTUB_VAR=''
   fi],
  [
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_GDBSTUB, 0)
    GDBSTUB_VAR=''
    ]
  )
AC_SUBST(GDBSTUB_VAR)


AC_MSG_CHECKING(for I/O Interface to the debugger)
IODEBUG_OBJS=''
AC_ARG_ENABLE(iodebug,
  [  --enable-iodebug                  enable I/O interface to debugger],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_SUPPORT_IODEBUG, 1)
    IODEBUG_OBJS='iodebug.o'
   else
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SUPPORT_IODEBUG, 0)
   fi
   ],
  [
    if test "" = 1; then
      # enable by default if debugger is on
      AC_MSG_RESULT(yes)
      AC_DEFINE(BX_SUPPORT_IODEBUG, 1)
      IODEBUG_OBJS='iodebug.o'
    else
      AC_MSG_RESULT(no)
    fi
    ]
  )
AC_SUBST(IODEBUG_OBJS)


AC_PATH_PROG(DOCBOOK2HTML, docbook2html, not_found)
AC_MSG_CHECKING(whether to build docbook documentation)
build_docbook=0
AC_ARG_ENABLE(docbook,
  [  --enable-docbook                  build the Docbook documentation],
  [
    if test "$enableval" = yes; then build_docbook=1; fi
  ],
  [
    dnl Not specified. If they have docbook2html, then yes.
    if test "$DOCBOOK2HTML" != not_found; then build_docbook=1; fi
    ]
  )

if test $build_docbook = 1; then
  AC_MSG_RESULT(yes)
  BUILD_DOCBOOK_VAR=build_docbook
  INSTALL_DOCBOOK_VAR=install_docbook
  if test "$DOCBOOK2HTML" = not_found; then
    echo "ERROR: docbook2html must be installed to build the documentation"
    exit 1
  fi
else
  AC_MSG_RESULT(no)
fi
AC_SUBST(BUILD_DOCBOOK_VAR)
AC_SUBST(INSTALL_DOCBOOK_VAR)
AC_SUBST(DOCBOOK2HTML)

PRIMARY_TARGET='bochs'
PLUGIN_LIBNAME_TRANSFORMATION='%.o=libbx_%.la'

AC_DEFINE(BX_PROVIDE_DEVICE_MODELS, 1)
IODEV_LIB_VAR='iodev/libiodev.a'
AC_DEFINE(BX_PROVIDE_CPU_MEMORY, 1)
NONINLINE_VAR='$(NONINLINE_OBJS)'

AC_SUBST(IODEV_LIB_VAR)
AC_SUBST(EXTRA_BX_OBJS)
AC_SUBST(NONINLINE_VAR)
AC_SUBST(INLINE_VAR)
AC_SUBST(EXTERNAL_DEPENDENCY)
AC_SUBST(RC_CMD)


AC_ARG_WITH(x11,
  [  --with-x11                        use X11 GUI],
  )

AC_ARG_WITH(beos,
  [  --with-beos                       use BeOS GUI],
  )

AC_ARG_WITH(win32,
  [  --with-win32                      use Win32 GUI],
  )

AC_ARG_WITH(macos,
  [  --with-macos                      use Macintosh/CodeWarrior environment],
  )

AC_ARG_WITH(carbon,
  [  --with-carbon                     compile for MacOS X with Carbon GUI],
  )

AC_ARG_WITH(nogui,
  [  --with-nogui                      no native GUI, just use blank stubs],
  )

AC_ARG_WITH(term,
  [  --with-term                       textmode terminal environment],
  )

AC_ARG_WITH(rfb,
  [  --with-rfb                        use RFB protocol, works with VNC viewer],
  )

AC_ARG_WITH(amigaos,
  [  --with-amigaos                    use AmigaOS (or MorphOS) GUI],
  )

AC_ARG_WITH(sdl,
  [  --with-sdl                        use SDL libraries],
  )

AC_ARG_WITH(svga,
  [  --with-svga                       use SVGALib libraries],
  )

AC_ARG_WITH(wx,
  [  --with-wx                         use wxWidgets libraries],
  )

AC_ARG_WITH(all-libs,
  [  --with-all-libs                   compile all guis that Bochs supports],
  )

dnl // DASH is option prefix for your platform
dnl // SLASH is directory for your platform
dnl // CXXFP is C++ File Prefix; the flag that tells the compiler
dnl //   this is a C++ source file
dnl // CFP is C File Prefix; the flag that tells the compiler
dnl //   this is a C source file
dnl // OFP is Object File Prefix; the flag that tells the compiler
dnl //   generate an object file with this name
DASH="-"
SLASH="/"
CXXFP=""
CFP=""
OFP="-o "
MAKELIB="ar rv \$@"
RMCOMMAND="rm -f "
# first define link variables without libtool
LINK="\$(CXX) -o \$@ \$(CXXFLAGS) \$(LDFLAGS)"
LINK_CONSOLE="\$(CXX) -o \$@ \$(CXXFLAGS_CONSOLE) \$(LDFLAGS)"
# unless NO_LT is set, add libtool to the front of the link command
if test "$NO_LT" != 1; then
  LINK="\$(LIBTOOL) --mode=link $LINK"
  LINK_CONSOLE="\$(LIBTOOL) --mode=link $LINK_CONSOLE"
fi
EXE=""
COMMAND_SEPARATOR="&& \\"
CD_UP_ONE="echo done"
CD_UP_TWO="echo done"
CD_UP_THREE="echo done"

INSTALL_TARGET=install_unix
INSTALL_LIST_FOR_PLATFORM=

# check for existence of and usable version of wxWidgets.  This comes
# early so that it could affect which one gets chosen.
if test x$WX_CONFIG = x; then
  AC_CHECK_PROG(WX_CONFIG, [ wx-config --version ], wx-config, not_found)
fi
AC_MSG_CHECKING(for wxWidgets configuration script)
AC_MSG_RESULT($WX_CONFIG)

ok_wx_version=0
wx_multi_lib=0
wx_needs_gtk2=0
AC_MSG_CHECKING(for wxWidgets library version)
if test x$WX_CONFIG != xnot_found; then
  WX_VERSION=`$WX_CONFIG --version`
  WX_BASENAME=`$WX_CONFIG --basename`
  [
  # test that version >= 2.3.2.  Anybody have a better way to do this? Yuck.
  case x$WX_VERSION in
    x2.[012]*) ;; # less than version 2.3.x
    x2.3.[01]) ;; # less than version 2.3.2
    x2.3.[2-4]*) ok_wx_version=1 ;;  # 2.3.2 or greater
    x2.[4-5]*) ok_wx_version=1 ;;  # version 2.4 / 2.5
    x2.[6-9]*)  # version 2.6 or greater
      ok_wx_version=1
      wx_multi_lib=1
      case x$WX_BASENAME in
	xwx_gtk2|xwx_gtk2u) wx_needs_gtk2=1 ;;
	*) ;;
      esac
      ;;
    x[3-9]*) ok_wx_version=1 ;;  # version 3 or greater
    *) ;; # who knows?
  esac
  ]
fi
AC_MSG_RESULT($WX_VERSION)
if test "$cross_configure" = 0; then
  if test "$ok_wx_version" = 1; then
    # detected a usable version
    if test "$with_all_libs" = yes; then
      with_wx=yes
    fi
  else
    if test "$with_wx" = yes; then
      AC_MSG_WARN([Bochs for wxWidgets cannot be compiled here, disabling it])
    fi
    with_wx=no
  fi
fi

AC_MSG_CHECKING(for default gui on this platform)
AC_MSG_RESULT($DEFAULT_GUI)

display_libs=""

# the $with_* variable tells the gui library to use, but does NOT necessarily
# indicate the platform.  Settings that depend on the platform should be
# handled later.

XPM_LIB=''
if test "$with_x11" = yes; then
  display_libs="$display_libs X11"
  if test "$no_x" = yes; then
    echo ERROR: X windows gui was selected, but X windows libraries were not found.
    exit 1
  fi
  AC_DEFINE(BX_WITH_X11, 1)
  SPECIFIC_GUI_OBJS="$SPECIFIC_GUI_OBJS \$(GUI_OBJS_X11)"
  GUI_CFLAGS="$GUI_CFLAGS \$(X_CFLAGS)"
  GUI_CXXFLAGS="$GUI_CXXFLAGS \$(X_CFLAGS)"
  GUI_LINK_OPTS="$GUI_LINK_OPTS \$(GUI_LINK_OPTS_X)"
  check_xpm=0
  AC_MSG_CHECKING(whether user wants XPM support)
  AC_ARG_ENABLE(xpm,
    [  --enable-xpm                      enable the check for XPM support],
    [if test "$enableval" = yes; then
      check_xpm=0
      AC_MSG_RESULT(yes)
      check_xpm=1
     else
      AC_MSG_RESULT(no)
      check_xpm=0
     fi],
    [
      AC_MSG_RESULT(yes)
      check_xpm=1
      ]
    )
  if test $check_xpm = 1; then
    AC_CHECK_HEADER(X11/xpm.h, [
        AC_DEFINE(BX_HAVE_XPM_H)
        XPM_LIB='-lXpm'
      ])
  fi
fi
AC_SUBST(XPM_LIB)

if test "$with_beos" = yes; then
  display_libs="$display_libs beos"
  AC_DEFINE(BX_WITH_BEOS, 1)
  SPECIFIC_GUI_OBJS="$SPECIFIC_GUI_OBJS \$(GUI_OBJS_BEOS)"
  GUI_LINK_OPTS="$GUI_LINK_OPTS \$(GUI_LINK_OPTS_BEOS)"
fi

if test "$with_sdl" = yes; then
  display_libs="$display_libs sdl"
  AC_DEFINE(BX_WITH_SDL, 1)
  SPECIFIC_GUI_OBJS="$SPECIFIC_GUI_OBJS \$(GUI_OBJS_SDL)"
  # GUI_*FLAGS are added to the compilation of every bochs file, not just
  # the files in gui/*.cc.
  SDL_CFLAGS=`sdl-config --cflags`
  GUI_CFLAGS="$GUI_CFLAGS $SDL_CFLAGS"
  GUI_CXXFLAGS="$GUI_CXXFLAGS $SDL_CFLAGS"
  GUI_LINK_OPTS="$GUI_LINK_OPTS \$(GUI_LINK_OPTS_SDL)"
  if test "$with_win32" != yes -a "$with_wx" != yes; then
    case $target in
      *-pc-windows*)
         RC_CMD="rc /fo"
         EXTRA_BX_OBJS="$EXTRA_BX_OBJS win32res.o"
         ;;
      *-cygwin* | *-mingw32*)
         RC_CMD="windres -o "
         EXTRA_BX_OBJS="$EXTRA_BX_OBJS win32res.o"
         ;;
    esac
  fi
fi

if test "$with_svga" = yes; then
  display_libs="$display_libs svga"
  AC_DEFINE(BX_WITH_SVGA, 1)
  SPECIFIC_GUI_OBJS="$SPECIFIC_GUI_OBJS \$(GUI_OBJS_SVGA)"
  # GUI_*FLAGS are added to the compilation of every bochs file, not just
  # the files in gui/*.cc.
  GUI_CFLAGS="$GUI_CFLAGS"
  GUI_CXXFLAGS="$GUI_CXXFLAGS"
  GUI_LINK_OPTS="$GUI_LINK_OPTS \$(GUI_LINK_OPTS_SVGA)"
fi

if test "$with_rfb" = yes; then
  display_libs="$display_libs rfb"
  AC_DEFINE(BX_WITH_RFB, 1)
  SPECIFIC_GUI_OBJS="$SPECIFIC_GUI_OBJS \$(GUI_OBJS_RFB)"
  GUI_LINK_OPTS="$GUI_LINK_OPTS \$(GUI_LINK_OPTS_RFB)"
fi

if test "$with_amigaos" = yes; then
  display_libs="$display_libs amigaos"
  AC_DEFINE(BX_WITH_AMIGAOS, 1)
  SPECIFIC_GUI_OBJS="$SPECIFIC_GUI_OBJS \$(GUI_OBJS_AMIGAOS)"
  GUI_LINK_OPTS="$GUI_LINK_OPTS \$(GUI_LINK_OPTS_AMIGAOS)"
fi

if test "$with_win32" = yes; then
  display_libs="$display_libs win32"
  AC_DEFINE(BX_WITH_WIN32, 1)
  SPECIFIC_GUI_OBJS="$SPECIFIC_GUI_OBJS \$(GUI_OBJS_WIN32)"
  case $target in
    *-pc-windows*)
       if test "$with_wx" != yes; then
         RC_CMD="rc /fo"
         EXTRA_BX_OBJS="$EXTRA_BX_OBJS win32res.o"
       fi
       GUI_LINK_OPTS="$GUI_LINK_OPTS \$(GUI_LINK_OPTS_WIN32_VCPP)"
       ;;
    *-cygwin* | *-mingw32*)
       if test "$with_wx" != yes; then
         RC_CMD="windres -o "
         EXTRA_BX_OBJS="$EXTRA_BX_OBJS win32res.o"
       fi
       GUI_LINK_OPTS="$GUI_LINK_OPTS \$(GUI_LINK_OPTS_WIN32)"
       ;;
    *) echo Unsupported compile setup: GUI library is win32, but target is neither windows nor cygwin.
       ;;
  esac
fi

if test "$with_macos" = yes; then
  display_libs="$display_libs macos"
  AC_DEFINE(BX_WITH_MACOS, 1)
  SPECIFIC_GUI_OBJS="$SPECIFIC_GUI_OBJS \$(GUI_OBJS_MACOS)"
  GUI_LINK_OPTS="$GUI_LINK_OPTS \$(GUI_LINK_OPTS_MACOS)"
fi

if test "$with_carbon" = yes; then
  display_libs="$display_libs carbon"
  AC_DEFINE(BX_WITH_CARBON, 1)
  SPECIFIC_GUI_OBJS="$SPECIFIC_GUI_OBJS \$(GUI_OBJS_CARBON)"
  GUI_LINK_OPTS="$GUI_LINK_OPTS \$(GUI_LINK_OPTS_CARBON)"
  if test "$bx_plugins" = 1; then
    PRIMARY_TARGET=bochs.app/.build_plugins   # only for carbon application
  else
    PRIMARY_TARGET=bochs.app/.build   # only for carbon application
  fi
  INSTALL_TARGET='install_macosx'
fi

if test "$with_term" = yes; then
  display_libs="$display_libs term"
  AC_DEFINE(BX_WITH_TERM, 1)
  SPECIFIC_GUI_OBJS="$SPECIFIC_GUI_OBJS \$(GUI_OBJS_TERM)"
  GUI_LINK_OPTS="$GUI_LINK_OPTS \$(GUI_LINK_OPTS_TERM)"
  use_curses=yes
fi

if test "$with_wx" = yes; then
  display_libs="$display_libs wxWidgets"
  if test "$cross_configure" = 1; then
    true  # do not insist, if configuring for another machine
  else
    if test x$ok_wx_version != x1; then
      echo ERROR: A usable version of wxWidgets was not found.
      echo Upgrade the library or choose another gui.
      exit 1
    fi
  fi
  AC_DEFINE(BX_WITH_WX, 1)
  SPECIFIC_GUI_OBJS="$SPECIFIC_GUI_OBJS \$(GUI_OBJS_WX)"
  SPECIFIC_GUI_SUPPORT_OBJS="$SPECIFIC_GUI_SUPPORT_OBJS \$(GUI_OBJS_WX_SUPPORT)"
  WX_CFLAGS="`$WX_CONFIG --cflags`"
  WX_CXXFLAGS="`$WX_CONFIG --cxxflags`"
  if test "$wx_multi_lib" = 1; then
    GUI_LINK_OPTS_WX="`$WX_CONFIG --libs core,base`"
  else
    GUI_LINK_OPTS_WX="`$WX_CONFIG --libs`"
  fi
  if test "$wx_needs_gtk2" = 1; then
    PKG_CHECK_MODULES([GTK], [gtk+-2.0], [
      WX_CFLAGS="$WX_CFLAGS $GTK_CFLAGS"
      WX_CXXFLAGS="$WX_CXXFLAGS $GTK_CFLAGS"
    ])
  else
    # if gtk-config exists, then add it to the cflags.
    gtkconf=`gtk-config --cflags`
    if test $? = 0; then
      # gtk-config was found and returned 0, so it must return valid output
      WX_CFLAGS="$WX_CFLAGS $gtkconf"
      WX_CXXFLAGS="$WX_CXXFLAGS $gtkconf"
    fi
  fi
  # GUI_C*FLAGS are added to the compilation of every bochs file, not just
  # the files in gui/*.cc.  They are not used when building other things
  # such as bximage.
  GUI_CFLAGS="$GUI_CFLAGS $WX_CFLAGS"
  GUI_CXXFLAGS="$GUI_CXXFLAGS $WX_CXXFLAGS"
  GUI_LINK_OPTS="$GUI_LINK_OPTS \$(GUI_LINK_OPTS_WX)"
  # using debugger with readline is failing due to thread/signal handler
  # problems.
  case $target in
    *-pc-windows* | *-cygwin* | *-mingw32*)
       EXTRA_BX_OBJS="$EXTRA_BX_OBJS wxbochs_resources.o"
	   GUI_LINK_OPTS_WX="$GUI_LINK_OPTS_WX --subsystem,windows -mwindows"
       ;;
  esac
fi

if test "$with_nogui" = yes; then
  display_libs="$display_libs nogui"
  AC_DEFINE(BX_WITH_NOGUI, 1)
  SPECIFIC_GUI_OBJS="$SPECIFIC_GUI_OBJS \$(GUI_OBJS_NOGUI)"
fi

AC_MSG_CHECKING(for display libraries)
AC_MSG_RESULT($display_libs)

if test "$display_libs" = ""; then
  echo "No display libraries were selected. Use --with-* options to enable"
  echo "individual display libraries, or --with-all-libs to detect the ones"
  echo "that Bochs supports."
  exit 1
fi

dnl To use wxWidgets you must select it as both the configuration interface
dnl and the display library.  In the simplest case where the user has
dnl only configured with --with-wx, set both defaults to wxWidgets.
dnl Without this setting, the config interface would default to the text
dnl mode config interface, and then the wxWidgets display library would not
dnl be usable.
if test "$display_libs" = " wxWidgets"; then
  AC_MSG_CHECKING(for default configuration interface)
  AC_MSG_RESULT(wxWidgets)
  AC_MSG_CHECKING(for default display library)
  AC_MSG_RESULT(wxWidgets)
  AC_DEFINE(BX_DEFAULT_CONFIG_INTERFACE, "wx")
  AC_DEFINE(BX_DEFAULT_DISPLAY_LIBRARY, "wx")
  AC_DEFINE(BX_USE_TEXTCONFIG, 0)
else
  AC_DEFINE(BX_USE_TEXTCONFIG, 1)
fi

if test "$bx_plugins" = 1; then
  # every item in this list will be compiled as a plugin. Do not include
  # support objs; they will be mentioned in plugin-specific makefile rules.
  GUI_PLUGIN_OBJS="$GUI_PLUGIN_OBJS $SPECIFIC_GUI_OBJS"
else
  # include support objs
  GUI_NON_PLUGIN_OBJS="$GUI_NON_PLUGIN_OBJS $SPECIFIC_GUI_OBJS $SPECIFIC_GUI_SUPPORT_OBJS"
fi

AC_SUBST(GUI_CFLAGS)
AC_SUBST(GUI_CXXFLAGS)
AC_SUBST(WX_CONFIG)
AC_SUBST(WX_CFLAGS)
AC_SUBST(WX_CXXFLAGS)

AC_CHECK_PROGS(WGET, wget curl fetch, not_found)
if test "$WGET" = not_found; then
  AC_MSG_WARN([cannot find wget (or equivalent) command])
fi
# everybody has to re-invent the wheel. differently.
test "${WGET}" = "curl" && WGET="curl -O"

# modify settings based on target platform
case "$target" in
  *-macosx*)
    AC_DEFINE(BX_HAVE_STRDUP, 0)
    ;;
  *-macos*)
    AC_DEFINE(BX_HAVE_STRDUP, 0)
    AC_DEFINE(BX_PLUGINS, 0)
    AC_DEFINE(BX_HAVE_DLFCN_H, 0)
    AC_DEFINE(BX_HAVE_SOCKLEN_T, 0)
    AC_DEFINE(BX_HAVE_SELECT, 0)
    AC_DEFINE(BX_HAVE_GETTIMEOFDAY, 0)
    AC_DEFINE(BX_NO_ATTRIBUTES, 1)
    AC_DEFINE(HAVE_TUNTAP, 0)
    AC_DEFINE(HAVE_ETHERTAP, 0)
    AC_DEFINE(BX_HAVE_HASH_MAP, 0)
    ;;
  *-pc-windows*)
    INSTALL_TARGET='install_win32'
    CC="cl"
    CXX="$CC"
    #C_OPT="/Zi"   # for debugging
    C_OPT="/Ox"   # optimize for speed
    CFLAGS="/nologo /G6 /MT /W3 /GX- /DNDEBUG /DWIN32 /D_WINDOWS $C_OPT"
    CXXFLAGS="$CFLAGS"
    DASH="/"
    SLASH="\\"
    CXXFP="/Tp"
    CFP="/Tc"
    OFP="/Fo"
    MAKE=nmake
    MAKELIB="lib /nologo /subsystem:console /verbose /out:\$@"
    RMCOMMAND="-del"
    RANLIB="echo"
    #L_OPT="/debug"    # for debugging
    L_OPT=""           # no debug info
    LINK="link $L_OPT /nologo /subsystem:console /incremental:no /out:\$@ "
    LINK_CONSOLE=$LINK
    EXE=".exe"
    PRIMARY_TARGET="bochs.exe"
    BXIMAGE_LINK_OPTS="user32.lib"
    # also compile niclist if networking is on
    if test "$networking" = yes; then
      PRIMARY_TARGET="$PRIMARY_TARGET niclist.exe"
    fi
    COMMAND_SEPARATOR=""
    CD_UP_ONE="cd .."
    CD_UP_TWO="cd ..\.."
    CD_UP_THREE="cd ..\..\.."
    have_gettimeofday=0  # even though it may exist in build environment
    AC_DEFINE(BX_64BIT_CONSTANTS_USE_LL, 0)
    AC_DEFINE(inline, __inline)
    AC_DEFINE(BX_NO_EMPTY_STRUCTS, 1)
    AC_DEFINE(BX_NO_ATTRIBUTES, 1)
    AC_DEFINE(BX_HAVE_HASH_MAP, 0)
    AC_DEFINE(BX_HAVE_HASH_MAP_H, 0)
    AC_DEFINE(BX_HAVE_STRTOULL, 0)
    AC_DEFINE(BX_HAVE_STRTOUQ, 0)
    AC_DEFINE(HAVE_LIBREADLINE, 0)
    AC_DEFINE(BX_HAVE_GETTIMEOFDAY, 0)
    AC_DEFINE(BX_HAVE_DLFCN_H, 0)
    AC_DEFINE(BX_HAVE_MKSTEMP, 0)
    AC_DEFINE(BX_HAVE_SYS_MMAN_H, 0)
    AC_DEFINE(BX_HAVE_USLEEP, 0)
    AC_DEFINE(HAVE_ETHERTAP, 0)
    AC_DEFINE(BX_HAVE_SELECT, 1)
    AC_DEFINE(BX_HAVE_SOCKLEN_T, 0)
    ;;
  *-pc-cygwin*)
    EXE=".exe"
    PRIMARY_TARGET="bochs.exe"
    BXIMAGE_LINK_OPTS="-luser32"
    if test "$networking" = yes; then
      PRIMARY_TARGET="$PRIMARY_TARGET niclist.exe"
    fi
    AC_DEFINE(BX_HAVE_SELECT, 1)
    ;;
  *-pc-mingw*)
    BXIMAGE_LINK_OPTS="-luser32"
    if test "$networking" = yes; then
      PRIMARY_TARGET="$PRIMARY_TARGET niclist"
    fi
    AC_DEFINE(BX_HAVE_SELECT, 1)
    ;;
  *-beos*)
    PRIMARY_TARGET=.bochs_beos_target
    ;;
esac

DIALOG_OBJS=""
EXPORT_DYNAMIC="-export-dynamic"
case $target in
  *-pc-windows* | *-pc-winnt* | *-cygwin* | *-mingw*)
    if test "$bx_plugins" = 1; then
      AC_CHECK_LIB(mingwex, opendir, LIBS="$LIBS -lmingwex")
      # set variables for building DLL plugins
      PRIMARY_TARGET=".win32_dll_plugin_target"
      PLUGIN_LIBNAME_TRANSFORMATION='%.o=bx_%.dll'
      INSTALL_PLUGINS_VAR=install_dll_plugins
    else
      if test "$with_win32" != yes; then
        LIBS="$LIBS -lcomctl32"
      fi
    fi
    DIALOG_OBJS="win32dialog.o win32_enh_dbg_osdep.o"
    EXPORT_DYNAMIC=""
    ;;
esac
AC_SUBST(DIALOG_OBJS)
AC_SUBST(EXPORT_DYNAMIC)

if test "$use_curses" = yes -a "$cross_configure" = 0; then
  AC_CHECK_LIB(curses, mvaddch, GUI_LINK_OPTS_TERM='-lcurses')
  AC_CHECK_LIB(ncurses, mvaddch, GUI_LINK_OPTS_TERM='-lncurses')
  AC_CHECK_LIB(termlib, mvaddch, GUI_LINK_OPTS_TERM='-ltermlib')
  AC_CHECK_LIB(pdcurses, mvaddch, GUI_LINK_OPTS_TERM='-lpdcurses')
  if test "$GUI_LINK_OPTS_TERM" = ""; then
    echo Curses library not found: tried curses, ncurses, termlib and pdcurses.
    exit 1
  fi
fi

if test "$with_term" = yes; then
  old_LIBS="$LIBS"
  LIBS="$LIBS $GUI_LINK_OPTS_TERM"
  AC_CHECK_FUNCS(color_set, AC_DEFINE(BX_HAVE_COLOR_SET, 1))
  AC_CHECK_FUNCS(mvhline, AC_DEFINE(BX_HAVE_MVHLINE, 1))
  AC_CHECK_FUNCS(mvvline, AC_DEFINE(BX_HAVE_MVVLINE, 1))
  LIBS="$old_LIBS"
fi

if test "$with_rfb" = yes; then
  # we need the socket function
  case $target in
    *-pc-windows*)
      # is this okay without a check ?
      RFB_LIBS="$RFB_LIBS wsock32.lib"
      have_socket=yes
      ;;
    *-pc-winnt* | *-pc-cygwin* | *-pc-mingw32*)
      # is this okay without a check ?
      RFB_LIBS="$RFB_LIBS -lwsock32"
      have_socket=yes
      ;;
    *)
      AC_CHECK_FUNCS(socket, have_socket=yes)
      if test "$have_socket" != yes; then
        AC_CHECK_LIB(socket, socket,
          [
            RFB_LIBS="$RFB_LIBS -lsocket"
            have_socket=yes
          ])
      fi
      ;;
  esac
  if test "$have_socket" != yes; then
    echo 'ERROR: socket function required for RFB compile'
    exit 1
  fi
fi

# The ACX_PTHREAD function was written by
# Steven G. Johnson <stevenj@alum.mit.edu> and
# Alejandro Forero Cuervo <bachue@bachue.com>
# I found it in the ac-archive project on Source Forge.

AC_DEFUN([ACX_PTHREAD], [
AC_REQUIRE([AC_CANONICAL_HOST])
acx_pthread_ok=no

# First, check if the POSIX threads header, pthread.h, is available.
# If it isn't, don't bother looking for the threads libraries.
AC_CHECK_HEADER(pthread.h, , acx_pthread_ok=noheader)

# We must check for the threads library under a number of different
# names; the ordering is very important because some systems
# (e.g. DEC) have both -lpthread and -lpthreads, where one of the
# libraries is broken (non-POSIX).

# First of all, check if the user has set any of the PTHREAD_LIBS,
# etcetera environment variables, and if threads linking works using
# them:
if test x"$PTHREAD_LIBS$PTHREAD_CFLAGS" != x; then
	save_CFLAGS="$CFLAGS"
	CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
	CXXFLAGS="$CXXFLAGS $PTHREAD_CFLAGS"
	save_LIBS="$LIBS"
	LIBS="$PTHREAD_LIBS $LIBS"
	AC_MSG_CHECKING([for pthread_join in LIBS=$PTHREAD_LIBS with CFLAGS=$PTHREAD_CFLAGS])
	AC_TRY_LINK_FUNC(pthread_join, acx_pthread_ok=yes)
	AC_MSG_RESULT($acx_pthread_ok)
	if test x"$acx_pthread_ok" = xno; then
		PTHREAD_LIBS=""
		PTHREAD_CFLAGS=""
	fi
	LIBS="$save_LIBS"
	CFLAGS="$save_CFLAGS"
fi

# Create a list of thread flags to try.  Items starting with a "-" are
# C compiler flags, and other items are library names, except for "none"
# which indicates that we try without any flags at all.

acx_pthread_flags="pthreads none -Kthread -kthread lthread -pthread -pthreads -mthreads pthread --thread-safe -mt"

# The ordering *is* (sometimes) important.  Some notes on the
# individual items follow:

# pthreads: AIX (must check this before -lpthread)
# none: in case threads are in libc; should be tried before -Kthread and
#       other compiler flags to prevent continual compiler warnings
# -Kthread: Sequent (threads in libc, but -Kthread needed for pthread.h)
# -kthread: FreeBSD kernel threads (preferred to -pthread since SMP-able)
# lthread: LinuxThreads port on FreeBSD (also preferred to -pthread)
# -pthread: Linux/gcc (kernel threads), BSD/gcc (userland threads)
# -pthreads: Solaris/gcc
# -mthreads: Mingw32/gcc, Lynx/gcc
# -mt: Sun Workshop C (may only link SunOS threads [-lthread], but it
#      doesn't hurt to check since this sometimes defines pthreads too;
#      also defines -D_REENTRANT)
# pthread: Linux, etcetera
# --thread-safe: KAI C++

case "${host_cpu}-${host_os}" in
	*solaris*)

	# On Solaris (at least, for some versions), libc contains stubbed
	# (non-functional) versions of the pthreads routines, so link-based
	# tests will erroneously succeed.  (We need to link with -pthread or
	# -lpthread.)  (The stubs are missing pthread_cleanup_push, or rather
	# a function called by this macro, so we could check for that, but
	# who knows whether they'll stub that too in a future libc.)  So,
	# we'll just look for -pthreads and -lpthread first:

	acx_pthread_flags="-pthread -pthreads pthread -mt $acx_pthread_flags"
	;;
esac

if test x"$acx_pthread_ok" = xno; then
for flag in $acx_pthread_flags; do

	case $flag in
		none)
		AC_MSG_CHECKING([whether pthreads work without any flags])
		;;

		-*)
		AC_MSG_CHECKING([whether pthreads work with $flag])
		PTHREAD_CFLAGS="$flag"
		;;

		*)
		AC_MSG_CHECKING([for the pthreads library -l$flag])
		PTHREAD_LIBS="-l$flag"
		;;
	esac

	save_LIBS="$LIBS"
	save_CFLAGS="$CFLAGS"
	LIBS="$PTHREAD_LIBS $LIBS"
	CFLAGS="$CFLAGS $PTHREAD_CFLAGS"

	# Check for various functions.  We must include pthread.h,
	# since some functions may be macros.  (On the Sequent, we
	# need a special flag -Kthread to make this header compile.)
	# We check for pthread_join because it is in -lpthread on IRIX
	# while pthread_create is in libc.  We check for pthread_attr_init
	# due to DEC craziness with -lpthreads.  We check for
	# pthread_cleanup_push because it is one of the few pthread
	# functions on Solaris that doesn't have a non-functional libc stub.
	# We try pthread_create on general principles.
	AC_TRY_LINK([#include <pthread.h>],
		    [pthread_t th; pthread_join(th, 0);
		     pthread_attr_init(0); pthread_cleanup_push(0, 0);
		     pthread_create(0,0,0,0); pthread_cleanup_pop(0); ],
		    [acx_pthread_ok=yes])

	LIBS="$save_LIBS"
	CFLAGS="$save_CFLAGS"

	AC_MSG_RESULT($acx_pthread_ok)
	if test "x$acx_pthread_ok" = xyes; then
		break;
	fi

	PTHREAD_LIBS=""
	PTHREAD_CFLAGS=""
done
fi

# Various other checks:
if test "x$acx_pthread_ok" = xyes; then
	save_LIBS="$LIBS"
	LIBS="$PTHREAD_LIBS $LIBS"
	save_CFLAGS="$CFLAGS"
	CFLAGS="$CFLAGS $PTHREAD_CFLAGS"

	# Detect AIX lossage: threads are created detached by default
	# and the JOINABLE attribute has a nonstandard name (UNDETACHED).
	AC_MSG_CHECKING([for joinable pthread attribute])
	AC_TRY_LINK([#include <pthread.h>],
		    [int attr=PTHREAD_CREATE_JOINABLE;],
		    ok=PTHREAD_CREATE_JOINABLE, ok=unknown)
	if test x"$ok" = xunknown; then
		AC_TRY_LINK([#include <pthread.h>],
			    [int attr=PTHREAD_CREATE_UNDETACHED;],
			    ok=PTHREAD_CREATE_UNDETACHED, ok=unknown)
	fi
	if test x"$ok" != xPTHREAD_CREATE_JOINABLE; then
		AC_DEFINE(PTHREAD_CREATE_JOINABLE, $ok,
			  [Define to the necessary symbol if this constant
			   uses a non-standard name on your system.])
	fi
	AC_MSG_RESULT(${ok})
	if test x"$ok" = xunknown; then
		AC_MSG_WARN([we do not know how to create joinable pthreads])
	fi

	AC_MSG_CHECKING([if more special flags are required for pthreads])
	flag=no
	case "${host_cpu}-${host_os}" in
		*-aix* | *-freebsd*)     flag="-D_THREAD_SAFE";;
		*solaris* | alpha*-osf*) flag="-D_REENTRANT";;
	esac
	AC_MSG_RESULT(${flag})
	if test "x$flag" != xno; then
		PTHREAD_CFLAGS="$flag $PTHREAD_CFLAGS"
	fi

	LIBS="$save_LIBS"
	CFLAGS="$save_CFLAGS"

	# More AIX lossage: must compile with cc_r
	AC_CHECK_PROG(PTHREAD_CC, cc_r, cc_r, ${CC})
else
	PTHREAD_CC="$CC"
fi

AC_SUBST(PTHREAD_LIBS)
AC_SUBST(PTHREAD_CFLAGS)
AC_SUBST(PTHREAD_CC)

# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
if test x"$acx_pthread_ok" = xyes; then
	ifelse([$1],,AC_DEFINE(HAVE_PTHREAD,1,[Define if you have POSIX threads libraries and header files.]),[$1])
	:
else
	acx_pthread_ok=no
	$2
fi

])dnl ACX_PTHREAD

pthread_ok=no
ACX_PTHREAD([
  pthread_ok=yes
  #echo Using PTHREAD_LIBS=$PTHREAD_LIBS
  #echo Using PTHREAD_CFLAGS=$PTHREAD_CFLAGS
  #echo Using PTHREAD_CC=$PTHREAD_CC
  ])


# since RFB (usually) needs pthread library, check that it was found.
# But on win32 platforms, the pthread library is not needed.
if test "$with_rfb" = yes -a "$cross_configure" = 0; then
  if test "$pthread_ok" = yes; then
    RFB_LIBS="$RFB_LIBS $PTHREAD_LIBS"
    CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
    CXXFLAGS="$CXXFLAGS $PTHREAD_CFLAGS"
    CC="$PTHREAD_CC"
  else
    case "$target" in
	  *-pc-windows* | *-pc-winnt* | *-cygwin* | *-mingw*)
	    # pthread not needed for win32 platform
		;;
	  *)
    echo ERROR: --with-rfb requires the pthread library, which could not be found.; exit 1
    esac
  fi
fi

dnl // DEPRECATED configure options - force users to remove them

AC_MSG_CHECKING(for guest to host TLB support (deprecated))
AC_ARG_ENABLE(guest2host-tlb,
  [  --enable-guest2host-tlb          enables guest to host addr TLB for speed (deprecated)],
  [AC_MSG_RESULT($enableval)
   AC_MSG_ERROR([DEPRECATED - ALWAYS ON])
  ],
  [
   AC_MSG_RESULT(no)
  ])

AC_MSG_CHECKING(for external debugger interface (deprecated))
AC_ARG_ENABLE(external-debugger,
  [  --enable-external-debugger       enables external debugger interface (deprecated)],
  [AC_MSG_RESULT($enableval)
   AC_MSG_ERROR([DEPRECATED - Peter Tattam's external debugger interface is not supported anymore])
  ],
  [
   AC_MSG_RESULT(no)
  ])

AC_MSG_CHECKING(for magic breakpoints (deprecated))
AC_ARG_ENABLE(magic-breakpoints,
  [  --enable-magic-breakpoints        enables magic breakpoints (deprecated)],
  [AC_MSG_RESULT($enableval)
   AC_MSG_ERROR([DEPRECATED - magic breakpoints are always enabled with Bochs internal debugger])
  ],
  [
   AC_MSG_RESULT(no)
  ])

AC_MSG_CHECKING(for save/restore (deprecated))
AC_ARG_ENABLE(save-restore,
  [  --enable-save-restore             enables save/restore (deprecated)],
  [AC_MSG_RESULT($enableval)
   AC_MSG_ERROR([DEPRECATED - save/restore feature is always enabled])
  ],
  [
   AC_MSG_RESULT(no)
  ])

# Create some subdirectories for when you run configure from some other
# directory.
if test ! -d instrument; then mkdir instrument; fi
if test ! -d build; then mkdir build; fi
if test ! -d build/linux; then mkdir build/linux; fi
if test ! -d build/win32; then mkdir build/win32; fi
if test ! -d build/win32/nsis; then mkdir build/win32/nsis; fi

AC_SUBST(INSTALL_TARGET)
AC_SUBST(INSTALL_LIST_FOR_PLATFORM)
AC_SUBST(RFB_LIBS)
AC_SUBST(GUI_OBJS)
AC_SUBST(DEVICE_LINK_OPTS)
AC_SUBST(GUI_LINK_OPTS)
AC_SUBST(GUI_LINK_OPTS_TERM)
AC_SUBST(GUI_LINK_OPTS_WX)
AC_SUBST(BXIMAGE_LINK_OPTS)
AC_SUBST(DASH)
AC_SUBST(SLASH)
AC_SUBST(CXXFP)
AC_SUBST(CFP)
AC_SUBST(OFP)
AC_SUBST(MAKELIB)
AC_SUBST(RMCOMMAND)
AC_SUBST(LINK)
AC_SUBST(LINK_CONSOLE)
AC_SUBST(EXE)
AC_SUBST(PRIMARY_TARGET)
AC_SUBST(PLUGIN_LIBNAME_TRANSFORMATION)
AC_SUBST(COMMAND_SEPARATOR)
AC_SUBST(CD_UP_ONE)
AC_SUBST(CD_UP_TWO)
AC_SUBST(CD_UP_THREE)
AC_SUBST(VERSION)
AC_SUBST(VER_STRING)
AC_SUBST(WIN_VER_STRING)
AC_SUBST(REL_STRING)
AC_SUBST(EXTRA_LINK_OPTS)
AC_SUBST(GUI_NON_PLUGIN_OBJS)
AC_SUBST(GUI_PLUGIN_OBJS)
AC_SUBST(IODEV_NON_PLUGIN_OBJS)
AC_SUBST(IODEV_PLUGIN_OBJS)
AC_SUBST(PLUGIN_VAR)
AC_SUBST(PLUGIN_TARGET)
AC_SUBST(INSTALL_PLUGINS_VAR)

AC_PATH_PROG(GZIP, gzip)
AC_PATH_PROG(TAR, tar)

AC_OUTPUT(Makefile iodev/Makefile bx_debug/Makefile bios/Makefile \
	 cpu/Makefile memory/Makefile gui/Makefile \
	 disasm/Makefile ${INSTRUMENT_DIR}/Makefile misc/Makefile \
	 fpu/Makefile doc/docbook/Makefile \
	 build/linux/bochs-dlx \
	 bxversion.h bxversion.rc build/macosx/Info.plist \
	 build/win32/nsis/Makefile build/win32/nsis/bochs.nsi \
	 host/linux/pcidev/Makefile)