configure.ac

AC_INIT([adios], [1.13.1])
AC_CONFIG_SRCDIR([configure.ac])
AC_CONFIG_AUX_DIR(config)
AC_CONFIG_MACRO_DIR(config)
AC_REVISION($Revision$)

AC_CONFIG_HEADERS(config.h)
dnl Require Automake 1.12.0 or better.
dnl We need automake correctly generate object file path for .F90 modules when
dnl enabling subdir-objects
dnl Automake 1.10 wants to use ./adiosf_read_mod.o for libadiosf.a, although
dnl it correctly places that object file into core/adiosf_read_mod.o
dnl Also use EXTRA_libraryname_DEPENDENCIES which is not available in 1.11
AM_INIT_AUTOMAKE([1.12.0])    

AM_MAINTAINER_MODE([enable])

AC_LANG(C)

AC_PROG_CC
AM_PROG_CC_C_O
AC_PROG_CXX

AC_LANG(C)
ACX_MPI([], [AC_MSG_ERROR([could not find mpi library for C])])
if test -z "${HAVE_MPI_TRUE}"; then
    AC_LANG(C++)
    ACX_MPI([], [AC_MSG_ERROR([could not find mpi library for C++])])
else
    AC_DEFINE(HAVE_MPI,0,[Don not have MPI to build parallel libraries])
fi

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

AC_CANONICAL_HOST

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
    if test -z "${HAVE_MPI_TRUE}"; then
        AC_LANG(Fortran)
        ACX_MPI([], [AC_MSG_ERROR([could not find mpi library for Fortran])])
    fi
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_SEARCH_LIBS([clock_gettime], [rt])
AC_CHECK_FUNCS([nanosleep gettimeofday clock_gettime clock_get_time strncpy strerror])

AC_CHECK_HEADERS([time.h])
AC_CHECK_TYPES([clockid_t], [], [], [[#include <time.h>]])

AC_C_STRINGIZE
dnl generates HAVE_STRINGIZE
AC_FUNC_STRTOLD
dnl generates HAVE_STRTOLD


dnl ========== Some checks inherited from MXML's configure =============

dnl Inline functions...
AC_C_INLINE

dnl Checks for string functions.
AC_CHECK_FUNCS(strdup)
AC_CHECK_FUNCS(strndup)
AC_CHECK_FUNCS(snprintf vsnprintf)

dnl Check for "long long" support...
AC_CACHE_CHECK([for long long int], ac_cv_c_long_long,
    [if test "$GCC" = yes; then
        ac_cv_c_long_long=yes
    else
        AC_TRY_COMPILE(,[long long int i;],
            ac_cv_c_long_long=yes,
            ac_cv_c_long_long=no)
    fi])

if test $ac_cv_c_long_long = yes; then
    AC_DEFINE(HAVE_LONG_LONG,1,[Have long long int, a type may be used by MXML])
fi

dnl ========== End of checks inherited from MXML's configure =============




dnl check if -lm is needed to be added
AC_SEARCH_LIBS([ceil], [m])

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

AC_MXML
dnl MXML is required for Write API, build from source in mxml/mxml-2.9 if not provided by user
if test -z "${HAVE_MXML_FALSE}" -a -z "${BUILD_WRITE_TRUE}"; then
    AC_MSG_NOTICE([External MXML library not provided. Build the included MXML source])
    AM_CONDITIONAL(HAVE_MXML,true)
    AM_CONDITIONAL(BUILD_MXML,true)
    MXML_CPPFLAGS="${CPPFLAGS} -I\$(top_srcdir)/src/mxml/mxml-2.9"
    MXML_BUILD_LDFLAGS=
    MXML_LDFLAGS=
    MXML_LIBS=
    AC_SUBST(MXML_CPPFLAGS)
    AC_SUBST(MXML_LIBS)
    AC_SUBST(MXML_BUILD_LDFLAGS)
    AC_SUBST(MXML_LDFLAGS)
    AC_DEFINE_UNQUOTED(MXML_VERSION, [Mini-XML v2.9], [MXML version string])
    dnl AC_DEFINE(HAVE_PTHREAD_H, 0, [We build Mini-XML without pthread support because ADIOS does not need it])
    dnl AC_CONFIG_SUBDIRS([mxml/mxml-2.9])
    dnl AC_MSG_ERROR([The ADIOS libraries for writing cannot be built without the MXML library. Either specify where the MXML library is found, or use --disable-write to build ADIOS for reading only.])
    dnl AM_CONDITIONAL([BUILD_WRITE], false)
else
    AM_CONDITIONAL(BUILD_MXML,false)
fi

AC_MSG_NOTICE([PTHREAD_LIBS=${PTHREAD_LIBS}])
if test ! -z "${PTHREAD_LIBS}"; then
    LIBS="${PTHREAD_LIBS} ${LIBS}"
fi
if test ! -z "${PTHREAD_CFLAGS}"; then
    CFLAGS="$CFLAGS ${PTHREAD_CFLAGS}"
fi

# Make sure we find Python2
m4_define_default([_AM_PYTHON_INTERPRETER_LIST],
                  [python python2 python3 python3.7 python3.6 python3.5 python3.4 python3.3 python3.2 python3.1 python3.0 python2.7 python2.6 python2.5 python2.4 python2.3 python2.2 python2.1 python2.0])
AM_PATH_PYTHON([2.0])
dnl AS_VERSION_COMPARE([${PYTHON_VERSION}], [3.0], [HAVE_PYTHON2=yes], [HAVE_PYTHON2=no], [HAVE_PYTHON2=no])
dnl if test "x${HAVE_PYTHON2}" == "xno"; then 
dnl     AC_MSG_ERROR([ADIOS requires python 2.x installed.])
dnl fi
dnl Set PYTHON_EXECUTABLE to have the same variable as with CMake
AC_SUBST(PYTHON_EXECUTABLE,${PYTHON})

dnl AC_PROG_GENGETOPT
AC_PAMI
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_FGR
AC_GLIB
AC_DATATAP
AC_FLEXPATH
AC_ZLIB
AC_BZIP2
AC_SZIP
AC_ISOBAR
AC_APLOD
AC_ALACRITY
AC_FASTBIT
AC_BGQ
AC_LZ4
AC_BLOSC


AC_ZFP
dnl ZFP is included in the source, so we build it unless a) explicitely disabled by --without-zfp
dnl or b) an external zfp lib is provided by --with-zfp=path
dnl config/ac_zfp.m4 sets BUILD_ZFP if none of the above options were given
if test -z "${BUILD_ZFP_TRUE}"; then
    AC_MSG_NOTICE([Build the included ZFP source. Use --without-zfp to turn this off, --with-zfp=path to use an external library.])
    AM_CONDITIONAL(HAVE_ZFP,true)
    ZFP_CPPFLAGS="${CPPFLAGS} -I\$(top_srcdir)/src/zfp/zfp-0.5.5/include"
    ZFP_BUILD_LDFLAGS=
    ZFP_LDFLAGS=
    ZFP_LIBS=
    AC_SUBST(ZFP_CPPFLAGS)
    AC_SUBST(ZFP_LIBS)
    AC_SUBST(ZFP_LDFLAGS)
fi
AC_SZ
AC_ZCHECKER
AC_MGARD


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(timers,
    [AS_HELP_STRING([--disable-timers],
        [Disable the adios timing mechanism. By default the timers are used.])])
AM_CONDITIONAL([ADIOS_TIMERS], [test "x$enable_timers" != "xno"])


if test "x$enable_timers" != "xno"; then
    AC_DEFINE(ADIOS_TIMERS, 1, [Adios 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(ADIOS_TIMERS)


AC_ARG_ENABLE(timer-events,
    [AS_HELP_STRING([--enable-timer-events],
        [Enable adios timing events. By default the events are not used.])])
AM_CONDITIONAL([ADIOS_TIMER_EVENTS], [test "x$enable_timer_events" == "xyes"])


if test "x$enable_timer_events" == "xyes"; then
    AC_DEFINE(ADIOS_TIMER_EVENTS, 1, [Adios timing events are enabled])
fi
AC_SUBST(ADIOS_TIMER_EVENTS)


AC_LANG(C)

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


dnl Unset if MPILIBS == " ", a byproduct of config/acx_mpi.m4 on success
if test "x y" == "x${MPILIBS}y"; then
    MPILIBS=""
fi
if test -n "${MPILIBS}"; then
    LIBS="${MPILIBS} ${LIBS}"
fi

AM_CONDITIONAL(USE_PARALLEL_HDF5_FOR_UTILS,false)
AM_CONDITIONAL(USE_PARALLEL_NETCDF_FOR_UTILS,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_HDF5_FOR_UTILS,true)
    AC_MSG_NOTICE([Use PHDF5 for sequential HDF5 tools])
    BP2H5_CC="${MPICC}"
else
    BP2H5_CC="${CC}"
fi
AC_SUBST(BP2H5_CC)

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_NETCDF_FOR_UTILS,true)
    AC_MSG_NOTICE([Use NC4PAR for sequential NETCDF tools])
    BP2NCD_CC="${MPICC}"
else
    BP2NCD_CC="${CC}"
fi
AC_SUBST(BP2NCD_CC)

opsys=''
canonical=${host}

case "${canonical}" in
     *-*-cygwin )
        AM_CONDITIONAL(HAVE_CYGWIN, true)
        AC_DEFINE(__USE_LINUX_IOCTL_DEFS,1,[Define if you use CYGWIN.])
     ;;
     * )
        AM_CONDITIONAL(HAVE_CYGWIN, false)
     ;;
