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.133 2002-09-26 02:36:04 bdenney Exp $]])
AC_CONFIG_HEADER(config.h)

dnl // Put Bochs version information right here so that it gets substituted
dnl // into all the right places.
VERSION="1.4.cvs"
VER_STRING="cvs-snapshot"
REL_STRING=""

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

dnl Detect host and target
AC_CANONICAL_HOST
AC_CANONICAL_TARGET

if test "$with_win32_vcpp"; then
  echo "WARNING: The --with-win32-vcpp option will be treated as:"
  echo "   --with-win32 --target=i686-pc-windows"
  target="i686-pc-windows"
  with_win32=yes
fi

AC_MSG_CHECKING(if you are configuring for another platform)
if test "$target" = "$build"; then
  AC_MSG_RESULT(no)
  cross_configure=0
else
  AC_MSG_RESULT(yes)
  cross_configure=1
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.
case "$target" in
  *-pc-windows* | *-pc-winnt*)
    DEFAULT_GUI=win32                 # default to win32 gui
    ;;
  *-pc-cygwin* | *-pc-mingw32*)
    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 -arch ppc -Wno-four-char-constants -Wno-unknown-pragmas -Dmacintosh"      # required for macosx compile
    DEFAULT_GUI=carbon                # default to carbon
    ;;
  *-macos*)
    DEFAULT_GUI=macos                 # macos defaults to macos
    ;;
  *-beos*)
    DEFAULT_GUI=beos                  # beos defaults to beos
    ;;
  *-amigaos*)
    DEFAULT_GUI=amigaos               # amigaos defaults to amigaos
    ;;
  *)
    DEFAULT_GUI=x11
    ;;
esac
CFLAGS="$CFLAGS $ADD_FLAGS"
CXXFLAGS="$CXXFLAGS $ADD_FLAGS"

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_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
AC_PROG_RANLIB

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(select, AC_DEFINE(BX_HAVE_SELECT))
AC_CHECK_FUNCS(snprintf, AC_DEFINE(BX_HAVE_SNPRINTF))
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(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_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.h)
AC_TRY_COMPILE([#include <hash_map.h>], [],
   [
     AC_MSG_RESULT(yes)
     AC_DEFINE(BX_HAVE_HASH_MAP)
   ], AC_MSG_RESULT(no))
AC_LANG_RESTORE

use_config_interface=1
AC_MSG_CHECKING(for configuration interface)
AC_ARG_ENABLE(config-interface,
  [  --enable-config-interface        turns on/off configuration interface],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
	use_config_interface=1
   else
    AC_MSG_RESULT(no)
	use_config_interface=0
   fi],
  [
    AC_MSG_RESULT(yes)
	use_config_interface=1
    ]
  )

# continue to support --enable-control-panel and make it do the same
# as before.
AC_MSG_CHECKING(for control panel)
AC_ARG_ENABLE(control-panel,
  [  --enable-control-panel           Deprecated. Use --enable-config-interface.],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
	use_config_interface=1
   else
    AC_MSG_RESULT(no)
	use_config_interface=0
   fi],
  [
    AC_MSG_RESULT(yes)
	use_config_interface=1
    ]
  )

if test "$use_config_interface" = 1; then
  AC_DEFINE(BX_USE_CONFIG_INTERFACE, 1)
else
  AC_DEFINE(BX_USE_CONFIG_INTERFACE, 0)
fi

AC_MSG_CHECKING(for new PIT model)
AC_ARG_ENABLE(new-pit,
  [  --enable-new-pit                  use Greg Alexander's new PIT model],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_USE_NEW_PIT, 1)
   else
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_USE_NEW_PIT, 0)
   fi],
  [
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_USE_NEW_PIT, 1)
    ]
  )
AC_SUBST(BX_USE_NEW_PIT)

AC_MSG_CHECKING(for realtime PIT)
AC_ARG_ENABLE(realtime-pit,
  [  --enable-realtime-pit                  try to keep clk in sync w/ real time],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_USE_REALTIME_PIT, 1)
   else
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_USE_REALTIME_PIT, 0)
   fi],
  [
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_USE_REALTIME_PIT, 0)
    ]
  )
