configure.in

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

AC_PREREQ([2.65])
AC_INIT(c_runtime/boolean_array.c)
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_qwt)
AC_SUBST(with_qwt_suffix)
AC_SUBST(LIBSOCKET)
AC_SUBST(LIBNSL)
AC_SUBST(LIBLPSOLVE55)
AC_SUBST(LPSOLVEINC)
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(USE_MODPAR)
AC_SUBST(BOOSTHOME)
AC_SUBST(GENERATED_AUTOCONF_FILES)
AC_SUBST(COIN_LIBS)
AC_SUBST(SOQT_LIBS)
AC_SUBST(COIN_INCLUDE)
AC_SUBST(SOQT_INCLUDE)
AC_SUBST(HAVE_COIN)
AC_SUBST(LIBSENDDATA)
AC_SUBST(LIBSENDDATA_LDFLAGS)
AC_SUBST(WITH_SENDDATA)
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(SQLITE3_LIBS)

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

dnl Disables the default CFLAGS="-g -O2"
if test -z "$CFLAGS"; then
if  test "Darwin" = `uname`; then
CFLAGS="-O3"
else
CFLAGS="-O3 -march=native"
fi
fi

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

if test "`uname -m`" = "x86_64"; then

AC_MSG_CHECKING([x86_64 CFLAGS])

if echo $CFLAGS | grep -q -- -fPIC; then
  AC_MSG_RESULT([already got -fPIC])
else
  CFLAGS+=" -fPIC"
  AC_MSG_RESULT([adding -fPIC])
fi

fi

dnl Simulations spin forever unless -msse2 -mfpmath=sse is set
dnl Or if -ffloat-store  is set
dnl With the new solver interface, this seems to work even with -mpfpath=387
#AC_MSG_CHECKING([for floating point bugs])
#if echo $CFLAGS | grep -q -- -ffloat-store; then
#  AC_MSG_RESULT([have -ffloat-store])
#elif echo $CFLAGS | grep -q -- -msse2 && echo $CFLAGS | grep -q -- -mfpmath=sse; then
#  AC_MSG_RESULT([have SSE2])
#else
#  CFLAGS+=" -msse2 -mfpmath=sse"
#  AC_MSG_RESULT([adding -msse2 -mfpmath=sse])
#fi

fi # End x86-specific CFLAGS

dnl Checks for programs.
AC_PROG_CC
AC_PROG_CXX
AC_PROG_CPP
AC_PROG_MAKE_SET
AC_PROG_LEX

dnl check for environment variables

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

dnl Checks for libraries.

dnl Checks for header files.
AC_HEADER_STDC
AC_CHECK_HEADERS(sys/time.h sqlite3.h, [], [AC_MSG_ERROR(Missing header files)])
AC_CHECK_HEADERS(f2c.h, [], [LIBF2C=libf2c/libf2c.a])

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, [--enable-rml-trace[[=no]]                RML -trace support],[test "xno" = x"$enableval" && RML_TRACE=""])
if test -z "$RML_TRACE" ; then
AC_MSG_RESULT([no])
else
AC_MSG_RESULT([yes])
fi

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 c_runtime/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])
  AC_MSG_RESULT([no])
fi

AC_MSG_CHECKING([if the user wants to compile OMShell-terminal])
OMSHELL_TERMINAL="mosh"
AC_ARG_ENABLE(omshell-terminal, [--enable-omshell-terminal[[=yes]]        Enables compilation of OMShell-terminal],[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_SEARCH_LIBS(readline,readline,,[AC_MSG_ERROR([readline missing])])
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 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"])

if test "$WANT_STATIC_LPSOLVE" = "no"; then
  LIBS=""
  AC_SEARCH_LIBS(dlopen,dl)
  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.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])])
])


dnl check for socket

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

dnl check for gethostbyname

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

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
  SQLITE3_LIBS=$LIBS
elif test ! -f "$WANT_STATIC_SQLITE" ; then
  AC_ERROR([File not found: $WANT_STATIC_SQLITE])
else
  SQLITE3_LIBS=$WANT_STATIC_SQLITE
fi

dnl should we use corba?

