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

AC_PREREQ(2.4)
AC_INIT(bochs.h)
AC_CONFIG_HEADER(config.h)

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

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

AC_MSG_CHECKING(for control panel)
AC_ARG_ENABLE(control-panel,
  [  --enable-control-panel           turns on/off control panel],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_USE_CONTROL_PANEL, 1)
   else
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_USE_CONTROL_PANEL, 0)
   fi],
  [
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_USE_CONTROL_PANEL, 1)
    ]
  )
AC_SUBST(BX_USE_CONTROL_PANEL)


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 slowdown timer)
AC_ARG_ENABLE(slowdown,
  [  --enable-slowdown                 use 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 number of processors)
AC_ARG_ENABLE(processors,
  [  --enable-processors               select number of processors (1,2,4)],
  [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)
       ;;
     *)
       echo " "
       echo "WARNING: processors != [1,2,4] 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)
    ])

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; 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 dynamic translation support)
AC_ARG_ENABLE(dynamic,
  [  --enable-dynamic                  enable dynamic translation support],
  [if test "$enableval" = no; then
     AC_MSG_RESULT(no)
     AC_DEFINE(BX_DYNAMIC_TRANSLATION, 0)
     DYNAMIC_VAR=''
     AS_DYNAMIC_OBJS=''
     AS_DYNAMIC_INCS=''
   else
     if test "$enableval" = yes; then
       echo " "
       echo \!\!\!Error\!\!\!
       echo "You must specify a CPU type to dynamic-translation option"
       echo \!\!\!Error\!\!\!
       exit 1
     fi
     case "$enableval" in
       i386)
         AC_DEFINE(BX_DYNAMIC_CPU_I386, 1)
         AS_DYNAMIC_OBJS='$(X86_OBJS)'
         AS_DYNAMIC_INCS='$(X86_H)'
         ;;
       sparc)
         AC_DEFINE(BX_DYNAMIC_CPU_SPARC, 1)
         AS_DYNAMIC_OBJS='$(SPARC_OBJS).o'
         AS_DYNAMIC_INCS='$(SPARC_H)'
         ;;
       *)
         echo " "
         echo \!\!\!Error\!\!\!
         echo "Sorry, dynamic translation is not yet available on your platform"
         echo \!\!\!Error\!\!\!
         AS_DYNAMIC_OBJS=''
         AS_DYNAMIC_INCS=''
         exit 1 ;;
     esac
     AC_MSG_RESULT(yes)
     AC_DEFINE(BX_DYNAMIC_TRANSLATION, 1)
     DYNAMIC_VAR='$(DYNAMIC_LIB)'
   fi],
  [
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_DYNAMIC_TRANSLATION, 0)
    DYNAMIC_VAR=''
    AS_DYNAMIC_OBJS=''
    AS_DYNAMIC_INCS=''
    ]
  )
AC_SUBST(DYNAMIC_VAR)
AC_SUBST(AS_DYNAMIC_OBJS)
AC_SUBST(AS_DYNAMIC_INCS)

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")
    if test "$with_win32" = yes -o "$with_win32_vcpp" = yes; then
      NE2K_OBJS="$NE2K_OBJS eth_win32.o"
    fi
   else
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_NE2K_SUPPORT, 0)
    NE2K_OBJS=''
   fi],
  [
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_NE2K_SUPPORT, 0)
    NE2K_OBJS=''
    ]
  )
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'
   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 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(no)
    AC_DEFINE(BX_PORT_E9_HACK, 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],
  [
    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
    ]
 )

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"
    elif test "$rl_with_curses_ok" = yes; then
      AC_MSG_RESULT(yes)
      AC_DEFINE(HAVE_LIBREADLINE, 1)
      READLINE_LIB="-lreadline -lcurses"
    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)
  )

AC_MSG_CHECKING(for loader support)
AC_ARG_ENABLE(loader,
  [  --enable-loader                   support calling external loader from debugger],
  [if test "$enableval" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(BX_USE_LOADER, 1)
    BX_LOADER_OBJS='bx_loader.o loader.o'
   else
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_USE_LOADER, 0)
    BX_LOADER_OBJS=''
   fi],
  [
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_USE_LOADER, 0)
    BX_LOADER_OBJS=''
    ]
  )
AC_SUBST(BX_LOADER_OBJS)



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 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_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"
    fi
    AC_DEFINE(BX_SUPPORT_CDROM, 1)
   fi],
  [
    AC_MSG_RESULT(no)
    CDROM_OBJS=''
    AC_DEFINE(BX_SUPPORT_CDROM, 0)
    ]
  )
AC_SUBST(CDROM_OBJS)