AC_SUBST(BX_USE_REALTIME_PIT)

AC_MSG_CHECKING(for slowdown timer)
AC_ARG_ENABLE(slowdown,
  [  --enable-slowdown                 use Greg Alexander's slowdown timer],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_USE_SLOWDOWN_TIMER, 1)
    SLOWDOWN_OBJS='$(SLOWDOWN_OBJS)'
   else
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_USE_SLOWDOWN_TIMER, 0)
    SLOWDOWN_OBJS=''
   fi],
  [
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_USE_SLOWDOWN_TIMER, 0)
    SLOWDOWN_OBJS=''
    ]
  )
AC_SUBST(BX_USE_SLOWDOWN_TIMER)
AC_SUBST(SLOWDOWN_OBJS)

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_MSG_CHECKING(for number of processors)
AC_ARG_ENABLE(processors,
  [  --enable-processors               select number of processors (1,2,4,8)],
  [case "$enableval" in
     1)
       AC_MSG_RESULT(1)
       AC_DEFINE(BX_SMP_PROCESSORS, 1)
       AC_DEFINE(BX_BOOTSTRAP_PROCESSOR, 0)
       AC_DEFINE(BX_IOAPIC_DEFAULT_ID, 1)
       ;;
     2)
       AC_MSG_RESULT(2)
       AC_DEFINE(BX_SMP_PROCESSORS, 2)
       AC_DEFINE(BX_BOOTSTRAP_PROCESSOR, 0)
       AC_DEFINE(BX_IOAPIC_DEFAULT_ID, 2)
       AC_DEFINE(BX_USE_CPU_SMF, 0)
       ;;
     4)
       AC_MSG_RESULT(4)
       AC_DEFINE(BX_SMP_PROCESSORS, 4)
       AC_DEFINE(BX_BOOTSTRAP_PROCESSOR, 2)
       AC_DEFINE(BX_IOAPIC_DEFAULT_ID, 4)
       AC_DEFINE(BX_USE_CPU_SMF, 0)
       ;;
     8)
       AC_MSG_RESULT(8)
       AC_DEFINE(BX_SMP_PROCESSORS, 8)
       AC_DEFINE(BX_BOOTSTRAP_PROCESSOR, 0)
       AC_DEFINE(BX_IOAPIC_DEFAULT_ID, 0x11)
       AC_DEFINE(BX_USE_CPU_SMF, 0)
       ;;
     *)
       echo " "
       echo "WARNING: processors != [1,2,4,8] can work, but you need to modify rombios.c manually"
       AC_MSG_RESULT($enable_val)
       AC_DEFINE(BX_SMP_PROCESSORS, $enable_val)
       AC_DEFINE(BX_BOOTSTRAP_PROCESSOR, 0)
       AC_DEFINE(BX_IOAPIC_DEFAULT_ID, $enable_val)
       AC_DEFINE(BX_USE_CPU_SMF, 0)
       ;;
   esac
   bx_procs="$enableval"
  ],
  [
     AC_MSG_RESULT(1)
     AC_DEFINE(BX_SMP_PROCESSORS, 1)
     AC_DEFINE(BX_BOOTSTRAP_PROCESSOR, 0)
     AC_DEFINE(BX_IOAPIC_DEFAULT_ID, 1)
     bx_procs=1
  ]
  )

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)

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 "$bx_procs" -gt 1 -a "$enableval" -lt 6; then
     echo "ERROR: with >1 processor, use --enable-cpu-level=6"
     exit 1
   fi
  ],
  [
    # for multiprocessors, cpu level must be 6
    if test "$bx_procs" -gt 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'
    APIC_OBJS='apic.o'
   else
    AC_MSG_RESULT(no)
    if test "$bx_procs" -gt 1; then
      echo "Number of processors = $bx_procs"
      echo "ERROR: With processors > 1 you must use --enable-apic"
      exit 1
    fi
    AC_DEFINE(BX_SUPPORT_APIC, 0)
    IOAPIC_OBJS=''
    APIC_OBJS=''
   fi
   ],
  [
    if test "$bx_procs" -gt 1 -o "$bx_cpu_level" -gt 5; then
      # enable APIC by default, if processors>1 or if cpulevel>5
      AC_MSG_RESULT(yes)
      AC_DEFINE(BX_SUPPORT_APIC, 1)
      IOAPIC_OBJS='ioapic.o'
      APIC_OBJS='apic.o'
    else
      AC_MSG_RESULT(no)
      AC_DEFINE(BX_SUPPORT_APIC, 0)
      IOAPIC_OBJS=''
      APIC_OBJS=''
     fi
   ]
  )
