
AC_INIT(configure.ac)
AC_CONFIG_AUX_DIR(config)
AC_CONFIG_MACRO_DIR(config)
AC_REVISION($Revision$)

AC_CONFIG_HEADERS(config.h)
AM_INIT_AUTOMAKE(adios,1.5.0)

AM_MAINTAINER_MODE([enable])

AC_LANG(C)
AC_C_STRINGIZE
dnl generates HAVE_STRINGIZE

AC_PROG_CC
AM_PROG_CC_C_O
AC_PROG_CXX

AC_LANG(C)
ACX_MPI([], [AC_MSG_ERROR([couldn't find mpi library for C])])

AC_LANG(C++)
ACX_MPI([], [AC_MSG_ERROR([couldn't find mpi library for C++])])

AC_ARG_ENABLE(fortran,
    [AS_HELP_STRING([--disable-fortran],[disable Fortran test programs in ADIOS.])])
AM_CONDITIONAL([BUILD_FORTRAN], [test "x$enable_fortran" != "xno"])

if test "x$enable_fortran" != "xno"; then
    AC_PROG_FC
    AC_PROG_FC_C_O
    AC_FC_WRAPPERS
    F77=$FC
    dnl AC_PROG_F77
    dnl AC_PROG_F77_C_O
    AC_LANG(Fortran)
    ACX_MPI([], [AC_MSG_ERROR([couldn't find mpi library for Fortran])])
fi

AC_LANG(C)

dnl Generate libtool script and then do a nasty thing.
dnl PGI compiler (behind MPICC) does not like --rpath.
dnl The only way I found to avoid the problem is to remove the chance of using it
dnl inside the libtool script. Similar to what HDF5 configure does.
dnl see: http://www.hdfgroup.org/ftp/HDF5/current/src/unpacked/configure.in
dnl look the snippet after LT_INIT there.
AC_PROG_LIBTOOL
#LT_INIT([disable-shared])
dnl echo 'fixing hardcode_libdir_flag_spec in' $ofile
dnl ed - $ofile <<EOF 2> /dev/null
dnl g/^wl=".*"/s//wl="-Wl,"/
dnl w
dnl q
dnl EOF
dnl g/^hardcode_libdir_flag_spec=".*"/s//hardcode_libdir_flag_spec=""/
dnl g/^hardcode_libdir_flag_spec_ld=".*"/s//hardcode_libdir_flag_spec_ld=""/

AC_SEARCH_LIBS([nanosleep], [rt])
AC_CHECK_FUNCS([nanosleep strncpy strerror gettimeofday])
AC_PROG_MXML
dnl AC_PROG_GENGETOPT
AC_DCMF
AC_INFINIBAND
AC_PORTALS
AC_CRAY_PMI
AC_CRAY_UGNI
AC_HDF5
AC_PHDF5
AC_NETCDF
AC_NC4PAR
AC_NSSI
AC_PROG_DATASPACES
AC_PROG_DIMES
AC_DMALLOC
AC_LUSTRE
AC_DATATAP
AC_FLEXPATH

AC_LANG(C)


AC_ARG_ENABLE(research-transports,
    [AS_HELP_STRING([--enable-research-transports],
        [Enable building the various research transports. Default is not to build these as they are not part of the base distribution.])])
AM_CONDITIONAL([RESEARCH_TRANSPORTS], [test "x$enable_research_transports" == "xyes"])

AC_LANG(C)


AC_ARG_ENABLE(skel-timing,
    [AS_HELP_STRING([--enable-skel-timing],
        [Include the skel timing mechanism. By default this is not included])])
AM_CONDITIONAL([SKEL_TIMING], [test "x$enable_skel_timing" == "xyes"])


if test "x$enable_skel_timing" == "xyes"; then
    AC_DEFINE(SKEL_TIMING, 1, [Skel timing is enabled])
    AC_SUBST(SKEL_HAVE_ADIOS_TIMING,True)
    dnl The macro AM_SUBST_NOTMAKE does not work on Hopper with automake 10.1
    dnl AM_SUBST_NOTMAKE(SKEL_HAVE_ADIOS_TIMING,true)
else
    AC_SUBST(SKEL_HAVE_ADIOS_TIMING,False)
    dnl AM_SUBST_NOTMAKE(SKEL_HAVE_ADIOS_TIMING,false)
fi
AC_SUBST(SKEL_TIMING)


AC_LANG(C)

AM_CONDITIONAL([HAVE_DATATAP], [test x$datatap != xdisable])

AC_ARG_ENABLE(write,
    [AS_HELP_STRING([--disable-write],[disable building the write methods in ADIOS.])])
AM_CONDITIONAL([BUILD_WRITE], [test "x$enable_write" != "xno"])

dnl CC="$MPICC"
dnl CXX="$MPICXX"
dnl FC="$MPIFC"

LIBS="$MPILIBS"

AM_CONDITIONAL(USE_PARALLEL_COMPILER,false)

if test -z "${MACRODEFFLAG}"; then
    MACRODEFFLAG="-D"
fi
AC_SUBST(MACRODEFFLAG)


dnl Use PHDF5 for bp2h5 if no sequential HDF5 was found
if test -z "${HAVE_PHDF5_TRUE}" -a -z "${HAVE_HDF5_FALSE}"; then
    HDF5_CPPFLAGS="${PHDF5_CPPFLAGS}"
    HDF5_CFLAGS="${PHDF5_CFLAGS}"
    HDF5_LDFLAGS="${PHDF5_LDFLAGS}"
    HDF5_LIBS="${PHDF5_LIBS}"
    AM_CONDITIONAL(HAVE_HDF5,true)
    AC_DEFINE(HAVE_HDF5,1,[Define if you have HDF5.])
    AM_CONDITIONAL(USE_PARALLEL_COMPILER,true)
    AC_MSG_NOTICE([Use PHDF5 for sequential HDF5 tools])
fi

dnl Use NC4PAR for bp2ncd if no sequential NETCDF was found
if test -z "${HAVE_NC4PAR_TRUE}" -a -z "${HAVE_NETCDF_FALSE}"; then
    NETCDF_CPPFLAGS="${NC4PAR_CPPFLAGS}"
    NETCDF_CFLAGS="${NC4PAR_CFLAGS}"
    NETCDF_LDFLAGS="${NC4PAR_LDFLAGS}"
    NETCDF_LIBS="${NC4PAR_LIBS}"
    AM_CONDITIONAL(HAVE_NETCDF,true)
    AC_DEFINE(HAVE_NETCDF,1,[Define if you have NETCDF.])
    AM_CONDITIONAL(USE_PARALLEL_COMPILER,true)
    AC_MSG_NOTICE([Use NC4PAR for sequential NETCDF tools])
fi


dnl Generate flags for adios lib creation which depends on the packages we found
dnl ADIOSLIB_* for compiling libadios.a and libadiosf.a, and linking codes with those
dnl ADIOSLIB_SEQ_* for compiling libadios_nompi.a and libadiosf_nompi.a with dummy MPI
dnl ADIOSLIB_INT_* for codes using libadios_internal_nompi.a (like bp2ncd, bp2h5, bpdump etc)
dnl ADIOSREADLIB_* for codes using libadiosread.a, libadiosreadf.a
dnl ADIOSREADLIB_SEQ_* for codes using libadiosread_nompi.a
dnl adios_config will contain flags for users' code linking based on these flags
dnl EXTRA flags are used for compiling adios stuff, which need not go into adios_config for user codes
ADIOSLIB_EXTRA_CPPFLAGS="${MACRODEFFLAG}_FILE_OFFSET_BITS=64 ${MACRODEFFLAG}_LARGEFILE_SOURCE ${MACRODEFFLAG}_LARGEFILE64_SOURCE ${MACRODEFFLAG}_GNU_SOURCE"
ADIOSLIB_CPPFLAGS="${MXML_CPPFLAGS}"
ADIOSLIB_CFLAGS=
ADIOSLIB_LDFLAGS="${MXML_LDFLAGS}"
ADIOSLIB_LDADD="-lm ${MXML_LIBS}"
ADIOSLIB_SEQ_CPPFLAGS="${MACRODEFFLAG}_NOMPI ${MXML_CPPFLAGS}"
ADIOSLIB_SEQ_CFLAGS=
ADIOSLIB_SEQ_LDFLAGS="${MXML_LDFLAGS}"
ADIOSLIB_SEQ_LDADD="-lm ${MXML_LIBS}"
ADIOSLIB_INT_CPPFLAGS="${MACRODEFFLAG}_NOMPI ${MXML_CPPFLAGS}"
ADIOSLIB_INT_CFLAGS=
ADIOSLIB_INT_LDFLAGS="${MXML_LDFLAGS}"
ADIOSLIB_INT_LDADD="-lm ${MXML_LIBS}"
ADIOSREADLIB_CPPFLAGS=
ADIOSREADLIB_CFLAGS=
ADIOSREADLIB_LDFLAGS=
ADIOSREADLIB_LDADD="-lm"
ADIOSREADLIB_SEQ_CPPFLAGS="${MACRODEFFLAG}_NOMPI"
ADIOSREADLIB_SEQ_CFLAGS=
ADIOSREADLIB_SEQ_LDFLAGS=
ADIOSREADLIB_SEQ_LDADD="-lm"
if test "x${datatap}" != "xdisable"; then
    ADIOSLIB_CPPFLAGS="${ADIOSLIB_CPPFLAGS} ${DT_CPPFLAGS}"
    ADIOSLIB_CFLAGS="${ADIOSLIB_CFLAGS} ${DT_CFLAGS}"
    ADIOSLIB_LDFLAGS="${ADIOSLIB_LDFLAGS} ${DT_LDFLAGS}"
    ADIOSLIB_LDADD="${ADIOSLIB_LDADD} ${DT_LIBS}"
    ADIOSREADLIB_CPPFLAGS="${ADIOSREADLIB_CPPFLAGS} ${DT_CPPFLAGS}"
    ADIOSREADLIB_CFLAGS="${ADIOSREADLIB_CFLAGS} ${DT_CFLAGS}"
    ADIOSREADLIB_LDFLAGS="${ADIOSREADLIB_LDFLAGS} ${DT_LDFLAGS}"
    ADIOSREADLIB_LDADD="${ADIOSREADLIB_LDADD} ${DT_LIBS}"
    ADIOSREADLIB_SEQ_CPPFLAGS="${ADIOSREADLIB_SEQ_CPPFLAGS} ${DT_CPPFLAGS}"
    ADIOSREADLIB_SEQ_CFLAGS="${ADIOSREADLIB_SEQ_CFLAGS} ${DT_CFLAGS}"
    ADIOSREADLIB_SEQ_LDFLAGS="${ADIOSREADLIB_SEQ_LDFLAGS} ${DT_LDFLAGS}"
    ADIOSREADLIB_SEQ_LDADD="${ADIOSREADLIB_SEQ_LDADD} ${DT_LIBS}"
fi
if test -z "${HAVE_DATASPACES_TRUE}"; then
    ADIOSLIB_CPPFLAGS="${ADIOSLIB_CPPFLAGS} ${DATASPACES_CPPFLAGS}"
    ADIOSLIB_CFLAGS="${ADIOSLIB_CFLAGS}"
    ADIOSLIB_LDFLAGS="${ADIOSLIB_LDFLAGS} ${DATASPACES_LDFLAGS}"
    ADIOSLIB_LDADD="${ADIOSLIB_LDADD} ${DATASPACES_LIBS}"
    ADIOSLIB_SEQ_CPPFLAGS="${ADIOSLIB_SEQ_CPPFLAGS} ${DATASPACES_CPPFLAGS}"
    ADIOSLIB_SEQ_CFLAGS="${ADIOSLIB_SEQ_CFLAGS}"
    ADIOSLIB_SEQ_LDFLAGS="${ADIOSLIB_SEQ_LDFLAGS} ${DATASPACES_LDFLAGS}"
    ADIOSLIB_SEQ_LDADD="${ADIOSLIB_SEQ_LDADD} ${DATASPACES_LIBS}"
    ADIOSREADLIB_CPPFLAGS="${ADIOSREADLIB_CPPFLAGS} ${DATASPACES_CPPFLAGS}"
    ADIOSREADLIB_CFLAGS="${ADIOSREADLIB_CFLAGS} ${DATASPACES_CFLAGS}"
    ADIOSREADLIB_LDFLAGS="${ADIOSREADLIB_LDFLAGS} ${DATASPACES_LDFLAGS}"
    ADIOSREADLIB_LDADD="${ADIOSREADLIB_LDADD} ${DATASPACES_LIBS}"
    ADIOSREADLIB_SEQ_CPPFLAGS="${ADIOSREADLIB_SEQ_CPPFLAGS} ${DATASPACES_CPPFLAGS}"
    ADIOSREADLIB_SEQ_CFLAGS="${ADIOSREADLIB_SEQ_CFLAGS} ${DATASPACES_CFLAGS}"
    ADIOSREADLIB_SEQ_LDFLAGS="${ADIOSREADLIB_SEQ_LDFLAGS} ${DATASPACES_LDFLAGS}"
    ADIOSREADLIB_SEQ_LDADD="${ADIOSREADLIB_SEQ_LDADD} ${DATASPACES_LIBS}"
fi
if test -z "${HAVE_DIMES_TRUE}"; then
    ADIOSLIB_CPPFLAGS="${ADIOSLIB_CPPFLAGS} ${DIMES_CPPFLAGS}"
    ADIOSLIB_CFLAGS="${ADIOSLIB_CFLAGS}"
    ADIOSLIB_LDFLAGS="${ADIOSLIB_LDFLAGS} ${DIMES_LDFLAGS}"
    ADIOSLIB_LDADD="${ADIOSLIB_LDADD} ${DIMES_LIBS}"
    ADIOSLIB_SEQ_CPPFLAGS="${ADIOSLIB_SEQ_CPPFLAGS} ${DIMES_CPPFLAGS}"
    ADIOSLIB_SEQ_CFLAGS="${ADIOSLIB_SEQ_CFLAGS}"
    ADIOSLIB_SEQ_LDFLAGS="${ADIOSLIB_SEQ_LDFLAGS} ${DIMES_LDFLAGS}"
    ADIOSLIB_SEQ_LDADD="${ADIOSLIB_SEQ_LDADD} ${DIMES_LIBS}"
    ADIOSREADLIB_CPPFLAGS="${ADIOSREADLIB_CPPFLAGS} ${DIMES_CPPFLAGS}"
    ADIOSREADLIB_CFLAGS="${ADIOSREADLIB_CFLAGS} ${DIMES_CFLAGS}"
    ADIOSREADLIB_LDFLAGS="${ADIOSREADLIB_LDFLAGS} ${DIMES_LDFLAGS}"
    ADIOSREADLIB_LDADD="${ADIOSREADLIB_LDADD} ${DIMES_LIBS}"
    ADIOSREADLIB_SEQ_CPPFLAGS="${ADIOSREADLIB_SEQ_CPPFLAGS} ${DIMES_CPPFLAGS}"
    ADIOSREADLIB_SEQ_CFLAGS="${ADIOSREADLIB_SEQ_CFLAGS} ${DIMES_CFLAGS}"
    ADIOSREADLIB_SEQ_LDFLAGS="${ADIOSREADLIB_SEQ_LDFLAGS} ${DIMES_LDFLAGS}"
    ADIOSREADLIB_SEQ_LDADD="${ADIOSREADLIB_SEQ_LDADD} ${DIMES_LIBS}"
fi
if test -z "${HAVE_NSSI_TRUE}"; then
    ADIOSLIB_CPPFLAGS="${ADIOSLIB_CPPFLAGS} ${NSSI_CPPFLAGS}"
    ADIOSLIB_CFLAGS="${ADIOSLIB_CFLAGS} ${NSSI_CFLAGS}"
    ADIOSLIB_LDFLAGS="${ADIOSLIB_LDFLAGS} ${NSSI_LDFLAGS}"
    ADIOSLIB_LDADD="${ADIOSLIB_LDADD} ${NSSI_LIBS}"
    ADIOSLIB_SEQ_CPPFLAGS="${ADIOSLIB_SEQ_CPPFLAGS} ${NSSI_CPPFLAGS}"
    ADIOSLIB_SEQ_CFLAGS="${ADIOSLIB_SEQ_CFLAGS} ${NSSI_CFLAGS}"
    ADIOSLIB_SEQ_LDFLAGS="${ADIOSLIB_SEQ_LDFLAGS} ${NSSI_LDFLAGS}"
    ADIOSLIB_SEQ_LDADD="${ADIOSLIB_SEQ_LDADD} ${NSSI_LIBS}"
    ADIOSREADLIB_CPPFLAGS="${ADIOSREADLIB_CPPFLAGS} ${MXML_CPPFLAGS} ${NSSI_CPPFLAGS}"
    ADIOSREADLIB_CFLAGS="${ADIOSREADLIB_CFLAGS} ${MXML_CPPFLAGS} ${NSSI_CFLAGS}"
    ADIOSREADLIB_LDFLAGS="${ADIOSREADLIB_LDFLAGS} ${MXML_LDFLAGS} ${NSSI_LDFLAGS}"
    ADIOSREADLIB_LDADD="${ADIOSREADLIB_LDADD} ${MXML_LIBS} ${NSSI_LIBS}"
    ADIOSREADLIB_SEQ_CPPFLAGS="${ADIOSREADLIB_SEQ_CPPFLAGS} ${MXML_CPPFLAGS} ${NSSI_CPPFLAGS}"
    ADIOSREADLIB_SEQ_CFLAGS="${ADIOSREADLIB_SEQ_CFLAGS} ${MXML_CPPFLAGS} ${NSSI_CFLAGS}"
    ADIOSREADLIB_SEQ_LDFLAGS="${ADIOSREADLIB_SEQ_LDFLAGS} ${MXML_LDFLAGS} ${NSSI_LDFLAGS}"
    ADIOSREADLIB_SEQ_LDADD="${ADIOSREADLIB_SEQ_LDADD} ${MXML_LIBS} ${NSSI_LIBS}"
fi
if test -z "${HAVE_FLEXPATH_TRUE}"; then
    ADIOSLIB_CPPFLAGS="${ADIOSLIB_CPPFLAGS} ${FP_CPPFLAGS}"
    ADIOSLIB_CFLAGS="${ADIOSLIB_CFLAGS} ${FP_CFLAGS}"
    ADIOSLIB_LDFLAGS="${ADIOSLIB_LDFLAGS} ${FP_LDFLAGS}"
    ADIOSLIB_LDADD="${ADIOSLIB_LDADD} ${FP_LIBS}"
    ADIOSLIB_SEQ_CPPFLAGS="${ADIOSLIB_SEQ_CPPFLAGS} ${FP_CPPFLAGS}"
    ADIOSLIB_SEQ_CFLAGS="${ADIOSLIB_SEQ_CFLAGS} ${FP_CFLAGS}"
    ADIOSLIB_SEQ_LDFLAGS="${ADIOSLIB_SEQ_LDFLAGS} ${FP_LDFLAGS}"
    ADIOSLIB_SEQ_LDADD="${ADIOSLIB_SEQ_LDADD} ${FP_LIBS}"
    ADIOSREADLIB_CPPFLAGS="${ADIOSREADLIB_CPPFLAGS} ${FP_CPPFLAGS}"
    ADIOSREADLIB_CFLAGS="${ADIOSREADLIB_CFLAGS} ${FP_CFLAGS}"
    ADIOSREADLIB_LDFLAGS="${ADIOSREADLIB_LDFLAGS} ${FP_LDFLAGS}"
    ADIOSREADLIB_LDADD="${ADIOSREADLIB_LDADD} ${FP_LIBS}"
    ADIOSREADLIB_SEQ_CPPFLAGS="${ADIOSREADLIB_SEQ_CPPFLAGS} ${FP_CPPFLAGS}"
    ADIOSREADLIB_SEQ_CFLAGS="${ADIOSREADLIB_SEQ_CFLAGS} ${FP_CFLAGS}"
    ADIOSREADLIB_SEQ_LDFLAGS="${ADIOSREADLIB_SEQ_LDFLAGS} ${FP_LDFLAGS}"
    ADIOSREADLIB_SEQ_LDADD="${ADIOSREADLIB_SEQ_LDADD} ${FP_LIBS}"
fi
if test -z "${HAVE_NC4PAR_TRUE}"; then
    ADIOSLIB_CPPFLAGS="${ADIOSLIB_CPPFLAGS} ${NC4PAR_CPPFLAGS}"
    ADIOSLIB_CFLAGS="${ADIOSLIB_CFLAGS} ${NC4PAR_CFLAGS}"
    ADIOSLIB_LDFLAGS="${ADIOSLIB_LDFLAGS} ${NC4PAR_LDFLAGS}"
    ADIOSLIB_LDADD="${ADIOSLIB_LDADD} ${NC4PAR_LIBS}"
fi
if test -z "${HAVE_PHDF5_TRUE}"; then
    ADIOSLIB_CPPFLAGS="${ADIOSLIB_CPPFLAGS} ${PHDF5_CPPFLAGS}"
    ADIOSLIB_CFLAGS="${ADIOSLIB_CFLAGS} ${PHDF5_CFLAGS}"
    ADIOSLIB_LDFLAGS="${ADIOSLIB_LDFLAGS} ${PHDF5_LDFLAGS}"
    ADIOSLIB_LDADD="${ADIOSLIB_LDADD} ${PHDF5_LIBS}"
fi
if test -z "${HAVE_PORTALS_TRUE}"; then
    ADIOSLIB_CPPFLAGS="${ADIOSLIB_CPPFLAGS} ${PORTALS_CPPFLAGS}"
    ADIOSLIB_CFLAGS="${ADIOSLIB_CFLAGS} ${PORTALS_CFLAGS}"
    ADIOSLIB_LDFLAGS="${ADIOSLIB_LDFLAGS} ${PORTALS_LDFLAGS}"
    ADIOSLIB_LDADD="${ADIOSLIB_LDADD} ${PORTALS_LIBS}"
    ADIOSLIB_SEQ_CPPFLAGS="${ADIOSLIB_SEQ_CPPFLAGS} ${PORTALS_CPPFLAGS}"
    ADIOSLIB_SEQ_CFLAGS="${ADIOSLIB_SEQ_CFLAGS} ${PORTALS_CFLAGS}"
    ADIOSLIB_SEQ_LDFLAGS="${ADIOSLIB_SEQ_LDFLAGS} ${PORTALS_LDFLAGS}"
    ADIOSLIB_SEQ_LDADD="${ADIOSLIB_SEQ_LDADD} ${PORTALS_LIBS}"
    ADIOSREADLIB_CPPFLAGS="${ADIOSREADLIB_CPPFLAGS} ${PORTALS_CPPFLAGS}"
    ADIOSREADLIB_CFLAGS="${ADIOSREADLIB_CFLAGS} ${PORTALS_CFLAGS}"
    ADIOSREADLIB_LDFLAGS="${ADIOSREADLIB_LDFLAGS} ${PORTALS_LDFLAGS}"
    ADIOSREADLIB_LDADD="${ADIOSREADLIB_LDADD} ${PORTALS_LIBS}"
    ADIOSREADLIB_SEQ_CPPFLAGS="${ADIOSREADLIB_SEQ_CPPFLAGS} ${PORTALS_CPPFLAGS}"
    ADIOSREADLIB_SEQ_CFLAGS="${ADIOSREADLIB_SEQ_CFLAGS} ${PORTALS_CFLAGS}"
    ADIOSREADLIB_SEQ_LDFLAGS="${ADIOSREADLIB_SEQ_LDFLAGS} ${PORTALS_LDFLAGS}"
    ADIOSREADLIB_SEQ_LDADD="${ADIOSREADLIB_SEQ_LDADD} ${PORTALS_LIBS}"
fi
if test -z "${HAVE_INFINIBAND_TRUE}"; then
    ADIOSLIB_CPPFLAGS="${ADIOSLIB_CPPFLAGS} ${INFINIBAND_CPPFLAGS}"
    ADIOSLIB_CFLAGS="${ADIOSLIB_CFLAGS} ${INFINIBAND_CFLAGS}"
    ADIOSLIB_LDFLAGS="${ADIOSLIB_LDFLAGS} ${INFINIBAND_LDFLAGS}"
    ADIOSLIB_LDADD="${ADIOSLIB_LDADD} ${INFINIBAND_LIBS}"
    ADIOSLIB_SEQ_CPPFLAGS="${ADIOSLIB_SEQ_CPPFLAGS} ${INFINIBAND_CPPFLAGS}"
    ADIOSLIB_SEQ_CFLAGS="${ADIOSLIB_SEQ_CFLAGS} ${INFINIBAND_CFLAGS}"
    ADIOSLIB_SEQ_LDFLAGS="${ADIOSLIB_SEQ_LDFLAGS} ${INFINIBAND_LDFLAGS}"
    ADIOSLIB_SEQ_LDADD="${ADIOSLIB_SEQ_LDADD} ${INFINIBAND_LIBS}"
    ADIOSREADLIB_CPPFLAGS="${ADIOSREADLIB_CPPFLAGS} ${INFINIBAND_CPPFLAGS}"
    ADIOSREADLIB_CFLAGS="${ADIOSREADLIB_CFLAGS} ${INFINIBAND_CFLAGS}"
    ADIOSREADLIB_LDFLAGS="${ADIOSREADLIB_LDFLAGS} ${INFINIBAND_LDFLAGS}"
    ADIOSREADLIB_LDADD="${ADIOSREADLIB_LDADD} ${INFINIBAND_LIBS}"
    ADIOSREADLIB_SEQ_CPPFLAGS="${ADIOSREADLIB_SEQ_CPPFLAGS} ${INFINIBAND_CPPFLAGS}"
    ADIOSREADLIB_SEQ_CFLAGS="${ADIOSREADLIB_SEQ_CFLAGS} ${INFINIBAND_CFLAGS}"
    ADIOSREADLIB_SEQ_LDFLAGS="${ADIOSREADLIB_SEQ_LDFLAGS} ${INFINIBAND_LDFLAGS}"
    ADIOSREADLIB_SEQ_LDADD="${ADIOSREADLIB_SEQ_LDADD} ${INFINIBAND_LIBS}"
fi
if test -z "${HAVE_CRAY_PMI_TRUE}"; then
    ADIOSLIB_CPPFLAGS="${ADIOSLIB_CPPFLAGS} ${CRAY_PMI_CPPFLAGS}"
    ADIOSLIB_CFLAGS="${ADIOSLIB_CFLAGS} ${CRAY_PMI_CFLAGS}"
    ADIOSLIB_LDFLAGS="${ADIOSLIB_LDFLAGS} ${CRAY_PMI_LDFLAGS}"
    ADIOSLIB_LDADD="${ADIOSLIB_LDADD} ${CRAY_PMI_LIBS}"
    ADIOSLIB_SEQ_CPPFLAGS="${ADIOSLIB_SEQ_CPPFLAGS} ${CRAY_PMI_CPPFLAGS}"
    ADIOSLIB_SEQ_CFLAGS="${ADIOSLIB_SEQ_CFLAGS} ${CRAY_PMI_CFLAGS}"
    ADIOSLIB_SEQ_LDFLAGS="${ADIOSLIB_SEQ_LDFLAGS} ${CRAY_PMI_LDFLAGS}"
    ADIOSLIB_SEQ_LDADD="${ADIOSLIB_SEQ_LDADD} ${CRAY_PMI_LIBS}"
    ADIOSREADLIB_CPPFLAGS="${ADIOSREADLIB_CPPFLAGS} ${CRAY_PMI_CPPFLAGS}"
    ADIOSREADLIB_CFLAGS="${ADIOSREADLIB_CFLAGS} ${CRAY_PMI_CFLAGS}"
    ADIOSREADLIB_LDFLAGS="${ADIOSREADLIB_LDFLAGS} ${CRAY_PMI_LDFLAGS}"
    ADIOSREADLIB_LDADD="${ADIOSREADLIB_LDADD} ${CRAY_PMI_LIBS}"
    ADIOSREADLIB_SEQ_CPPFLAGS="${ADIOSREADLIB_SEQ_CPPFLAGS} ${CRAY_PMI_CPPFLAGS}"
    ADIOSREADLIB_SEQ_CFLAGS="${ADIOSREADLIB_SEQ_CFLAGS} ${CRAY_PMI_CFLAGS}"
    ADIOSREADLIB_SEQ_LDFLAGS="${ADIOSREADLIB_SEQ_LDFLAGS} ${CRAY_PMI_LDFLAGS}"
    ADIOSREADLIB_SEQ_LDADD="${ADIOSREADLIB_SEQ_LDADD} ${CRAY_PMI_LIBS}"
fi
if test -z "${HAVE_CRAY_UGNI_TRUE}"; then
    ADIOSLIB_CPPFLAGS="${ADIOSLIB_CPPFLAGS} ${CRAY_UGNI_CPPFLAGS}"
    ADIOSLIB_CFLAGS="${ADIOSLIB_CFLAGS} ${CRAY_UGNI_CFLAGS}"
    ADIOSLIB_LDFLAGS="${ADIOSLIB_LDFLAGS} ${CRAY_UGNI_LDFLAGS}"
    ADIOSLIB_LDADD="${ADIOSLIB_LDADD} ${CRAY_UGNI_LIBS}"
    ADIOSLIB_SEQ_CPPFLAGS="${ADIOSLIB_SEQ_CPPFLAGS} ${CRAY_UGNI_CPPFLAGS}"
    ADIOSLIB_SEQ_CFLAGS="${ADIOSLIB_SEQ_CFLAGS} ${CRAY_UGNI_CFLAGS}"
    ADIOSLIB_SEQ_LDFLAGS="${ADIOSLIB_SEQ_LDFLAGS} ${CRAY_UGNI_LDFLAGS}"
    ADIOSLIB_SEQ_LDADD="${ADIOSLIB_SEQ_LDADD} ${CRAY_UGNI_LIBS}"
    ADIOSREADLIB_CPPFLAGS="${ADIOSREADLIB_CPPFLAGS} ${CRAY_UGNI_CPPFLAGS}"
    ADIOSREADLIB_CFLAGS="${ADIOSREADLIB_CFLAGS} ${CRAY_UGNI_CFLAGS}"
    ADIOSREADLIB_LDFLAGS="${ADIOSREADLIB_LDFLAGS} ${CRAY_UGNI_LDFLAGS}"
    ADIOSREADLIB_LDADD="${ADIOSREADLIB_LDADD} ${CRAY_UGNI_LIBS}"
    ADIOSREADLIB_SEQ_CPPFLAGS="${ADIOSREADLIB_SEQ_CPPFLAGS} ${CRAY_UGNI_CPPFLAGS}"
    ADIOSREADLIB_SEQ_CFLAGS="${ADIOSREADLIB_SEQ_CFLAGS} ${CRAY_UGNI_CFLAGS}"
    ADIOSREADLIB_SEQ_LDFLAGS="${ADIOSREADLIB_SEQ_LDFLAGS} ${CRAY_UGNI_LDFLAGS}"
    ADIOSREADLIB_SEQ_LDADD="${ADIOSREADLIB_SEQ_LDADD} ${CRAY_UGNI_LIBS}"
fi
if test -z "${HAVE_DCMF_TRUE}"; then
    ADIOSLIB_CPPFLAGS="${ADIOSLIB_CPPFLAGS} ${DCMF_CPPFLAGS}"
    ADIOSLIB_CFLAGS="${ADIOSLIB_CFLAGS} ${DCMF_CFLAGS}"
    ADIOSLIB_LDFLAGS="${ADIOSLIB_LDFLAGS} ${DCMF_LDFLAGS}"
    ADIOSLIB_LDADD="${ADIOSLIB_LDADD} ${DCMF_LIBS}"
    ADIOSLIB_SEQ_CPPFLAGS="${ADIOSLIB_SEQ_CPPFLAGS} ${DCMF_CPPFLAGS}"
    ADIOSLIB_SEQ_CFLAGS="${ADIOSLIB_SEQ_CFLAGS} ${DCMF_CFLAGS}"
    ADIOSLIB_SEQ_LDFLAGS="${ADIOSLIB_SEQ_LDFLAGS} ${DCMF_LDFLAGS}"
    ADIOSLIB_SEQ_LDADD="${ADIOSLIB_SEQ_LDADD} ${DCMF_LIBS}"
    ADIOSREADLIB_CPPFLAGS="${ADIOSREADLIB_CPPFLAGS} ${DCMF_CPPFLAGS}"
    ADIOSREADLIB_CFLAGS="${ADIOSREADLIB_CFLAGS} ${DCMF_CFLAGS}"
    ADIOSREADLIB_LDFLAGS="${ADIOSREADLIB_LDFLAGS} ${DCMF_LDFLAGS}"
    ADIOSREADLIB_LDADD="${ADIOSREADLIB_LDADD} ${DCMF_LIBS}"
    ADIOSREADLIB_SEQ_CPPFLAGS="${ADIOSREADLIB_SEQ_CPPFLAGS} ${DCMF_CPPFLAGS}"
    ADIOSREADLIB_SEQ_CFLAGS="${ADIOSREADLIB_SEQ_CFLAGS} ${DCMF_CFLAGS}"
    ADIOSREADLIB_SEQ_LDFLAGS="${ADIOSREADLIB_SEQ_LDFLAGS} ${DCMF_LDFLAGS}"
    ADIOSREADLIB_SEQ_LDADD="${ADIOSREADLIB_SEQ_LDADD} ${DCMF_LIBS}"
fi
if test -z "${HAVE_NETCDF_TRUE}"; then
    ADIOSLIB_INT_CPPFLAGS="${ADIOSLIB_INT_CPPFLAGS} ${NETCDF_CPPFLAGS}"
    ADIOSLIB_INT_CFLAGS="${ADIOSLIB_INT_CFLAGS} ${NETCDF_CFLAGS}"
    ADIOSLIB_INT_LDFLAGS="${ADIOSLIB_INT_LDFLAGS} ${NETCDF_LDFLAGS}"
    ADIOSLIB_INT_LDADD="${ADIOSLIB_INT_LDADD} ${NETCDF_LIBS}"
fi
if test -z "${HAVE_HDF5_TRUE}"; then
    ADIOSLIB_INT_CPPFLAGS="${ADIOSLIB_INT_CPPFLAGS} ${HDF5_CPPFLAGS}"
    ADIOSLIB_INT_CFLAGS="${ADIOSLIB_INT_CFLAGS} ${HDF5_CFLAGS}"
    ADIOSLIB_INT_LDFLAGS="${ADIOSLIB_INT_LDFLAGS} ${HDF5_LDFLAGS}"
    ADIOSLIB_INT_LDADD="${ADIOSLIB_INT_LDADD} ${HDF5_LIBS}"
fi
if test -z "${HAVE_DMALLOC_TRUE}"; then
    ADIOSLIB_CPPFLAGS="${ADIOSLIB_CPPFLAGS} ${MACRODEFFLAG}DMALLOC ${DMALLOC_CPPFLAGS}"
    ADIOSLIB_CFLAGS="${ADIOSLIB_CFLAGS} ${DMALLOC_CFLAGS}"
    ADIOSLIB_LDFLAGS="${ADIOSLIB_LDFLAGS} ${DMALLOC_LDFLAGS}"
    ADIOSLIB_LDADD="${ADIOSLIB_LDADD} ${DMALLOC_LIBS}"
    ADIOSLIB_SEQ_CPPFLAGS="${ADIOSLIB_SEQ_CPPFLAGS} ${DMALLOC_CPPFLAGS}"
    ADIOSLIB_SEQ_CFLAGS="${ADIOSLIB_SEQ_CFLAGS} ${DMALLOC_CFLAGS}"
    ADIOSLIB_SEQ_LDFLAGS="${ADIOSLIB_SEQ_LDFLAGS} ${DMALLOC_LDFLAGS}"
    ADIOSLIB_SEQ_LDADD="${ADIOSLIB_SEQ_LDADD} ${DMALLOC_LIBS}"
    ADIOSLIB_INT_CPPFLAGS="${ADIOSLIB_INT_CPPFLAGS} ${DMALLOC_CPPFLAGS}"
    ADIOSLIB_INT_CFLAGS="${ADIOSLIB_INT_CFLAGS} ${DMALLOC_CFLAGS}"
    ADIOSLIB_INT_LDFLAGS="${ADIOSLIB_INT_LDFLAGS} ${DMALLOC_LDFLAGS}"
    ADIOSLIB_INT_LDADD="${ADIOSLIB_INT_LDADD} ${DMALLOC_LIBS}"
    ADIOSREADLIB_CPPFLAGS="${ADIOSREADLIB_CPPFLAGS} ${DMALLOC_CPPFLAGS}"
    ADIOSREADLIB_CFLAGS="${ADIOSREADLIB_CFLAGS} ${DMALLOC_CFLAGS}"
    ADIOSREADLIB_LDFLAGS="${ADIOSREADLIB_LDFLAGS} ${DMALLOC_LDFLAGS}"
    ADIOSREADLIB_LDADD="${ADIOSREADLIB_LDADD} ${DMALLOC_LIBS}"
    ADIOSREADLIB_SEQ_CPPFLAGS="${ADIOSREADLIB_SEQ_CPPFLAGS} ${DMALLOC_CPPFLAGS}"
    ADIOSREADLIB_SEQ_CFLAGS="${ADIOSREADLIB_SEQ_CFLAGS} ${DMALLOC_CFLAGS}"
    ADIOSREADLIB_SEQ_LDFLAGS="${ADIOSREADLIB_SEQ_LDFLAGS} ${DMALLOC_LDFLAGS}"
    ADIOSREADLIB_SEQ_LDADD="${ADIOSREADLIB_SEQ_LDADD} ${DMALLOC_LIBS}"
fi
if test -z "${HAVE_LUSTRE_TRUE}"; then
    ADIOSLIB_CPPFLAGS="${ADIOSLIB_CPPFLAGS} ${LUSTRE_CPPFLAGS}" 
    ADIOSLIB_CFLAGS="${ADIOSLIB_CFLAGS} ${LUSTRE_CFLAGS}"
    ADIOSLIB_LDFLAGS="${ADIOSLIB_LDFLAGS} ${LUSTRE_LDFLAGS}"
    ADIOSLIB_LDADD="${ADIOSLIB_LDADD} ${LUSTRE_LIBS}"
    ADIOSLIB_SEQ_CPPFLAGS="${ADIOSLIB_SEQ_CPPFLAGS} ${LUSTRE_CPPFLAGS}"
    ADIOSLIB_SEQ_CFLAGS="${ADIOSLIB_SEQ_CFLAGS} ${LUSTRE_CFLAGS}"
    ADIOSLIB_SEQ_LDFLAGS="${ADIOSLIB_SEQ_LDFLAGS} ${LUSTRE_LDFLAGS}"
    ADIOSLIB_SEQ_LDADD="${ADIOSLIB_SEQ_LDADD} ${LUSTRE_LIBS}"
fi
AC_SUBST(ADIOSLIB_CPPFLAGS)
AC_SUBST(ADIOSLIB_CFLAGS)
AC_SUBST(ADIOSLIB_LDFLAGS)
AC_SUBST(ADIOSLIB_LDADD)
AC_SUBST(ADIOSLIB_SEQ_CPPFLAGS)
AC_SUBST(ADIOSLIB_SEQ_CFLAGS)
AC_SUBST(ADIOSLIB_SEQ_LDFLAGS)
AC_SUBST(ADIOSLIB_SEQ_LDADD)
AC_SUBST(ADIOSLIB_INT_CPPFLAGS)
AC_SUBST(ADIOSLIB_INT_CFLAGS)
AC_SUBST(ADIOSLIB_INT_LDFLAGS)
AC_SUBST(ADIOSLIB_INT_LDADD)
AC_SUBST(ADIOSREADLIB_CPPFLAGS)
AC_SUBST(ADIOSREADLIB_CFLAGS)
AC_SUBST(ADIOSREADLIB_LDFLAGS)
AC_SUBST(ADIOSREADLIB_LDADD)
AC_SUBST(ADIOSREADLIB_SEQ_CPPFLAGS)
AC_SUBST(ADIOSREADLIB_SEQ_CFLAGS)
AC_SUBST(ADIOSREADLIB_SEQ_LDFLAGS)
AC_SUBST(ADIOSREADLIB_SEQ_LDADD)
AC_SUBST(ADIOSLIB_EXTRA_CPPFLAGS)

if test -z "${USE_PARALLEL_COMPILER_TRUE}"; then
        AC_DEFINE(USE_PARALLEL_COMPILER, 1, [Need to use MPI compiler for sequential utils])
        echo "#### Defined USE_PARALLEL_COMPILER to = [${USE_PARALLEL_COMPILER}]"
fi

dnl Generate major/minor/micro version numbers
VERSION_MAJOR=[`echo ${VERSION} | sed -e "s/\..*//"`]
AC_DEFINE_UNQUOTED(VERSION_MAJOR, ${VERSION_MAJOR}, [Major version number])
VERSION_MINOR=[`echo ${VERSION} | sed -e "s/[0-9]*\.\([0-9]*\).*/\1/"`]
AC_DEFINE_UNQUOTED(VERSION_MINOR, ${VERSION_MINOR}, [Minor version number])
VERSION_MICRO=[`echo ${VERSION} | sed -e "s/[0-9]*\.[0-9]*\.\([0-9]*\).*/\1/"`]
dnl if micro not defined, here it equals to VERSION; do a minus
VERSION_MICRO=`echo ${VERSION_MICRO} | sed -e "s/${VERSION}//"`
if test -z "${VERSION_MICRO}"; then
    VERSION_MICRO=0
fi
AC_DEFINE_UNQUOTED(VERSION_MICRO, ${VERSION_MICRO}, [Micro version number])

# Get the version of the source we are configuring here
# Just to print it out at the end of configure
# see also Makefile.am:install-data-hook
if type svnversion &>/dev/null; then
    SVNVERSION=`svnversion`
else
    SVNVERSION="unknown"
fi
AC_DEFINE_UNQUOTED(VERSION_SVNREV, "${SVNVERSION}", [svn revision number])




AC_CONFIG_FILES([Makefile
                 src/Makefile
                 tests/Makefile
                 tests/C/Makefile
                 tests/Fortran/Makefile
                 tests/genarray/Makefile
                 tests/bp_read/Makefile
                 tests/suite/Makefile
                 tests/suite/programs/Makefile
                 utils/Makefile
                 utils/skel/Makefile
                 utils/skel/etc/Makefile
                 utils/skel/src/Makefile
                 utils/skel/lib/skel_have_adios_timing.py
                 utils/adios_lint/Makefile
                 utils/gpp/Makefile
                 utils/bpdump/Makefile
                 utils/bp2h5/Makefile
                 utils/bp2ncd/Makefile
                 utils/bp2ascii/Makefile
                 utils/bpsplit/Makefile
                 utils/bpls/Makefile
                 utils/bp2bp/Makefile
                 examples/Makefile
                 examples/C/Makefile
                 examples/C/scalars/Makefile
                 examples/C/arrays/Makefile
                 examples/C/flexpath_arrays/Makefile
                 examples/C/flexpath_arrays/process_select/Makefile
                 examples/C/flexpath_arrays/global_range_select/Makefile
                 examples/C/attributes/Makefile
                 examples/C/manual/Makefile
                 examples/C/global-array/Makefile
                 examples/C/global-array-time/Makefile
                 examples/C/stat/Makefile
                 examples/C/read_all/Makefile
                 examples/C/schema/Makefile
                 examples/Fortran/Makefile
                 examples/Fortran/scalars/Makefile
                 examples/Fortran/arrays/Makefile
                 examples/Fortran/global-array/Makefile
                 examples/Fortran/global-array-time/Makefile
                 adios_config.flags
                ])

AC_OUTPUT

echo
echo "*********************************"
echo $PACKAGE configured as follows:
echo "*********************************"
echo
echo "  - General Compile FLAGS";
echo "      - CC  = $CC";
echo "      - CXX = $CXX";
echo "      - FC  = $FC";
echo "      - CPPFLAGS = $CPPFLAGS";
echo "      - CFLAGS   = $CFLAGS";
echo "      - CXXFLAGS = $CXXFLAGS";
echo "      - FCFLAGS  = $FCFLAGS";
echo "      - LDLAGS   = $LDFLAGS";
echo "      - LIBS     = $LIBS";
echo
echo "      - MPICC   = $MPICC";
echo "      - MPICXX  = $MPICXX";
echo "      - MPIFC   = $MPIFC";
echo "      - MPILIBS = $MPILIBS";
echo

if test "x$enable_research_transports" == "xyes"; then
    echo "  - Research Transports Included";

else
    echo "  - No research transport methods";
fi

if test "x$enable_skel_timing" == "xyes"; then
    echo "  - Skel Timing Mechanism Enabled";

else
    echo "  - Skel Timing Mechanism Disabled";
fi

if test -z "${HAVE_MXML_TRUE}"; then
    echo "  - MXML";
    echo "      - MXML_CFLAGS = $MXML_CFLAGS";
    echo "      - MXML_CPPFLAGS = $MXML_CPPFLAGS";
    echo "      - MXML_LDFLAGS = $MXML_LDFLAGS";
    echo "      - MXML_LIBS = $MXML_LIBS";
    echo
else
    echo "  - No MXML"
fi

if test -z "${HAVE_LUSTRE_TRUE}"; then
        echo "  - LUSTRE";
        echo "      - LUSTRE_CFLAGS = $LUSTRE_CFLAGS";
        echo "      - LUSTRE_CPPFLAGS = $LUSTRE_CPPFLAGS";
        echo "      - LUSTRE_LDFLAGS = $LUSTRE_LDFLAGS";
        echo "      - LUSTRE_LIBS = $LUSTRE_LIBS";
        echo
else
        echo "  - No LUSTRE"
fi

    echo "  - Networking library for staging methods:";
if test -z "${HAVE_PORTALS_TRUE}"; then
    echo "    - PORTALS";
    echo "      - PORTALS_CFLAGS = $PORTALS_CFLAGS";
    echo "      - PORTALS_CPPFLAGS = $PORTALS_CPPFLAGS";
    echo "      - PORTALS_LDFLAGS = $PORTALS_LDFLAGS";
    echo "      - PORTALS_LIBS = $PORTALS_LIBS";
    echo
#else
#    echo "  - No Portals"
#fi

elif test -z "${HAVE_INFINIBAND_TRUE}"; then
    echo "    - INFINIBAND";
    echo "      - INFINIBAND_CFLAGS = $INFINIBAND_CFLAGS";
    echo "      - INFINIBAND_CPPFLAGS = $INFINIBAND_CPPFLAGS";
    echo "      - INFINIBAND_LDFLAGS = $INFINIBAND_LDFLAGS";
    echo "      - INFINIBAND_LIBS = $INFINIBAND_LIBS";
    echo
#else
#    echo "  - No InfiniBand"
#fi

elif test -z "${HAVE_CRAY_PMI_TRUE}" -a -z "${HAVE_CRAY_UGNI_TRUE}"; then
    echo "    - CRAY uGNI with PMI";
    echo "      - CFLAGS = $CRAY_PMI_CFLAGS $CRAY_UGNI_CFLAGS";
    echo "      - CPPFLAGS = $CRAY_PMI_CPPFLAGS $CRAY_UGNI_CPPFLAGS";
    echo "      - LDFLAGS = $CRAY_PMI_LDFLAGS $CRAY_UGNI_LDFLAGS";
    echo "      - LIBS = $CRAY_PMI_LIBS $CRAY_UGNI_LIBS";
    echo
#else
#    echo "  - No Cray uGNI"

elif test -z "${HAVE_DCMF_TRUE}"; then
    echo "    - IBM DCMF";
    echo "      - DCMF_CFLAGS = $DCMF_CFLAGS";
    echo "      - DCMF_CPPFLAGS = $DCMF_CPPFLAGS";
    echo "      - DCMF_LDFLAGS = $DCMF_LDFLAGS";
    echo "      - DCMF_LIBS = $DCMF_LIBS";
    echo
else 
    echo "    - No supported networking library found"
fi

dnl if test -z "${HAVE_GENGETOPT_TRUE}"; then
dnl         echo "  - GENGETOPT";
dnl         echo "      - GENGETOPT_CFLAGS = $GENGETOPT_CFLAGS";
dnl         echo "      - GENGETOPT_CPPFLAGS = $GENGETOPT_CPPFLAGS";
dnl         echo "      - GENGETOPT_LDFLAGS = $GENGETOPT_LDFLAGS";
dnl         echo "      - GENGETOPT_LIBS = $GENGETOPT_LIBS";
dnl         echo
dnl else
dnl         echo "  - No Gengetopt"
dnl fi

if test "x${datatap}" != "xdisable"; then
    echo "  - DataTap with interconnect: $datatap";
    echo "      - DT_CFLAGS     = $DT_CFLAGS";
    echo "      - DT_CPPFLAGS   = $DT_CPPFLAGS";
    echo "      - DT_LDFLAGS    = $DT_LDFLAGS";
    echo "      - DT_LIBS       = $DT_LIBS";
    echo
else
    echo "  - No DataTap transport to build DATATAP transport method";
fi

if test -z "${HAVE_DATASPACES_TRUE}"; then
    echo "  - DATASPACES transport method";
    echo "      - DATASPACES_CFLAGS = $DATASPACES_CFLAGS";
    echo "      - DATASPACES_CPPFLAGS = $DATASPACES_CPPFLAGS";
    echo "      - DATASPACES_LDFLAGS = $DATASPACES_LDFLAGS";
    echo "      - DATASPACES_LIBS = $DATASPACES_LIBS";
    echo
else
    echo "  - No DATASPACES to build DATASPACES transport method"
fi

if test -z "${HAVE_DIMES_TRUE}"; then
    echo "  - DIMES transport method";
    echo "      - DIMES_CFLAGS = $DIMES_CFLAGS";
    echo "      - DIMES_CPPFLAGS = $DIMES_CPPFLAGS";
    echo "      - DIMES_LDFLAGS = $DIMES_LDFLAGS";
    echo "      - DIMES_LIBS = $DIMES_LIBS";
    echo
else
    echo "  - No DIMES to build DIMES transport method"
fi

if test -z "${HAVE_PHDF5_TRUE}"; then
    echo "  - PHDF5";
    echo "      - PHDF5_CFLAGS = $PHDF5_CFLAGS";
    echo "      - PHDF5_CPPFLAGS = $PHDF5_CPPFLAGS";
    echo "      - PHDF5_LDFLAGS = $PHDF5_LDFLAGS";
    echo "      - PHDF5_LIBS = $PHDF5_LIBS";
    echo
else
    echo "  - No PHDF5 to build PHDF5 transport method"
fi

if test -z "${HAVE_HDF5_TRUE}"; then
    echo "  - HDF5";
    echo "      - HDF5_CFLAGS = $HDF5_CFLAGS";
    echo "      - HDF5_CPPFLAGS = $HDF5_CPPFLAGS";
    echo "      - HDF5_LDFLAGS = $HDF5_LDFLAGS";
    echo "      - HDF5_LIBS = $HDF5_LIBS";
    echo
else
    echo "  - No HDF5"
fi

if test -z "${HAVE_NC4PAR_TRUE}"; then
    echo "  - NetCDF 4 Parallel";
    echo "      - NC4PAR_CFLAGS = $NC4PAR_CFLAGS";
    echo "      - NC4PAR_CPPFLAGS = $NC4PAR_CPPFLAGS";
    echo "      - NC4PAR_LDFLAGS = $NC4PAR_LDFLAGS";
    echo "      - NC4PAR_LIBS = $NC4PAR_LIBS";
    echo
else
    echo "  - No NETCDF 4 Parallel to build NC4 transport method"
fi

if test -z "${HAVE_NETCDF_TRUE}"; then
    echo "  - NetCDF";
    echo "      - NETCDF_CFLAGS = $NETCDF_CFLAGS";
    echo "      - NETCDF_CPPFLAGS = $NETCDF_CPPFLAGS";
    echo "      - NETCDF_LDFLAGS = $NETCDF_LDFLAGS";
    echo "      - NETCDF_LIBS = $NETCDF_LIBS";
    echo
else
    echo "  - No NETCDF"
fi

if test -z "${HAVE_NSSI_TRUE}"; then
    echo "  - NSSI";
    echo "      - NSSI_CFLAGS = $NSSI_CFLAGS";
    echo "      - NSSI_CPPFLAGS = $NSSI_CPPFLAGS";
    echo "      - NSSI_LDFLAGS = $NSSI_LDFLAGS";
    echo "      - NSSI_LIBS = $NSSI_LIBS";
    echo
else
    echo "  - No NSSI to build NSSI transport method"
fi

if test -z "${HAVE_FLEXPATH_TRUE}"; then
    echo "  - FLEXPATH";
    echo "      - FP_CFLAGS = $FP_CFLAGS";
    echo "      - FP_CPPFLAGS = $FP_CPPFLAGS";
    echo "      - FP_LDFLAGS = $FP_LDFLAGS";
    echo "      - FP_LIBS = $FP_LIBS";
    echo
else
    echo "  - No FLEXPATH to build FLEXPATH transport method"
fi

echo "  - SVN version = ${SVNVERSION}"
echo "  - Install path = ${prefix}"