esac




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 ${MXML_CPPFLAGS}"
ADIOSLIB_EXTRA_LDFLAGS="${MXML_BUILD_LDFLAGS}"
if test -z "${HAVE_ZFP_TRUE}"; then
    ADIOSLIB_EXTRA_CPPFLAGS="${ADIOSLIB_EXTRA_CPPFLAGS} ${MACRODEFFLAG}ZFP ${ZFP_CPPFLAGS}"
    ADIOSLIB_EXTRA_LDFLAGS="${ADIOSLIB_EXTRA_LDFLAGS} ${ZFP_BUILD_LDFLAGS}"
fi
ADIOSLIB_CPPFLAGS=
ADIOSLIB_CFLAGS=
ADIOSLIB_LDFLAGS="${MXML_LDFLAGS}"
ADIOSLIB_LDADD="${MXML_LIBS}"
ADIOSLIB_SEQ_CPPFLAGS="${MACRODEFFLAG}_NOMPI"
ADIOSLIB_SEQ_CFLAGS=
ADIOSLIB_SEQ_LDFLAGS="${MXML_LDFLAGS}"
ADIOSLIB_SEQ_LDADD="${MXML_LIBS}"
ADIOSLIB_INT_CPPFLAGS="${MACRODEFFLAG}_NOMPI"
ADIOSLIB_INT_CFLAGS=
if test "x$enable_write" != "xno"; then
    ADIOSLIB_INT_LDFLAGS="${MXML_LDFLAGS}"
    ADIOSLIB_INT_LDADD="${MXML_LIBS}"
else
    ADIOSLIB_INT_LDFLAGS=
    ADIOSLIB_INT_LDADD=
fi
ADIOSREADLIB_CPPFLAGS=
ADIOSREADLIB_CFLAGS=
ADIOSREADLIB_LDFLAGS=
ADIOSREADLIB_LDADD=""
ADIOSREADLIB_SEQ_CPPFLAGS="${MACRODEFFLAG}_NOMPI"
ADIOSREADLIB_SEQ_CFLAGS=
ADIOSREADLIB_SEQ_LDFLAGS=
ADIOSREADLIB_SEQ_LDADD=""
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}"
    dnl ADIOSLIB_SEQ_CPPFLAGS="${ADIOSLIB_SEQ_CPPFLAGS} ${DATASPACES_CPPFLAGS}"
    dnl ADIOSLIB_SEQ_CFLAGS="${ADIOSLIB_SEQ_CFLAGS}"
    dnl ADIOSLIB_SEQ_LDFLAGS="${ADIOSLIB_SEQ_LDFLAGS} ${DATASPACES_LDFLAGS}"
    dnl 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}"
    dnl ADIOSREADLIB_SEQ_CPPFLAGS="${ADIOSREADLIB_SEQ_CPPFLAGS} ${DATASPACES_CPPFLAGS}"
    dnl ADIOSREADLIB_SEQ_CFLAGS="${ADIOSREADLIB_SEQ_CFLAGS} ${DATASPACES_CFLAGS}"
    dnl ADIOSREADLIB_SEQ_LDFLAGS="${ADIOSREADLIB_SEQ_LDFLAGS} ${DATASPACES_LDFLAGS}"
    dnl 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}"
    dnl ADIOSLIB_SEQ_CPPFLAGS="${ADIOSLIB_SEQ_CPPFLAGS} ${DIMES_CPPFLAGS}"
    dnl ADIOSLIB_SEQ_CFLAGS="${ADIOSLIB_SEQ_CFLAGS}"
    dnl ADIOSLIB_SEQ_LDFLAGS="${ADIOSLIB_SEQ_LDFLAGS} ${DIMES_LDFLAGS}"
    dnl 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}"
    dnl ADIOSREADLIB_SEQ_CPPFLAGS="${ADIOSREADLIB_SEQ_CPPFLAGS} ${DIMES_CPPFLAGS}"
    dnl ADIOSREADLIB_SEQ_CFLAGS="${ADIOSREADLIB_SEQ_CFLAGS} ${DIMES_CFLAGS}"
    dnl ADIOSREADLIB_SEQ_LDFLAGS="${ADIOSREADLIB_SEQ_LDFLAGS} ${DIMES_LDFLAGS}"
    dnl 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} ${NSSI_CPPFLAGS}"
    ADIOSREADLIB_CFLAGS="${ADIOSREADLIB_CFLAGS} ${NSSI_CFLAGS}"
    ADIOSREADLIB_LDFLAGS="${ADIOSREADLIB_LDFLAGS} ${MXML_LDFLAGS} ${NSSI_LDFLAGS}"
    ADIOSREADLIB_LDADD="${ADIOSREADLIB_LDADD} ${NSSI_LIBS}"
    ADIOSREADLIB_SEQ_CPPFLAGS="${ADIOSREADLIB_SEQ_CPPFLAGS} ${NSSI_CPPFLAGS}"
    ADIOSREADLIB_SEQ_CFLAGS="${ADIOSREADLIB_SEQ_CFLAGS} ${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_PAMI_TRUE}"; then
    ADIOSLIB_CPPFLAGS="${ADIOSLIB_CPPFLAGS} ${PAMI_CPPFLAGS}"
    ADIOSLIB_CFLAGS="${ADIOSLIB_CFLAGS} ${PAMI_CFLAGS}"
    ADIOSLIB_LDFLAGS="${ADIOSLIB_LDFLAGS} ${PAMI_LDFLAGS}"
    ADIOSLIB_LDADD="${ADIOSLIB_LDADD} ${PAMI_LIBS}"
    ADIOSLIB_SEQ_CPPFLAGS="${ADIOSLIB_SEQ_CPPFLAGS} ${PAMI_CPPFLAGS}"
    ADIOSLIB_SEQ_CFLAGS="${ADIOSLIB_SEQ_CFLAGS} ${PAMI_CFLAGS}"
    ADIOSLIB_SEQ_LDFLAGS="${ADIOSLIB_SEQ_LDFLAGS} ${PAMI_LDFLAGS}"
    ADIOSLIB_SEQ_LDADD="${ADIOSLIB_SEQ_LDADD} ${PAMI_LIBS}"
    ADIOSREADLIB_CPPFLAGS="${ADIOSREADLIB_CPPFLAGS} ${PAMI_CPPFLAGS}"
    ADIOSREADLIB_CFLAGS="${ADIOSREADLIB_CFLAGS} ${PAMI_CFLAGS}"
    ADIOSREADLIB_LDFLAGS="${ADIOSREADLIB_LDFLAGS} ${PAMI_LDFLAGS}"
    ADIOSREADLIB_LDADD="${ADIOSREADLIB_LDADD} ${PAMI_LIBS}"
    ADIOSREADLIB_SEQ_CPPFLAGS="${ADIOSREADLIB_SEQ_CPPFLAGS} ${PAMI_CPPFLAGS}"
    ADIOSREADLIB_SEQ_CFLAGS="${ADIOSREADLIB_SEQ_CFLAGS} ${PAMI_CFLAGS}"
    ADIOSREADLIB_SEQ_LDFLAGS="${ADIOSREADLIB_SEQ_LDFLAGS} ${PAMI_LDFLAGS}"
    ADIOSREADLIB_SEQ_LDADD="${ADIOSREADLIB_SEQ_LDADD} ${PAMI_LIBS}"
fi
if test -z "${HAVE_NETCDF_TRUE}"; then
    ADIOSLIB_SEQ_CPPFLAGS="${ADIOSLIB_SEQ_CPPFLAGS} ${NETCDF_CPPFLAGS}"
    ADIOSLIB_SEQ_CFLAGS="${ADIOSLIB_SEQ_CFLAGS} ${NETCDF_CFLAGS}"
    ADIOSLIB_SEQ_LDFLAGS="${ADIOSLIB_SEQ_LDFLAGS} ${NETCDF_LDFLAGS}"
    ADIOSLIB_SEQ_LDADD="${ADIOSLIB_SEQ_LDADD} ${NETCDF_LIBS}"
fi
if test -z "${HAVE_HDF5_TRUE}"; then
    ADIOSLIB_SEQ_CPPFLAGS="${ADIOSLIB_SEQ_CPPFLAGS} ${HDF5_CPPFLAGS}"
    ADIOSLIB_SEQ_CFLAGS="${ADIOSLIB_SEQ_CFLAGS} ${HDF5_CFLAGS}"
    ADIOSLIB_SEQ_LDFLAGS="${ADIOSLIB_SEQ_LDFLAGS} ${HDF5_LDFLAGS}"
    ADIOSLIB_SEQ_LDADD="${ADIOSLIB_SEQ_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