AC_SUBST(IOAPIC_OBJS)
AC_SUBST(APIC_OBJS)

AC_MSG_CHECKING(for split hard disk image support)
AC_ARG_ENABLE(split-hd,
  [  --enable-split-hd                 allows split hard disk image],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_SPLIT_HD_SUPPORT, 1)
   else
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SPLIT_HD_SUPPORT, 0)
   fi],
  [
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_SPLIT_HD_SUPPORT, 1)
    ]
  )
AC_SUBST(BX_SPLIT_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_NE2K_SUPPORT, 1)
    NE2K_OBJS='ne2k.o eth.o eth_null.o'
    AC_CHECK_HEADER(net/bpf.h, NE2K_OBJS="$NE2K_OBJS eth_fbsd.o")
    AC_CHECK_HEADER(netpacket/packet.h, NE2K_OBJS="$NE2K_OBJS eth_linux.o")
    AC_CHECK_HEADER(linux/netlink.h, [
        NE2K_OBJS="$NE2K_OBJS eth_tap.o"
        AC_DEFINE(HAVE_ETHERTAP, 1)
      ], [], 
      [
	#include <asm/types.h>
	#include <sys/socket.h>
      ])
    AC_CHECK_HEADER(linux/if_tun.h, [
        NE2K_OBJS="$NE2K_OBJS eth_tuntap.o"
        AC_DEFINE(HAVE_TUNTAP, 1)
      ], [], 
      [
	#include <asm/types.h>
	#include <sys/socket.h>
      ])
    case "$target" in
      *-pc-windows* | *-pc-winnt* | *-pc-cygwin* | *-pc-mingw32*)
      NE2K_OBJS="$NE2K_OBJS eth_win32.o"
      ;;
    esac
    networking=yes
   else
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_NE2K_SUPPORT, 0)
    NE2K_OBJS=''
    networking=no
   fi],
  [
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_NE2K_SUPPORT, 0)
    NE2K_OBJS=''
    networking=no
    ]
  )
AC_SUBST(NE2K_OBJS)


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_PCI_SUPPORT, 1)
    PCI_OBJ='pci.o pci2isa.o'
   else
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_PCI_SUPPORT, 0)
    PCI_OBJ=''
   fi],
  [
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_PCI_SUPPORT, 0)
    PCI_OBJ=''
    ]
  )
AC_SUBST(PCI_OBJ)

AC_MSG_CHECKING(for Promise DC2300 VLB-IDE support)
AC_ARG_ENABLE(dc2300-vlb-ide,
  [  --enable-dc2300-vlb-ide           enable Promise DC2300 VLB-IDE support],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_PDC20230C_VLBIDE_SUPPORT, 1)
   else
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_PDC20230C_VLBIDE_SUPPORT, 0)
   fi],
  [
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_PDC20230C_VLBIDE_SUPPORT, 0)
    ]
  )


