dnl Process this file with autoconf to produce a configure script.
dnl
dnl COPYRIGHT (c) 2014 The Diderot Project
dnl All rights reserved.
dnl

AC_INIT(diderot,0.1,)

AC_PREREQ(2.60)
AC_COPYRIGHT([[COPYRIGHT (c) 2014 The Diderot Project (http://diderot-language.cs.uchicago.edu)]])
AC_CONFIG_SRCDIR(src/compiler/driver/main.sml)
AC_CONFIG_AUX_DIR(config)
AC_CONFIG_MACRO_DIR(config)

dnl
dnl include additional macros
dnl
sinclude(config/acx_pthread.m4)
sinclude(config/check_smlnj.m4)
sinclude(config/check_smlnj_heap_suffix.m4)
sinclude(config/ax_check_framework.m4)

dnl
dnl get host information
dnl
AC_CANONICAL_HOST

dnl check for standard programs
dnl
AC_PROG_CC([clang gcc cc])
AC_PROG_CPP
AC_PROG_INSTALL
AC_PROG_MAKE_SET

dnl FIXME: this works for now, but we should probably switch to libtool
dnl
AC_PATH_PROG(LD, [ld], [none])
if test x$LD = xnone ; then
  AC_MSG_ERROR([cannot find ld command])
fi
AC_SUBST(LD)

dnl check for c99 support
dnl
AC_PROG_CC_C99
if test x"$ac_cv_prog_cc_c99" = xno ; then
  AC_MSG_ERROR([Diderot requires c99 support])
fi

AC_ARG_ENABLE([32-bit],
  AC_HELP_STRING([--enable-32-bit], [configure Diderot to produce 32-bit executables]),
  [CFLAG_MXX="-m32"],
  [CFLAG_MXX="-m64"])

dnl extra C compiler options
dnl
CFLAGS=""
CFLAGS_BASE="-Wformat -Wreturn-type -Wuninitialized"
AC_SUBST(CFLAG_MXX)
AC_SUBST(CFLAGS_BASE)

dnl
dnl standard headers
dnl
AC_HEADER_STDBOOL

dnl
dnl check for pthreads support
dnl
ACX_PTHREAD

dnl
dnl Look for NVIDIA's nvcc compiler
dnl
AC_MSG_NOTICE([checking for CUDA and nvcc])
AC_PATH_PROG(NVCC, nvcc, no, $PATH)
if test x"$NVCC" = xno ; then
  AC_MSG_WARN([nvcc not found])
  CUDA_ENABLED=false
  NVCC=":"
else
  AC_MSG_RESULT([$NVCC])
  CUDA_ENABLED=true
fi
AC_SUBST(NVCC)
AC_SUBST(CUDA_ENABLED)

dnl
dnl check for OpenCL support
dnl
LIBS_CL="none"
case "$host_os" in
  darwin*) # On Mac OS X we check for installed frameworks
    AX_CHECK_FRAMEWORK([OpenCL], [LIBS_CL="-framework OpenCL"], [])
  ;;
  *)
    AC_CHECK_LIB([OpenCL],[clGetPlatformIDs],[LIBS_CL="-lOpenCL"])
  ;;
esac
if test x"$LIBS_CL" = xnone ; then
  AC_MSG_WARN([no OpenCL library found])
  CL_ENABLED=false
  CL_VERSION=0
else
  CL_ENABLED=true
  CPPFLAGS_CL=""
  CL_HEADER=""
  AC_CHECK_HEADERS([CL/cl.h OpenCL/cl.h], [HAVE_CL_H="yes"; CL_HEADER="$ac_header"; break], [HAVE_CL_H="no"])
  if test x"$HAVE_CL_H" = xno ; then
    # check for AMD's SDK
    AC_MSG_CHECKING([for cl.h in AMD's SDK])
    if test -d /opt/AMDAPP/include/CL ; then
      HAVE_CL_H="yes"
      CL_HEADER="/opt/AMDAPP/include/CL/cl.h"
      AC_DEFINE([HAVE_CL_CL_H])
      CPPFLAGS_CL="-I/opt/AMDAPP/include"
    fi
    AC_MSG_RESULT([$HAVE_CL_H])
  fi
  if test x"$HAVE_CL_H" = xno ; then
    # check for NVIDIA's SDK
    AC_MSG_CHECKING([for NVIDIA's SDK cl.h])
    if test -d /usr/local/cuda/include/CL ; then
      HAVE_CL_H="yes"
      AC_DEFINE([HAVE_CL_CL_H])
      CPPFLAGS_CL="-I/usr/local/cuda/include"
    fi
    AC_MSG_RESULT([$HAVE_CL_H])
  fi
  if test x"$HAVE_CL_H" = xno ; then
    AC_MSG_WARN([no cl.h found])
    CL_ENABLED=false
    CL_VERSION=0
    SIZEOF_CL_INT=0
    SIZEOF_CL_LONG=0
    SIZEOF_CL_FLOAT=0
    SIZEOF_CL_DOUBLE=0
  else
    # check the cl.h header for which version of OpenCL is supported
    AC_LANG([C])
    save_CPPFLAGS=$CPPFLAGS
    CPPFLAGS="$CPPFLAGS_CL $CPPFLAGS"
    AC_LINK_IFELSE([AC_LANG_PROGRAM([[
#include <stdio.h>
# ifdef HAVE_CL_CL_H
#   include <CL/cl.h>
# elif defined(HAVE_OPENCL_CL_H)
#   include <OpenCL/cl.h>
# else
#   error no cl.h
# endif]],
[[#if defined(CL_VERSION_1_1)
  printf("11000\n");
#elif defined(CL_VERSION_1_0)
  printf("10000\n");
#else
  printf("0\n");
#endif
      ]])],
      [CL_VERSION=`./conftest$EXEEXT`], [CL_VERSION=0])
dnl
dnl check to see how we access the host-side vector types.  For OpenCL 1.1,
dnl the specification specifies the behavior, but it was unspecified in 1.0.
dnl
    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
#include "$CL_HEADER"
]],
      [[cl_float4 x; x[0] = 0.0;]])],
      [AC_DEFINE([CL_HOST_VECTORS_ARE_ARRAYS],[1],[host vector types are arrays])],
dnl
dnl not arrays, so try the OpenCL 1.1 structure representation
dnl
      [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
#include "$CL_HEADER"
]],
      [[cl_float4 x; x.s[0] = 0.0;]])],
      [AC_DEFINE([CL_HOST_VECTORS_ARE_STRUCTS],[1],[host vector types are structs])],
      [AC_MSG_ERROR([unable to figure out host types for OpenCL vectors])])])
  # restore saved CPPFLAGS
    CPPFLAGS=$save_CPPFLAGS
  # substitutions
    AC_SUBST(LIBS_CL)
    AC_SUBST(CPPFLAGS_CL)
  #
  # determine the sizes of the host-side OpenCL types
  AC_CHECK_SIZEOF([cl_int], [], [#include "$CL_HEADER"])
  SIZEOF_CL_INT=$ac_cv_sizeof_cl_int
  AC_CHECK_SIZEOF([cl_long], [], [#include "$CL_HEADER"])
  SIZEOF_CL_LONG=$ac_cv_sizeof_cl_long
  AC_CHECK_SIZEOF([cl_float], [], [#include "$CL_HEADER"])
  SIZEOF_CL_FLOAT=$ac_cv_sizeof_cl_float
  AC_CHECK_SIZEOF([cl_double], [], [#include "$CL_HEADER"])
  SIZEOF_CL_DOUBLE=$ac_cv_sizeof_cl_double
  fi
fi
AC_SUBST(CL_ENABLED)
AC_SUBST(CL_VERSION)

AC_SUBST(SIZEOF_CL_INT)
AC_SUBST(SIZEOF_CL_LONG)
AC_SUBST(SIZEOF_CL_FLOAT)
AC_SUBST(SIZEOF_CL_DOUBLE)

dnl
dnl check for various library routines etc.
dnl
AC_CHECK_FUNCS(posix_memalign)
if test x"$ac_cv_func_posix_memalign" != xyes ; then
  AC_CHECK_FUNCS(memalign)
  if test x"$ac_cv_func_posix_memalign" != xyes ; then
    AC_CHECK_FUNCS(valloc)
  fi
fi

AC_CHECK_FUNCS(mach_absolute_time)
AC_CHECK_TYPES([struct timespec])
AC_CHECK_FUNCS(pthread_barrier_init)

dnl
dnl check for clock_gettime.  On Linux, this requires librt.
dnl
save_LIBS=$LIBS
LIBS="-lrt $LIBS"
AC_MSG_CHECKING([for clock_gettime])
AC_LINK_IFELSE(
  [AC_LANG_PROGRAM(
    [[#include <time.h>]],
    [[struct timespec t; clock_gettime(CLOCK_REALTIME, &t); ]])],
  [ ac_cv_func_clock_gettime=yes;
    AC_DEFINE(HAVE_CLOCK_GETTIME, [1], [is clock_gettime available?])],
  [ac_cv_func_clock_gettime=no])
AC_MSG_RESULT($ac_cv_func_clock_gettime)
if test "$ac_cv_func_clock_gettime" = "no" ; then
  LIBS=$save_LIBS
fi

AC_CHECK_FUNCS(pthread_getcpuclockid)
AC_CHECK_FUNCS(sigtimedwait nanosleep)

dnl
dnl check for sched_setaffinity
dnl
AC_CHECK_FUNCS(sched_setaffinity)

dnl
dnl check for pthread_setaffinity_np
dnl
save_LIBS=$LIBS
save_CFLAGS=$CFLAGS
LIBS="$PTHREAD_LIBS $LIBS"
CFLAGS="$PTHREAD_CFLAGS $CFLAGS"
AC_MSG_CHECKING([for pthread_setaffinity_np])
AC_LINK_IFELSE(
  [AC_LANG_PROGRAM(
    [[#include <pthread.h>]],
    [[cpu_set_t s; pthread_setaffinity_np(pthread_self(), sizeof(s), &s); ]])],
  [ ac_cv_func_pthread_setaffinity_np=yes;
    AC_DEFINE(HAVE_PTHREAD_SETAFFINITY_NP, [1], [is pthread_setaffinity_np available?])],
  [ac_cv_func_pthread_setaffinity_np=no])
AC_MSG_RESULT($ac_cv_func_pthread_setaffinity_np)
LIBS=$save_LIBS
CFLAGS=$save_CFLAGS

dnl
dnl check for Linux NUMA support (libnuma)
dnl
AC_CHECK_LIB(numa,numa_available)
if test "$ac_cv_lib_numa_numa_available" = "yes" ; then
  PTHREAD_LIBS="$PTHREAD_LIBS -lnuma"
fi

dnl check for /proc/cpuinfo
dnl
AC_CHECK_FILES(/proc/cpuinfo)

dnl
dnl OS-specific linking issues
dnl
LD_NEEDS_RPATH=false;
LIBM=""
case "$host_os" in
  darwin*) # On Mac OS X we check for the presence of macports and/or fink
    if test -x /opt/local/bin/port ; then
      HAS_MACPORTS=yes
    else
      HAS_MACPORTS=no
    fi
    if test -x /sw/bin/fink ; then
      HAS_FINK=yes
    else
      HAS_FINK=no
    fi
  ;;
  linux*) # On Linux we include the -rpath option to pick up dynamically-loaded libraries
    LD_NEEDS_RPATH=true
    LIBM="-lm"
  ;;
esac

if test x"$HAS_MACPORTS" = xyes ; then
  LDPATHS="-L/opt/local/lib"
elif test x"$HAS_FINK" = xyes ; then
  LDPATHS="-L/sw/lib"
else
  LDPATHS=""
fi
AC_SUBST(LDPATHS)
AC_SUBST(LD_NEEDS_RPATH)
AC_SUBST(LIBM)

dnl
dnl get the path to the TEEM installation.  We need this to build the Diderot
dnl runtime code and we use the path when searching for teem in the Diderot
dnl compiler.
dnl
AC_ARG_WITH(teem,
  AC_HELP_STRING([--with-teem=<path>], [specify path to teem installation]),
  [ac_cv_use_teem=$withval], [ac_cv_use_teem=no])
if test x"$ac_cv_use_teem" = xno ; then
  TEEM_DIR=none
else
  AC_MSG_CHECKING([path to teem ($ac_cv_use_teem)])
  case $ac_cv_use_teem in
    /*) ;;
    *) AC_MSG_ERROR([path to teem must be absolute]) ;;
  esac
  if test -x $ac_cv_use_teem ; then
    TEEM_DIR=$ac_cv_use_teem
    # check that TEEM_DIR actually points to something that looks like teem
    if test -f $TEEM_DIR/include/teem/nrrd.h ; then
      AC_MSG_RESULT([yes])
    else
      TEEM_DIR=none
      AC_MSG_RESULT([no])
    fi
  else
    TEEM_DIR=none
    AC_MSG_RESULT([no])
  fi
fi
if test x"$TEEM_DIR" = xnone ; then
  AC_MSG_ERROR([unable to find teem; use --with-teem option to specify location])
fi
dnl
dnl check that unu supports the dnorm command
dnl
if test x"$TEEM_DIR" != xnone ; then
  AC_MSG_CHECKING([that \"unu dnorm\" works])
  if test -x $TEEM_DIR/bin/unu ; then
    $TEEM_DIR/bin/unu dnorm > /dev/null 2> /dev/null
    if test $? -eq 0 ; then
      AC_MSG_RESULT([yes])
    else
      AC_MSG_ERROR([\"unu dnorm\" is not supported; please update your teem installation])
    fi
  else
    AC_MSG_ERROR([unable to find unu executable in $TEEM_DIR/bin"])
  fi
fi
AC_SUBST(TEEM_DIR)

dnl ******************** SML/NJ configuration ********************
dnl

dnl check that we have a compatible version of SML/NJ
dnl
CHECK_SMLNJ([AC_MSG_ERROR([unable to find SML/NJ installation; check your PATH or set SMLNJ_CMD])])
if test $SMLNJ_MAJOR_VERSION -lt 110 \
  -o $SMLNJ_MINOR_VERSION -lt 77
then
  AC_MSG_ERROR([installation requires SML/NJ version 110.77+ (available from smlnj.org)])
fi
AC_SUBST(SMLNJ_VERSION)

dnl determine the heap-image suffix
dnl
CHECK_SMLNJ_HEAP_SUFFIX([
  AC_MSG_ERROR([unsupported configuration ${host_cpu}-${host_os}])])

dnl look for ml-makedepend
dnl
AC_MSG_CHECKING([for ml-makedepend])
tmpPATH="$SMLNJ_PATH:$PATH"
AC_PATH_PROG(ML_MAKEDEPEND, ml-makedepend, ":", $tmpPATH)
if test $ML_MAKEDEPEND = none ; then
  AC_MSG_ERROR([ml-makedepend not found])
else
  AC_MSG_RESULT([$ML_MAKEDEPEND])
fi
AC_SUBST(ML_MAKEDEPEND)

dnl
dnl look for ml-build
dnl
tmpPATH="$SMLNJ_PATH:$PATH"
AC_PATH_PROG(ML_BUILD, ml-build, none, $tmpPATH)
if test $ML_BUILD = none ; then
  AC_MSG_ERROR([ml-build not found])
fi
AC_SUBST(ML_BUILD)

dnl ******************** Documentation tools ********************

dnl check for doxygen
dnl
AC_ARG_WITH([doxygen],
  [AS_HELP_STRING([--with-doxygen=PATH], [specify location of doxygen executable])],
  [DOXYGEN=$with_doxygen],
  [DOXYGEN=none])
if test x$DOXYGEN = xnone ; then
  # see if we can find doxygen in the user's path
  AC_PATH_PROG(DOXYGEN, [doxygen], [none])
fi
if test x$with_doxygen = xyes -o x$with_doxygen = xno ; then
  AC_MSG_ERROR([--with-doxygen option must specify directory argument])
elif test x$DOXYGEN != xnone -a ! -x $DOXYGEN ; then
  AC_MSG_ERROR([doxygen not found at $DOXYGEN])
elif test x$DOXYGEN != xnone ; then
dnl
dnl verify that $DOXYGEN is an absolute path
dnl
  case $DOXYGEN in
    /*) ;;
    *) AC_MSG_ERROR([--with-doxygen path must be absolute]) ;;
  esac
fi
if test $DOXYGEN = xnone ; then
  DOXYGEN=:
fi
AC_SUBST(DOXYGEN)

dnl check for asciidoc and related tools
dnl
AC_PATH_PROGS([ASCIIDOC], [asciidoc], [none])
AC_PATH_PROGS([A2X], [a2x], [none])
AC_PATH_PROGS([HIGHLIGHTER], [pygmentize], [none])
AC_PATH_PROGS([DBLATEX], [dblatex], [none])

dnl
dnl get the path to the asciidoc cofiguration files
dnl
if test x"$ASCIIDOC" != xnone ; then
  AC_MSG_CHECKING([path to asciidoc configuration files])
  ASCIIDOC_CONF_DIR=`$ASCIIDOC -v /dev/null 2>&1 | head -n 1 | sed 's|.*reading: \(.*\)/asciidoc.conf|\1|'`
  AC_MSG_RESULT([$ASCIIDOC_CONF_DIR])
fi
AC_SUBST(ASCIIDOC)
AC_SUBST(A2X)
AC_SUBST(ASCIIDOC_CONF_DIR)
AC_SUBST(HIGHLIGHTER)
AC_SUBST(DBLATEX)


dnl ******************** Paths ********************

DIDEROT_ROOT=`pwd`
DIDEROT_DOCDIR=$DIDEROT_ROOT/doc
DIDEROT_SRCDIR=$DIDEROT_ROOT/src
DIDEROT_LIBDIR=$DIDEROT_ROOT/lib
DIDEROT_BINDIR=$DIDEROT_ROOT/bin
DIDEROT_MKDIR=$DIDEROT_ROOT/mk

HEAP_IMAGE_DIR=$DIDEROT_BINDIR/.heap
INSTALL_SMLNJ_WRAPPER=$DIDEROT_BINDIR/install-sml-wrapper.sh

AC_SUBST(DIDEROT_ROOT)
AC_SUBST(DIDEROT_DOCDIR)
AC_SUBST(DIDEROT_SRCDIR)
AC_SUBST(DIDEROT_LIBDIR)
AC_SUBST(DIDEROT_BINDIR)
AC_SUBST(DIDEROT_MKDIR)
AC_SUBST(HEAP_IMAGE_DIR)
AC_SUBST(INSTALL_SMLNJ_WRAPPER)

dnl
dnl ******************** C compiler properties ********************
dnl

dnl
dnl run the compiler tests in 64-bit mode
dnl
save_CFLAGS=$CFLAGS
CFLAGS="$CFLAGS $CFLAG_MXX"

dnl
dnl check for gcc builtin atomic operations
dnl
AC_MSG_CHECKING([for builtin atomic operations])
AC_LINK_IFELSE(
   [AC_LANG_PROGRAM([], [int foo1; int foo2 = __sync_fetch_and_add(&foo1, 1);])],
   AC_MSG_RESULT(yes)
   AC_DEFINE(
    [HAVE_BUILTIN_ATOMIC_OPS], 1,
    [Define to 1 if gcc compiler provides atomic operations.]),
   AC_MSG_RESULT(no))

AC_C_BIGENDIAN

#
# determine the sizes of the standard C types
AC_CHECK_SIZEOF([int])
SIZEOF_C_INT=$ac_cv_sizeof_int
AC_CHECK_SIZEOF([long])
SIZEOF_C_LONG=$ac_cv_sizeof_long
AC_CHECK_SIZEOF([float])
SIZEOF_C_FLOAT=$ac_cv_sizeof_float
AC_CHECK_SIZEOF([double])
SIZEOF_C_DOUBLE=$ac_cv_sizeof_double

AC_SUBST(SIZEOF_C_INT)
AC_SUBST(SIZEOF_C_LONG)
AC_SUBST(SIZEOF_C_FLOAT)
AC_SUBST(SIZEOF_C_DOUBLE)

dnl
dnl restore CFLAGS
dnl
CFLAGS=$save_CFLAGS

dnl
dnl ******************** config.h stuff ********************
dnl

AC_DEFINE_UNQUOTED(DIDEROT_INCLUDE_PATH,["$DIDEROT_SRCDIR/include"], [path for Diderot header files])

AH_TOP([
/*
 * COPYRIGHT (c) 2011 Diderot project. (http://diderot-language.cs.uchicago.edu)
 * All rights reserved.
 */

#ifndef _DIDEROT_CONFIG_H_
#define _DIDEROT_CONFIG_H_

])
AH_BOTTOM([

#ifdef NDEBUG
#define STATIC_INLINE   static inline
#else
#define STATIC_INLINE   static
#endif

#endif /* !_DIDEROT_CONFIG_H_ */
])

dnl
dnl ******************** write output ********************
dnl

AC_CONFIG_FILES(
dnl
dnl ***** Makefiles *****
  Makefile
  doc/Makefile
  doc/man/Makefile
  src/clinfo/Makefile
  src/compiler/Makefile
  src/lib/build/Makefile
  src/lib/build/mk/build.gmk:src/lib/build/mk/build_gmk.in
  test/MIP/Makefile
  test/probe/Makefile
  test/iso2d-polyline/Makefile
  test/vr-lite-cam/Makefile
  test/hlic/Makefile
dnl
dnl ***** SML source files *****
  src/compiler/nrrd/run-dnorm.sml:src/compiler/nrrd/run-dnorm_sml.in
  src/compiler/common/paths.sml:src/compiler/common/paths_sml.in
  src/compiler/common/size-of.sml:src/compiler/common/size-of_sml.in
)

AC_CONFIG_HEADERS(src/include/Diderot/config.h:config/config_h.in)

dnl
dnl shell scripts
dnl
AC_CONFIG_FILES([
  bin/install-sml-wrapper.sh:config/install-sml-wrapper_sh.in
], [chmod +x bin/install-sml-wrapper.sh])
AC_CONFIG_FILES([
  src/compiler/gen/file2str/file2str.sh:src/compiler/gen/file2str/file2str_sh.in
], [chmod +x src/compiler/gen/file2str/file2str.sh])
AC_CONFIG_FILES([
  rtest/scripts/run.sh:rtest/scripts/run_sh.in
], [chmod +x rtest/scripts/run.sh])
AC_CONFIG_FILES([
  rtest/scripts/run-one.sh:rtest/scripts/run-one_sh.in
], [chmod +x rtest/scripts/run-one.sh])

dnl
dnl generate makefiles for runtime library builds
dnl
dnl usage: MK_BUILD_DIR(<build-dir>, <target-platform>, <options>)
dnl
AC_DEFUN([MK_BUILD_DIR], [
    if test ! -d src/lib/build/$1 ; then
      mkdir src/lib/build/$1
    fi
    [sed -e 's,@BUILD_TARGET@,$1,g' \
      -e 's,@TARGET_PLATFORM@,$2,g' \
      -e 's,@BUILD_OPTIONS@,$3,g' \
      src/lib/build/mk/Makefile.in \
        > src/lib/build/$1/Makefile.in]
    AC_CONFIG_FILES(src/lib/build/$1/Makefile)
  ])

MK_BUILD_DIR(rt-c-f, c, [float])
MK_BUILD_DIR(rt-c-d, c, [double])
MK_BUILD_DIR(rt-c-f-debug, c, [float debug])
MK_BUILD_DIR(rt-c-d-debug, c, [double debug])
MK_BUILD_DIR(rt-c-f-par, parallel, [parallel float])
MK_BUILD_DIR(rt-c-d-par, parallel, [parallel double])
MK_BUILD_DIR(rt-c-f-par-debug, parallel, [parallel float debug])
MK_BUILD_DIR(rt-c-d-par-debug, parallel, [parallel double debug])

if test x"$CL_ENABLED" = xtrue ; then
  MK_BUILD_DIR(rt-cl-f, cl, [float])
  MK_BUILD_DIR(rt-cl-d, cl, [double])
  MK_BUILD_DIR(rt-cl-f-debug, cl, [float debug])
  MK_BUILD_DIR(rt-cl-d-debug, cl, [double debug])
fi

AC_OUTPUT