if test -z "${HAVE_FGR_TRUE}"; then
    ADIOSLIB_CPPFLAGS="${ADIOSLIB_CPPFLAGS} ${FGR_CPPFLAGS}"
    ADIOSLIB_CFLAGS="${ADIOSLIB_CFLAGS} ${FGR_CFLAGS}"
    ADIOSLIB_LDFLAGS="${ADIOSLIB_LDFLAGS} ${FGR_LDFLAGS}"
    ADIOSLIB_LDADD="${ADIOSLIB_LDADD} ${FGR_LIBS}"
    ADIOSLIB_SEQ_CPPFLAGS="${ADIOSLIB_SEQ_CPPFLAGS} ${FGR_CPPFLAGS}"
    ADIOSLIB_SEQ_CFLAGS="${ADIOSLIB_SEQ_CFLAGS} ${FGR_CFLAGS}"
    ADIOSLIB_SEQ_LDFLAGS="${ADIOSLIB_SEQ_LDFLAGS} ${FGR_LDFLAGS}"
    ADIOSLIB_SEQ_LDADD="${ADIOSLIB_SEQ_LDADD} ${FGR_LIBS}"
fi
if test -z "${HAVE_GLIB_TRUE}"; then
    ADIOSLIB_CPPFLAGS="${ADIOSLIB_CPPFLAGS} ${GLIB_CPPFLAGS}"
    ADIOSLIB_CFLAGS="${ADIOSLIB_CFLAGS} ${GLIB_CFLAGS}"
    ADIOSLIB_LDFLAGS="${ADIOSLIB_LDFLAGS} ${GLIB_LDFLAGS}"
    ADIOSLIB_LDADD="${ADIOSLIB_LDADD} ${GLIB_LIBS}"
    ADIOSLIB_SEQ_CPPFLAGS="${ADIOSLIB_SEQ_CPPFLAGS} ${GLIB_CPPFLAGS}"
    ADIOSLIB_SEQ_CFLAGS="${ADIOSLIB_SEQ_CFLAGS} ${GLIB_CFLAGS}"
    ADIOSLIB_SEQ_LDFLAGS="${ADIOSLIB_SEQ_LDFLAGS} ${GLIB_LDFLAGS}"
    ADIOSLIB_SEQ_LDADD="${ADIOSLIB_SEQ_LDADD} ${GLIB_LIBS}"
fi
if test -z "${HAVE_ZLIB_TRUE}"; then
    ADIOSLIB_CPPFLAGS="${ADIOSLIB_CPPFLAGS} -DZLIB ${ZLIB_CPPFLAGS}"
    ADIOSLIB_CFLAGS="${ADIOSLIB_CFLAGS} ${ZLIB_CFLAGS}"
    ADIOSLIB_LDFLAGS="${ADIOSLIB_LDFLAGS} ${ZLIB_LDFLAGS}"
    ADIOSLIB_LDADD="${ADIOSLIB_LDADD} ${ZLIB_LIBS}"
    ADIOSLIB_SEQ_CPPFLAGS="${ADIOSLIB_SEQ_CPPFLAGS} -DZLIB ${ZLIB_CPPFLAGS}"
    ADIOSLIB_SEQ_CFLAGS="${ADIOSLIB_SEQ_CFLAGS} ${ZLIB_CFLAGS}"
    ADIOSLIB_SEQ_LDFLAGS="${ADIOSLIB_SEQ_LDFLAGS} ${ZLIB_LDFLAGS}"
    ADIOSLIB_SEQ_LDADD="${ADIOSLIB_SEQ_LDADD} ${ZLIB_LIBS}"
    ADIOSLIB_INT_CPPFLAGS="${ADIOSLIB_INT_CPPFLAGS} -DZLIB ${ZLIB_CPPFLAGS}"
    ADIOSLIB_INT_CFLAGS="${ADIOSLIB_INT_CFLAGS} ${ZLIB_CFLAGS}"
    ADIOSLIB_INT_LDFLAGS="${ADIOSLIB_INT_LDFLAGS} ${ZLIB_LDFLAGS}"
    ADIOSLIB_INT_LDADD="${ADIOSLIB_INT_LDADD} ${ZLIB_LIBS}"
    ADIOSREADLIB_CPPFLAGS="${ADIOSREADLIB_CPPFLAGS} -DZLIB ${ZLIB_CPPFLAGS}"
    ADIOSREADLIB_CFLAGS="${ADIOSREADLIB_CFLAGS} ${ZLIB_CFLAGS}"
    ADIOSREADLIB_LDFLAGS="${ADIOSREADLIB_LDFLAGS} ${ZLIB_LDFLAGS}"
    ADIOSREADLIB_LDADD="${ADIOSREADLIB_LDADD} ${ZLIB_LIBS}"
    ADIOSREADLIB_SEQ_CPPFLAGS="${ADIOSREADLIB_SEQ_CPPFLAGS} -DZLIB ${ZLIB_CPPFLAGS}"
    ADIOSREADLIB_SEQ_CFLAGS="${ADIOSREADLIB_SEQ_CFLAGS} ${ZLIB_CFLAGS}"
    ADIOSREADLIB_SEQ_LDFLAGS="${ADIOSREADLIB_SEQ_LDFLAGS} ${ZLIB_LDFLAGS}"
    ADIOSREADLIB_SEQ_LDADD="${ADIOSREADLIB_SEQ_LDADD} ${ZLIB_LIBS}"
fi
if test -z "${HAVE_BZIP2_TRUE}"; then
    ADIOSLIB_CPPFLAGS="${ADIOSLIB_CPPFLAGS} -DBZIP2 ${BZIP2_CPPFLAGS}"
    ADIOSLIB_CFLAGS="${ADIOSLIB_CFLAGS} ${BZIP2_CFLAGS}"
    ADIOSLIB_LDFLAGS="${ADIOSLIB_LDFLAGS} ${BZIP2_LDFLAGS}"
    ADIOSLIB_LDADD="${ADIOSLIB_LDADD} ${BZIP2_LIBS}"
    ADIOSLIB_SEQ_CPPFLAGS="${ADIOSLIB_SEQ_CPPFLAGS} -DBZIP2 ${BZIP2_CPPFLAGS}"
    ADIOSLIB_SEQ_CFLAGS="${ADIOSLIB_SEQ_CFLAGS} ${BZIP2_CFLAGS}"
    ADIOSLIB_SEQ_LDFLAGS="${ADIOSLIB_SEQ_LDFLAGS} ${BZIP2_LDFLAGS}"
    ADIOSLIB_SEQ_LDADD="${ADIOSLIB_SEQ_LDADD} ${BZIP2_LIBS}"
    ADIOSLIB_INT_CPPFLAGS="${ADIOSLIB_INT_CPPFLAGS} -DBZIP2 ${BZIP2_CPPFLAGS}"
    ADIOSLIB_INT_CFLAGS="${ADIOSLIB_INT_CFLAGS} ${BZIP2_CFLAGS}"
    ADIOSLIB_INT_LDFLAGS="${ADIOSLIB_INT_LDFLAGS} ${BZIP2_LDFLAGS}"
    ADIOSLIB_INT_LDADD="${ADIOSLIB_INT_LDADD} ${BZIP2_LIBS}"
    ADIOSREADLIB_CPPFLAGS="${ADIOSREADLIB_CPPFLAGS} -DBZIP2 ${BZIP2_CPPFLAGS}"
    ADIOSREADLIB_CFLAGS="${ADIOSREADLIB_CFLAGS} ${BZIP2_CFLAGS}"
    ADIOSREADLIB_LDFLAGS="${ADIOSREADLIB_LDFLAGS} ${BZIP2_LDFLAGS}"
    ADIOSREADLIB_LDADD="${ADIOSREADLIB_LDADD} ${BZIP2_LIBS}"
    ADIOSREADLIB_SEQ_CPPFLAGS="${ADIOSREADLIB_SEQ_CPPFLAGS} -DBZIP2 ${BZIP2_CPPFLAGS}"
    ADIOSREADLIB_SEQ_CFLAGS="${ADIOSREADLIB_SEQ_CFLAGS} ${BZIP2_CFLAGS}"
    ADIOSREADLIB_SEQ_LDFLAGS="${ADIOSREADLIB_SEQ_LDFLAGS} ${BZIP2_LDFLAGS}"
    ADIOSREADLIB_SEQ_LDADD="${ADIOSREADLIB_SEQ_LDADD} ${BZIP2_LIBS}"