AC_MSG_CHECKING(for 4Meg pages support)
AC_ARG_ENABLE(4meg-pages,
  [  --enable-4meg-pages               support 4Megabyte pages extensions],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_SUPPORT_4MEG_PAGES, 1)
   else
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SUPPORT_4MEG_PAGES, 0)
   fi],
  [
    if test "$bx_cpu_level" -gt 5; then
      AC_MSG_RESULT(yes)
      AC_DEFINE(BX_SUPPORT_4MEG_PAGES, 1)
    else
      AC_MSG_RESULT(no)
      AC_DEFINE(BX_SUPPORT_4MEG_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_SupportPAE, 1)
   else
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SupportPAE, 0)
   fi],
  [
    if test "$bx_cpu_level" -gt 5; then
      AC_MSG_RESULT(yes)
      AC_DEFINE(BX_SupportPAE, 1)
    else
      AC_MSG_RESULT(no)
      AC_DEFINE(BX_SupportPAE, 0)
    fi
    ]
  )


AC_MSG_CHECKING(for guest to host TLB support)
AC_ARG_ENABLE(guest2host-tlb,
  [  --enable-guest2host-tlb           support guest to host addr TLB for speed],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_SupportGuest2HostTLB, 1)
   else
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SupportGuest2HostTLB, 0)
   fi],
  [
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SupportGuest2HostTLB, 0)
    ]
  )

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)
    AC_DEFINE(BX_SupportRepeatSpeedups, 1)
   else
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SupportRepeatSpeedups, 0)
   fi],
  [
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SupportRepeatSpeedups, 0)
    ]
  )

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

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_SupportGlobalPages, 1)
   else
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SupportGlobalPages, 0)
   fi],
  [
    if test "$bx_cpu_level" -gt 5; then
      # enable by default
      AC_MSG_RESULT(yes)
      AC_DEFINE(BX_SupportGlobalPages, 1)
    else
      AC_MSG_RESULT(no)
      AC_DEFINE(BX_SupportGlobalPages, 0)
    fi
    ]
  )

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)
    AC_DEFINE(BX_SupportHostAsms, 1)
   else
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SupportHostAsms, 0)
   fi],
  [
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_SupportHostAsms, 1)
    ]
  )

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],
  [
    # default: normally disabled, but in x86-64 mode enable it.
    if test "$use_x86_64" = 1; 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_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(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 external debugger)
EXT_DEBUG_OBJS=''
AC_ARG_ENABLE(external-debugger,
  [  --enable-external-debugger        enable external debugger support],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_EXTERNAL_DEBUGGER, 1)
    EXT_DEBUG_OBJS=extdb.o
   else
    AC_MSG_RESULT(no)
   fi],
  [
    AC_MSG_RESULT(no)
  ])
AC_SUBST(BX_EXTERNAL_DEBUGGER)

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],
  [
    if test "$bx_debugger" = 1; then
      AC_MSG_RESULT(yes)
      AC_DEFINE(BX_DISASM, 1)
      DISASM_VAR='$(DISASM_LIB)'
    else
      AC_MSG_RESULT(no)
      AC_DEFINE(BX_DISASM, 0)
      DISASM_VAR=''
    fi
    ]
  )
AC_SUBST(DISASM_VAR)

READLINE_LIB=""
rl_without_curses_ok=no
rl_with_curses_ok=no

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

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
    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)

AC_ARG_ENABLE(simid,
  [  --enable-simid=0 or 1             CPU simulator ID if using more than one],
  [if test "$enableval" = yes; then
    AC_DEFINE(BX_SIM_ID, 0)
   elif test "$enableval" = no; then
    AC_DEFINE(BX_SIM_ID, 0)
   else
    AC_DEFINE_UNQUOTED(BX_SIM_ID, $enableval)
   fi],
  [
    AC_DEFINE(BX_SIM_ID, 0)
    ]
  )

AC_ARG_ENABLE(num-sim,
  [  --enable-num-sim=1 or 2           number of CPU simulators],
  [if test "$enableval" = yes; then
    AC_DEFINE(BX_NUM_SIMULATORS, 1)
   elif test "$enableval" = no; then
    AC_DEFINE(BX_NUM_SIMULATORS, 1)
   else
    AC_DEFINE_UNQUOTED(BX_NUM_SIMULATORS, $enableval)
   fi],
  [
    AC_DEFINE(BX_NUM_SIMULATORS, 1)
    ]
  )

