configure.in

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

AC_PREREQ([2.63])
AC_INIT([OpenModelica],[dev],[https://trac.openmodelica.org/OpenModelica],[openmodelica],[https://openmodelica.org])
AC_SUBST(date)
AC_SUBST(rmlc_bin)
AC_SUBST(rmlhome)
AC_SUBST(rmlinc)
AC_SUBST(omc_antlr_jar)
AC_SUBST(antlrinc)
AC_SUBST(antlrlib)
AC_SUBST(with_paradiseo)
AC_SUBST(with_paradiseo_include)
AC_SUBST(with_paradiseo_lib)
AC_SUBST(with_qwt)
AC_SUBST(with_qwt_suffix)
AC_SUBST(EXTRA_CFLAGS_GENERATED_CODE)
AC_SUBST(LIBSOCKET)
AC_SUBST(LIBNSL)
AC_SUBST(LIBLPSOLVE55)
AC_SUBST(LPSOLVEINC)
AC_SUBST(MODELICA3D)
AC_SUBST(USE_CORBA)
AC_SUBST(QT_USE_CORBA)
AC_SUBST(CORBA_QMAKE_INCLUDES)
AC_SUBST(CORBACFLAGS)
AC_SUBST(CORBALIBS)
AC_SUBST(IDLCMD)
AC_SUBST(OPENCL)
AC_SUBST(IDLPYTHONCMD)
AC_SUBST(USE_GRAPH)
AC_SUBST(USE_METIS)
AC_SUBST(USE_PATOH)
AC_SUBST(METISHOME)
AC_SUBST(PATOHHOME)
AC_SUBST(GENERATED_AUTOCONF_FILES)
AC_SUBST(RT_LDFLAGS)
AC_SUBST(RT_LDFLAGS_SIM)
AC_SUBST(RT_LDFLAGS_GENERATED_CODE)
AC_SUBST(RT_LDFLAGS_GENERATED_CODE_SIM)
AC_SUBST(SUNDIALS_LDFLAGS)
AC_SUBST(IPOPT_LDFLAGS)
AC_SUBST(IPOPT_CFLAGS)
AC_SUBST(QMAKE)
AC_SUBST(EXE)
AC_SUBST(RML_TRACE)
AC_SUBST(SOURCE_REVISION)
AC_SUBST(LIBF2C)
AC_SUBST(OMSHELL_TERMINAL)
AC_SUBST(MODELICA_SPEC_PLATFORM)
AC_SUBST(OPENMODELICA_SPEC_PLATFORM)
AC_SUBST(OMC_LIBS)
AC_SUBST(OMPCC)
AC_SUBST(RUNTIMECC)
AC_SUBST(RUNTIMECFLAGS)
AC_SUBST(MAKE)
AC_SUBST(LIBREADLINE)
AC_SUBST(LD_LAPACK)
AC_SUBST(PYTHON_INTERFACE)
AC_SUBST(WITH_SUNDIALS)
AC_SUBST(WITH_IPOPT)
AC_SUBST(UMFPACK_TARGET)
AC_SUBST(OMNOTEBOOK)
AC_SUBST(FPMATHFORTRAN)
AC_SUBST(OMOPTIM_CC)
AC_SUBST(OMOPTIM_CXX)
AC_SUBST(LIBGC)
AC_SUBST(LIBSIMULATION)
AC_SUBST(LIBRUNTIME)
AC_SUBST(LIBFMIRUNTIME)
AC_SUBST(LIBFMILIB)
AC_SUBST(FMILIB_SHARED)
AC_SUBST(LIBCMINPACKLIB)
AC_SUBST(CMINPACKLIB_SHARED)
AC_SUBST(SHREXT)
AC_SUBST(LINK)
AC_SUBST(RPATH)
AC_SUBST(RPATH_QMAKE)
AC_SUBST(MSL_EXTRA_ARGS)
AC_SUBST(WITH_HWLOC)
AC_SUBST(OS_TARGET)
AC_SUBST(LIS_LDFLAGS)
AC_SUBST(LAPACK_TARGET)
AC_SUBST(CONFIG_WITH_OPENMP)
AC_SUBST(OPENBLAS_EXTRA_ARGS)
AC_SUBST(AR)
AC_SUBST(AR_SH)
AC_SUBST(CPPFLAGS_F2C)
AC_SUBST(LDFLAGS_SOCKET)
AC_SUBST(APP)
AC_SUBST(OMC)
AC_SUBST(OMCTARGET)
AC_SUBST(BOOTSTRAP_STATIC)

FINAL_MESSAGES="\nConfigured OpenModelica successfully using the following options:"

AC_CANONICAL_HOST
AC_CANONICAL_TARGET

if test -z "$AR"; then
  AR=ar
fi

if test -z "$MAKE"; then
  MAKE=make
fi

if test x"$prefix" = xNONE; then
  PREFIX=`pwd`/build
else
  PREFIX=$prefix
fi
AC_PREFIX_DEFAULT($PREFIX)
prefix=$PREFIX

AC_ARG_ENABLE(non-free-packages, [  --enable-non-free-packages     Enables you to link non-free packages. But doing so limits your ability to distribute code under GPL3, even to co-workers and the like. If you are an OSMC member you might be allowed to link and ship such libraries if you have a commercial license for the linked packages.],[test "yes" = "$enableval" && ENABLE_NON_FREE_PACKAGES=1 && NON_FREE_VERSION=") (non-free version for personal use only; seriously do not distribute this binary"] && FINAL_MESSAGES="$FINAL_MESSAGES\nLinking against non-free packages: Yes (this version of omc not for distribution)")

dnl Checks for programs.
AC_LANG([C])
AC_PROG_CC
AC_PROG_CXX
AC_PROG_CPP
AC_PROG_MAKE_SET
AC_PROG_LEX
AC_PROG_FC

CFLAGS_BEFORE="$CFLAGS"
CFLAGS="$CFLAGS -Werror"
AC_MSG_CHECKING([if -Werror works])
AC_TRY_LINK([void abc() {}], [abc();], [AC_MSG_RESULT([ok])], [AC_MSG_ERROR([failed (check your CFLAGS)])])
CFLAGS="$CFLAGS_BEFORE"

dnl Disables the default CFLAGS="-g -O2"
if test -z "$CFLAGS"; then
if  test "Darwin" = `uname`; then
CFLAGS="-O3"
else
CFLAGS_BEFORE="$CFLAGS"
CFLAGS="-O3 -march=native"
AC_MSG_CHECKING([looking for -march=native])
AC_TRY_LINK([void abc() {}], [abc();], [AC_MSG_RESULT([yes])], [AC_MSG_RESULT([no]);CFLAGS="-O3"])
fi
fi

# GCC 4.8 generates bad code with some optimisation flags. Let's try to disable them.
for flag in  -fno-tree-ch -fno-tree-vrp -fno-tree-pre; do
  OLD_CFLAGS="$CFLAGS"
  CFLAGS="$RUNTIMECFLAGS $flag -Werror"
  AC_TRY_LINK([], [return 0;], [CFLAGS="$OLD_CFLAGS $flag"],[CFLAGS="$OLD_CFLAGS"])
done
for flag in -fno-stack-protector; do
  OLD_CFLAGS="$CFLAGS"
  CFLAGS="$RUNTIMECFLAGS $flag -Werror"
  AC_TRY_LINK([], [return 0;], [CFLAGS="$OLD_CFLAGS $flag"],[CFLAGS="$OLD_CFLAGS"])
done
OLD_CFLAGS="$CFLAGS"
for flag in -Wno-parentheses-equality -Wno-unused-variable; do
  CFLAGS="$RUNTIMECFLAGS $flag -Werror"
  AC_TRY_LINK([], [return 0;], [EXTRA_CFLAGS_GENERATED_CODE="$EXTRA_CFLAGS_GENERATED_CODE $flag"],[])
done
CFLAGS="$OLD_CFLAGS"

if test "Darwin" != `uname`; then

if test "`getconf LONG_BIT`" = "64"; then

AC_MSG_CHECKING([x86_64 CFLAGS])

if echo $CFLAGS | grep -q -- -fPIC; then
  AC_MSG_RESULT([already got -fPIC])
else
  CFLAGS_BEFORE="$CFLAGS"
  CFLAGS="$CFLAGS -fPIC -Werror"
  AC_TRY_LINK([void abc() {}], [abc();], [AC_MSG_RESULT([adding -fPIC]); CFLAGS="$CFLAGS_BEFORE -fPIC"; FPIC="-fPIC"], [AC_MSG_RESULT([don't need -fPIC]); CFLAGS="$CFLAGS_BEFORE"])
fi

fi

else # Is Darwin

AC_LANG([C++])
OLD_CXXFLAGS=$CXXFLAGS
for flag in -stdlib=libstdc++; do
  AC_TRY_LINK([], [return 0;], [CXXFLAGS="$OLD_CXXFLAGS $flag"],[CXXFLAGS="$OLD_CXXFLAGS"])
done
AC_LANG([C])

fi

if test "`getconf LONG_BIT`" = "32"; then
dnl Simulations spin forever unless -msse2 -mfpmath=sse is set

CFLAGS_BEFORE=$CFLAGS
CFLAGS="-mfpmath=sse -Werror"
AC_MSG_CHECKING([for floating point bugs])
AC_TRY_LINK([int abc() {}], [abc();], [AC_MSG_RESULT([force SSE2]); FPMATHFORTRAN="-msse -mfpmath=sse"], [AC_MSG_RESULT([no]); FPMATHFORTRAN=-ffloat-store])
CFLAGS=$CFLAGS_BEFORE

fi # End x86-specific CFLAGS

dnl check for environment variables

AC_ARG_WITH(omc,  [  --with-omc=[omc]       (the installed omc path which we will use to compile omc)],[OMC="$withval"],[OMC=`which omc`])
while test -h "$OMC"; do
  OMC=`readlink "$OMC"`
done

AC_MSG_CHECKING([for omc])

if test "$OMC" = "no" ; then
  AC_MSG_RESULT([building it through bootstrapping (you might end up unable to recompile omc if you modify source code)])
  OMC="$ac_pwd$ac_dir_suffix/build/bin/omc"
elif "$OMC" ++v > /dev/null 2>&1; then
  AC_MSG_RESULT([$OMC])
else
  AC_MSG_RESULT([failed (tried $OMC). Building it through bootstrapping (you might end up unable to recompile omc if you modify source code).])
  OMC="$ac_pwd$ac_dir_suffix/build/bin/omc"
fi

AC_ARG_WITH(rml,  [  --with-rml=[no]       (use =no if you are using experimental bootstrapping)],[WANT_RML="$withval";OMCTARGET=omc-rml],[WANT_RML="yes";OMCTARGET=omc-rml])

if test "$WANT_RML" != "no"; then
AC_MSG_CHECKING([for \$RMLHOME])
if test ! -z "$RMLHOME" ; then
  rmlhome=$RMLHOME
  AC_MSG_RESULT([$RMLHOME])

  AC_MSG_CHECKING([for rmlc])
  if test -x $rmlhome/bin/rmlc ; then
    rmlc_bin=$rmlhome/bin/rmlc
    AC_MSG_RESULT([yes])
  else
    AC_MSG_ERROR([rmlc not found in \$rmlhome/bin])
  fi

else
  AC_MSG_RESULT([no])
  AC_PATH_PROG(RMLC,rmlc)
  if test -z $RMLC ; then
    AC_MSG_ERROR([RML not installed])
  fi
  rmlhome=`dirname \`dirname $RMLC\``
  rmlc_bin=$RMLC
fi

AC_MSG_CHECKING([for rml includefiles in $rmlhome])
if test ! -f "$rmlhome/include/plain/rml.h" ; then
  AC_MSG_ERROR([rml headers not found])
  AC_MSG_RESULT([no])
else
  AC_MSG_RESULT([yes])
fi
rmlinc=$rmlhome/include/plain/

AC_MSG_CHECKING([if the user wants RML -trace support])
RML_TRACE=",-ftrace"
AC_ARG_ENABLE(rml-trace,        [  --disable-rml-trace           RML -trace support (enabled by default)],[test "xno" = x"$enableval" && RML_TRACE=""])
if test -z "$RML_TRACE" ; then
AC_MSG_RESULT([no])
else
AC_MSG_RESULT([yes])
fi
else
  rmlhome=CONFIGUREDWITHOUTRMLDONTTRYTHISMAKEFILETARGETAGAIN
  OMCTARGET=omc-bootstrapped
fi

dnl Checks for libraries.

if test ! "Darwin" = `uname`; then
  LIBS=""
  AC_SEARCH_LIBS(clock_gettime,rt,[],[AC_MSG_ERROR([clock_gettime missing])])
  LIBRT="$LIBS"
  LIBS=""
fi

dnl Checks for header files.
AC_HEADER_STDC

AC_CHECK_HEADERS(sys/time.h, [], [AC_MSG_ERROR(Missing header files)])
# AC_CHECK_HEADERS(sqlite3.h, [], [AC_MSG_ERROR(Missing header files)])

# OSX and other systems might have different sizes in f2c headers. Let's always use our own...
# AC_CHECK_HEADERS(f2c.h, [], [LIBF2C=libf2c/libf2c.a])
LIBF2C=libf2c/libf2c.a

AC_MSG_CHECKING([for antlr.Tool support])
omc_antlr_jar=build/share/omc/java/antlr-3.1.3.jar
mkdir -p build/share/omc/java
cp SimulationRuntime/c/util/java_interface/antlr-3.1.3.jar $omc_antlr_jar
echo "" > $$grammar.g
if java -cp $omc_antlr_jar antlr.Tool $$grammar.g ; then
  rm -f $$grammar.g
  AC_MSG_RESULT([yes])
else
  rm -f $$grammar.g
  AC_MSG_ERROR([no antlr.Tool support])
fi

AC_MSG_CHECKING([if the user wants to compile OMShell-terminal])
OMSHELL_TERMINAL="mosh"
AC_ARG_ENABLE(omshell-terminal, [  --disable-omshell-terminal    Disables compilation of OMShell-terminal (enabled by default)],[test "xno" = x"$enableval" && OMSHELL_TERMINAL=""])
if test -z "$OMSHELL_TERMINAL" ; then
  AC_MSG_RESULT([no])
else
  AC_MSG_RESULT([yes])
  AC_CHECK_HEADER(readline/readline.h,,AC_MSG_ERROR([readline missing]))
  AC_CHECK_HEADER(readline/history.h,,AC_MSG_ERROR([readline missing]))

  AC_ARG_WITH(static-readline,  [  --with-static-readline=DIR       (default to dynamic linking; searches /usr if no other directory is provided)],[WANT_STATIC_READLINE="$withval"],[WANT_STATIC_READLINE="no"])

  if test "$WANT_STATIC_READLINE" = "no"; then
    LIBS=""
    AC_SEARCH_LIBS(readline,readline,,[AC_MSG_ERROR([readline missing])])
    LIBREADLINE=$LIBS
    LIBS=""
  else
    if test "$WANT_STATIC_READLINE" = "yes"; then
      READLINELIB=/usr/lib;
    else
      READLINELIB=$WANT_STATIC_READLINE/lib
    fi
    test -f $READLINELIB/*/libreadline.a && READLINELIB=`dirname $READLINELIB/*/libreadline.a`
    LIBS="-lncurses $READLINELIB/libreadline.a -ltermcap"
    AC_MSG_CHECKING([for static readline $LIBS])
    AC_LINK_IFELSE([AC_LANG_CALL([], [rl_message])], [LIBREADLINE=$LIBS], [AC_MSG_ERROR([failed])])
    AC_MSG_RESULT([ok])
    LIBS=""
  fi
fi

dnl Misc. headers

AC_CHECK_HEADER(expat.h,,AC_MSG_ERROR([expat missing]))

dnl Checks for typedefs, structures, and compiler characteristics.
AC_C_CONST
AC_TYPE_SIZE_T

dnl Checks for library functions.
AC_FUNC_VPRINTF
AC_CHECK_FUNCS(getcwd select strdup strerror)


dnl Check if scandir is available
AC_MSG_CHECKING([for scandir])

AC_TRY_LINK([
#include <dirent.h>
], [
int file_select_directories(const struct dirent *entry) {
 return 0;
}

int main() {
char dir[]=".";
int count;
struct dirent **files;
scandir(dir, &files, file_select_directories, 0);
return 0;
}
], [AC_MSG_RESULT([yes]); AC_DEFINE([HAVE_SCANDIR])],
      [AC_MSG_RESULT([no])])

dnl Check if OpenMP is available
AC_MSG_CHECKING([for OpenMP])

AC_ARG_VAR(OMPCC, [Selects a compiler to be used to compile OpenMP code. Useful if the main CC does not support OpenMP.])

CC_OLD="$CC"
CFLAGS_OLD="$CFLAGS"
if test -z "$OMPCC"; then
  CFLAGS=" -fopenmp"
else
  CC="$OMPCC"
  CFLAGS=""
fi

AC_TRY_LINK([
#if !defined(_OPENMP)
  #error "Not an OpenMP compiler"
#endif
#include <omp.h>
#include <stdio.h>
], [int main() {
  int i;
#pragma omp parallel for private(i) schedule(dynamic)
  for (i=0; i<16; i++)
    printf("Thread %d\n", i);
  return 0;
}
], [OMPCC="$CC$CFLAGS"; AC_MSG_RESULT([$OMPCC]); CONFIG_WITH_OPENMP=1],
  [
  if test -z "$OMPCC"; then
    OMPCC="$CC_OLD"
    AC_MSG_RESULT([no]);
  else
    AC_MSG_ERROR([failed (user gave $OMPCC)]);
  fi
  CONFIG_WITH_OPENMP=0
  ]
)
CC="$CC_OLD"
CFLAGS="$CFLAGS_OLD"

AC_ARG_VAR(RUNTIMECC, [Selects a compiler to be used to compile generated code. It is more important to compile fast than to generate fast code for the runtime compiler.])
AC_ARG_VAR(RUNTIMECFLAGS, [CFLAGS for the selected runtime compiler (defaults to -O0 -falign-functions -march=native -mfpmath=sse -fPIC as long as neither gives warnings to the CC). Note that heavy optimisations may cause the run-time to be faster while increasing compile-time. -O0 is often best.])

CC_OLD="$CC"
CFLAGS_OLD="$CFLAGS"
if test ! -z "$RUNTIMECC"; then
  CC="$RUNTIMECC"
else
  RUNTIMECC="$CC"
fi
AC_MSG_CHECKING([runtime compiler])
if test -z "$RUNTIMECFLAGS"; then
  CFLAGS="$FPIC -Werror"
  AC_TRY_LINK([], [return 0;], [AC_MSG_RESULT($CC ok);],[AC_MSG_ERROR($CC failed)])
  CFLAGS="$FPIC"
  AC_MSG_CHECKING([runtime compiler CFLAGS])
  for flag in -O0 -falign-functions -march=native -mfpmath=sse; do
    RUNTIMECFLAGS="$CFLAGS"
    CFLAGS="$RUNTIMECFLAGS $flag -Werror"
    AC_TRY_LINK([], [int main() {return 0;}], [CFLAGS="$RUNTIMECFLAGS $flag"],[CFLAGS="$RUNTIMECFLAGS"])
  done
else
  CFLAGS="$RUNTIMECFLAGS $FPIC -Werror"
  AC_TRY_LINK([], [return 0;], [RUNTIMECFLAGS="$RUNTIMECFLAGS $FPIC"],[AC_MSG_ERROR([$CC $CFLAGS -Werror failed])])
fi
AC_MSG_RESULT([$RUNTIMECFLAGS])

CC="$CC_OLD"
CFLAGS="$CFLAGS_OLD"

dnl check for lpsolve55

AC_ARG_WITH(static-lpsolve,  [  --with-static-lpsolve=DIR        (default to dynamic linking; searches /usr if no other directory is provided)],[WANT_STATIC_LPSOLVE="$withval"],[WANT_STATIC_LPSOLVE="no"])

LIBS=""
AC_SEARCH_LIBS(dlopen,dl)
LIBDL="$LIBS"
LIBS=""

if test "$WANT_STATIC_LPSOLVE" = "no"; then
  LIBS=""
  AC_SEARCH_LIBS(dlopen,dl)
  LIBDL="$LIBS"
  AC_SEARCH_LIBS(sqrt,m)
  AC_SEARCH_LIBS(colamd,colamd)
  AC_SEARCH_LIBS(make_lp,[lpsolve55_pic lpsolve55],[],[AC_MSG_ERROR([lpsolve linking failed using $LIBS])])
  LIBLPSOLVE55=$LIBS
  LIBS=""
else
  if test "$WANT_STATIC_LPSOLVE" = "yes"; then
    LPLIB=/usr/lib;
  else
    LPLIB=$WANT_STATIC_LPSOLVE/lib
  fi
  LIBS=""
  AC_SEARCH_LIBS(dlopen,dl)
  AC_SEARCH_LIBS(sqrt,m)
  LIBS="$LPLIB/liblpsolve55_pic.a $LPLIB/libcolamd.a $LIBS"
  AC_MSG_CHECKING([for static lpsolve55])
  AC_LINK_IFELSE([AC_LANG_CALL([], [make_lp])], [LIBLPSOLVE55=$LIBS], [AC_MSG_ERROR([failed])])
  AC_MSG_RESULT([$LIBLPSOLVE55])
  LIBS=""
fi
AC_CHECK_HEADER([lp_lib.h],[LPSOLVEINC=lp_lib.h],[
  AC_CHECK_HEADER([lpsolve/lp_lib.h],[LPSOLVEINC=lpsolve/lp_lib.h],[AC_MSG_ERROR([failed to find lpsolve55 headers])])
])


if test "$host" != "i586-pc-mingw32msvc"; then
  AC_CHECK_FUNC(socket,[LIBSOCKET=""],
   [AC_MSG_CHECKING([for libsocket]);
    AC_CHECK_LIB(socket, socket,[AC_MSG_RESULT([yes]); LIBSOCKET="-lsocket"],[AC_MSG_ERROR([neither socket nor libsocket.a found])])
  ])

  AC_CHECK_FUNC(gethostbyname,
   [LIBNSL=""],
   [AC_MSG_CHECKING([for libnsl]);
    AC_CHECK_LIB(nsl,gethostbyname, [AC_MSG_RESULT([yes]); LIBNSL="-lnsl"],[AC_MSG_ERROR([neither gethostbyname nor libnsl.a found])])
  ])
fi


# Sqlite is not used
if false; then

AC_ARG_WITH(static-sqlite,  [  --with-static-sqlite=FILE        (default to dynamic linking)],[WANT_STATIC_SQLITE="$withval"],[WANT_STATIC_SQLITE="no"])

LIBS=""
AC_CHECK_LIB(sqlite3,sqlite3_libversion,[],[AC_MSG_ERROR([sqlite3 not found])])

if test "$WANT_STATIC_SQLITE" = "no"; then
  OMC_LIBS=$LIBS
elif test ! -f "$WANT_STATIC_SQLITE" ; then
  AC_ERROR([File not found: $WANT_STATIC_SQLITE])
else
  OMC_LIBS=$WANT_STATIC_SQLITE
fi

fi

# Cannot use AX_LAPACK since it assumes a Fortran compiler is used
AC_ARG_WITH(lapack,  [  --with-lapack=[-llapack -lblas]    (use -llapack -lblas to use system-provided version instead of OpenBLAS. Use openblas for automatically detected OpenBLAS. Use --with-lapack=openblas-NEHALEM or other OpenBLAS target to compile against a certain architecture. Note that you need to include BLAS in this.)],[LD_LAPACK="$withval"],[LD_LAPACK="-llapack -lblas"])
AC_MSG_CHECKING([LAPACK/BLAS flags])
if echo "$LD_LAPACK" | grep -oq "^openblas"; then
  LD_LAPACK=`echo $LD_LAPACK | sed s/"^openblas-//"`
  if test "$LD_LAPACK" = "openblas"; then
    AC_MSG_RESULT([OpenBLAS compiled using auto detected architecture])
  else
    OPENBLAS_EXTRA_ARGS="TARGET=$LD_LAPACK"
    AC_MSG_RESULT([OpenBLAS compiled using architecture $LD_LAPACK])
  fi
  LD_LAPACK="-lopenblas_openmodelica"
  LAPACK_TARGET="openblas"
else
  LIBS="$LD_LAPACK"
  AC_LINK_IFELSE([AC_LANG_CALL([], [dgesv_])],[],[AC_MSG_ERROR([dgesv (LAPACK) linking failed using $LD_LAPACK])])
  AC_LINK_IFELSE([AC_LANG_CALL([], [dswap_])],[AC_MSG_RESULT([$LD_LAPACK])],[AC_MSG_ERROR([dswap (BLAS) linking failed using $LD_LAPACK])])
fi

AC_CHECK_HEADERS(kinsol/kinsol.h kinsol/kinsol_dense.h nvector/nvector_serial.h sundials/sundials_types.h sundials/sundials_math.h,[],[NO_SUNDIALS="yes"])
SUNDIALS_LDFLAGS="-lsundials_kinsol -lsundials_nvecserial $LD_LAPACK"
LIBS="$SUNDIALS_LDFLAGS -lm"
AC_MSG_CHECKING([Sundials linking])
AC_LINK_IFELSE([AC_LANG_CALL([], [KINInit])],
  [AC_MSG_RESULT([ok])],
  [LIBS="-lsundials_kinsol -lsundials_nvecserial -llapack -lblas -lm";
  AC_LINK_IFELSE([AC_LANG_CALL([], [KINInit])],
  [AC_MSG_RESULT([ok])],[AC_MSG_RESULT([failed to link KINInit]); NO_SUNDIALS="yes"])])

if ! test "$NO_SUNDIALS" = "yes"; then
  FINAL_MESSAGES="$FINAL_MESSAGES\nSimulations may use sundials suite: Yes"
  WITH_SUNDIALS="#define WITH_SUNDIALS"
else
  FINAL_MESSAGES="$FINAL_MESSAGES\nSimulations may use sundials suite: No"
  WITH_SUNDIALS="/* Without Sundials */"
# We need -llapack regardless if we use Sundials or not
  SUNDIALS_LDFLAGS="$LD_LAPACK"
fi

LIBS=""

AC_CHECK_HEADERS(locale.h libintl.h,[],[AC_MSG_ERROR([gettext headers not found])])

AC_MSG_CHECKING([gettext linking])
AC_TRY_LINK([
#include <libintl.h>
], [
  gettext("");
], [AC_MSG_RESULT([in C-library])],
  [
  LIBS="-lintl";
  AC_TRY_LINK([
    #include <libintl.h>
  ], [
      gettext("");
  ], [AC_MSG_RESULT([in intl]);RT_LDFLAGS="$RT_LDFLAGS $LIBS"],
      [AC_MSG_ERROR([no])])
])

LIBS=""
AC_CHECK_HEADERS(hwloc.h,
  [AC_CHECK_LIB(hwloc,hwloc_get_nbobjs_by_depth,
    [WITH_HWLOC="#define WITH_HWLOC 1";OMC_LIBS="$OMC_LIBS -lhwloc"],
    [WITH_HWLOC="/* Without hwloc */"])],
  [WITH_HWLOC="/* Without hwloc */"]
)

LIBS=""

AC_CHECK_LIB(pthread,pthread_self,[RT_LDFLAGS="$RT_LDFLAGS $LIBS"],[AC_MSG_ERROR([pthreads not found])])

LIBS=""

if ! test "$NO_IPOPT" = "yes"; then
  FINAL_MESSAGES="$FINAL_MESSAGES\nSimulations may use IPOPT: Yes"
  WITH_IPOPT="#define WITH_IPOPT"
  IPOPT_LDFLAGS="-lipopt -lcoinmumps"
else
  FINAL_MESSAGES="$FINAL_MESSAGES\nSimulations may use IPOPT: No"
  WITH_IPOPT="/* Without IPOPT */"
  IPOPT_CFLAGS=""
  IPOPT_LDFLAGS=""
fi

dnl should we use corba?

WANT_ORBIT2="no"
WANT_MICO="no"
AC_ARG_WITH(MICO, [  --with-MICO=DIR                  use mico corba installed in DIR (or use mico-config)],[WANT_MICO="$withval"],[])
AC_ARG_WITH(omniORB, [  --with-omniORB=DIR               use omniORB installed in DIR (recommended CORBA implementation)],[WANT_OMNIORB="$withval"],[WANT_OMNIORB="no"])

if test ! "$WANT_MICO" = "no"; then
  if test "$WANT_MICO" = "yes"; then
    MICO="mico-config";
    IDLCMD="idl";
  else
    MICO="$WANT_MICO/bin/mico-config";
    IDLCMD="$WANT_MICO/bin/idl";
  fi
  if test "$USE_CORBA" = "no"; then
    AC_MSG_ERROR([failed to find mico-corba])
  fi
  AC_MSG_CHECKING([mico version])
  if ! $MICO --version; then
    AC_MSG_ERROR([failed to call $MICO])
  fi
  USE_CORBA="-DUSE_CORBA -DUSE_MICO"
  QT_USE_CORBA="USE_MICO"
  AC_MSG_CHECKING([mico settings])
  CORBACFLAGS="-I`$MICO --prefix`/include -I.";
  CORBA_QMAKE_INCLUDES="`$MICO --prefix`/include -I.";
  CORBALIBS="`$MICO --libs`";
  AC_MSG_RESULT([$CORBACFLAGS $USE_CORBA $QT_USE_CORBA])
  DESIRED_CORBA="mico"
elif test ! "$WANT_ORBIT2" = "no"; then
  if test "$WANT_ORBIT2" = "yes"; then
    ORBIT2="orbit2-config";
  else
    ORBIT2="$withval/bin/orbit2-config";
  fi
  AC_CHECK_PROG(USE_CORBA,$ORBIT2,[-DUSE_CORBA -DUSE_ORBIT2],[no])
  if test "$USE_CORBA" = "no"; then
    AC_MSG_ERROR([failed to find orbit2])
  fi
  USE_CORBA="-DUSE_CORBA -DUSE_ORBIT"
  QT_USE_CORBA="USE_ORBIT2"
  CORBACFLAGS=`orbit2-config --cflags`;
  # Don't have orbit2-config installed to verify
  CORBA_QMAKE_INCLUDES=`orbit2-config --prefix`/include/;
  CORBALIBS=`orbit2-config --libs`;
  IDLCMD="orbit-idl-2";
  DESIRED_CORBA="orbit2"
  AC_MSG_ERROR([ORBIT2 is not supported yet])
elif test ! "$WANT_OMNIORB" = "no"; then
  if test "$WANT_OMNIORB" = "yes"; then
    OMNIORB_LDFLAGS="";
    IDLPATH="omniidl";
  else
    CORBA_QMAKE_INCLUDES="$WANT_OMNIORB/include";
    CORBACFLAGS="-I$CORBA_QMAKE_INCLUDES";
    IDLPATH="$WANT_OMNIORB/bin/omniidl"
    OMNIORB_LDFLAGS="-L'$WANT_OMNIORB/lib'";
  fi
  AC_PATH_PROG(IDLPATH,$IDLPATH,[no])
  if test "$IDLPATH" = "no"; then
    AC_MSG_ERROR([failed to find $IDLPATH])
  fi
  USE_CORBA="-DUSE_CORBA -DUSE_OMNIORB"
  # Cannot search for libs (C++ symbols) or includes (automatically generated; may differ between platforms)
  IDLCMD="$IDLPATH -bcxx -Wbh=.h -Wbs=.cc";
  IDLPYTHONCMD="$IDLPATH -bpython";
  QT_USE_CORBA="USE_OMNIORB"
  CORBALIBS="$LIBS -lomniORB4 -lomnithread -lpthread"
  DESIRED_CORBA="omniorb"
  PYTHON_INTERFACE="yes"
else
  USE_CORBA="";
  CORBACFLAGS="";
  CORBALIBS="";
  IDLCMD="";
  DESIRED_CORBA="none"
fi

AC_MSG_CHECKING([for CORBA]);
AC_MSG_RESULT([$DESIRED_CORBA]);

AC_MSG_CHECKING([if the user wants to use the Python interface])
AC_ARG_ENABLE(python-interface, [  --disable-python-interface    Python interface to omc. Enabled by default if CORBA is enabled.],[test "xno" = x"$enableval" && PYTHON_INTERFACE=""])
if test -z "$PYTHON_INTERFACE" ; then
AC_MSG_RESULT([no])
else
AC_MSG_RESULT([yes])
fi

AC_MSG_CHECKING([if the user wants Modelica3D])
AC_ARG_ENABLE(modelica3d, [  --disable-modelica3d          Modelica3D library (dependencies checked by cmake later on; enabled by default)],[test "xno" = x"$enableval" && MODELICA3D=""],[MODELICA3D="yes"])
if test -z "$MODELICA3D" ; then
AC_MSG_RESULT([no])
else
AC_MSG_RESULT([yes])
fi

AC_MSG_CHECKING([for OpenCL])
AC_CHECK_HEADER([CL/cl.h],[OPENCL="Yes"],[
  AC_CHECK_HEADER([OpenCL/cl.h],[OPENCL="Yes"],[OPENCL="No"])
])
FINAL_MESSAGES="$FINAL_MESSAGES\nParModelica: $OPENCL"

dnl Check for Qt

AC_CHECK_PROGS(QMAKE,qmake-qt4 qmake-mac qmake,"")
AC_CHECK_PROGS(LRELEASE,lrelease-qt4 lrelease,"")

if test -n "$QMAKE"; then
  AC_MSG_CHECKING([for qmake arguments])
  if test "Darwin" = `uname`; then
    echo "#!/bin/sh -x" > ./qmake.sh
    echo "$QMAKE \$*" >> ./qmake.sh
    echo 'MAKEFILE=`echo -- $* | grep -o "Makefile@<:@A-Z.a-z@:>@*"`' >> ./qmake.sh
    echo 'if test -z "$MAKEFILE"; then MAKEFILE=Makefile; fi' >> ./qmake.sh
    # echo 'echo $MAKEFILE' >> ./qmake.sh
    echo 'cat $MAKEFILE | \
      sed "s/-arch i386//g" | \
      sed "s/-arch x86_64//g" | \
      sed "s/-arch//g" > $MAKEFILE.fixed && \
      mv $MAKEFILE.fixed $MAKEFILE' >> qmake.sh
    QMAKE="sh `pwd`/qmake.sh"
  fi
  AC_MSG_RESULT([$QMAKE])
fi

if test -n "$QMAKE"; then

  AC_MSG_CHECKING([if the user wants OMNotebook])
  AC_ARG_ENABLE(omnotebook, [  --disable-omnotebook          OMNotebook is a notebook for Modelica. Enabled by default if CORBA is enabled. Does not work on OSX.],[test "xno" = x"$enableval" && OMNOTEBOOK=""],[OMNOTEBOOK="omnotebook"])
  if test -z "$OMNOTEBOOK" ; then
  AC_MSG_RESULT([no])
  FINAL_MESSAGES="$FINAL_MESSAGES\nBuild OMNotebook: No"
  else
  AC_MSG_RESULT([yes])
  FINAL_MESSAGES="$FINAL_MESSAGES\nBuild OMNotebook: Yes"
  fi

fi

if test -n "$QMAKE"; then
  AC_MSG_CHECKING([for paradisEO])
  AC_ARG_WITH(paradiseo, [  --with-paradiseo                 Required for OMOptim. Default searches {PREFIX,/usr,/opt} for {include,lib}/paradiseo], [], [with_paradiseo=yes])

  if test -f "$with_paradiseo/paradiseo-eo/src/eo"; then
    # User used a local paradiseo installation
    with_paradiseo_include="$with_paradiseo/paradiseo-eo/src $with_paradiseo/paradiseo-mo/src $with_paradiseo/paradiseo-moeo/src $with_paradiseo/paradiseo-eo/src/utils $with_paradiseo/paradiseo-mo/src/utils $with_paradiseo/paradiseo-moeo/src/utils"
    if test -d "$with_paradiseo/paradiseo-eo/build/lib"; then
      paradiseo_build="build"
    else
      paradiseo_build=""
    fi
    with_paradiseo_lib="-L$with_paradiseo/paradiseo-eo/$paradiseo_build/lib -L$with_paradiseo/paradiseo-moeo/$paradiseo_build/lib"
    AC_MSG_RESULT(stock version in: $with_paradiseo)
  else

    if test x"$with_paradiseo" = "xyes"; then
      with_paradiseo_checked=""
      for f in /{usr,opt,$PREFIX}; do
        if test -d "$f/include/paradiseo/" -a -d "$f"/lib/paradiseo/; then
          with_paradiseo_include="$f/include/paradiseo/ $f/include/paradiseo/utils/"
          with_paradiseo_lib="-L$f"/lib/paradiseo/
          with_paradiseo="$f"
        elif test -d "$f/include/paradiseo/" -a -f "$f"/lib*/libeo.a ; then
          with_paradiseo_include=`for inc in $f/include/paradiseo/*; do echo -n " $inc"; done`
          with_paradiseo_lib="-L"`dirname "$f"/lib*/libeo.a`
          with_paradiseo="$f"
        else
          with_paradiseo_checked="$with_paradiseo_checked $f"
        fi
      done
    fi

    if test x"$with_paradiseo" = "xno"; then
      with_paradiseo=""
      AC_MSG_RESULT([disabled])
    elif test x"$with_paradiseo" = "xyes"; then
      AC_MSG_ERROR([not found (searched $with_paradiseo_checked)])
    else
      AC_MSG_RESULT($with_paradiseo)
    fi

  fi
  if test -f /usr/bin/gcc-4.4 -a -f /usr/bin/g++-4.4; then
    OMOPTIM_CC=gcc-4.4
    OMOPTIM_CXX=g++-4.4
  else
    OMOPTIM_CC=$CC
    OMOPTIM_CXX=$CXX
  fi
fi

if test "Darwin" = `uname`; then
  APP=".app"
  EXE=".app"
  SHREXT=".dylib"
  LIBGC="build/lib/omc/libgc.a"
  LIBSIMULATION=libSimulationRuntimeC.dylib
  LIBRUNTIME=libOpenModelicaRuntimeC.dylib
  LIBFMIRUNTIME=libOpenModelicaFMIRuntimeC.dylib
  LIBFMILIB=libfmilib_shared.dylib
  FMILIB_SHARED=ON
  LIBCMINPACKLIB=libcminpack.dylib
  CMINPACKLIB_SHARED=ON
  RT_LDFLAGS_SIM="$LDFLAGS $RT_LDFLAGS $SUNDIALS_LDFLAGS $IPOPT_LDFLAGS -linteractive -llis -lcdaskr -lcminpack -lf2c -lexpat -liconv -lgc -lpthread -lm $LIBDL -lstdc++"
  RT_LDFLAGS="$LDFLAGS $RT_LDFLAGS $LD_LAPACK -liconv -lgc -lpthread -lm $LIBDL -lstdc++"
  # All libraries are dynamically linked; we don't need anything else
  RT_LDFLAGS_GENERATED_CODE="$LDFLAGS -lOpenModelicaRuntimeC $LD_LAPACK -lm"
  RT_LDFLAGS_GENERATED_CODE_SIM="$LDFLAGS -lSimulationRuntimeC $LD_LAPACK -lm -lgc"
  LINK="cp -fr"
  RPATH="-Wl,-rpath,'@loader_path/../lib/omc'"
  RPATH_QMAKE="-Wl,-rpath,'@loader_path/../../../../lib/omc',-rpath,'@loader_path/../../../../lib/',-rpath,'$PREFIX/lib/omc',-rpath,'$PREFIX/lib/'"
  MSL_EXTRA_ARGS="--disable-hdf5 --enable-static-zlib --enable-static --disable-shared"
  OS_TARGET="osx"
  LIS_LDFLAGS="-Wl,-install_name,@rpath/liblis.dylib"
  AR_SH="sh -x ar.sh"
  BOOTSTRAP_STATIC="static"
elif test "$host" = "i586-pc-mingw32msvc"; then
  APP=".exe"
  EXE=".exe"
  # Yes, we build static libs on Windows, so the "shared" extension is .a
  SHREXT=".a"
  LIBGC="build/lib/omc/libgc.a"
  LIBSIMULATION=libSimulationRuntimeC.a
  LIBRUNTIME=libOpenModelicaRuntimeC.a
  LIBFMIRUNTIME=libOpenModelicaFMIRuntimeC.a
  LIBFMILIB=libfmilib.a
  FMILIB_SHARED=OFF
  LIBCMINPACKLIB=libcminpack.a
  CMINPACKLIB_SHARED=OFF
  RT_LDFLAGS_SIM="$LDFLAGS $RT_LDFLAGS $SUNDIALS_LDFLAGS $IPOPT_LDFLAGS -linteractive -llis -lcminpack -lstdc++ -lf2c -lgc -lexpat -lm"
  RT_LDFLAGS="$LDFLAGS $RT_LDFLAGS $LD_LAPACK -lgc -lexpat -lpthread -lm"
  RT_LDFLAGS_GENERATED_CODE="$LDFLAGS -lOpenModelicaRuntimeC $RT_LDFLAGS"
  RT_LDFLAGS_GENERATED_CODE_SIM="$LDFLAGS -lSimulationRuntimeC -lcdaskr $RT_LDFLAGS_SIM"
  LINK="cp -frl"
  RPATH="-Wl,-z,origin -Wl,-rpath,'\$\$ORIGIN/../lib/omc' -Wl,-rpath,'\$\$ORIGIN'"
  RPATH_QMAKE="-Wl,-z,origin -Wl,-rpath,\\'\\\$\$ORIGIN/../lib/omc\\' -Wl,-rpath,\\'\\\$\$ORIGIN\\'"
  OS_TARGET="windows"
  AR_SH="$AR -ru"
  CPPFLAGS_F2C=" -DUSE_CLOCK"
  LDFLAGS_SOCKET=" -lwsock32"
  BOOTSTRAP_STATIC="static"
else
  APP=""
  EXE=""
  SHREXT=".so"
  LIBGC="build/lib/omc/libgc.so"
  LIBSIMULATION=libSimulationRuntimeC.so
  LIBRUNTIME=libOpenModelicaRuntimeC.so
  LIBFMIRUNTIME=libOpenModelicaFMIRuntimeC.so
  LIBFMILIB=libfmilib_shared.so
  FMILIB_SHARED=ON
  LIBCMINPACKLIB=libcminpack.so
  CMINPACKLIB_SHARED=ON
  # For static runtime on Linux:
  # -Wl,-whole-archive -lSimulationRuntimeC -Wl,-no-whole-archive
  RT_LDFLAGS_SIM="$LDFLAGS -Wl,-z,origin -Wl,-rpath,'\$\$ORIGIN' $RT_LDFLAGS $SUNDIALS_LDFLAGS $IPOPT_LDFLAGS $LIBRT -linteractive -llis -lcdaskr -lcminpack -Wl,-Bstatic -lf2c -Wl,-Bdynamic -lexpat -lgc $LIBRT -lpthread -lm $LIBDL -lstdc++ -rdynamic"
  RT_LDFLAGS="$LDFLAGS $RT_LDFLAGS $LD_LAPACK -lgc $LIBRT -lpthread -lm $LIBDL -lstdc++ -rdynamic"
  # All libraries are dynamically linked; we don't need anything else
  RT_LDFLAGS_GENERATED_CODE="$LDFLAGS -lOpenModelicaRuntimeC $LD_LAPACK -lm -lpthread -rdynamic"
  RT_LDFLAGS_GENERATED_CODE_SIM="$LDFLAGS -lSimulationRuntimeC $LD_LAPACK -lm -lgc -lpthread -rdynamic"
  LINK="cp -frl"
  RPATH="-Wl,-z,origin -Wl,-rpath,'\$\$ORIGIN/../lib/omc' -Wl,-rpath,'\$\$ORIGIN'"
  RPATH_QMAKE="-Wl,-z,origin -Wl,-rpath,\\'\\\$\$ORIGIN/../lib/omc\\' -Wl,-rpath,\\'\\\$\$ORIGIN\\'"
  OS_TARGET="linux"
  AR_SH="$AR -ru"
  BOOTSTRAP_STATIC=""
fi

AC_ARG_WITH(METIS, [  --with-METIS=DIR                 Compile with Metis graph partitioner in DIR],
[
  USE_METIS=1
  USE_GRAPH=1
  AC_MSG_RESULT([Enabling METIS... METISHOME="$withval"]);
  METISHOME="$withval";
  USE_PATOH=0
], [
    USE_GRAPH=0
    USE_METIS=0
])

AC_ARG_WITH(PATOH, [  --with-PATOH=DIR                 Compile with PATOH hypergraph partitioner in DIR],
[
    USE_PATOH=1
    if test "$ENABLE_NON_FREE_PACKAGES" = ""; then
      AC_MSG_ERROR([May not compile PATOH unless non-free packages are enabled (enabling those limits your ability to distribute code under GPL3, even to co-workers and the like; if you are an OSMC member you might be allowed to link and ship the library, but only if you have a commercial license...)] )
    fi
    if test "$USE_METIS" = 1; then
      AC_MSG_ERROR([Cannot compile with METIS and PATOH] )
      METISHOME="";
    fi
    USE_METIS=0
    USE_GRAPH=1
    AC_MSG_RESULT([Enabling PATOH... PATOHHOME="$withval"]);
  PATOHHOME="$withval";
], [
    if test "$USE_METIS" = 0; then
        USE_GRAPH=0
    fi
    USE_PATOH=0;
])

AC_ARG_WITH(UMFPACK, [  --with-UMFPACK                   Compile with UMFPACK, a sparse linear systems solver],
[
    UMFPACK_TARGET="umfpack";
], [
    UMFPACK_TARGET="";
])

AC_MSG_CHECKING([for revision])
SOURCE_REVISION=""
test -f REVISION && SOURCE_REVISION=`head -n1 REVISION | grep -o @<:@0-9@:>@@<:@0-9@:>@*`
test -z "$SOURCE_REVISION" && SOURCE_REVISION=`svn info 2>&1 | grep ^Revision: | cut -d\  -f2`
test -z "$SOURCE_REVISION" && SOURCE_REVISION="????"

AC_MSG_RESULT([$SOURCE_REVISION])
SOURCE_REVISION="$SOURCE_REVISION$NON_FREE_VERSION"

AC_MSG_CHECKING([for OpenModelica platform name])
# I don't really agree with the Modelica specification since "Intel 32-bit" is
# very unspecific.
# Also, they forgot about Mac users. We will just default to uname -sm and patch
# to Modelica Spec standards as well.
OPENMODELICA_SPEC_PLATFORM=`uname -sm | tr "@<:@:upper:@:>@ " "@<:@:lower:@:>@-"`
AC_MSG_RESULT([$OPENMODELICA_SPEC_PLATFORM])
AC_MSG_CHECKING([for Modelica platform name])
if test "$OPENMODELICA_SPEC_PLATFORM" = "linux-x86_64" -o "$OPENMODELICA_SPEC_PLATFORM" = "linux-i.86"; then
  MODELICA_SPEC_PLATFORM=`echo $OPENMODELICA_SPEC_PLATFORM | sed "s/linux-x86_64/linux64/" | sed "s/linux-i.86/linux32/"`
elif test "$OPENMODELICA_SPEC_PLATFORM" = "darwin-x86_64" -o "$OPENMODELICA_SPEC_PLATFORM" = "linux-i.86"; then
  MODELICA_SPEC_PLATFORM=`echo $OPENMODELICA_SPEC_PLATFORM | sed "s/darwin-x86_64/darwin64/" | sed "s/darwin-i.86/darwin32/"`
else
  MODELICA_SPEC_PLATFORM=$OPENMODELICA_SPEC_PLATFORM
fi
AC_MSG_RESULT([$MODELICA_SPEC_PLATFORM])

CFLAGS="$CFLAGS"

date=`date "+%Y-%m-%d %H:%M:%S"`

GENERATED_AUTOCONF_FILES="Makefile \
Compiler/Makefile \
Compiler/Template/Makefile \
Compiler/omc_release/Makefile \
Compiler/runtime/Makefile \
Compiler/runtime/config.unix.h \
PythonInterface/Makefile \
PythonInterface/OMPython/OMConfig.py \
Parser/Makefile \
3rdParty/qwt/Makefile.unix \
OMNotebook/OMNotebookGUI/OMNotebook.config \
OMNotebook/OMNotebookGUI/Makefile.unix \
OMShell/OMShellGUI/OMShell.config \
OMShell/OMShellGUI/Makefile.unix \
OMEdit/OMEditGUI/Makefile.unix \
OMEdit/OMEditGUI/OMEdit.config \
OMEdit/OMEditGUI/Debugger/Parser/Makefile.unix \
OMEdit/OMEditGUI/Debugger/Parser/Makefile.lib.unix \
OMPlot/OMPlotGUI/Makefile.unix \
OMPlot/OMPlotGUI/OMPlotGUI.config \
OMOptim/build/Makefile.unix \
OMOptim/build/OMOptim.config \
OMOptimBasis/build/Makefile.unix \
OMOptimBasis/build/OMOptimBasis.config \
OMVisualize/OMVisualizeGUI/OMVisualizeGUI.config \
SimulationRuntime/c/Makefile \
SimulationRuntime/c/simulation/libf2c/makefile.u \
SimulationRuntime/ParModelica/explicit/openclrt/Makefile \
SimulationRuntime/interactive/Makefile \
mosh/src/Makefile \
Compiler/boot/Makefile \
"

AC_CONFIG_COMMANDS([config.unix.h.fix],[./configure-post.sh $ac_cs_config])

AC_OUTPUT(${GENERATED_AUTOCONF_FILES})

echo -e "$FINAL_MESSAGES"