fi
if test -z "${HAVE_SZIP_TRUE}"; then
    ADIOSLIB_CPPFLAGS="${ADIOSLIB_CPPFLAGS} -DSZIP ${SZIP_CPPFLAGS}"
    ADIOSLIB_CFLAGS="${ADIOSLIB_CFLAGS} ${SZIP_CFLAGS}"
    ADIOSLIB_LDFLAGS="${ADIOSLIB_LDFLAGS} ${SZIP_LDFLAGS}"
    ADIOSLIB_LDADD="${ADIOSLIB_LDADD} ${SZIP_LIBS}"
    ADIOSLIB_SEQ_CPPFLAGS="${ADIOSLIB_SEQ_CPPFLAGS} -DSZIP ${SZIP_CPPFLAGS}"
    ADIOSLIB_SEQ_CFLAGS="${ADIOSLIB_SEQ_CFLAGS} ${SZIP_CFLAGS}"
    ADIOSLIB_SEQ_LDFLAGS="${ADIOSLIB_SEQ_LDFLAGS} ${SZIP_LDFLAGS}"
    ADIOSLIB_SEQ_LDADD="${ADIOSLIB_SEQ_LDADD} ${SZIP_LIBS}"
    ADIOSLIB_INT_CPPFLAGS="${ADIOSLIB_INT_CPPFLAGS} -DSZIP ${SZIP_CPPFLAGS}"
    ADIOSLIB_INT_CFLAGS="${ADIOSLIB_INT_CFLAGS} ${SZIP_CFLAGS}"
    ADIOSLIB_INT_LDFLAGS="${ADIOSLIB_INT_LDFLAGS} ${SZIP_LDFLAGS}"
    ADIOSLIB_INT_LDADD="${ADIOSLIB_INT_LDADD} ${SZIP_LIBS}"
    ADIOSREADLIB_CPPFLAGS="${ADIOSREADLIB_CPPFLAGS} -DSZIP ${SZIP_CPPFLAGS}"
    ADIOSREADLIB_CFLAGS="${ADIOSREADLIB_CFLAGS} ${SZIP_CFLAGS}"
    ADIOSREADLIB_LDFLAGS="${ADIOSREADLIB_LDFLAGS} ${SZIP_LDFLAGS}"
    ADIOSREADLIB_LDADD="${ADIOSREADLIB_LDADD} ${SZIP_LIBS}"
    ADIOSREADLIB_SEQ_CPPFLAGS="${ADIOSREADLIB_SEQ_CPPFLAGS} -DSZIP ${SZIP_CPPFLAGS}"
    ADIOSREADLIB_SEQ_CFLAGS="${ADIOSREADLIB_SEQ_CFLAGS} ${SZIP_CFLAGS}"
    ADIOSREADLIB_SEQ_LDFLAGS="${ADIOSREADLIB_SEQ_LDFLAGS} ${SZIP_LDFLAGS}"
    ADIOSREADLIB_SEQ_LDADD="${ADIOSREADLIB_SEQ_LDADD} ${SZIP_LIBS}"
fi
if test -z "${HAVE_LZ4_TRUE}"; then
    ADIOSLIB_CPPFLAGS="${ADIOSLIB_CPPFLAGS} -DLZ4 ${LZ4_CPPFLAGS}"
    ADIOSLIB_CFLAGS="${ADIOSLIB_CFLAGS} ${LZ4_CFLAGS}"
    ADIOSLIB_LDFLAGS="${ADIOSLIB_LDFLAGS} ${LZ4_LDFLAGS}"
    ADIOSLIB_LDADD="${ADIOSLIB_LDADD} ${LZ4_LIBS}"
    ADIOSLIB_SEQ_CPPFLAGS="${ADIOSLIB_SEQ_CPPFLAGS} -DLZ4 ${LZ4_CPPFLAGS}"
    ADIOSLIB_SEQ_CFLAGS="${ADIOSLIB_SEQ_CFLAGS} ${LZ4_CFLAGS}"
    ADIOSLIB_SEQ_LDFLAGS="${ADIOSLIB_SEQ_LDFLAGS} ${LZ4_LDFLAGS}"
    ADIOSLIB_SEQ_LDADD="${ADIOSLIB_SEQ_LDADD} ${LZ4_LIBS}"
    ADIOSLIB_INT_CPPFLAGS="${ADIOSLIB_INT_CPPFLAGS} -DLZ4 ${LZ4_CPPFLAGS}"
    ADIOSLIB_INT_CFLAGS="${ADIOSLIB_INT_CFLAGS} ${LZ4_CFLAGS}"
    ADIOSLIB_INT_LDFLAGS="${ADIOSLIB_INT_LDFLAGS} ${LZ4_LDFLAGS}"
    ADIOSLIB_INT_LDADD="${ADIOSLIB_INT_LDADD} ${LZ4_LIBS}"
    ADIOSREADLIB_CPPFLAGS="${ADIOSREADLIB_CPPFLAGS} -DLZ4 ${LZ4_CPPFLAGS}"
    ADIOSREADLIB_CFLAGS="${ADIOSREADLIB_CFLAGS} ${LZ4_CFLAGS}"
    ADIOSREADLIB_LDFLAGS="${ADIOSREADLIB_LDFLAGS} ${LZ4_LDFLAGS}"
    ADIOSREADLIB_LDADD="${ADIOSREADLIB_LDADD} ${LZ4_LIBS}"
    ADIOSREADLIB_SEQ_CPPFLAGS="${ADIOSREADLIB_SEQ_CPPFLAGS} -DLZ4 ${LZ4_CPPFLAGS}"
    ADIOSREADLIB_SEQ_CFLAGS="${ADIOSREADLIB_SEQ_CFLAGS} ${LZ4_CFLAGS}"
    ADIOSREADLIB_SEQ_LDFLAGS="${ADIOSREADLIB_SEQ_LDFLAGS} ${LZ4_LDFLAGS}"
    ADIOSREADLIB_SEQ_LDADD="${ADIOSREADLIB_SEQ_LDADD} ${LZ4_LIBS}"
fi
if test -z "${HAVE_BLOSC_TRUE}"; then
    ADIOSLIB_CPPFLAGS="${ADIOSLIB_CPPFLAGS} -DBLOSC ${BLOSC_CPPFLAGS}"
    ADIOSLIB_CFLAGS="${ADIOSLIB_CFLAGS} ${BLOSC_CFLAGS}"
    ADIOSLIB_LDFLAGS="${ADIOSLIB_LDFLAGS} ${BLOSC_LDFLAGS}"
    ADIOSLIB_LDADD="${ADIOSLIB_LDADD} ${BLOSC_LIBS}"
    ADIOSLIB_SEQ_CPPFLAGS="${ADIOSLIB_SEQ_CPPFLAGS} -DBLOSC ${BLOSC_CPPFLAGS}"
    ADIOSLIB_SEQ_CFLAGS="${ADIOSLIB_SEQ_CFLAGS} ${BLOSC_CFLAGS}"
    ADIOSLIB_SEQ_LDFLAGS="${ADIOSLIB_SEQ_LDFLAGS} ${BLOSC_LDFLAGS}"
    ADIOSLIB_SEQ_LDADD="${ADIOSLIB_SEQ_LDADD} ${BLOSC_LIBS}"
    ADIOSLIB_INT_CPPFLAGS="${ADIOSLIB_INT_CPPFLAGS} -DBLOSC ${BLOSC_CPPFLAGS}"
    ADIOSLIB_INT_CFLAGS="${ADIOSLIB_INT_CFLAGS} ${BLOSC_CFLAGS}"
    ADIOSLIB_INT_LDFLAGS="${ADIOSLIB_INT_LDFLAGS} ${BLOSC_LDFLAGS}"
    ADIOSLIB_INT_LDADD="${ADIOSLIB_INT_LDADD} ${BLOSC_LIBS}"
    ADIOSREADLIB_CPPFLAGS="${ADIOSREADLIB_CPPFLAGS} -DBLOSC ${BLOSC_CPPFLAGS}"
    ADIOSREADLIB_CFLAGS="${ADIOSREADLIB_CFLAGS} ${BLOSC_CFLAGS}"
    ADIOSREADLIB_LDFLAGS="${ADIOSREADLIB_LDFLAGS} ${BLOSC_LDFLAGS}"
    ADIOSREADLIB_LDADD="${ADIOSREADLIB_LDADD} ${BLOSC_LIBS}"
    ADIOSREADLIB_SEQ_CPPFLAGS="${ADIOSREADLIB_SEQ_CPPFLAGS} -DBLOSC ${BLOSC_CPPFLAGS}"
    ADIOSREADLIB_SEQ_CFLAGS="${ADIOSREADLIB_SEQ_CFLAGS} ${BLOSC_CFLAGS}"
    ADIOSREADLIB_SEQ_LDFLAGS="${ADIOSREADLIB_SEQ_LDFLAGS} ${BLOSC_LDFLAGS}"
    ADIOSREADLIB_SEQ_LDADD="${ADIOSREADLIB_SEQ_LDADD} ${BLOSC_LIBS}"