AC_ARG_ENABLE(time0,
  [  --enable-time0=n                  start at n instead of using time()],
  [if test "$enableval" = yes; then
    AC_DEFINE(BX_USE_SPECIFIED_TIME0, 917385580)
   elif test "$enableval" = no; then
    AC_DEFINE(BX_USE_SPECIFIED_TIME0, 0)
   else
    AC_DEFINE_UNQUOTED(BX_USE_SPECIFIED_TIME0, $enableval)
   fi],
  [
    AC_DEFINE(BX_USE_SPECIFIED_TIME0, 0)
    ]
  )



AC_MSG_CHECKING(for VGA emulation)
AC_ARG_ENABLE(vga,
  [  --enable-vga                      use VGA emulation],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_SUPPORT_VGA, 1)
    VIDEO_OBJS='$(VIDEO_OBJS_VGA)'
   else
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SUPPORT_VGA, 0)
    VIDEO_OBJS='$(VIDEO_OBJS_HGA)'
   fi],
  [
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_SUPPORT_VGA, 1)
    VIDEO_OBJS='$(VIDEO_OBJS_VGA)'
    ]
  )
AC_SUBST(VIDEO_OBJS)

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)
   else
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SUPPORT_VBE, 0)
   fi],
  [
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_SUPPORT_VBE, 0)
    ]
  )

AC_MSG_CHECKING(for MMX support)
AC_ARG_ENABLE(mmx,
  [  --enable-mmx                      compile in MMX emulation],
  [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)
   fi
   ],
  [
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_SUPPORT_MMX, 1)
    ]
  )

AC_MSG_CHECKING(for FPU emulation)
FPU_VAR=''
FPU_GLUE_OBJ=''
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)'
    FPU_GLUE_OBJ='$(FPU_GLUE_OBJ)'
   elif test "$enableval" = no; then
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_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)'
    FPU_GLUE_OBJ='$(FPU_GLUE_OBJ)'
    ]
  )
AC_SUBST(FPU_VAR)
AC_SUBST(FPU_GLUE_OBJ)



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)
   else
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_X86_DEBUGGER, 1)
   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
    AC_MSG_RESULT(no)
    CDROM_OBJS=''
    AC_DEFINE(BX_SUPPORT_CDROM, 0)
   else
    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_osx.o"
      EXTRA_LINK_OPTS="${EXTRA_LINK_OPTS} -framework IOKit -framework CoreFoundation"
    elif test "$with_beos" = yes; then
      # use the beos cdrom file instead
      CDROM_OBJS="$CDROM_OBJS cdrom_beos.o"
    fi
    AC_DEFINE(BX_SUPPORT_CDROM, 1)
   fi],
  [
    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_osx.o"
      EXTRA_LINK_OPTS="${EXTRA_LINK_OPTS} -framework IOKit -framework CoreFoundation"
    elif test "$with_beos" = yes; then
      # use the beos cdrom file instead
      CDROM_OBJS="$CDROM_OBJS cdrom_beos.o"
    fi
    AC_DEFINE(BX_SUPPORT_CDROM, 1)
    ]
  )

AC_SUBST(CDROM_OBJS)