AC_ARG_WITH(CORBA,  [  --with-CORBA=DIR       use mico corba installed in DIR (or use mico-config)],[WANT_MICO="$withval"],[WANT_MICO="no"])
AC_ARG_WITH(MICO,   [  --with-MICO=DIR        use mico corba installed in DIR (or use mico-config)],[WANT_MICO="$withval"],[])
dnl AC_ARG_WITH(ORBIT2, [  --with-ORBIT2=DIR      use orbit2 installed in DIR (or use orbit2-config)],[WANT_ORBIT2="$withval"],[WANT_ORBIT2="no"])
WANT_ORBIT2="no"
AC_ARG_WITH(omniORB,[  --with-omniORB=DIR     use omniORB installed in DIR],[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;
  CORBA_QMAKE_INCLUDES=`$MICO --prefix`/include;
  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
    WANT_OMNIORB="/usr";
    IDLCMD="omniidl -bcxx -Wbh=.h -Wbs=.cc";
  else
    CORBA_QMAKE_INCLUDES="$WANT_OMNIORB/include";
    CORBACFLAGS="-I$CORBA_QMAKE_INCLUDES";
    AC_MSG_CHECKING([for $WANT_OMNIORB/bin/omniidl]);
    if test -f "$WANT_OMNIORB/bin/omniidl"; then
    AC_MSG_RESULT([ok])
    else
    AC_MSG_ERROR([not found])
    fi
    IDLCMD="$WANT_OMNIORB/bin/omniidl -bcxx -Wbh=.h -Wbs=.cc";
  fi
  USE_CORBA="-DUSE_CORBA -DUSE_OMNIORB";
  QT_USE_CORBA="USE_OMNIORB"
  if test "Darwin" = `uname`; then
    CORBALIBS="$WANT_OMNIORB/lib/libomniORB4.a $WANT_OMNIORB/lib/libomnithread.a -lpthread"
  else
    CORBALIBS="-L'$WANT_OMNIORB/lib' -lomniORB4 -lomnithread -lpthread"
  fi
  DESIRED_CORBA="omniorb"
else
  USE_CORBA="";
  CORBACFLAGS="";
  CORBALIBS="";
  IDLCMD="";
  DESIRED_CORBA="none"
fi

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

dnl Check for Qt

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

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([for qwt])
  AC_ARG_WITH(qwt, [  --with-qwt        Compile plotting libraries using qwt. Default searches PREFIX/include/{qwt,qwt-qt4}], [], [with_qwt=yes])

  if test x"$with_qwt" = "xyes"; then
    with_qwt_checked=""
    with_qwt_suffix=""
    for f in {/usr,/opt,$PREFIX}/include/{qwt,qwt-qt4}/; do
      test -f "$f/qwt.h" && with_qwt="$f" || with_qwt_checked="$with_qwt_checked $f"
    done
    echo $with_qwt | grep -q -- -qt4 && with_qwt_suffix="-qt4"
  fi

  if test x"$with_qwt" = "xno"; then
    QMAKE=""
    AC_MSG_RESULT([disabled])
  elif test x"$with_qwt" = "xyes"; then
    AC_MSG_ERROR([not found (searched $with_qwt_checked)])
  else
    AC_MSG_RESULT($with_qwt)
  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 x"$with_paradiseo" = "xyes"; then
    with_paradiseo_checked=""
    for f in /{usr,opt,$PREFIX}; do
      test -d "$f/include/paradiseo/" -a -d "$f/lib/paradiseo/" && with_paradiseo="$f" || with_paradiseo_checked="$with_paradiseo_checked $f"
    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 "Darwin" = `uname`; then
  EXE=".app"
else
  EXE=""
fi

AC_MSG_CHECKING([for sendData-Qt]);
AC_ARG_WITH(sendData-Qt, [  --with-sendData-Qt     Compile with support for plot().],
[
  if test -z "$QMAKE"; then
    AC_MSG_ERROR("Cannot compile with libSendData unless qmake is present.");
  fi
  LIBSENDDATA="libsendData.a"
  WITH_SENDDATA="#define CONFIG_WITH_SENDDATA 1"
  #if test "Darwin" = `uname`; then
  #  LIBSENDDATA_LDFLAGS="-framework QtNetwork -framework QtCore -framework QtGui -lz -framework Carbon"
  #  if test -d /opt/local/Library/Frameworks/; then
  #    LIBSENDDATA_LDFLAGS="-F/opt/local/Library/Frameworks/ $LIBSENDDATA_LDFLAGS"
  #  fi
  #else
    LIBSENDDATA_LDFLAGS="-lQtNetwork -lQtCore -lQtGui"
  #fi
  
  LDFLAGS_BAK=$LDFLAGS
  LDFLAGS+=" $LIBSENDDATA_LDFLAGS"
  AC_LINK_IFELSE([AC_LANG_PROGRAM()],AC_MSG_RESULT([ok]),AC_MSG_ERROR([Compilation failed using LDFLAGS='$LDFLAGS'. Try specifying your own LDFLAGS to link to Qt.]))
  LDFLAGS=$LDFLAGS_BAK
  LIBSENDDATA_LDFLAGS="$LDFLAGS -lsendData $LIBSENDDATA_LDFLAGS"
],
[
  LIBSENDDATA=""
  LIBSENDDATA_LDFLAGS="$LDFLAGS"
  WITH_SENDDATA="// #undef CONFIG_WITH_SENDDATA"
  AC_MSG_RESULT([disabled])
])

if test "Darwin" != `uname`; then
  LIBSENDDATA_LDFLAGS+=" -lrt"
fi

dnl Check for libCoin

AC_MSG_CHECKING([for libCoin])
AC_ARG_WITH(Coin, [  --with-Coin=[yes|no|static]     Compile with support for plotting in 3D.],
[
  if test -z "$QMAKE"; then
    AC_MSG_ERROR("Cannot compile with libCoin unless qmake is present.");
  fi
  #Would be duplicated by soqt-libs...
  #COIN_LIBS=`coin-config --ldflags --libs | tr \\\\n \\ `
  SOQT_LIBS=`soqt-config --ldflags --libs | tr \\\\n \\ `
  COIN_INCLUDE=`coin-config --includedir | tr \\\\n \\ `
  SOQT_INCLUDE=`soqt-config --includedir | tr \\\\n \\ `
  HAVE_COIN="HAVE_COIN"
  if test "$withval" = "static" ; then
    SOQT_LIBS=`echo $SOQT_LIBS | sed "s/-lCoin/-Wl,-Bstatic -lCoin -Wl,-Bdynamic/"`
    SOQT_LIBS=`echo $SOQT_LIBS | sed "s/-lSoQt4/-Wl,-Bstatic -lSoQt4 -Wl,-Bdynamic/"`
  fi
  if test -z "$COIN_INCLUDE" || test -z "$SOQT_INCLUDE" || test -z "$SOQT_LIBS"; then
    AC_MSG_ERROR([failure]);
  fi
  AC_MSG_RESULT([ok])
],
[
  AC_MSG_RESULT([disabled])
])

dnl should we compile modpar

AC_ARG_WITH(MODPAR, [  --with-MODPAR        Compile with automatic parallelization, requires boost],
[
	USE_MODPAR="-DUSE_MODPAR"
], [
AC_MSG_RESULT([Not compiling ModPar]); USE_MODPAR=""; BOOSTHOME=""
])

AC_ARG_WITH(BOOST, [  --with-BOOST=DIR        With BOOST library in DIR],
[
	if test "$USE_MODPAR" = "-DUSE_MODPAR" ; then
	  AC_MSG_RESULT([enabling BOOST... BOOSTHOME="$withval"]);
	  BOOSTHOME="$withval";
  else
    AC_MSG_RESULT([ Warning, MODPAR requires BOOST, disabling MODPAR ] )
  	USE_MODPAR="";
	  BOOSTHOME="";
  fi
], [
AC_MSG_RESULT([Not compiling with BOOST]); USE_MODPAR=""; BOOSTHOME=""
])

AC_MSG_CHECKING([for revision])
SOURCE_REVISION=""
test -f REVISION && SOURCE_REVISION=`head -n1 REVISION | grep -o @<:@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])

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/"`
else
  MODELICA_SPEC_PLATFORM=$OPENMODELICA_SPEC_PLATFORM
fi
AC_MSG_RESULT([$MODELICA_SPEC_PLATFORM])

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

GENERATED_AUTOCONF_FILES="Makefile c_runtime/Makefile mosh/src/Makefile \
Compiler/Makefile Compiler/omc_release/Makefile Compiler/omc_debug/Makefile \
Compiler/omc_profiler/Makefile Compiler/runtime/Makefile \
Compiler/modpar/Makefile c_runtime/interactive/Makefile \
Compiler/runtime/config.unix.h \
Parser/Makefile c_runtime/ModelicaExternalC/Makefile \
OMNotebook/OMPlotWindow/OMPlotWindow.config \
OMNotebook/OMPlotWindow/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 \
OMPlot/OMPlotGUI/Makefile.unix \
OMPlot/OMPlotGUI/OMPlotGUI.config \
OMOptim/build/Makefile.unix \
OMOptim/build/OMOptim.config \
testsuite/bootstrapping/LinkMain.makefile \
c_runtime/libf2c/makefile.u \
FMI/import/source/Makefile \
"

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

AC_OUTPUT(${GENERATED_AUTOCONF_FILES})