fi
if test -z "${HAVE_ZFP_TRUE}"; then
    ADIOSLIB_LDFLAGS="${ADIOSLIB_LDFLAGS} ${ZFP_LDFLAGS}"
    ADIOSLIB_LDADD="${ADIOSLIB_LDADD} ${ZFP_LIBS}"
    ADIOSLIB_SEQ_LDFLAGS="${ADIOSLIB_SEQ_LDFLAGS} ${ZFP_LDFLAGS}"
    ADIOSLIB_SEQ_LDADD="${ADIOSLIB_SEQ_LDADD} ${ZFP_LIBS}"
    ADIOSLIB_INT_LDFLAGS="${ADIOSLIB_INT_LDFLAGS} ${ZFP_LDFLAGS}"
    ADIOSLIB_INT_LDADD="${ADIOSLIB_INT_LDADD} ${ZFP_LIBS}"
    ADIOSREADLIB_LDFLAGS="${ADIOSREADLIB_LDFLAGS} ${ZFP_LDFLAGS}"
    ADIOSREADLIB_LDADD="${ADIOSREADLIB_LDADD} ${ZFP_LIBS}"
    ADIOSREADLIB_SEQ_LDFLAGS="${ADIOSREADLIB_SEQ_LDFLAGS} ${ZFP_LDFLAGS}"
    ADIOSREADLIB_SEQ_LDADD="${ADIOSREADLIB_SEQ_LDADD} ${ZFP_LIBS}"
fi
if test -z "${HAVE_SZ_TRUE}"; then
    ADIOSLIB_CPPFLAGS="${ADIOSLIB_CPPFLAGS} ${SZ_CPPFLAGS}"
    ADIOSLIB_CFLAGS="${ADIOSLIB_CFLAGS} ${SZ_CFLAGS}"
    ADIOSLIB_LDFLAGS="${ADIOSLIB_LDFLAGS} ${SZ_LDFLAGS}"
    ADIOSLIB_LDADD="${ADIOSLIB_LDADD} ${SZ_LIBS}"
    ADIOSLIB_SEQ_CPPFLAGS="${ADIOSLIB_SEQ_CPPFLAGS} ${SZ_CPPFLAGS}"
    ADIOSLIB_SEQ_CFLAGS="${ADIOSLIB_SEQ_CFLAGS} ${SZ_CFLAGS}"
    ADIOSLIB_SEQ_LDFLAGS="${ADIOSLIB_SEQ_LDFLAGS} ${SZ_LDFLAGS}"
    ADIOSLIB_SEQ_LDADD="${ADIOSLIB_SEQ_LDADD} ${SZ_LIBS}"
    ADIOSLIB_INT_CPPFLAGS="${ADIOSLIB_INT_CPPFLAGS} ${SZ_CPPFLAGS}"
    ADIOSLIB_INT_CFLAGS="${ADIOSLIB_INT_CFLAGS} ${SZ_CFLAGS}"
    ADIOSLIB_INT_LDFLAGS="${ADIOSLIB_INT_LDFLAGS} ${SZ_LDFLAGS}"
    ADIOSLIB_INT_LDADD="${ADIOSLIB_INT_LDADD} ${SZ_LIBS}"
    ADIOSREADLIB_CPPFLAGS="${ADIOSREADLIB_CPPFLAGS} ${SZ_CPPFLAGS}"
    ADIOSREADLIB_CFLAGS="${ADIOSREADLIB_CFLAGS} ${SZ_CFLAGS}"
    ADIOSREADLIB_LDFLAGS="${ADIOSREADLIB_LDFLAGS} ${SZ_LDFLAGS}"
    ADIOSREADLIB_LDADD="${ADIOSREADLIB_LDADD} ${SZ_LIBS}"
    ADIOSREADLIB_SEQ_CPPFLAGS="${ADIOSREADLIB_SEQ_CPPFLAGS} ${SZ_CPPFLAGS}"
    ADIOSREADLIB_SEQ_CFLAGS="${ADIOSREADLIB_SEQ_CFLAGS} ${SZ_CFLAGS}"
    ADIOSREADLIB_SEQ_LDFLAGS="${ADIOSREADLIB_SEQ_LDFLAGS} ${SZ_LDFLAGS}"
    ADIOSREADLIB_SEQ_LDADD="${ADIOSREADLIB_SEQ_LDADD} ${SZ_LIBS}"
fi
if test -z "${HAVE_ZCHECKER_TRUE}"; then
    ADIOSLIB_CPPFLAGS="${ADIOSLIB_CPPFLAGS} ${ZCHECKER_CPPFLAGS}"
    ADIOSLIB_CFLAGS="${ADIOSLIB_CFLAGS} ${ZCHECKER_CFLAGS}"
    ADIOSLIB_LDFLAGS="${ADIOSLIB_LDFLAGS} ${ZCHECKER_LDFLAGS}"
    ADIOSLIB_LDADD="${ADIOSLIB_LDADD} ${ZCHECKER_LIBS}"
    ADIOSLIB_SEQ_CPPFLAGS="${ADIOSLIB_SEQ_CPPFLAGS} ${ZCHECKER_CPPFLAGS}"
    ADIOSLIB_SEQ_CFLAGS="${ADIOSLIB_SEQ_CFLAGS} ${ZCHECKER_CFLAGS}"
    ADIOSLIB_SEQ_LDFLAGS="${ADIOSLIB_SEQ_LDFLAGS} ${ZCHECKER_LDFLAGS}"
    ADIOSLIB_SEQ_LDADD="${ADIOSLIB_SEQ_LDADD} ${ZCHECKER_LIBS}"
    ADIOSLIB_INT_CPPFLAGS="${ADIOSLIB_INT_CPPFLAGS} ${ZCHECKER_CPPFLAGS}"
    ADIOSLIB_INT_CFLAGS="${ADIOSLIB_INT_CFLAGS} ${ZCHECKER_CFLAGS}"
    ADIOSLIB_INT_LDFLAGS="${ADIOSLIB_INT_LDFLAGS} ${ZCHECKER_LDFLAGS}"
    ADIOSLIB_INT_LDADD="${ADIOSLIB_INT_LDADD} ${ZCHECKER_LIBS}"
    ADIOSREADLIB_CPPFLAGS="${ADIOSREADLIB_CPPFLAGS} ${ZCHECKER_CPPFLAGS}"
    ADIOSREADLIB_CFLAGS="${ADIOSREADLIB_CFLAGS} ${ZCHECKER_CFLAGS}"
    ADIOSREADLIB_LDFLAGS="${ADIOSREADLIB_LDFLAGS} ${ZCHECKER_LDFLAGS}"
    ADIOSREADLIB_LDADD="${ADIOSREADLIB_LDADD} ${ZCHECKER_LIBS}"
    ADIOSREADLIB_SEQ_CPPFLAGS="${ADIOSREADLIB_SEQ_CPPFLAGS} ${ZCHECKER_CPPFLAGS}"
    ADIOSREADLIB_SEQ_CFLAGS="${ADIOSREADLIB_SEQ_CFLAGS} ${ZCHECKER_CFLAGS}"
    ADIOSREADLIB_SEQ_LDFLAGS="${ADIOSREADLIB_SEQ_LDFLAGS} ${ZCHECKER_LDFLAGS}"
    ADIOSREADLIB_SEQ_LDADD="${ADIOSREADLIB_SEQ_LDADD} ${ZCHECKER_LIBS}"
fi
if test -z "${HAVE_MGARD_TRUE}"; then
    ADIOSLIB_CPPFLAGS="${ADIOSLIB_CPPFLAGS} ${MGARD_CPPFLAGS}"
    ADIOSLIB_CFLAGS="${ADIOSLIB_CFLAGS} ${MGARD_CFLAGS}"
    ADIOSLIB_LDFLAGS="${ADIOSLIB_LDFLAGS} ${MGARD_LDFLAGS}"
    ADIOSLIB_LDADD="${ADIOSLIB_LDADD} ${MGARD_LIBS}"
    ADIOSLIB_SEQ_CPPFLAGS="${ADIOSLIB_SEQ_CPPFLAGS} ${MGARD_CPPFLAGS}"
    ADIOSLIB_SEQ_CFLAGS="${ADIOSLIB_SEQ_CFLAGS} ${MGARD_CFLAGS}"
    ADIOSLIB_SEQ_LDFLAGS="${ADIOSLIB_SEQ_LDFLAGS} ${MGARD_LDFLAGS}"
    ADIOSLIB_SEQ_LDADD="${ADIOSLIB_SEQ_LDADD} ${MGARD_LIBS}"
    ADIOSLIB_INT_CPPFLAGS="${ADIOSLIB_INT_CPPFLAGS} ${MGARD_CPPFLAGS}"
    ADIOSLIB_INT_CFLAGS="${ADIOSLIB_INT_CFLAGS} ${MGARD_CFLAGS}"
    ADIOSLIB_INT_LDFLAGS="${ADIOSLIB_INT_LDFLAGS} ${MGARD_LDFLAGS}"
    ADIOSLIB_INT_LDADD="${ADIOSLIB_INT_LDADD} ${MGARD_LIBS}"
    ADIOSREADLIB_CPPFLAGS="${ADIOSREADLIB_CPPFLAGS} ${MGARD_CPPFLAGS}"
    ADIOSREADLIB_CFLAGS="${ADIOSREADLIB_CFLAGS} ${MGARD_CFLAGS}"
    ADIOSREADLIB_LDFLAGS="${ADIOSREADLIB_LDFLAGS} ${MGARD_LDFLAGS}"
    ADIOSREADLIB_LDADD="${ADIOSREADLIB_LDADD} ${MGARD_LIBS}"
    ADIOSREADLIB_SEQ_CPPFLAGS="${ADIOSREADLIB_SEQ_CPPFLAGS} ${MGARD_CPPFLAGS}"
    ADIOSREADLIB_SEQ_CFLAGS="${ADIOSREADLIB_SEQ_CFLAGS} ${MGARD_CFLAGS}"
    ADIOSREADLIB_SEQ_LDFLAGS="${ADIOSREADLIB_SEQ_LDFLAGS} ${MGARD_LDFLAGS}"
    ADIOSREADLIB_SEQ_LDADD="${ADIOSREADLIB_SEQ_LDADD} ${MGARD_LIBS}"