AC_MSG_CHECKING(for Sound Blaster 16 support)
AC_ARG_ENABLE(sb16,
  [  --enable-sb16=xxx                 Sound Blaster 16 Support (xxx=dummy|win|linux|freebsd)],
  [if test "$enableval" = no; then
     AC_MSG_RESULT(no)
     SB16_OBJS=''
     AC_DEFINE(BX_SUPPORT_SB16, 0)
   else
     case "$enableval" in
       dummy)
         SB16_OBJS='$(SB16_DUMMY_OBJS)'
         AC_DEFINE(BX_SOUND_OUTPUT_C, bx_sound_output_c)
         AC_MSG_RESULT(dummy)
         ;;
       freebsd|linux)
         SB16_OBJS='$(SB16_LINUX_OBJS)'
         AC_DEFINE(BX_SOUND_OUTPUT_C, bx_sound_linux_c)
         AC_MSG_RESULT(linux)
         ;;
       win)
         SB16_OBJS='$(SB16_WIN_OBJS)'
         AC_DEFINE(BX_SOUND_OUTPUT_C, bx_sound_windows_c)
         AC_MSG_RESULT(win)
         ;;
       *)
         echo " "
         echo \!\!\!Error\!\!\!
         echo "You must pass one of dummy, linux, win to --enable-sb16"
         exit 1 ;;
     esac
     AC_DEFINE(BX_SUPPORT_SB16, 1)
   fi],

  [
    AC_MSG_RESULT(no)
    SB16_OBJS=''
    AC_DEFINE(BX_SUPPORT_SB16, 0)
    ]
  )
AC_SUBST(SB16_OBJS)


AC_ARG_ENABLE(hga-dumps,
  [  --enable-hga-dumps=Nmicroseconds  copy memory to HGA video buffer every N useconds],
  AC_DEFINE_UNQUOTED(BX_EMULATE_HGA_DUMPS, $enableval),
  )

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_IODEBUG_SUPPORT, 1)
    IODEBUG_OBJS='iodebug.o'
   else
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_IODEBUG_SUPPORT, 0)
   fi
   ],
  [
    if test "" = 1; then
      # enable by default if debugger is on
      AC_MSG_RESULT(yes)
      AC_DEFINE(BX_IODEBUG_SUPPORT, 1)
      IODEBUG_OBJS='iodebug.o'
    else
      AC_MSG_RESULT(no)
    fi
    ]
  )
AC_SUBST(IODEBUG_OBJS)



PRIMARY_TARGET='bochs'

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(NONINLINE_VAR)
AC_SUBST(INLINE_VAR)
AC_SUBST(EXTERNAL_DEPENDENCY)
AC_SUBST(EXT_DEBUG_OBJS)


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(win32-vcpp,
  [  --with-win32-vcpp                 use Win32 GUI/Visual C++ environment],
  )

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 MorphOS (Amiga)],
  )

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

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

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 "
LINK="\$(CXX) -o \$@ \$(CXXFLAGS)"
EXE=""
COMMAND_SEPARATOR="&& \\"
CD_UP_ONE="echo done"
CD_UP_TWO="echo done"

INSTALL_TARGET=install_unix
INSTALL_LIST_FOR_PLATFORM=

# check for existence of and usable version of wxWindows.  This comes
# early so that it could affect which one gets chosen.
AC_CHECK_PROG(WX_CONFIG, [ wx-config --version ], wx-config, not_found)
ok_wx_version=0
AC_MSG_CHECKING(for wxWindows library version)
if test x$WX_CONFIG != xnot_found; then
  WX_VERSION=`$WX_CONFIG --version`
  [
  # 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-9]*) ok_wx_version=1 ;;  # 2.3.2 or greater
    x2.3.[1-9][0-9]*) ok_wx_version=1 ;;  # 2.3.10 or greater
    x2.[4-9]*) ok_wx_version=1 ;;  # version 2.4 or greater
    x[3-9]*) ok_wx_version=1 ;;  # version 3 or greater
    *) ;; # who knows?
  esac
  ]
fi
AC_MSG_RESULT($WX_VERSION)

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

# 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.

if test "$with_x11" = yes; then
  AC_MSG_RESULT(X windows)
  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)
  GUI_OBJS='$(GUI_OBJS_X11) control.o'
  GUI_LINK_OPTS='$(GUI_LINK_OPTS_X)'
  INSTALL_LIST_FOR_PLATFORM='$(INSTALL_LIST_X11)'
elif test "$with_beos" = yes; then
  AC_MSG_RESULT(beos)
  AC_DEFINE(BX_WITH_BEOS, 1)
  GUI_OBJS='$(GUI_OBJS_BEOS) control.o'
  GUI_LINK_OPTS='$(GUI_LINK_OPTS_BEOS)'
