hdf5_ep

AC_SUBST([CPPFLAGS])

​

dnl H5_CFLAGS (and company) are for CFLAGS that should be used on HDF5, but

dnl not exported to h5cc (or h5fc, etc.)

AC_SUBST([H5_CFLAGS])

AC_SUBST([H5_CPPFLAGS])

AC_SUBST([H5_FCFLAGS])

AC_SUBST([H5_CXXFLAGS])

​

dnl Make sure flags are set to something (otherwise macros may set them later).

CFLAGS="${CFLAGS}"

CXXFLAGS="${CXXFLAGS}"

FCFLAGS="${FCFLAGS}"

​

dnl Different compilers may need default libraries. They are specified in

dnl the config/* files, so we put this statement here so that it'll be

dnl set by the code which follows...

dnl

DEFAULT_LIBS=""

​

dnl Support F9X variable to define Fortran compiler if FC variable is

dnl not used.  This should be deprecated in the future.

if test "x" = "x$FC"; then

  AC_SUBST([HSIZE_T])

  AC_SUBST([HSSIZE_T])

  AC_SUBST([HID_T])

  AC_SUBST([SIZE_T])

  AC_SUBST([OBJECT_NAMELEN_DEFAULT_F])

​

  dnl --------------------------------------------------------------------

  dnl General Fortran flags

  dnl

​

  dnl --------------------------------------------------------------------

  dnl Fortran source extention

  dnl

  AC_FC_SRCEXT([f90])

​

  AC_SUBST([F9XSUFFIXFLAG])

  AC_SUBST([FSEARCH_DIRS])

​

  dnl --------------------------------------------------------------------

​

  dnl --------------------------------------------------------------------

  dnl Define wrappers for the C compiler to use Fortran function names

  dnl

  AC_FC_WRAPPERS

​

  dnl --------------------------------------------------------------------

  dnl See if the compiler will support the "-I." option

  dnl

​

dnl  AC_MSG_CHECKING(if compiler supports -I. option)

dnl  AC_TRY_FCOMPILE([

dnl      program conftest

dnl      end

dnl  ], AC_MSG_RESULT(yes),

dnl     AC_MSG_RESULT(no)

​

dnl --------------------------------------------------------------------

dnl See if the fortran compiler supports the intrinsic function "SIZEOF"

​

  AC_MSG_CHECKING([if Fortran compiler supports intrinsic SIZEOF])

  AC_TRY_RUN([ 

   PROGRAM main

     i = sizeof(x)

   END PROGRAM

  ], [AC_MSG_RESULT(yes)

  AC_MSG_CHECKING([if $CXX needs old style header files in includes])

  AC_TRY_RUN([

#include <iostream>

​

int main(void) { return 0; }

  ], [

    echo no

  ], [

    echo yes

  ])

​

  AC_MSG_CHECKING([if $CXX can handle namespaces])

  AC_TRY_RUN([

namespace H5 {

int fnord;

}

​

int main(void) {

   using namespace H5;

   fnord = 37;

   return 0;

} 

  ], [

     echo yes

  ], [

     echo no

  ])

​

  AC_MSG_CHECKING([if $CXX supports std])

  AC_TRY_RUN([

#include <string>

​

using namespace std;

​

int main(void) {

   string myString("testing namespace std");

   return 0;

}

  ], [

     echo yes

  ], [

     echo no

  ])

​

  AC_MSG_CHECKING([if $CXX supports bool types])

  AC_TRY_RUN([

int main(void) {

   bool flag;

   return 0;

}

  ], [

     echo yes

  ], [

     echo no

  ])

​

  AC_MSG_CHECKING([if $CXX has offsetof extension])

    AC_TRY_COMPILE([

  #include <stdio.h>

  #include <stddef.h>

    ],[

    struct index_st

    {

      unsigned char type;

   int test_int;

   test_float = 37.0;

   test_int = static_cast <int> (test_float);

   return 0;

}

  ], [

    echo yes

  ], [

    echo no

  ])

else

  echo "no"

  CXX="no"

fi

​

dnl Change back to the C language

AC_LANG_POP(C++)

​

dnl ----------------------------------------------------------------------

  if (${FC} -V 2>&1 | grep '^pgf90') > /dev/null; then

    H5_FORTRAN_SHARED="no"

  fi

​

  if (${FC} -V 2>&1 | grep '^Intel(R) Fortran') > /dev/null; then

    if (${FC} -v 2>&1 | grep '^Version 8.') > /dev/null; then

      H5_FORTRAN_SHARED="no"

    else

dnl echo 'adding fortran compiler flag needed for building shared libraries'

    fi

  fi

  if (${FC} +version 2>&1 | grep '^HP F90') > /dev/null; then

    H5_FORTRAN_SHARED="no"

  fi

​

  if (${FC} -V 2>&1 | grep '^Absoft') > /dev/null; then

    H5_FORTRAN_SHARED="no"

  fi

​

        if test ${MAJOR_VER} -gt 2 -o ${MAJOR_VER} -eq 2 -a ${MINOR_VER} -ge 4; then

          LINUX_LFS="yes"

        fi

        ;;

    esac

​

    AC_MSG_CHECKING([for large file support mode on Linux])

    if test "X$LINUX_LFS" = "Xyes"; then

      AC_MSG_RESULT([enabled])

    else

      AC_MSG_RESULT([disabled])

    fi

​

    dnl Add POSIX support on Linux systems, so <features.h> defines

    dnl __USE_POSIX, which is required to get the prototype for fdopen

    dnl defined correctly in <stdio.h>

​

    dnl Also add BSD support on Linux systems, so <features.h> defines

    dnl __USE_BSD, which is required to get the prototype for strdup

    dnl defined correctly in <string.h> and snprintf & vsnprintf defined

    dnl correctly in <stdio.h>

    ;;

esac

​

AC_TRY_COMPILE([#include <sys/types.h>],

               [off64_t n = 0;],

               [AC_CHECK_FUNCS([lseek64 fseek64 ftruncate64])],

               [AC_MSG_RESULT([skipping test for lseek64(), fseek64(), ftruncate64()])])

AC_CHECK_FUNCS(fseeko ftello)

AC_TRY_COMPILE([

#include <sys/types.h>

#include <sys/stat.h>],

[struct stat64 sb;],

[AC_CHECK_FUNCS([stat64 fstat64])],

    fi

​

    saved_CPPFLAGS="$CPPFLAGS"

    saved_LDFLAGS="$LDFLAGS"

​

    if test -n "$dmalloc_inc"; then

      CPPFLAGS="$CPPFLAGS -I$dmalloc_inc"

    fi

​

​

    if test -n "$dmalloc_lib"; then

      LDFLAGS="$LDFLAGS -L$dmalloc_lib"

    fi

​

    AC_CHECK_LIB(dmalloc, dmalloc_shutdown,, LDFLAGS="$saved_LDFLAGS"; unset HAVE_DMALLOC)

​

    if test -z "$HAVE_DMALLOC" -a -n "$HDF5_CONFIG_ABORT"; then

      AC_MSG_ERROR(couldn't find dmalloc library)

    fi

    ;;

esac

​

dnl ----------------------------------------------------------------------

dnl Is the GNU zlib present? It has a header file `zlib.h' and a library

dnl `-lz' and their locations might be specified with the `--with-zlib'

dnl command-line switch. The value is an include path and/or a library path.

​

    saved_CPPFLAGS="$CPPFLAGS"

    saved_LDFLAGS="$LDFLAGS"

​

    if test -n "$zlib_inc"; then

      CPPFLAGS="$CPPFLAGS -I$zlib_inc"

    fi

​

    AC_CHECK_HEADERS([zlib.h],

                     [CPPFLAGS="$saved_CPPFLAGS"])

​

    if test -n "$zlib_lib"; then

      LDFLAGS="$LDFLAGS -L$zlib_lib"

    fi

​

    AC_CHECK_LIB([z], [compress2],,

                 [LDFLAGS="$saved_LDFLAGS"; unset HAVE_ZLIB])

    AC_CHECK_FUNC([compress2], [HAVE_COMPRESS2="yes"])

​

    if test -z "$HAVE_ZLIB" -a -n "$HDF5_CONFIG_ABORT"; then

      AC_MSG_ERROR([couldn't find zlib library])

    fi

    ;;

esac

​

if test "x$HAVE_ZLIB" = "xyes" -a "x$HAVE_ZLIB_H" = "xyes" -a "x$HAVE_COMPRESS2" = "xyes"; then

    AC_DEFINE([HAVE_FILTER_DEFLATE], [1], [Define if support for deflate (zlib) filter is enabled])

    USE_FILTER_DEFLATE="yes"

​

    saved_CPPFLAGS="$CPPFLAGS"

    saved_LDFLAGS="$LDFLAGS"

    if test -n "$szlib_inc"; then

      CPPFLAGS="$CPPFLAGS -I$szlib_inc"

    fi

    AC_CHECK_HEADERS([szlib.h],

                     [CPPFLAGS="$saved_CPPFLAGS"])

    if test -n "$szlib_lib"; then

      LDFLAGS="$LDFLAGS -L$szlib_lib"

    fi

    AC_CHECK_LIB([sz], [SZ_BufftoBuffCompress],,

                 [LDFLAGS="$saved_LDFLAGS"; unset HAVE_SZLIB])

    if test -z "$HAVE_SZLIB" -a -n "$HDF5_CONFIG_ABORT"; then

      AC_MSG_ERROR([couldn't find szlib library])

    fi

    ;;

esac

​

if test "x$HAVE_SZLIB" = "xyes" -a "x$HAVE_SZLIB_H" = "xyes"; then

    dnl SZLIB library is available.  Check if it can encode

    AC_MSG_CHECKING([for szlib encoder])

​

      pthread_inc=""

    fi

    if test "X$pthread_lib" = "X/usr/lib"; then

      pthread_lib=""

    fi

​

    if test -n "$pthread_inc"; then

      saved_CPPFLAGS="$CPPFLAGS"

      CPPFLAGS="$CPPFLAGS -I$pthread_inc"

    else

      AC_CHECK_HEADERS([pthread.h],, [unset PTHREAD])

    fi

​

    if test -n "$pthread_lib"; then

      saved_LDFLAGS="$LDFLAGS"

      LDFLAGS="$LDFLAGS -L$pthread_lib"

      AC_CHECK_LIB([pthread], [pthread_create],,

                   [LDFLAGS="$saved_LDFLAGS"; unset PTHREAD])

    else

      AC_CHECK_LIB([pthread], [pthread_create],, [unset PTHREAD])

    fi

    ;;

esac

​

dnl ----------------------------------------------------------------------

dnl Enable thread-safe version of library.  It requires Pthreads support.

dnl

AC_MSG_CHECKING([for thread safe support])

dnl Try to figure out how to print `long long'.  Some machines use `%lld'

dnl and others use `%qd'.  There may be more!  The final `l' is a

dnl default in case none of the others work.

dnl Need to patch up LD_LIBRARY_PATH so that the execution can find all

dnl the dynamic library.  The correct way to do it should be updating

dnl LD_LIBRARY_PATH along with LDFLAGS or do it with the AC_TRY_RUN macro.

dnl

AC_MSG_CHECKING([how to print long long])

AC_CACHE_VAL([hdf5_cv_printf_ll],

export LD_LIBRARY_PATH

​

for hdf5_cv_printf_ll in l ll L q unknown; do

   AC_TRY_RUN([

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

​

int main(void)

{

        mpe_inc=""

      fi

      if test "X$mpe_lib" = "X/usr/lib"; then

        mpe_lib=""

      fi

      if test -n "$mpe_inc"; then

        saved_CPPFLAGS="$CPPFLAGS"

        CPPFLAGS="$CPPFLAGS -I$mpe_inc"

      else

        AC_CHECK_HEADERS([mpe.h],, [unset MPE])

      fi

      if test -n "$mpe_lib"; then

        saved_LDFLAGS="$LDFLAGS"

        LDFLAGS="$LDFLAGS -L$mpe_lib"

        AC_CHECK_LIB([mpe], [MPE_Init_log],,

                     [LDFLAGS="$saved_LDFLAGS"; unset MPE])

        AC_CHECK_LIB([lmpe], [CLOG_Init],,

                     [LDFLAGS="$saved_LDFLAGS"; unset MPE])

      else

        AC_CHECK_LIB([mpe], [MPE_Init_log],, [unset MPE])

        AC_CHECK_LIB([lmpe], [CLOG_Init],, [unset MPE])

      fi

      ;;

  esac

​

  if test "X-$MPE" = "X-yes"; then

    AC_DEFINE([HAVE_MPE], [1], [Define if we have MPE support])

  fi

LIBS="$DEFAULT_LIBS $LIBS"

​

dnl ----------------------------------------------------------------------

dnl Determine the runtime libraries we may need to include in the

dnl libtools command so that executables will find the correct dynamic

dnl libraries.

dnl 

AC_SUBST([DYNAMIC_DIRS]) DYNAMIC_DIRS=""

​

    case "$d" in

      -L*)

        d="`echo $d | sed -e 's/-L//g'`"

        case "$d" in

          .*)

            dnl If the path isn't absolute, make it so by

            dnl prepending the ROOT directory to it.

            d=${ROOT}/$d

            ;;

        esac

        DYNAMIC_DIRS="-R${d} $DYNAMIC_DIRS"

        ;;

    esac

  done

fi

​

  TEMP_CPPFLAGS=""

    case "$d" in

      -I.*)

        dnl If the path isn't absolute, make it so by prepending

        dnl the ROOT directory to it.

        d="`echo $d | sed -e 's/-I//g'`"

        d="-I${ROOT}/${d}"

        ;;

    esac

    TEMP_CPPFLAGS="$d $TEMP_CPPFLAGS"

  done

fi

​

dnl ----------------------------------------------------------------------

dnl Check if they would like the High Level library  compiled

dnl

​

AC_SUBST(HL) HL=""

# name of fortran folder inside "hl", if FORTRAN compile is requested

AC_SUBST(HL_FOR) HL_FOR=""

AC_MSG_CHECKING([if high level library is enabled])

    ], [

    AC_DEFINE([NO_ALIGNMENT_RESTRICTIONS], [1], [Define if we can violate pointer alignment restrictions])

    AC_MSG_RESULT([no])

    ], [

    AC_MSG_RESULT([yes])

    ], [

    AC_MSG_RESULT([unknown, assuming yes])

    ])

​

dnl ----------------------------------------------------------------------

dnl Create automake conditionals to tell automake makefiles which directories

dnl need to be compiled

​

AM_CONDITIONAL([BUILD_CXX_CONDITIONAL], [test "X$HDF_CXX" = "Xyes"])

AM_CONDITIONAL([BUILD_PARALLEL_CONDITIONAL], [test -n "$TESTPARALLEL"])

AM_CONDITIONAL([BUILD_FORTRAN_CONDITIONAL], [test "X$HDF_FORTRAN" = "Xyes"])

AM_CONDITIONAL([BUILD_HDF5_HL_CONDITIONAL], [test "X$HDF5_HL" = "Xyes"])

​

​