fi
if test -z "${HAVE_ISOBAR_TRUE}"; then
    ADIOSLIB_CPPFLAGS="${ADIOSLIB_CPPFLAGS} -DISOBAR ${ISOBAR_CPPFLAGS}"
    ADIOSLIB_CFLAGS="${ADIOSLIB_CFLAGS} ${ISOBAR_CFLAGS}"
    ADIOSLIB_LDFLAGS="${ADIOSLIB_LDFLAGS} ${ISOBAR_LDFLAGS}"
    ADIOSLIB_LDADD="${ADIOSLIB_LDADD} ${ISOBAR_LIBS}"
    ADIOSLIB_SEQ_CPPFLAGS="${ADIOSLIB_SEQ_CPPFLAGS} -DISOBAR ${ISOBAR_CPPFLAGS}"
    ADIOSLIB_SEQ_CFLAGS="${ADIOSLIB_SEQ_CFLAGS} ${ISOBAR_CFLAGS}"
    ADIOSLIB_SEQ_LDFLAGS="${ADIOSLIB_SEQ_LDFLAGS} ${ISOBAR_LDFLAGS}"
    ADIOSLIB_SEQ_LDADD="${ADIOSLIB_SEQ_LDADD} ${ISOBAR_LIBS}"
    ADIOSLIB_INT_CPPFLAGS="${ADIOSLIB_INT_CPPFLAGS} -DISOBAR ${ISOBAR_CPPFLAGS}"
    ADIOSLIB_INT_CFLAGS="${ADIOSLIB_INT_CFLAGS} ${ISOBAR_CFLAGS}"
    ADIOSLIB_INT_LDFLAGS="${ADIOSLIB_INT_LDFLAGS} ${ISOBAR_LDFLAGS}"
    ADIOSLIB_INT_LDADD="${ADIOSLIB_INT_LDADD} ${ISOBAR_LIBS}"
    ADIOSREADLIB_CPPFLAGS="${ADIOSREADLIB_CPPFLAGS} -DISOBAR ${ISOBAR_CPPFLAGS}"
    ADIOSREADLIB_CFLAGS="${ADIOSREADLIB_CFLAGS} ${ISOBAR_CFLAGS}"
    ADIOSREADLIB_LDFLAGS="${ADIOSREADLIB_LDFLAGS} ${ISOBAR_LDFLAGS}"
    ADIOSREADLIB_LDADD="${ADIOSREADLIB_LDADD} ${ISOBAR_LIBS}"
    ADIOSREADLIB_SEQ_CPPFLAGS="${ADIOSREADLIB_SEQ_CPPFLAGS} -DISOBAR ${ISOBAR_CPPFLAGS}"
    ADIOSREADLIB_SEQ_CFLAGS="${ADIOSREADLIB_SEQ_CFLAGS} ${ISOBAR_CFLAGS}"
    ADIOSREADLIB_SEQ_LDFLAGS="${ADIOSREADLIB_SEQ_LDFLAGS} ${ISOBAR_LDFLAGS}"
    ADIOSREADLIB_SEQ_LDADD="${ADIOSREADLIB_SEQ_LDADD} ${ISOBAR_LIBS}"
fi






if test -z "${HAVE_APLOD_TRUE}"; then
    ADIOSLIB_CPPFLAGS="${ADIOSLIB_CPPFLAGS} -DAPLOD ${APLOD_CPPFLAGS}"
    ADIOSLIB_CFLAGS="${ADIOSLIB_CFLAGS} ${APLOD_CFLAGS}"
    ADIOSLIB_LDFLAGS="${ADIOSLIB_LDFLAGS} ${APLOD_LDFLAGS}"
    ADIOSLIB_LDADD="${ADIOSLIB_LDADD} ${APLOD_LIBS}"
    ADIOSLIB_SEQ_CPPFLAGS="${ADIOSLIB_SEQ_CPPFLAGS} -DAPLOD ${APLOD_CPPFLAGS}"
    ADIOSLIB_SEQ_CFLAGS="${ADIOSLIB_SEQ_CFLAGS} ${APLOD_CFLAGS}"
    ADIOSLIB_SEQ_LDFLAGS="${ADIOSLIB_SEQ_LDFLAGS} ${APLOD_LDFLAGS}"
    ADIOSLIB_SEQ_LDADD="${ADIOSLIB_SEQ_LDADD} ${APLOD_LIBS}"
    ADIOSLIB_INT_CPPFLAGS="${ADIOSLIB_INT_CPPFLAGS} -DAPLOD ${APLOD_CPPFLAGS}"
    ADIOSLIB_INT_CFLAGS="${ADIOSLIB_INT_CFLAGS} ${APLOD_CFLAGS}"
    ADIOSLIB_INT_LDFLAGS="${ADIOSLIB_INT_LDFLAGS} ${APLOD_LDFLAGS}"
    ADIOSLIB_INT_LDADD="${ADIOSLIB_INT_LDADD} ${APLOD_LIBS}"
    ADIOSREADLIB_CPPFLAGS="${ADIOSREADLIB_CPPFLAGS} -DAPLOD ${APLOD_CPPFLAGS}"
    ADIOSREADLIB_CFLAGS="${ADIOSREADLIB_CFLAGS} ${APLOD_CFLAGS}"
    ADIOSREADLIB_LDFLAGS="${ADIOSREADLIB_LDFLAGS} ${APLOD_LDFLAGS}"
    ADIOSREADLIB_LDADD="${ADIOSREADLIB_LDADD} ${APLOD_LIBS}"
    ADIOSREADLIB_SEQ_CPPFLAGS="${ADIOSREADLIB_SEQ_CPPFLAGS} -DAPLOD ${APLOD_CPPFLAGS}"
    ADIOSREADLIB_SEQ_CFLAGS="${ADIOSREADLIB_SEQ_CFLAGS} ${APLOD_CFLAGS}"
    ADIOSREADLIB_SEQ_LDFLAGS="${ADIOSREADLIB_SEQ_LDFLAGS} ${APLOD_LDFLAGS}"
    ADIOSREADLIB_SEQ_LDADD="${ADIOSREADLIB_SEQ_LDADD} ${APLOD_LIBS}"
fi
if test -z "${HAVE_ALACRITY_TRUE}"; then
    ADIOSLIB_CPPFLAGS="${ADIOSLIB_CPPFLAGS} -DALACRITY ${ALACRITY_CPPFLAGS}"
    ADIOSLIB_CFLAGS="${ADIOSLIB_CFLAGS} ${ALACRITY_CFLAGS}"
    ADIOSLIB_LDFLAGS="${ADIOSLIB_LDFLAGS} ${ALACRITY_LDFLAGS}"
    ADIOSLIB_LDADD="${ADIOSLIB_LDADD} ${ALACRITY_LIBS}"
    ADIOSLIB_SEQ_CPPFLAGS="${ADIOSLIB_SEQ_CPPFLAGS} -DALACRITY ${ALACRITY_CPPFLAGS}"
    ADIOSLIB_SEQ_CFLAGS="${ADIOSLIB_SEQ_CFLAGS} ${ALACRITY_CFLAGS}"
    ADIOSLIB_SEQ_LDFLAGS="${ADIOSLIB_SEQ_LDFLAGS} ${ALACRITY_LDFLAGS}"
    ADIOSLIB_SEQ_LDADD="${ADIOSLIB_SEQ_LDADD} ${ALACRITY_LIBS}"
    ADIOSLIB_INT_CPPFLAGS="${ADIOSLIB_INT_CPPFLAGS} -DALACRITY ${ALACRITY_CPPFLAGS}"
    ADIOSLIB_INT_CFLAGS="${ADIOSLIB_INT_CFLAGS} ${ALACRITY_CFLAGS}"
    ADIOSLIB_INT_LDFLAGS="${ADIOSLIB_INT_LDFLAGS} ${ALACRITY_LDFLAGS}"
    ADIOSLIB_INT_LDADD="${ADIOSLIB_INT_LDADD} ${ALACRITY_LIBS}"
    ADIOSREADLIB_CPPFLAGS="${ADIOSREADLIB_CPPFLAGS} -DALACRITY ${ALACRITY_CPPFLAGS}"
    ADIOSREADLIB_CFLAGS="${ADIOSREADLIB_CFLAGS} ${ALACRITY_CFLAGS}"
    ADIOSREADLIB_LDFLAGS="${ADIOSREADLIB_LDFLAGS} ${ALACRITY_LDFLAGS}"
    ADIOSREADLIB_LDADD="${ADIOSREADLIB_LDADD} ${ALACRITY_LIBS}"
    ADIOSREADLIB_SEQ_CPPFLAGS="${ADIOSREADLIB_SEQ_CPPFLAGS} -DALACRITY ${ALACRITY_CPPFLAGS}"
    ADIOSREADLIB_SEQ_CFLAGS="${ADIOSREADLIB_SEQ_CFLAGS} ${ALACRITY_CFLAGS}"
    ADIOSREADLIB_SEQ_LDFLAGS="${ADIOSREADLIB_SEQ_LDFLAGS} ${ALACRITY_LDFLAGS}"
    ADIOSREADLIB_SEQ_LDADD="${ADIOSREADLIB_SEQ_LDADD} ${ALACRITY_LIBS}"
