mirror of
https://github.com/Unidata/netcdf-c.git
synced 2024-12-09 08:11:38 +08:00
752 lines
18 KiB
Plaintext
752 lines
18 KiB
Plaintext
dnl $Id: acinclude.m4,v 1.34 2009/10/14 21:12:01 dmh Exp $
|
|
dnl UD macros for netcdf configure
|
|
|
|
|
|
dnl Convert a string to all uppercase.
|
|
dnl
|
|
define([uppercase],
|
|
[translit($1, abcdefghijklmnopqrstuvwxyz, ABCDEFGHIJKLMNOPQRSTUVWXYZ)])
|
|
|
|
dnl
|
|
dnl Check for an nm(1) utility.
|
|
dnl
|
|
AC_DEFUN([UD_PROG_NM],
|
|
[
|
|
case "${NM-unset}" in
|
|
unset) AC_CHECK_PROGS(NM, nm, nm) ;;
|
|
*) AC_CHECK_PROGS(NM, $NM nm, nm) ;;
|
|
esac
|
|
AC_MSG_CHECKING(nm flags)
|
|
case "${NMFLAGS-unset}" in
|
|
unset) NMFLAGS= ;;
|
|
esac
|
|
AC_MSG_RESULT($NMFLAGS)
|
|
AC_SUBST(NMFLAGS)
|
|
])
|
|
|
|
dnl
|
|
dnl Check for an m4(1) preprocessor utility.
|
|
dnl
|
|
AC_DEFUN([UD_PROG_M4],
|
|
[
|
|
case "${M4-unset}" in
|
|
unset) AC_CHECK_PROGS(M4, m4 gm4, m4) ;;
|
|
*) AC_CHECK_PROGS(M4, $M4 m4 gm4, m4) ;;
|
|
esac
|
|
AC_MSG_CHECKING(m4 flags)
|
|
case "${M4FLAGS-unset}" in
|
|
unset) M4FLAGS=-B10000 ;;
|
|
esac
|
|
AC_MSG_RESULT($M4FLAGS)
|
|
AC_SUBST(M4FLAGS)
|
|
])
|
|
|
|
dnl
|
|
dnl Set the top-level source-directory.
|
|
dnl
|
|
AC_DEFUN([UD_SRCDIR],
|
|
[
|
|
AC_MSG_CHECKING(for top-level source-directory)
|
|
SRCDIR=`(cd $srcdir && pwd)`
|
|
AC_MSG_RESULT($SRCDIR)
|
|
AC_SUBST(SRCDIR)
|
|
])
|
|
|
|
|
|
dnl
|
|
dnl like AC_LONG_DOUBLE, except checks for 'long long'
|
|
dnl
|
|
AC_DEFUN([UD_C_LONG_LONG],
|
|
[AC_MSG_CHECKING(for long long)
|
|
AC_CACHE_VAL(ac_cv_c_long_long,
|
|
[if test "$GCC" = yes; then
|
|
ac_cv_c_long_long=yes
|
|
else
|
|
AC_TRY_RUN([int main() {
|
|
long long foo = 0;
|
|
exit(sizeof(long long) < sizeof(long)); }],
|
|
ac_cv_c_long_long=yes, ac_cv_c_long_long=no, :)
|
|
fi])dnl
|
|
AC_MSG_RESULT($ac_cv_c_long_long)
|
|
if test "$ac_cv_c_long_long" = yes; then
|
|
AC_DEFINE([HAVE_LONG_LONG], [], [have long long type])
|
|
fi
|
|
])
|
|
|
|
dnl UD_CHECK_SIZEOF(TYPE)
|
|
AC_DEFUN([UD_CHECK_SIZEOF],
|
|
[changequote(<<, >>)dnl
|
|
dnl The name to #define.
|
|
define(<<AC_TYPE_NAME>>, translit(sizeof_$1, [a-z *], [A-Z_P]))dnl
|
|
dnl The cache variable name.
|
|
define(<<AC_CV_NAME>>, translit(ac_cv_sizeof_$1, [ *], [_p]))dnl
|
|
changequote([, ])dnl
|
|
AC_MSG_CHECKING(size of $1)
|
|
AC_CACHE_VAL(AC_CV_NAME,
|
|
[AC_TRY_RUN([#include <stdio.h>
|
|
#include <sys/types.h>
|
|
#if STDC_HEADERS
|
|
#include <stdlib.h>
|
|
#endif
|
|
main()
|
|
{
|
|
FILE *f=fopen("conftestval", "w");
|
|
if (!f) exit(1);
|
|
fprintf(f, "%d\n", sizeof($1));
|
|
exit(0);
|
|
}], AC_CV_NAME=`cat conftestval`, AC_CV_NAME=0, AC_CV_NAME=0)])dnl
|
|
AC_MSG_RESULT($AC_CV_NAME)
|
|
AC_DEFINE_UNQUOTED(AC_TYPE_NAME, $AC_CV_NAME, [type size])
|
|
undefine([AC_TYPE_NAME])dnl
|
|
undefine([AC_CV_NAME])dnl
|
|
])
|
|
|
|
|
|
dnl
|
|
dnl UD_CHECK_IEEE
|
|
dnl If the 'double' is not an IEEE double
|
|
dnl or the 'float' is not and IEEE single,
|
|
dnl define NO_IEEE_FLOAT
|
|
dnl
|
|
AC_DEFUN([UD_CHECK_IEEE],
|
|
[
|
|
AC_MSG_CHECKING(for IEEE floating point format)
|
|
AC_TRY_RUN([#ifndef NO_FLOAT_H
|
|
#include <float.h>
|
|
#endif
|
|
|
|
#define EXIT_NOTIEEE 1
|
|
#define EXIT_MAYBEIEEE 0
|
|
|
|
int
|
|
main()
|
|
{
|
|
#if defined(FLT_RADIX) && FLT_RADIX != 2
|
|
return EXIT_NOTIEEE;
|
|
#elif defined(DBL_MAX_EXP) && DBL_MAX_EXP != 1024
|
|
return EXIT_NOTIEEE;
|
|
#elif defined(DBL_MANT_DIG) && DBL_MANT_DIG != 53
|
|
return EXIT_NOTIEEE;
|
|
#elif defined(FLT_MAX_EXP) && !(FLT_MAX_EXP == 1024 || FLT_MAX_EXP == 128)
|
|
return EXIT_NOTIEEE;
|
|
#elif defined(FLT_MANT_DIG) && !(FLT_MANT_DIG == 53 || FLT_MANT_DIG == 24)
|
|
return EXIT_NOTIEEE;
|
|
#else
|
|
/* (assuming eight bit char) */
|
|
if(sizeof(double) != 8)
|
|
return EXIT_NOTIEEE;
|
|
if(!(sizeof(float) == 4 || sizeof(float) == 8))
|
|
return EXIT_NOTIEEE;
|
|
|
|
return EXIT_MAYBEIEEE;
|
|
#endif
|
|
}],ac_cv_c_ieeefloat=yes, ac_cv_c_ieeefloat=no, :)
|
|
AC_MSG_RESULT($ac_cv_c_ieeefloat)
|
|
if test "$ac_cv_c_ieeefloat" = no; then
|
|
AC_DEFINE([NO_IEEE_FLOAT], [], [no IEEE float on this platform])
|
|
fi
|
|
])
|
|
|
|
dnl Check for utility for generating makefile dependencies.
|
|
dnl Should only be used at the UPC.
|
|
dnl
|
|
AC_DEFUN([UD_PROG_CC_MAKEDEPEND],
|
|
[
|
|
AC_MSG_CHECKING(how to make dependencies)
|
|
case `uname -s` in
|
|
IRIX*|OSF1)
|
|
CC_MAKEDEPEND='cc -M'
|
|
;;
|
|
SunOS)
|
|
case `uname -r` in
|
|
4*)
|
|
CC_MAKEDEPEND='cc -M'
|
|
;;
|
|
5*|*)
|
|
CC_MAKEDEPEND='cc -xM'
|
|
;;
|
|
esac
|
|
;;
|
|
ULTRIX)
|
|
case `uname -m` in
|
|
RISC)
|
|
CC_MAKEDEPEND='cc -M'
|
|
;;
|
|
VAX) # Can't handle prototypes in netcdf.h
|
|
;;
|
|
esac
|
|
;;
|
|
AIX) # Writes to .u files rather than standard out
|
|
;;
|
|
HP-UX) # Writes escaped newlines to standard error
|
|
;;
|
|
esac
|
|
case "${CC_MAKEDEPEND}" in
|
|
'')
|
|
CC_MAKEDEPEND=false
|
|
;;
|
|
esac
|
|
AC_MSG_RESULT($CC_MAKEDEPEND)
|
|
AC_SUBST(CC_MAKEDEPEND)
|
|
])
|
|
|
|
dnl Check for a Fortran type equivalent to a netCDF type.
|
|
dnl
|
|
dnl UD_CHECK_FORTRAN_NCTYPE(forttype, possibs, nctype)
|
|
dnl
|
|
AC_DEFUN([UD_CHECK_FORTRAN_NCTYPE],
|
|
[
|
|
AC_MSG_CHECKING(for Fortran-equivalent to netCDF \"$3\")
|
|
for type in $2; do
|
|
cat >conftest.f <<EOF
|
|
$type foo
|
|
end
|
|
EOF
|
|
doit='$FC -c ${FFLAGS} conftest.f'
|
|
if AC_TRY_EVAL(doit); then
|
|
break;
|
|
fi
|
|
done
|
|
rm -f conftest.f conftest.o
|
|
AC_DEFINE_UNQUOTED($1, $type, [type definition])
|
|
AC_MSG_RESULT($type)
|
|
$1=$type
|
|
])
|
|
|
|
|
|
dnl Check for a Fortran type equivalent to a C type.
|
|
dnl
|
|
dnl UD_CHECK_FORTRAN_CTYPE(v3forttype, v2forttype, ctype, min, max)
|
|
dnl
|
|
AC_DEFUN([UD_CHECK_FORTRAN_CTYPE],
|
|
[
|
|
AC_MSG_CHECKING(for Fortran-equivalent to C \"$3\")
|
|
cat >conftest.f <<EOF
|
|
subroutine sub(values, minval, maxval)
|
|
implicit none
|
|
$2 values(5), minval, maxval
|
|
minval = values(2)
|
|
maxval = values(4)
|
|
if (values(2) .ge. values(4)) then
|
|
minval = values(4)
|
|
maxval = values(2)
|
|
endif
|
|
end
|
|
EOF
|
|
doit='$FC -c ${FFLAGS conftest.f'
|
|
if AC_TRY_EVAL(doit); then
|
|
mv conftest.o conftestf.o
|
|
cat >conftest.c <<EOF
|
|
#include <limits.h>
|
|
#include <float.h>
|
|
void main()
|
|
{
|
|
$3 values[[]] = {0, $4, 0, $5, 0};
|
|
$3 minval, maxval;
|
|
void $FCALLSCSUB($3*, $3*, $3*);
|
|
$FCALLSCSUB(values, &minval, &maxval);
|
|
exit(!(minval == $4 && maxval == $5));
|
|
}
|
|
EOF
|
|
doit='$CC -o conftest ${CPPFLAGS} ${CFLAGS} ${LDFLAGS} conftest.c conftestf.o ${LIBS}'
|
|
if AC_TRY_EVAL(doit); then
|
|
doit=./conftest
|
|
if AC_TRY_EVAL(doit); then
|
|
AC_MSG_RESULT($2)
|
|
$1=$2
|
|
AC_DEFINE_UNQUOTED($1,$2, [take a guess])
|
|
else
|
|
AC_MSG_RESULT(no equivalent type)
|
|
unset $1
|
|
fi
|
|
else
|
|
AC_MSG_ERROR(Could not compile-and-link conftest.c and conftestf.o)
|
|
fi
|
|
else
|
|
AC_MSG_ERROR(Could not compile conftest.f)
|
|
fi
|
|
rm -f conftest*
|
|
])
|
|
|
|
|
|
dnl Check for a Fortran data type.
|
|
dnl
|
|
dnl UD_CHECK_FORTRAN_TYPE(varname, ftypes)
|
|
dnl
|
|
AC_DEFUN([UD_CHECK_FORTRAN_TYPE],
|
|
[
|
|
for ftype in $2; do
|
|
AC_MSG_CHECKING(for Fortran \"$ftype\")
|
|
cat >conftest.f <<EOF
|
|
subroutine sub(value)
|
|
$ftype value
|
|
end
|
|
EOF
|
|
doit='$FC -c ${FFLAGS} conftest.f'
|
|
if AC_TRY_EVAL(doit); then
|
|
AC_MSG_RESULT(yes)
|
|
$1=$ftype
|
|
AC_DEFINE_UNQUOTED($1, $ftype, [type thing])
|
|
break
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
fi
|
|
done
|
|
rm -f conftest*
|
|
])
|
|
|
|
|
|
dnl Check for the name format of a Fortran-callable C routine.
|
|
dnl
|
|
dnl UD_CHECK_FCALLSCSUB
|
|
AC_DEFUN([UD_CHECK_FCALLSCSUB],
|
|
[
|
|
# AC_REQUIRE([UD_PROG_FC])
|
|
case "$FC" in
|
|
'') ;;
|
|
*)
|
|
AC_REQUIRE([UD_PROG_NM])
|
|
AC_BEFORE([UD_CHECK_FORTRAN_CTYPE])
|
|
AC_BEFORE([UD_CHECK_CTYPE_FORTRAN])
|
|
AC_MSG_CHECKING(for C-equivalent to Fortran routine \"SUB\")
|
|
cat >conftest.f <<\EOF
|
|
call sub()
|
|
end
|
|
EOF
|
|
doit='$FC -c ${FFLAGS} conftest.f'
|
|
if AC_TRY_EVAL(doit); then
|
|
FCALLSCSUB=`$NM $NMFLAGS conftest.o | awk '
|
|
/SUB_/{print "SUB_";exit}
|
|
/SUB/ {print "SUB"; exit}
|
|
/sub_/{print "sub_";exit}
|
|
/sub/ {print "sub"; exit}'`
|
|
case "$FCALLSCSUB" in
|
|
'') AC_MSG_ERROR(not found)
|
|
;;
|
|
*) AC_MSG_RESULT($FCALLSCSUB)
|
|
;;
|
|
esac
|
|
else
|
|
AC_MSG_ERROR(Could not compile conftest.f)
|
|
fi
|
|
rm -f conftest*
|
|
;;
|
|
esac
|
|
])
|
|
|
|
|
|
dnl Check for a C type equivalent to a Fortran type.
|
|
dnl
|
|
dnl UD_CHECK_CTYPE_FORTRAN(ftype, ctypes, fmacro_root)
|
|
dnl
|
|
AC_DEFUN([UD_CHECK_CTYPE_FORTRAN],
|
|
[
|
|
cat >conftestf.f <<EOF
|
|
$1 values(4)
|
|
data values /-1, -2, -3, -4/
|
|
call sub(values)
|
|
end
|
|
EOF
|
|
for ctype in $2; do
|
|
AC_MSG_CHECKING(if Fortran \"$1\" is C \"$ctype\")
|
|
cat >conftest.c <<EOF
|
|
void $FCALLSCSUB(values)
|
|
$ctype values[[4]];
|
|
{
|
|
exit(values[[1]] != -2 || values[[2]] != -3);
|
|
}
|
|
EOF
|
|
doit='$CC -c ${CPPFLAGS} ${CFLAGS} conftest.c'
|
|
if AC_TRY_EVAL(doit); then
|
|
doit='$FC ${FFLAGS} -c conftestf.f'
|
|
if AC_TRY_EVAL(doit); then
|
|
doit='$FC -o conftest ${FFLAGS} ${LDFLAGS} conftestf.o conftest.o ${FLIBS} ${LIBS}'
|
|
if AC_TRY_EVAL(doit); then
|
|
doit=./conftest
|
|
if AC_TRY_EVAL(doit); then
|
|
AC_MSG_RESULT(yes)
|
|
cname=`echo $ctype | tr ' abcdefghijklmnopqrstuvwxyz' \
|
|
_ABCDEFGHIJKLMNOPQRSTUVWXYZ`
|
|
AC_DEFINE_UNQUOTED(NF_$3[]_IS_C_$cname, [1], [fortran to c conversion])
|
|
break
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
fi
|
|
else
|
|
AC_MSG_ERROR(Could not link conftestf.o and conftest.o)
|
|
fi
|
|
else
|
|
AC_MSG_ERROR(Could not compile conftestf.f)
|
|
fi
|
|
else
|
|
AC_MSG_ERROR(Could not compile conftest.c)
|
|
fi
|
|
done
|
|
rm -f conftest*
|
|
])
|
|
|
|
|
|
dnl Get information about Fortran data types.
|
|
dnl
|
|
AC_DEFUN([UD_FORTRAN_TYPES],
|
|
[
|
|
# AC_REQUIRE([UD_PROG_FC])
|
|
case "$FC" in
|
|
'')
|
|
;;
|
|
*)
|
|
AC_REQUIRE([UD_CHECK_FCALLSCSUB])
|
|
dnl UD_CHECK_FORTRAN_TYPE(NF_INT1_T, byte integer*1 "integer(kind(1))")
|
|
dnl UD_CHECK_FORTRAN_TYPE(NF_INT2_T, integer*2 "integer(kind(2))")
|
|
UD_CHECK_FORTRAN_TYPE(NF_INT1_T, byte integer*1 "integer(kind=1)" "integer(selected_int_kind(2))")
|
|
UD_CHECK_FORTRAN_TYPE(NF_INT2_T, integer*2 "integer(kind=2)" "integer(selected_int_kind(4))")
|
|
|
|
case "${NF_INT1_T}" in
|
|
'') ;;
|
|
*) UD_CHECK_CTYPE_FORTRAN($NF_INT1_T, "signed char", INT1)
|
|
UD_CHECK_CTYPE_FORTRAN($NF_INT1_T, "short", INT1)
|
|
UD_CHECK_CTYPE_FORTRAN($NF_INT1_T, "int", INT1)
|
|
UD_CHECK_CTYPE_FORTRAN($NF_INT1_T, "long", INT1)
|
|
;;
|
|
esac
|
|
case "${NF_INT2_T}" in
|
|
'') ;;
|
|
*) UD_CHECK_CTYPE_FORTRAN($NF_INT2_T, short, INT2)
|
|
UD_CHECK_CTYPE_FORTRAN($NF_INT2_T, int, INT2)
|
|
UD_CHECK_CTYPE_FORTRAN($NF_INT2_T, long, INT2)
|
|
;;
|
|
esac
|
|
UD_CHECK_CTYPE_FORTRAN(integer, int long, INT)
|
|
UD_CHECK_CTYPE_FORTRAN(real, float double, REAL)
|
|
UD_CHECK_CTYPE_FORTRAN(doubleprecision, double float, DOUBLEPRECISION)
|
|
|
|
dnl UD_CHECK_FORTRAN_NCTYPE(NCBYTE_T, byte integer*1 integer, byte)
|
|
UD_CHECK_FORTRAN_NCTYPE(NCBYTE_T, byte integer*1 "integer(kind=1)" "integer(selected_int_kind(2))" integer, byte)
|
|
|
|
dnl UD_CHECK_FORTRAN_NCTYPE(NCSHORT_T, integer*2 integer, short)
|
|
UD_CHECK_FORTRAN_NCTYPE(NCSHORT_T, integer*2 "integer(kind=2)" "integer(selected_int_kind(4))" integer, short)
|
|
dnl UD_CHECK_FORTRAN_CTYPE(NF_SHORT_T, $NCSHORT_T, short, SHRT_MIN, SHRT_MAX)
|
|
|
|
dnl UD_CHECK_FORTRAN_NCTYPE(NCLONG_T, integer*4 integer, long)
|
|
dnl UD_CHECK_FORTRAN_CTYPE(NF_INT_T, integer, int, INT_MIN, INT_MAX)
|
|
|
|
dnl UD_CHECK_FORTRAN_NCTYPE(NCFLOAT_T, real*4 real, float)
|
|
dnl UD_CHECK_FORTRAN_CTYPE(NF_FLOAT_T, $NCFLOAT_T, float, FLT_MIN, FLT_MAX)
|
|
|
|
dnl UD_CHECK_FORTRAN_NCTYPE(NCDOUBLE_T, real*8 doubleprecision real, double)
|
|
dnl UD_CHECK_FORTRAN_CTYPE(NF_DOUBLE_T, $NCDOUBLE_T, double, DBL_MIN, DBL_MAX)
|
|
;;
|
|
esac
|
|
])
|
|
|
|
|
|
dnl Setup for making a manual-page database.
|
|
dnl
|
|
AC_DEFUN([UD_MAKEWHATIS],
|
|
[
|
|
#
|
|
# NB: We always want to define WHATIS to prevent the
|
|
# $(MANDIR)/$(WHATIS) make(1) target from being just $(MANDIR)/ and
|
|
# conflicting with the (directory creation) target with the same name.
|
|
#
|
|
WHATIS=whatis
|
|
case `uname -sr` in
|
|
BSD/OS*|FreeBSD*)
|
|
# Can't generate a user-database -- only /usr/share/man/whatis.db.
|
|
MAKEWHATIS_CMD=
|
|
;;
|
|
'IRIX64 6.5'|'IRIX 6.5')
|
|
MAKEWHATIS_CMD='/usr/lib/makewhatis -M $(MANDIR) $(MANDIR)/whatis'
|
|
;;
|
|
'IRIX 6'*)
|
|
# Can't generate a user-database.
|
|
MAKEWHATIS_CMD=
|
|
;;
|
|
HP-UX*)
|
|
# Can't generate a user-database -- only /usr/lib/whatis.
|
|
MAKEWHATIS_CMD=
|
|
;;
|
|
'Linux '*)
|
|
# /usr/sbin/makewhatis doesn't work
|
|
MAKEWHATIS_CMD=
|
|
;;
|
|
ULTRIX*)
|
|
# Can't generate a user-database -- only /usr/lib/whatis.
|
|
MAKEWHATIS_CMD=
|
|
;;
|
|
*)
|
|
if test -r /usr/man/windex; then
|
|
WHATIS=windex
|
|
fi
|
|
AC_CHECK_PROGS(prog, catman makewhatis /usr/lib/makewhatis)
|
|
case "$prog" in
|
|
*catman*)
|
|
MAKEWHATIS_CMD=$prog' -w -M $(MANDIR)'
|
|
;;
|
|
*makewhatis*)
|
|
MAKEWHATIS_CMD=$prog' $(MANDIR)'
|
|
;;
|
|
esac
|
|
;;
|
|
esac
|
|
AC_SUBST(WHATIS)
|
|
AC_SUBST(MAKEWHATIS_CMD)
|
|
AC_MSG_CHECKING(for manual-page index command)
|
|
AC_MSG_RESULT($MAKEWHATIS_CMD)
|
|
])
|
|
|
|
|
|
dnl Check for the math library.
|
|
dnl
|
|
AC_DEFUN([UD_CHECK_LIB_MATH],
|
|
[
|
|
case "${MATHLIB}" in
|
|
'')
|
|
AC_CHECK_LIB(c, tanh, MATHLIB=,
|
|
AC_CHECK_LIB(m, tanh, MATHLIB=-lm, MATHLIB=))
|
|
;;
|
|
*)
|
|
;;
|
|
esac
|
|
AC_SUBST(MATHLIB)
|
|
])
|
|
|
|
|
|
dnl Set the binary distribution directory.
|
|
dnl
|
|
AC_DEFUN([UD_FTPBINDIR], [dnl
|
|
AC_MSG_CHECKING([binary distribution directory])
|
|
case ${FTPBINDIR-unset} in
|
|
unset)
|
|
system=`(system) 2>/dev/null || echo dummy_system`
|
|
FTPBINDIR=${FTPDIR-/home/ftp}/pub/binary/$system
|
|
;;
|
|
esac
|
|
AC_SUBST(FTPBINDIR)dnl
|
|
AC_MSG_RESULT($FTPBINDIR)
|
|
])
|
|
|
|
|
|
dnl
|
|
dnl
|
|
dnl
|
|
|
|
dnl
|
|
dnl These headers won't get C style comments
|
|
dnl
|
|
dnl UD_CONFIG_HEADER(HEADER-TO-CREATE ...)
|
|
AC_DEFUN([UD_CONFIG_HEADER],
|
|
[define(UD_LIST_HEADER, $1)])
|
|
|
|
|
|
dnl
|
|
dnl Print which compilers are going to be used, the flags, and their
|
|
dnl locations. This is all to assist in debugging, and help with
|
|
dnl support questions.
|
|
dnl
|
|
AC_DEFUN([UD_DISPLAY_RESULTS],
|
|
[
|
|
AC_MSG_CHECKING(CPPFLAGS)
|
|
AC_MSG_RESULT($CPPFLAGS)
|
|
AC_MSG_CHECKING(CC CFLAGS)
|
|
AC_MSG_RESULT($CC $CFLAGS)
|
|
ud_type_cc=`type $CC`
|
|
AC_MSG_CHECKING(type $CC)
|
|
AC_MSG_RESULT($ud_type_cc)
|
|
|
|
AC_MSG_CHECKING(CXX)
|
|
if test -n "$CXX"; then
|
|
AC_MSG_RESULT($CXX)
|
|
AC_MSG_CHECKING(CXXFLAGS)
|
|
AC_MSG_RESULT($CXXFLAGS)
|
|
ud_type_CXX=`type $CXX`
|
|
AC_MSG_CHECKING(type $CXX)
|
|
AC_MSG_RESULT($ud_type_CXX)
|
|
else
|
|
AC_MSG_RESULT(unset)
|
|
fi
|
|
|
|
AC_MSG_CHECKING(FC)
|
|
if test -n "$FC"; then
|
|
AC_MSG_RESULT($FC)
|
|
AC_MSG_CHECKING(FFLAGS)
|
|
AC_MSG_RESULT($FFLAGS)
|
|
ud_type_fc=`type $FC`
|
|
AC_MSG_CHECKING(type $FC)
|
|
AC_MSG_RESULT($ud_type_fc)
|
|
else
|
|
AC_MSG_RESULT(unset)
|
|
fi
|
|
|
|
AC_MSG_CHECKING(F90)
|
|
if test -n "$F90"; then
|
|
AC_MSG_RESULT($F90)
|
|
AC_MSG_CHECKING(FCFLAGS)
|
|
AC_MSG_RESULT($FCFLAGS)
|
|
ud_type_F90=`type $F90`
|
|
AC_MSG_CHECKING(type $F90)
|
|
AC_MSG_RESULT($ud_type_F90)
|
|
else
|
|
AC_MSG_RESULT(unset)
|
|
fi
|
|
|
|
AC_MSG_CHECKING(AR)
|
|
if test -n "$AR"; then
|
|
AC_MSG_RESULT($AR)
|
|
AC_MSG_CHECKING(AR_FLAGS)
|
|
AC_MSG_RESULT($AR_FLAGS)
|
|
ud_type_AR=`type $AR`
|
|
AC_MSG_CHECKING(type $AR)
|
|
AC_MSG_RESULT($ud_type_AR)
|
|
else
|
|
AC_MSG_RESULT(unset)
|
|
fi
|
|
|
|
AC_MSG_CHECKING(NM)
|
|
if test -n "$NM"; then
|
|
AC_MSG_RESULT($NM)
|
|
AC_MSG_CHECKING(NMFLAGS)
|
|
AC_MSG_RESULT($NMFLAGS)
|
|
# ud_type_NM=`type $NM`
|
|
# AC_MSG_CHECKING(type $NM)
|
|
# AC_MSG_RESULT($ud_type_NM)
|
|
else
|
|
AC_MSG_RESULT(unset)
|
|
fi
|
|
|
|
])
|
|
|
|
# AC_PROG_FC_MOD
|
|
# ---------------
|
|
AC_DEFUN([AC_PROG_FC_UPPERCASE_MOD],
|
|
[
|
|
AC_LANG_PUSH(Fortran)
|
|
AC_MSG_CHECKING([if Fortran 90 compiler capitalizes .mod filenames])
|
|
cat <<EOF >conftest.f90
|
|
module conftest
|
|
end module conftest
|
|
EOF
|
|
ac_try='$F90 ${F90FLAGS} conftest.f90 ${F90LIBS}>&AS_MESSAGE_LOG_FD'
|
|
AC_TRY_EVAL(ac_try)
|
|
if test -f CONFTEST.mod ; then
|
|
ac_cv_prog_f90_uppercase_mod=yes
|
|
rm -f CONFTEST.mod
|
|
else
|
|
ac_cv_prog_f90_uppercase_mod=no
|
|
fi
|
|
AC_MSG_RESULT($ac_cv_prog_f90_uppercase_mod)
|
|
#rm -f conftest*
|
|
AC_LANG_POP(Fortran)
|
|
])
|
|
|
|
# [AC_LANG_CONFTEST([AC_LANG_SOURCE([ module conftest
|
|
# end module])])
|
|
# ac_try='$F90 -o conftest ${F90FLAGS} conftest.f90 ${F90LIBS}>&AS_MESSAGE_LOG_FD'
|
|
# if AC_TRY_EVAL(ac_try) &&
|
|
# test -f CONFTEST.mod ; then
|
|
# ac_cv_prog_f90_uppercase_mod=yes
|
|
# rm -f CONFTEST.mod
|
|
# else
|
|
# ac_cv_prog_f90_uppercase_mod=no
|
|
# fi
|
|
# rm -f conftest*
|
|
|
|
|
|
AC_DEFUN([AX_F90_MODULE_FLAG],[
|
|
AC_CACHE_CHECK([fortran 90 modules inclusion flag],
|
|
ax_cv_f90_modflag,
|
|
[AC_LANG_PUSH(Fortran)
|
|
i=0
|
|
while test \( -f tmpdir_$i \) -o \( -d tmpdir_$i \) ; do
|
|
i=`expr $i + 1`
|
|
done
|
|
mkdir tmpdir_$i
|
|
cd tmpdir_$i
|
|
AC_COMPILE_IFELSE([AC_LANG_SOURCE([module conftest_module
|
|
contains
|
|
subroutine conftest_routine
|
|
write(*,'(a)') 'gotcha!'
|
|
end subroutine conftest_routine
|
|
end module conftest_module])
|
|
],[],[])
|
|
cd ..
|
|
ax_cv_f90_modflag="not found"
|
|
for ax_flag in "-I" "-M" "-p"; do
|
|
if test "$ax_cv_f90_modflag" = "not found" ; then
|
|
ax_save_FCFLAGS="$FCFLAGS"
|
|
FCFLAGS="$ax_save_FCFLAGS ${ax_flag}tmpdir_$i"
|
|
AC_COMPILE_IFELSE([AC_LANG_SOURCE([program conftest_program
|
|
use conftest_module
|
|
call conftest_routine
|
|
end program conftest_program])
|
|
],[ax_cv_f90_modflag="$ax_flag"],[])
|
|
FCFLAGS="$ax_save_FCFLAGS"
|
|
fi
|
|
done
|
|
rm -fr tmpdir_$i
|
|
if test "$ax_flag" = "not found" ; then
|
|
AC_MSG_ERROR([unable to find compiler flag for modules inclusion])
|
|
fi
|
|
AC_LANG_POP(Fortran)
|
|
])])
|
|
|
|
# AX_C_FLOAT_WORDS_BIGENDIAN
|
|
# added by:
|
|
# Warren Turkal <wt@penguintechs.org>
|
|
#
|
|
# Copyright © 2006 Daniel Amelang <dan@amelang.net>
|
|
#
|
|
# Copying and distribution of this file, with or without modification, are
|
|
# permitted in any medium without royalty provided the copyright notice and
|
|
# this notice are preserved.
|
|
#
|
|
# This macro will detect if double variables are words packed in big endian
|
|
# order while the bits in the words are arranged in little endian order. This
|
|
# macro was added to support the ARM architecture. The FLOAT_WORDS_BIGENDIAN
|
|
# macro will be set to 1 if the word order is big endian. If the word order is
|
|
# not big endian, FLOAT_WORDS_BIGENDIAN will be not be set.
|
|
AC_DEFUN([AX_C_FLOAT_WORDS_BIGENDIAN],
|
|
[AC_CACHE_CHECK(whether float word ordering is bigendian,
|
|
ax_cv_c_float_words_bigendian, [
|
|
|
|
ax_cv_c_float_words_bigendian=unknown
|
|
AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
|
|
|
|
double d = 90904234967036810337470478905505011476211692735615632014797120844053488865816695273723469097858056257517020191247487429516932130503560650002327564517570778480236724525140520121371739201496540132640109977779420565776568942592.0;
|
|
|
|
]])], [
|
|
|
|
if grep noonsees conftest.$ac_objext >/dev/null ; then
|
|
ax_cv_c_float_words_bigendian=yes
|
|
fi
|
|
if grep seesnoon conftest.$ac_objext >/dev/null ; then
|
|
if test "$ax_cv_c_float_words_bigendian" = unknown; then
|
|
ax_cv_c_float_words_bigendian=no
|
|
else
|
|
ax_cv_c_float_words_bigendian=unknown
|
|
fi
|
|
fi
|
|
|
|
])])
|
|
|
|
case $ax_cv_c_float_words_bigendian in
|
|
yes)
|
|
m4_default([$1],
|
|
[AC_DEFINE([FLOAT_WORDS_BIGENDIAN], 1,
|
|
[Define to 1 if your system stores words within floats
|
|
with the most significant word first])]) ;;
|
|
no)
|
|
$2 ;;
|
|
*)
|
|
m4_default([$3],
|
|
[AC_MSG_ERROR([
|
|
|
|
Unknown float word ordering. You need to manually preset
|
|
ax_cv_c_float_words_bigendian=no (or yes) according to your system.
|
|
|
|
])]) ;;
|
|
esac
|
|
|
|
])# AX_C_FLOAT_WORDS_BIGENDIAN
|
|
|