changequote([, ])dnl
AC_CACHE_VAL(GRAS_CHECK_SIZEOF_RES,
[for ac_size in 4 8 1 2 16 $3 ; do # List sizes in rough order of prevalence.
- AC_TRY_COMPILE([#include "confdefs.h"
+ AC_COMPILE_IFELSE(AC_LANG_PROGRAM([#include "confdefs.h"
#include <sys/types.h>
$2
- ], [switch (0) case 0: case (sizeof ($1) == $ac_size):;], GRAS_CHECK_SIZEOF_RES=$ac_size)
+ ], [switch (0) case 0: case (sizeof ($1) == $ac_size):;]), GRAS_CHECK_SIZEOF_RES=$ac_size)
if test x$GRAS_CHECK_SIZEOF_RES != x ; then break; fi
done
])
AC_MSG_ERROR([cannot determine a size for $1])
fi
AC_MSG_RESULT($GRAS_CHECK_SIZEOF_RES)
-changequote(<<, >>)dnl
-dnl The name to #define.
-define(<<TYPE_NAME>>, translit(sizeof_$1, [a-z *()], [A-Z_P__]))dnl
-changequote([, ])dnl
-AC_DEFINE_UNQUOTED(TYPE_NAME, $GRAS_CHECK_SIZEOF_RES, [The number of bytes in type $1])
-undefine([TYPE_NAME])dnl
])
dnl
-dnl GRAS_TWO_COMPLIMENT: Make sure the type is two-compliment
+dnl GRAS_TWO_COMPLIMENT([type]): Make sure the type is two-compliment
+dnl warning, this does not work with char (quite logical)
dnl
AC_DEFUN([GRAS_TWO_COMPLIMENT],
[
-AC_TRY_COMPILE([#include "confdefs.h"
+AC_MSG_CHECKING(whether $1 is two-compliment)
+AC_RUN_IFELSE([AC_LANG_PROGRAM([[#include "confdefs.h"
union {
signed $1 testInt;
unsigned char bytes[sizeof($1)];
} intTester;
-],[
+]],[[
intTester.testInt = -2;
return ((unsigned int)intTester.bytes[0] +
- (unsigned int)intTester.bytes[sizeof($1) - 1]) != 509;
-],[],[AC_MSG_ERROR([GRAS works only two-compliment integers (yet)])])dnl end of AC_TRY_COMPILE
+ (unsigned int)intTester.bytes[sizeof($1) - 1]) - 509; /* should be 0 */
+]])], dnl end of AC LANG PROGRAM
+[two_compliment=yes],[two_compliment=no] )dnl end of AC COMPILE IFELSE
+
+AC_MSG_RESULT($two_compliment)
+if test x$two_compliment != xyes ; then
+ AC_MSG_ERROR([GRAS works only two-compliment integers (yet)])
+fi
])
dnl
AC_MSG_ERROR(['signed $1' and 'unsigned $1' have different sizes ! ($signed != $unsigned)])
fi
-dnl Make sure we don't run on a non-two-compliment arch, since we dunno
-dnl convert them
-GRAS_TWO_COMPLIMENT($1)
-
AC_MSG_RESULT($GRAS_CHECK_SIZEOF_RES)
-changequote(<<, >>)dnl
-dnl The name to #define.
-define(<<TYPE_NAME>>, translit(sizeof_$1, [a-z *()], [A-Z_P__]))dnl
-changequote([, ])dnl
-AC_DEFINE_UNQUOTED(TYPE_NAME, $GRAS_CHECK_SIZEOF_RES, [The number of bytes in type $1])
-undefine([TYPE_NAME])dnl
])
dnl
dnl
AC_DEFUN([CHECK_IEEE_FP],
[AC_MSG_CHECKING(if floating point datatypes are IEEE 754 compliant)
-AC_TRY_COMPILE([#include "confdefs.h"
+AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include "confdefs.h"
union {
double testFP;
unsigned char bytes[sizeof(double)];
float testFP;
unsigned char bytes[sizeof(float)];
} floatTester;
-],[
+]],[[
if (sizeof(double) != 8 || sizeof(float) != 4)
return 1;
(sizeof(float) == 4) ? 128 :
(sizeof(float) == 8) ? 16 :
(sizeof(float) == 16) ? 1 : 0;
-if (floatTester.testFP != -4.0) return 1;
-
-return 0;],[IEEE_FP=yes
-AC_DEFINE(IEEE_FP,1,[defines if this architecture floating point types are IEEE754 compliant])
-],[IEEE_FP=no
- AC_MSG_ERROR([GRAS works only for little or big endian systems (yet)])])dnl end of AC_TRY_COMPILE
+if (floatTester.testFP != -4.0) return 1;]])],[IEEE_FP=yes],[IEEE_FP=no])
AC_MSG_RESULT($IEEE_FP)
+
+if test x$IEEE_FP != xyes ; then
+ AC_MSG_ERROR([GRAS works only on IEEE754 compliant systems (yet)])
+else
+ AC_DEFINE(IEEE_FP,1,[defines if this architecture floating point types are IEEE754 compliant])
+fi
])dnl end of CHECK_IEEE_FP
[
# Check for the architecture
AC_C_BIGENDIAN(endian=1,endian=0,AC_MSG_ERROR([GRAS works only for little or big endian systems (yet)]))
+dnl Make sure we don't run on a non-two-compliment arch, since we dunno convert them
+GRAS_TWO_COMPLIMENT(int)
AC_DEFINE_UNQUOTED(GRAS_BIGENDIAN,$endian,[define if big endian])
GRAS_SIGNED_SIZEOF(char)
GRAS_CHECK_SIZEOF(float)
GRAS_CHECK_SIZEOF(double)
CHECK_IEEE_FP
-
+
AC_MSG_CHECKING(the GRAS signature of this architecture)
if test x$endian = x1 ; then
trace_endian=B
Please report this architecture trace ($trace) and what it corresponds to.])
fi
echo "$as_me:$LINENO: GRAS trace of this machine: $trace" >&AS_MESSAGE_LOG_FD
-AC_DEFINE_UNQUOTED(GRAS_THISARCH_NAME,"$gras_arch_name",[defines the GRAS architecture name of this machine])
AC_DEFINE_UNQUOTED(GRAS_THISARCH,$gras_arch,[defines the GRAS architecture signature of this machine])
AC_MSG_RESULT($gras_arch ($gras_arch_name))
])
# END OF GRAS ARCH CHECK
+
+AC_DEFUN([GRAS_CHECK_STRUCT_COMPACTION],
+[ AC_MSG_CHECKING(whether the struct gets packed)
+ AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include "confdefs.h"
+ #include <sys/types.h>
+ #include <stddef.h> /* offsetof() */
+ struct s {char c; double d;};
+ ]],[[switch (0)
+ case 0:
+ case (sizeof(struct s) == sizeof(double)+sizeof(char)):;
+ ]])],[gras_struct_packed=yes],[gras_struct_packed="no (good)"])
+
+ AC_MSG_RESULT($gras_struct_packed)
+ if test x$gras_struct_packed = xyes ; then
+ AC_MSG_ERROR([GRAS does not support packed structures since it leads to nasty misalignments])
+ fi
+
+ AC_MSG_CHECKING(whether the struct gets compacted)
+ AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include "confdefs.h"
+ #include <sys/types.h>
+ #include <stddef.h> /* offsetof() */
+ struct s {double d; int i; char c;};
+ ]],[[switch (0)
+ case 0:
+ case (offsetof(struct s,c) == sizeof(double)+sizeof(int)):;
+ ]])],[gras_struct_compact=yes],[gras_struct_compact=no])
+
+ AC_MSG_RESULT($gras_struct_compact)
+
+ if test x$gras_struct_compact = xyes ; then
+ AC_DEFINE_UNQUOTED(GRAS_STRUCT_COMPACT, 1,
+ [Defined if structures are compacted when possible.
+
+ Consider this structure: struct s {double d; int i; char c;};
+
+ If it is allowed, the char is placed just after the int. If not,
+ it has to be on the 8 bytes boundary imposed by the double.
+ ])
+ AC_MSG_CHECKING(whether arrays in struct can straddle struct alignment boundaries)
+
+ AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include "confdefs.h"
+ #include <sys/types.h>
+ #include <stddef.h> /* offsetof() */
+ struct s { double d; int i; char c[6]; };
+ ]],[[switch (0)
+ case 0:
+ case (offsetof(struct s,c) == sizeof(double)+sizeof(int)):;
+ ]])],[gras_array_straddle_struct=yes],[gras_array_straddle_struct=no])
+
+ AC_MSG_RESULT($gras_array_straddle_struct)
+
+ if test x$gras_array_straddle_struct = xyes ; then
+ AC_DEFINE_UNQUOTED(GRAS_ARRAY_STRADDLE_STRUCT, 1,
+ [Defined if arrays in struct can straddle struct alignment boundaries])
+ else
+ AC_MSG_ERROR([GRAS can only work on either architecture not compacting structures, or allowing array fields to straddle alignment boundaries (yet)])
+ fi
+ fi
+
+ AC_MSG_CHECKING(for changing alignment boundary structures)
+ AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include "confdefs.h"
+ #include <sys/types.h>
+
+ struct s {int i;double d;};
+ ]],[[switch (0)
+ case 0:
+ case (sizeof(struct s) == sizeof(double)+sizeof(int)):;
+ ]])],[gras_struct_changing=yes],[gras_struct_changing=no])
+
+ AC_MSG_RESULT($gras_struct_changing)
+
+ if test x$gras_struct_changing = xyes ; then
+ AC_DEFINE_UNQUOTED(GRAS_STRUCT_CHANGING, 1,
+ [Defined if the alignment of structures can vary over fields.
+
+ Consider the following structure:
+ struct s {
+ int i;
+ double d;
+ };
+
+ On Solaris, sizeof(struct s)=16, ie all fields get aligned to the
+ biggest boundary (and this will not be defined). On Linux,
+ sizeof(struct s)=12 (and this will be defined).
+ ])
+ fi
+])
+# END OF GRAS CHECK STRUCT COMPACTION
+
+AC_DEFUN([GRAS_C_COMPACT_STRUCT],
+[ AC_MSG_CHECKING(whether the struct gets compacted)
+ AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include "confdefs.h"
+ #include <sys/types.h>
+ #include <stddef.h> /* offsetof() */
+ struct s {double d; int a; int b;};
+ ]],[[switch (0)
+ case 0:
+ case (offsetof(struct s,b) == sizeof(double)+sizeof(int)):;
+ ]])],[gras_compact_struct=yes],[gras_compact_struct=no])
+
+ AC_MSG_RESULT($gras_compact_struct)
+
+ if test x$gras_compact_struct = xyes ; then
+ AC_DEFINE_UNQUOTED(GRAS_COMPACT_STRUCT, 1,
+ [Defined if structures are compacted when possible])
+ fi
+])
+# END OF GRAS COMPACT STRUCT