fi

if test -z "${HAVE_FASTBIT_TRUE}"; then
    ADIOSLIB_CPPFLAGS="${ADIOSLIB_CPPFLAGS} -DFASTBIT ${FASTBIT_CPPFLAGS}"
    ADIOSLIB_CFLAGS="${ADIOSLIB_CFLAGS} ${FASTBIT_CFLAGS}"
    ADIOSLIB_LDFLAGS="${ADIOSLIB_LDFLAGS} ${FASTBIT_LDFLAGS}"
    ADIOSLIB_LDADD="${ADIOSLIB_LDADD} ${FASTBIT_LIBS}"
    ADIOSLIB_SEQ_CPPFLAGS="${ADIOSLIB_SEQ_CPPFLAGS} -DFASTBIT ${FASTBIT_CPPFLAGS}"
    ADIOSLIB_SEQ_CFLAGS="${ADIOSLIB_SEQ_CFLAGS} ${FASTBIT_CFLAGS}"
    ADIOSLIB_SEQ_LDFLAGS="${ADIOSLIB_SEQ_LDFLAGS} ${FASTBIT_LDFLAGS}"
    ADIOSLIB_SEQ_LDADD="${ADIOSLIB_SEQ_LDADD} ${FASTBIT_LIBS}"
    ADIOSLIB_INT_CPPFLAGS="${ADIOSLIB_INT_CPPFLAGS} -DFASTBIT ${FASTBIT_CPPFLAGS}"
    ADIOSLIB_INT_CFLAGS="${ADIOSLIB_INT_CFLAGS} ${FASTBIT_CFLAGS}"
    ADIOSLIB_INT_LDFLAGS="${ADIOSLIB_INT_LDFLAGS} ${FASTBIT_LDFLAGS}"
    ADIOSLIB_INT_LDADD="${ADIOSLIB_INT_LDADD} ${FASTBIT_LIBS}"
    ADIOSREADLIB_CPPFLAGS="${ADIOSREADLIB_CPPFLAGS} -DFASTBIT ${FASTBIT_CPPFLAGS}"
    ADIOSREADLIB_CFLAGS="${ADIOSREADLIB_CFLAGS} ${FASTBIT_CFLAGS}"
    ADIOSREADLIB_LDFLAGS="${ADIOSREADLIB_LDFLAGS} ${FASTBIT_LDFLAGS}"
    ADIOSREADLIB_LDADD="${ADIOSREADLIB_LDADD} ${FASTBIT_LIBS}"
    ADIOSREADLIB_SEQ_CPPFLAGS="${ADIOSREADLIB_SEQ_CPPFLAGS} -DFASTBIT ${FASTBIT_CPPFLAGS}"
    ADIOSREADLIB_SEQ_CFLAGS="${ADIOSREADLIB_SEQ_CFLAGS} ${FASTBIT_CFLAGS}"
    ADIOSREADLIB_SEQ_LDFLAGS="${ADIOSREADLIB_SEQ_LDFLAGS} ${FASTBIT_LDFLAGS}"
    ADIOSREADLIB_SEQ_LDADD="${ADIOSREADLIB_SEQ_LDADD} ${FASTBIT_LIBS}"
fi

AM_CONDITIONAL([HAVE_ICEE], [test -z "${HAVE_FLEXPATH_TRUE}"])
if test -z "${HAVE_FLEXPATH_TRUE}"; then
    AC_DEFINE(HAVE_ICEE, 1, [ICEE method is enabled])
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)
AC_SUBST(ADIOSLIB_EXTRA_LDFLAGS)

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

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

dnl Generate major/minor/micro version numbers
VERSION_MAJOR=[`echo ${VERSION} | sed -e "s/\..*//"`]
dnl AC_DEFINE_UNQUOTED(VERSION_MAJOR, ${VERSION_MAJOR}, [Major version number])
VERSION_MINOR=[`echo ${VERSION} | sed -e "s/[0-9]*\.\([0-9]*\).*/\1/"`]
dnl 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
dnl AC_DEFINE_UNQUOTED(VERSION_MICRO, ${VERSION_MICRO}, [Micro version number])
AC_SUBST(VERSION_MAJOR)
AC_SUBST(VERSION_MINOR)
AC_SUBST(VERSION_MICRO)

# 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
                 src/zfp/Makefile
                 src/mxml/Makefile
                 tests/Makefile
                 tests/test_src/Makefile
                 tests/C/Makefile
                 tests/C/flexpath_tests/Makefile
                 tests/C/flexpath_tests/1D_arr_global/Makefile
                 tests/C/flexpath_tests/1D_arr_global_noxml/Makefile
                 tests/C/flexpath_tests/global_range_select/Makefile
                 tests/C/flexpath_tests/maya_noxml/Makefile
                 tests/C/flexpath_tests/scalar/Makefile
                 tests/C/flexpath_tests/local_arrays/Makefile
                 tests/C/flexpath_tests/two_streams/Makefile
                 tests/C/fgr_tests/Makefile
                 tests/C/query/Makefile
                 tests/C/query/common/Makefile
                 tests/C/query/fastbit/Makefile
                 tests/C/query/alacrity/Makefile
                 tests/Fortran/Makefile
                 tests/genarray/Makefile
                 tests/bp_read/Makefile
                 tests/suite/Makefile
                 tests/suite/programs/Makefile
                 tests/suite/programs/examples/Makefile
                 tests/suite/programs/examples/attributes/Makefile
                 tests/suite/programs/examples/scalars/Makefile
                 tests/suite/programs/examples/local_array/Makefile
                 tests/suite/programs/examples/global_array/Makefile
                 tests/suite/programs/examples/global_array_time/Makefile
                 utils/Makefile
                 utils/skeldump/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/gpp/gpp.py
                 utils/bpdump/Makefile
                 utils/bp2h5/Makefile
                 utils/bp2ncd/Makefile
                 utils/bp2ascii/Makefile
                 utils/bpsplit/Makefile
                 utils/bpls/Makefile
                 utils/bpdiff/Makefile
                 utils/bp2bp/Makefile
                 utils/adios_list_methods/Makefile
                 utils/bpmeta/Makefile
                 utils/bprecover/Makefile
                 utils/fastbit/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/icee_arrays/Makefile
                 examples/C/icee_arrays/array/Makefile
                 examples/C/attributes/Makefile
                 examples/C/manual/Makefile
                 examples/C/global-array/Makefile
                 examples/C/global-array-time/Makefile
                 examples/C/joined-array/Makefile
                 examples/C/stat/Makefile
                 examples/C/read_all/Makefile
                 examples/C/schema/Makefile
                 examples/C/transforms/Makefile
                 examples/C/query/Makefile
                 examples/C/time_aggregation/Makefile
                 examples/Fortran/Makefile
                 examples/Fortran/scalars/Makefile
                 examples/Fortran/arrays/Makefile
                 examples/Fortran/global-array/Makefile
                 examples/Fortran/global-array-time/Makefile
                 examples/Fortran/schema/Makefile
                 adios_config.flags.makesrc
                 adios_config.makesrc
                 src/public/adios_version.h
                ])


AC_OUTPUT

chmod +x utils/gpp/gpp.py

echo
echo "*********************************"
echo $PACKAGE configured as follows:
echo "*********************************"
echo
if test -z "${BUILD_WRITE_TRUE}"; then
    echo "  - Build both the Write and Read libraries";
else
    echo "  - Build only the Read libraries";
fi
if test -z "${BUILD_FORTRAN_TRUE}"; then
    echo "  - Build both the C and Fortran libraries";
else
    echo "  - Build only the C libraries (no Fortran)";
fi
if test -z "${HAVE_MPI_TRUE}"; then
    echo "  - Build both the parallel and sequential libraries";
else
    echo "  - Build only the sequential libraries (no MPI)";
fi
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
if test -z "${HAVE_MPI_TRUE}"; then
    echo "      - MPICC   = $MPICC";
    echo "      - MPICXX  = $MPICXX";
    echo "      - MPIFC   = $MPIFC";
    echo "      - MPILIBS = $MPILIBS";
    echo
fi

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

else
    echo "  - No research transport methods";
fi

if test -z "${ADIOS_TIMERS_TRUE}"; then
    echo "  - ADIOS Timing Mechanism Enabled";
