2010-06-03 21:37:03 +08:00
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
2010-11-30 06:23:16 +08:00
AC_COMPILE_IFELSE([AC_LANG_SOURCE([module conftest_module
2010-06-03 21:37:03 +08:00
contains
subroutine conftest_routine
write(*,'(a)') 'gotcha!'
end subroutine conftest_routine
2010-11-30 06:23:16 +08:00
end module conftest_module])
2010-06-03 21:37:03 +08:00
],[],[])
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"
2010-11-30 06:23:16 +08:00
AC_COMPILE_IFELSE([AC_LANG_SOURCE([program conftest_program
2010-06-03 21:37:03 +08:00
use conftest_module
call conftest_routine
2010-11-30 06:23:16 +08:00
end program conftest_program])
2010-06-03 21:37:03 +08:00
],[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