AC_MSG_CHECKING(for Sound Blaster 16 support)
AC_ARG_ENABLE(sb16,
  [  --enable-sb16                     Sound Blaster 16 Support],
  [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)
         ;;
       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
   ],
  [
    AC_MSG_RESULT(no)
    AC_DEFINE(BX_IODEBUG_SUPPORT, 0)
    ]
  )
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_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_MSG_CHECKING(for gui library to use)

dnl // make sure X Windows is default if no other chosen
if (test "$with_x11" != yes) && \
   (test "$with_beos" != yes) && \
   (test "$with_win32" != yes) && \
   (test "$with_nogui" != yes) && \
   (test "$with_win32_vcpp" != yes) && \
   (test "$with_term" != yes) && \
   (test "$with_rfb" != yes) && \
   (test "$with_amigaos" != yes) && \
   (test "$with_carbon" != yes) && \
   (test "$with_macos" != yes); then
  with_x11=yes
fi

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=

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)'
  GUI_LINK_OPTS='$(GUI_LINK_OPTS_X)'
  INSTALL_LIST_FOR_PLATFORM='$(INSTALL_LIST_X11)'
elif test "$with_win32" = yes; then
  AC_MSG_RESULT(win32)
  AC_DEFINE(BX_WITH_WIN32, 1)
  GUI_OBJS='$(GUI_OBJS_WIN32)'
  GUI_LINK_OPTS='$(GUI_LINK_OPTS_WIN32)'
  INSTALL_TARGET='install_win32'
elif test "$with_beos" = yes; then
  AC_MSG_RESULT(beos)
  AC_DEFINE(BX_WITH_BEOS, 1)
  GUI_OBJS='$(GUI_OBJS_BEOS)'
  GUI_LINK_OPTS='$(GUI_LINK_OPTS_BEOS)'
elif test "$with_rfb" = yes; then
  AC_MSG_RESULT(rfb)
  AC_DEFINE(BX_WITH_RFB, 1)
  GUI_OBJS='$(GUI_OBJS_RFB)'
  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)'
  GUI_LINK_OPTS='$(GUI_LINK_OPTS_AMIGAOS)'
elif test "$with_win32_vcpp" = yes; then
  AC_MSG_RESULT(win32-vcpp)
  AC_DEFINE(BX_WITH_WIN32, 1)
  GUI_OBJS='$(GUI_OBJS_WIN32)'
  INSTALL_TARGET='install_win32'
  GUI_LINK_OPTS='$(GUI_LINK_OPTS_WIN32_VCPP)'

  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"
  COMMAND_SEPARATOR=""
  CD_UP_ONE="cd .."
  CD_UP_TWO="cd ..\.."
  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)
elif test "$with_macos" = yes; then
  AC_MSG_RESULT(macos)
  AC_DEFINE(BX_WITH_MACOS, 1)
  AC_DEFINE(BX_HAVE_STRDUP, 0)
  GUI_OBJS='$(GUI_OBJS_MACOS)'
  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)'
  GUI_LINK_OPTS='$(GUI_LINK_OPTS_CARBON)'
  PRIMARY_TARGET=bochs.app/.build
elif test "$with_term" = yes; then
  AC_MSG_RESULT(term)
  AC_DEFINE(BX_WITH_TERM, 1)
  GUI_OBJS='$(GUI_OBJS_TERM)'
  GUI_LINK_OPTS='$(GUI_LINK_OPTS_TERM)'
  use_curses=yes
else
  AC_MSG_RESULT(none)
  AC_DEFINE(BX_WITH_NOGUI, 1)
  GUI_OBJS='$(GUI_OBJS_NOGUI)'
  GUI_LINK_OPTS='$(GUI_LINK_OPTS_NOGUI)'
fi

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_rfb" = yes; then
  # first see if compiler takes "-pthread" argument
  AC_MSG_CHECKING(for -pthread arg to compiler)
  CFLAGS_SAVE="$CFLAGS"
  CFLAGS="$CFLAGS -pthread"
  AC_TRY_LINK([ #include <pthread.h> ],
    [ pthread_create(0,0,0,0); ], 
    [ 
      # it compiles with -pthread
      AC_MSG_RESULT(yes) 
      CXXFLAGS="$CXXFLAGS -pthread"
    ],
    [
      AC_MSG_RESULT(no)
      # now try with -lpthread
      CFLAGS="$CFLAGS_SAVE"
      AC_CHECK_LIB(pthread, 
	pthread_create,
	[
	  # it compiles with -lpthread
	  RFB_LIBS='-lpthread'
	],
	[
	    echo ERROR: --with-rfb requires the pthread library, which could not be found.; exit 1
	])
    ])
fi

if test ! -d instrument; then
  mkdir instrument
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(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_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 dynamic/Makefile \
         fpu/Makefile)