else
    echo "  - ADIOS Timing Mechanism Disabled";
fi
if test -z "${ADIOS_TIMER_EVENTS_TRUE}"; then
    echo "  - ADIOS Timing event recording Enabled";
else
    echo "  - ADIOS Timing event recording Disabled";
fi


if test -z "${BUILD_MXML_TRUE}" -a -z "${BUILD_WRITE_TRUE}"; then
    echo "  - MXML is built with ADIOS";
else
    if test -z "${HAVE_MXML_TRUE}"; then
        echo "  - MXML";
        echo "      - MXML_CPPFLAGS = $MXML_CPPFLAGS";
        echo "      - MXML_LDFLAGS = $MXML_LDFLAGS";
        echo "      - MXML_LIBS = $MXML_LIBS";
        echo
    else
        echo "  - No MXML"
    fi
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

if test -z "${HAVE_FGR_TRUE}"; then
        echo "  - FGR";
        echo "      - FGR_CFLAGS = $FGR_CFLAGS";
        echo "      - FGR_CPPFLAGS = $FGR_CPPFLAGS";
        echo "      - FGR_LDFLAGS = $FGR_LDFLAGS";
        echo "      - FGR_LIBS = $FGR_LIBS";
        echo
else
        echo "  - No FGR"
fi

if test -z "${HAVE_GLIB_TRUE}"; then
        echo "  - GLIB";
        echo "      - GLIB_CFLAGS = $GLIB_CFLAGS";
        echo "      - GLIB_CPPFLAGS = $GLIB_CPPFLAGS";
        echo "      - GLIB_LDFLAGS = $GLIB_LDFLAGS";
        echo "      - GLIB_LIBS = $GLIB_LIBS";
        echo
else
        echo "  - No GLIB"
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

elif test -z "${HAVE_PAMI_TRUE}"; then
    echo "    - IBM PAMI";
    echo "      - PAMI_CFLAGS = $PAMI_CFLAGS";
    echo "      - PAMI_CPPFLAGS = $PAMI_CPPFLAGS";
    echo "      - PAMI_LDFLAGS = $PAMI_LDFLAGS";
    echo "      - PAMI_LIBS = $PAMI_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

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

if test -z "${HAVE_ZLIB_TRUE}"; then
    echo "  - ZLIB";
    echo "      - ZLIB_CFLAGS = $ZLIB_CFLAGS";
    echo "      - ZLIB_CPPFLAGS = $ZLIB_CPPFLAGS";
    echo "      - ZLIB_LDFLAGS = $ZLIB_LDFLAGS";
    echo "      - ZLIB_LIBS = $ZLIB_LIBS";
    echo
else
    echo "  - No ZLIB to build ZLIB transform method"
fi

if test -z "${HAVE_BZIP2_TRUE}"; then
    echo "  - BZIP2";
    echo "      - BZIP2_CFLAGS = $BZIP2_CFLAGS";
    echo "      - BZIP2_CPPFLAGS = $BZIP2_CPPFLAGS";
    echo "      - BZIP2_LDFLAGS = $BZIP2_LDFLAGS";
    echo "      - BZIP2_LIBS = $BZIP2_LIBS";
    echo
else
    echo "  - No BZIP2 to build BZIP2 transform method"
fi

if test -z "${HAVE_SZIP_TRUE}"; then
    echo "  - SZIP";
    echo "      - SZIP_CFLAGS = $SZIP_CFLAGS";
    echo "      - SZIP_CPPFLAGS = $SZIP_CPPFLAGS";
    echo "      - SZIP_LDFLAGS = $SZIP_LDFLAGS";
    echo "      - SZIP_LIBS = $SZIP_LIBS";
    echo
else
    echo "  - No SZIP to build SZIP transform method"
fi

if test -z "${HAVE_LZ4_TRUE}"; then
    echo "  - LZ4";
    echo "      - LZ4_CFLAGS = $LZ4_CFLAGS";
    echo "      - LZ4_CPPFLAGS = $LZ4_CPPFLAGS";
    echo "      - LZ4_LDFLAGS = $LZ4_LDFLAGS";
    echo "      - LZ4_LIBS = $LZ4_LIBS";
    echo
else
    echo "  - No LZ4 to build LZ4 transform method"
fi

if test -z "${HAVE_BLOSC_TRUE}"; then
    echo "  - BLOSC";
    echo "      - BLOSC_CFLAGS = $BLOSC_CFLAGS";
    echo "      - BLOSC_CPPFLAGS = $BLOSC_CPPFLAGS";
    echo "      - BLOSC_LDFLAGS = $BLOSC_LDFLAGS";
    echo "      - BLOSC_LIBS = $BLOSC_LIBS";
    echo
else
    echo "  - No Blosc to build Blosc transform method"
fi

if test -z "${BUILD_ZFP_TRUE}"; then
    echo "  - ZFP is built with ADIOS";
elif test -z "${HAVE_ZFP_TRUE}"; then
    echo "  - ZFP";
    echo "      - ZFP_CPPFLAGS = $ZFP_CPPFLAGS";
    echo "      - ZFP_LDFLAGS = $ZFP_LDFLAGS";
    echo "      - ZFP_LIBS = $ZFP_LIBS";
    echo
else
    echo "  - No ZFP to build ZFP transform method"
fi

if test -z "${HAVE_SZ_TRUE}"; then
    echo "  - SZ";
    echo "      - SZ_CFLAGS = $SZ_CFLAGS";
    echo "      - SZ_CPPFLAGS = $SZ_CPPFLAGS";
    echo "      - SZ_LDFLAGS = $SZ_LDFLAGS";
    echo "      - SZ_LIBS = $SZ_LIBS";
    echo
else
    echo "  - No SZ to build SZ transform method"
fi

if test -z "${HAVE_ZCHECKER_TRUE}"; then
    echo "  - Z-Checker";
    echo "      - ZCHECKER_CFLAGS = $ZCHECKER_CFLAGS";
    echo "      - ZCHECKER_CPPFLAGS = $ZCHECKER_CPPFLAGS";
    echo "      - ZCHECKER_LDFLAGS = $ZCHECKER_LDFLAGS";
    echo "      - ZCHECKER_LIBS = $ZCHECKER_LIBS";
    echo
else
    echo "  - No Z-Checker to be used in SZ transform method"
fi

if test -z "${HAVE_MGARD_TRUE}"; then
    echo "  - MGARD";
    echo "      - MGARD_CFLAGS = $MGARD_CFLAGS";
    echo "      - MGARD_CPPFLAGS = $MGARD_CPPFLAGS";
    echo "      - MGARD_LDFLAGS = $MGARD_LDFLAGS";
    echo "      - MGARD_LIBS = $MGARD_LIBS";
    echo
else
    echo "  - No MGARD to build MGARD transform method"
fi

if test -z "${HAVE_ISOBAR_TRUE}"; then
    echo "  - ISOBAR";
    echo "      - ISOBAR_CFLAGS = $ISOBAR_CFLAGS";
    echo "      - ISOBAR_CPPFLAGS = $ISOBAR_CPPFLAGS";
    echo "      - ISOBAR_LDFLAGS = $ISOBAR_LDFLAGS";
    echo "      - ISOBAR_LIBS = $ISOBAR_LIBS";
    echo
else
    echo "  - No ISOBAR to build ISOBAR transform method"
fi

if test -z "${HAVE_APLOD_TRUE}"; then
    echo "  - APLOD";
    echo "      - APLOD_CFLAGS = $APLOD_CFLAGS";
    echo "      - APLOD_CPPFLAGS = $APLOD_CPPFLAGS";
    echo "      - APLOD_LDFLAGS = $APLOD_LDFLAGS";
    echo "      - APLOD_LIBS = $APLOD_LIBS";
    echo
else
    echo "  - No APLOD to build APLOD transform method"
fi

if test -z "${HAVE_FASTBIT_TRUE}"; then
    echo "  - FASTBIT";
    echo "      - FASTBIT_CFLAGS = $FASTBIT_CFLAGS";
    echo "      - FASTBIT_CPPFLAGS = $FASTBIT_CPPFLAGS";
    echo "      - FASTBIT_LDFLAGS = $FASTBIT_LDFLAGS";
    echo "      - FASTBIT_LIBS = $FASTBIT_LIBS";
    echo
else
    echo "  - No FASTBIT to build FASTBIT query method"
fi

if test -z "${HAVE_ALACRITY_TRUE}"; then
    echo "  - ALACRITY";
    echo "      - ALACRITY_CFLAGS = $ALACRITY_CFLAGS";
    echo "      - ALACRITY_CPPFLAGS = $ALACRITY_CPPFLAGS";
    echo "      - ALACRITY_LDFLAGS = $ALACRITY_LDFLAGS";
    echo "      - ALACRITY_LIBS = $ALACRITY_LIBS";
    echo
else
    echo "  - No ALACRITY to build ALACRITY transform & query methods"
fi

if test -z "${HAVE_BGQ_TRUE}"; then
    echo "  - BGQ METHOD is enabled";
else
    echo "  - BGQ METHOD is disabled"
fi

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