From: Paul Eggert Date: Thu, 12 Apr 2007 00:12:06 +0000 (+0000) Subject: * doc/autoconf.texi (Generic Types): Document the restrictions X-Git-Tag: v2.62~332 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=fb82e1a12232ccbd6fa3ef10bdc04bd3e1e72e16;p=thirdparty%2Fautoconf.git * doc/autoconf.texi (Generic Types): Document the restrictions on types imposed by AC_CHECK_TYPE, AC_CHECK_TYPES. (Generic Compiler Characteristics): AC_CHECK_SIZEOF now works with objects too. Document the restrictions on its use. Document the restrictions on AC_CHECK_ALIGNOF's type argument. * lib/autoconf/types.m4 (_AC_CHECK_TYPE_NEW): For C, just try sizeof (TYPE) and sizeof ((TYPE)); if the former works but the latter doesn't, then it's a valid type. This lets people use function types and so forth. For C++ there doesn't seem to be a simple solution, so leave it alone. (AC_CHECK_SIZEOF): Allow argument to be a variable. (AC_CHECK_SIZEOF, AC_CHECK_ALIGNOF): Don't bother to invoke AC_CHECK_TYPE; that wasn't documented or necessary. --- diff --git a/ChangeLog b/ChangeLog index c7bb9aa3..b02ba72f 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,19 @@ +2007-04-11 Paul Eggert + + * doc/autoconf.texi (Generic Types): Document the restrictions + on types imposed by AC_CHECK_TYPE, AC_CHECK_TYPES. + (Generic Compiler Characteristics): AC_CHECK_SIZEOF now works + with objects too. Document the restrictions on its use. + Document the restrictions on AC_CHECK_ALIGNOF's type argument. + * lib/autoconf/types.m4 (_AC_CHECK_TYPE_NEW): + For C, just try sizeof (TYPE) and sizeof ((TYPE)); if the former + works but the latter doesn't, then it's a valid type. + This lets people use function types and so forth. + For C++ there doesn't seem to be a simple solution, so leave it alone. + (AC_CHECK_SIZEOF): Allow argument to be a variable. + (AC_CHECK_SIZEOF, AC_CHECK_ALIGNOF): Don't bother to invoke + AC_CHECK_TYPE; that wasn't documented or necessary. + 2007-04-11 Stepan Kasal * lib/autoconf/general.m4 (_AC_LINK_IFELSE): Skip AS_TEST_X diff --git a/doc/autoconf.texi b/doc/autoconf.texi index a23d885b..af6b5e9f 100644 --- a/doc/autoconf.texi +++ b/doc/autoconf.texi @@ -6119,13 +6119,22 @@ test macros. @acindex{CHECK_TYPE} Check whether @var{type} is defined. It may be a compiler builtin type or defined by the @var{includes} (@pxref{Default Includes}). + +In C, @var{type} must be a type-id, so that the expression @samp{sizeof +(@var{type})} is valid (but @samp{sizeof ((@var{type}))} is not). The +rules in C++ are currently more complicated and restrictive: @var{type} +must be a string of tokens such that @samp{typedef @var{type} foo;} is a +valid type definition. However, the C++ approach has problems (for +example, it mishandles function types) and may change in future versions +of Autoconf. @end defmac @defmac AC_CHECK_TYPES (@var{types}, @ovar{action-if-found}, @ovar{action-if-not-found}, @dvar{includes, default-includes}) @acindex{CHECK_TYPES} For each @var{type} of the @var{types} that is defined, define -@code{HAVE_@var{type}} (in all capitals). If no @var{includes} are +@code{HAVE_@var{type}} (in all capitals). Each @var{type} must follow +the rules of @code{AC_CHECK_TYPE}. If no @var{includes} are specified, the default includes are used (@pxref{Default Includes}). If @var{action-if-found} is given, it is additional shell code to execute when one of the types is found. If @var{action-if-not-found} is given, @@ -6208,11 +6217,13 @@ Autoconf works around this problem by casting @code{sizeof (int)} to @node Generic Compiler Characteristics @subsection Generic Compiler Characteristics -@defmac AC_CHECK_SIZEOF (@var{type}, @ovar{unused}, @dvar{includes, default-includes}) +@defmac AC_CHECK_SIZEOF (@var{type-or-expr}, @ovar{unused}, @dvar{includes, default-includes}) @acindex{CHECK_SIZEOF} -Define @code{SIZEOF_@var{type}} (@pxref{Standard Symbols}) to be the -size in bytes of @var{type}. If @samp{type} is unknown, it gets a size -of 0. If no @var{includes} are specified, the default includes are used +Define @code{SIZEOF_@var{type-or-expr}} (@pxref{Standard Symbols}) to be +the size in bytes of @var{type-or-expr}, which may be either a type or +an expression returning a value that has a size. If the expression +@samp{sizeof (@var{type-or-expr})} is invalid, the result is 0. If no +@var{includes} are specified, the default includes are used (@pxref{Default Includes}). This macro now works even when cross-compiling. The @var{unused} @@ -6231,8 +6242,9 @@ defines @code{SIZEOF_INT_P} to be 8 on DEC Alpha AXP systems. @defmac AC_CHECK_ALIGNOF (@var{type}, @dvar{includes, default-includes}) @acindex{CHECK_ALIGNOF} Define @code{ALIGNOF_@var{type}} (@pxref{Standard Symbols}) to be the -alignment in bytes of @var{type}. If @samp{type} is unknown, it gets a size -of 0. If no @var{includes} are specified, the default includes are used +alignment in bytes of @var{type}. @samp{@var{type} x;} must be valid as +a structure member declaration. If @samp{type} is unknown, the result +is 0. If no @var{includes} are specified, the default includes are used (@pxref{Default Includes}). @end defmac diff --git a/lib/autoconf/types.m4 b/lib/autoconf/types.m4 index 768519be..2fc95ed1 100644 --- a/lib/autoconf/types.m4 +++ b/lib/autoconf/types.m4 @@ -130,8 +130,11 @@ # But this succeeds if TYPE is a variable: you get the size of the # variable's type!!! # -# This time you tell yourself the last two options *together* will make -# it. And indeed this is the solution invented by Alexandre Oliva. +# So, to filter out the last possibility, you try this too: +# +# sizeof ((TYPE)); +# +# This fails if TYPE is a type, but succeeds if TYPE is actually a variable. # # Also note that we use # @@ -140,24 +143,37 @@ # to `read' sizeof (to avoid warnings), while not depending on its type # (not necessarily size_t etc.). Equally, instead of defining an unused # variable, we just use a cast to avoid warnings from the compiler. -# Suggested by Paul Eggert. # # Now, the next issue is that C++ disallows defining types inside casts # and inside `sizeof()', but we would like to allow unnamed structs, for -# use inside AC_CHECK_SIZEOF, for example. So we create a typedef of the -# new type. Note that this does not obviate the need for the other -# constructs in general. +# use inside AC_CHECK_SIZEOF, for example. So for C++ we create a typedef +# of the new type. Note that this breaks for some types, e.g., function +# types, but we don't know C++ well enough to fix this. m4_define([_AC_CHECK_TYPE_NEW], [AS_VAR_PUSHDEF([ac_Type], [ac_cv_type_$1])dnl AC_CACHE_CHECK([for $1], [ac_Type], -[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([AC_INCLUDES_DEFAULT([$4]) -typedef $1 ac__type_new_;], -[if ((ac__type_new_ *) 0) +[AS_VAR_SET([ac_Type], [no]) +AC_COMPILE_IFELSE([AC_LANG_PROGRAM([AC_INCLUDES_DEFAULT([$4]) +#ifdef __cplusplus +typedef $1 ac__type_new_; +#endif +], +[#ifdef __cplusplus +if ((ac__type_new_ *) 0) return 0; if (sizeof (ac__type_new_)) - return 0;])], - [AS_VAR_SET([ac_Type], [yes])], - [AS_VAR_SET([ac_Type], [no])])]) + return 0; +#else +if (sizeof ($1)) + return 0; +#endif +])], + [AC_COMPILE_IFELSE( + [AC_LANG_PROGRAM([AC_INCLUDES_DEFAULT([$4])], + [if (sizeof (($1))) + return 0;])], + [], + [AS_VAR_SET([ac_Type], [yes])])])]) AS_IF([test AS_VAR_GET([ac_Type]) = yes], [$2], [$3])[]dnl AS_VAR_POPDEF([ac_Type])dnl ])# _AC_CHECK_TYPE_NEW @@ -703,15 +719,13 @@ AC_DEFINE_UNQUOTED(RETSIGTYPE, $ac_cv_type_signal, AC_DEFUN([AC_CHECK_SIZEOF], [AS_LITERAL_IF([$1], [], [AC_FATAL([$0: requires literal arguments])])dnl -AC_CHECK_TYPE([$1], [], [], [$3]) # The cast to long int works around a bug in the HP C Compiler # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'. # This bug is HP SR number 8606223364. _AC_CACHE_CHECK_INT([size of $1], [AS_TR_SH([ac_cv_sizeof_$1])], - [(long int) (sizeof (ac__type_sizeof_))], - [AC_INCLUDES_DEFAULT([$3]) - typedef $1 ac__type_sizeof_;], + [(long int) (sizeof ($1))], + [AC_INCLUDES_DEFAULT([$3])], [if test "$AS_TR_SH([ac_cv_type_$1])" = yes; then AC_MSG_FAILURE([cannot compute sizeof ($1)], 77) else @@ -728,7 +742,6 @@ AC_DEFINE_UNQUOTED(AS_TR_CPP(sizeof_$1), $AS_TR_SH([ac_cv_sizeof_$1]), AC_DEFUN([AC_CHECK_ALIGNOF], [AS_LITERAL_IF([$1], [], [AC_FATAL([$0: requires literal arguments])])dnl -AC_CHECK_TYPE([$1], [], [], [$2]) # The cast to long int works around a bug in the HP C Compiler, # see AC_CHECK_SIZEOF for more information. _AC_CACHE_CHECK_INT([alignment of $1], [AS_TR_SH([ac_cv_alignof_$1])],