elif test "$with_sdl" = yes; then
  AC_MSG_RESULT(sdl)
  CFLAGS="$CFLAGS \`sdl-config --cflags\`"
  AC_DEFINE(BX_WITH_SDL, 1)
  GUI_OBJS='$(GUI_OBJS_SDL) control.o'
  GUI_LINK_OPTS='$(GUI_LINK_OPTS_SDL)'
elif test "$with_rfb" = yes; then
  AC_MSG_RESULT(rfb)
  AC_DEFINE(BX_WITH_RFB, 1)
  GUI_OBJS='$(GUI_OBJS_RFB) control.o'
  GUI_LINK_OPTS='$(GUI_LINK_OPTS_RFB)'
elif test "$with_amigaos" = yes; then
  AC_MSG_RESULT(amigaos)
  AC_DEFINE(BX_WITH_AMIGAOS, 1)
  GUI_OBJS='$(GUI_OBJS_AMIGAOS) control.o'
  GUI_LINK_OPTS='$(GUI_LINK_OPTS_AMIGAOS)'
elif test "$with_win32" = yes; then
  AC_MSG_RESULT(win32)
  AC_DEFINE(BX_WITH_WIN32, 1)
  GUI_OBJS='$(GUI_OBJS_WIN32) control.o'
  case $target in
    *-pc-windows*)
       GUI_LINK_OPTS='$(GUI_LINK_OPTS_WIN32_VCPP)'  # native libs for win gui
       ;;
    *-cygwin* | *-mingw32*)
       GUI_LINK_OPTS='$(GUI_LINK_OPTS_WIN32)'   # cygwin/mingw libs for win gui
       ;;
    *) echo Unsupported compile setup: GUI library is win32, but target is neither windows nor cygwin.
       ;;
  esac
elif test "$with_macos" = yes; then
  AC_MSG_RESULT(macos)
  AC_DEFINE(BX_WITH_MACOS, 1)
  GUI_OBJS='$(GUI_OBJS_MACOS) control.o'
  GUI_LINK_OPTS='$(GUI_LINK_OPTS_MACOS)'
elif test "$with_carbon" = yes; then
  AC_MSG_RESULT(carbon)
  AC_DEFINE(BX_WITH_CARBON, 1)
  GUI_OBJS='$(GUI_OBJS_CARBON) control.o'
  GUI_LINK_OPTS='$(GUI_LINK_OPTS_CARBON)'
  PRIMARY_TARGET=bochs.app/.build   # only for carbon application
elif test "$with_term" = yes; then
  AC_MSG_RESULT(term)
  AC_DEFINE(BX_WITH_TERM, 1)
  GUI_OBJS='$(GUI_OBJS_TERM) control.o'
  GUI_LINK_OPTS='$(GUI_LINK_OPTS_TERM)'
  use_curses=yes
elif test "$with_wx" = yes; then
  AC_MSG_RESULT(wxWindows)
  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 wxWindows was not found.  
      echo Upgrade the library or choose another gui.
      exit 1
    fi
  fi
  AC_DEFINE(BX_WITH_WX, 1)
  WX_CFLAGS="\`$WX_CONFIG --cflags\`"
  WX_CXXFLAGS="\`$WX_CONFIG --cxxflags\`"
  GUI_LINK_OPTS_WX="\`$WX_CONFIG --libs\`"
  # 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 \`gtk-config --cflags\`"
    WX_CXXFLAGS="$WX_CXXFLAGS \`gtk-config --cflags\`"
  fi
  # wxwindows is the only one without control.o in GUI_OBJS
  GUI_OBJS='$(GUI_OBJS_WX)'
  GUI_LINK_OPTS='$(GUI_LINK_OPTS_WX)'
  # using debugger with readline is failing due to thread/signal handler
  # problems.
  if test "$use_readline" = 1 -a "$bx_debugger" = 1; then
    echo ERROR: You have selected wxWindows, the debugger, and the readline 
    echo library.  This combination is known to trigger problems with SIGINT 
    echo handling.  Please run configure again with --disable-readline to 
    echo correct this.
    exit 1
  fi
else
  AC_MSG_RESULT(none)
  AC_DEFINE(BX_WITH_NOGUI, 1)
  GUI_OBJS='$(GUI_OBJS_NOGUI) control.o'
  GUI_LINK_OPTS='$(GUI_LINK_OPTS_NOGUI)'
fi

AC_SUBST(WX_CFLAGS)
AC_SUBST(WX_CXXFLAGS)

# modify settings based on target platform
case "$target" in
  *-macos*)
    AC_DEFINE(BX_HAVE_STRDUP, 0)
    ;;
  *-pc-windows*)
    INSTALL_TARGET='install_win32'
    CC="cl"
    CXX="$CC"
    #C_OPT="/Zi"   # for debugging
    C_OPT="/O2"   # 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"
    MAKELIB="lib.exe /nologo /subsystem:console /machine:I386 /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 /machine:I386 /out:\$@ BINMODE.OBJ"
    EXE=".exe"
    PRIMARY_TARGET="bochs.exe"
    # 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 ..\.."
    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_STRTOULL, 0)
    AC_DEFINE(BX_HAVE_STRTOUQ, 0)
    AC_DEFINE(HAVE_LIBREADLINE, 0)
    AC_DEFINE(BX_HAVE_GETTIMEOFDAY, 0)
    ;;
esac

if test "$use_curses" = yes; 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')
  if test "$GUI_LINK_OPTS_TERM" = ""; then
    echo Curses library not found: tried curses, ncurses, and termlib.
    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))
  LIBS="$old_LIBS"
fi

if test "$with_rfb" = yes -a "$cross_configure" = 0; then
  # we need the socket function. if cross configuring, don't bother.
  AC_CHECK_FUNCS(socket, have_socket=yes)
  if test "$have_socket" != yes; then
    AC_CHECK_LIB(socket, socket, 
      [ RFB_LIBS="$RFB_LIBS -lsocket" ], 
      [
        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
  ])


if test "$with_rfb" = yes; 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
    echo ERROR: --with-rfb requires the pthread library, which could not be found.; exit 1
  fi
fi

if test "$with_wx" = yes; then
  if test "$pthread_ok" = yes; then
	GUI_LINK_OPTS="$PTHREAD_LIBS $GUI_LINK_OPTS"
	CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
	CXXFLAGS="$CXXFLAGS $PTHREAD_CFLAGS"
	CC="$PTHREAD_CC"
  else
    case "$target" in
	  *-pc-windows* | *-pc-winnt*)
	    # pthread not needed for win32
		;;
	  *)
        echo ERROR: --with-wx requires the pthread library, which could not be found.; exit 1
    esac
  fi
fi

# 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

AC_SUBST(INSTALL_TARGET)
AC_SUBST(INSTALL_LIST_FOR_PLATFORM)
AC_SUBST(RFB_LIBS)
AC_SUBST(GUI_OBJS)
AC_SUBST(GUI_LINK_OPTS)
AC_SUBST(GUI_LINK_OPTS_TERM)
AC_SUBST(GUI_LINK_OPTS_WX)
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(EXE)
AC_SUBST(PRIMARY_TARGET)
AC_SUBST(COMMAND_SEPARATOR)
AC_SUBST(CD_UP_ONE)
AC_SUBST(CD_UP_TWO)
AC_SUBST(VERSION)
AC_SUBST(VER_STRING)
AC_SUBST(REL_STRING)
AC_SUBST(EXTRA_LINK_OPTS)

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

AC_OUTPUT(Makefile iodev/Makefile debug/Makefile bios/Makefile \
	 cpu/Makefile memory/Makefile gui/Makefile \
	 disasm/Makefile ${INSTRUMENT_DIR}/Makefile misc/Makefile \
	 fpu/Makefile install-x11-fonts build/linux/bochs-dlx \
	 build/linux/bochs-docs bxversion.h \
	 build/linux/DOC-linux.html \
	 build/macosx/Info.plist)