File: autoconf.info,  Node: Particular Types,  Next: Types.php">Generic Types,  Up: Types

5.9.1 Particular Type Checks
----------------------------

These macros check for particular C types in ‘sys/types.h’, ‘stdlib.h’,
‘stdint.h’, ‘inttypes.h’ and others, if they exist.

   The Gnulib ‘stdint’ module is an alternate way to define many of
these symbols; it is useful if you prefer your code to assume a
C99-or-better environment.  *Note Gnulib::.

 -- Macro: AC_TYPE_GETGROUPS
     Define ‘GETGROUPS_T’ to be whichever of ‘gid_t’ or ‘int’ is the
     base type of the array argument to ‘getgroups’.

     This macro caches the base type in the ‘ac_cv_type_getgroups’
     variable.

 -- Macro: AC_TYPE_INT8_T
     If ‘stdint.h’ or ‘inttypes.h’ does not define the type ‘int8_t’,
     define ‘int8_t’ to a signed integer type that is exactly 8 bits
     wide and that uses two's complement representation, if such a type
     exists.  If you are worried about porting to hosts that lack such a
     type, you can use the results of this macro as follows:

          #if HAVE_STDINT_H
          # include 
          #endif
          #if defined INT8_MAX || defined int8_t
           _code using int8_t_
          #else
           _complicated alternative using >8-bit 'signed char'_
          #endif

     This macro caches the type in the ‘ac_cv_c_int8_t’ variable.

 -- Macro: AC_TYPE_INT16_T
     This is like ‘AC_TYPE_INT8_T’, except for 16-bit integers.

 -- Macro: AC_TYPE_INT32_T
     This is like ‘AC_TYPE_INT8_T’, except for 32-bit integers.

 -- Macro: AC_TYPE_INT64_T
     This is like ‘AC_TYPE_INT8_T’, except for 64-bit integers.

 -- Macro: AC_TYPE_INTMAX_T
     If ‘stdint.h’ or ‘inttypes.h’ defines the type ‘intmax_t’, define
     ‘HAVE_INTMAX_T’.  Otherwise, define ‘intmax_t’ to the widest signed
     integer type.

 -- Macro: AC_TYPE_INTPTR_T
     If ‘stdint.h’ or ‘inttypes.h’ defines the type ‘intptr_t’, define
     ‘HAVE_INTPTR_T’.  Otherwise, define ‘intptr_t’ to a signed integer
     type wide enough to hold a pointer, if such a type exists.

 -- Macro: AC_TYPE_LONG_DOUBLE
     If the C compiler supports a working ‘long double’ type, define
     ‘HAVE_LONG_DOUBLE’.  The ‘long double’ type might have the same
     range and precision as ‘double’.

     This macro caches its result in the ‘ac_cv_type_long_double’
     variable.

     This macro is obsolescent, as current C compilers support ‘long
     double’.  New programs need not use this macro.

 -- Macro: AC_TYPE_LONG_DOUBLE_WIDER
     If the C compiler supports a working ‘long double’ type with more
     range or precision than the ‘double’ type, define
     ‘HAVE_LONG_DOUBLE_WIDER’.

     This macro caches its result in the ‘ac_cv_type_long_double_wider’
     variable.

 -- Macro: AC_TYPE_LONG_LONG_INT
     If the C compiler supports a working ‘long long int’ type, define
     ‘HAVE_LONG_LONG_INT’.  However, this test does not test ‘long long
     int’ values in preprocessor ‘#if’ expressions, because too many
     compilers mishandle such expressions.  *Note Preprocessor
     Arithmetic::.

     This macro caches its result in the ‘ac_cv_type_long_long_int’
     variable.

 -- Macro: AC_TYPE_MBSTATE_T
     Define ‘HAVE_MBSTATE_T’ if ‘’ declares the ‘mbstate_t’
     type.  Also, define ‘mbstate_t’ to be a type if ‘’ does
     not declare it.

     This macro caches its result in the ‘ac_cv_type_mbstate_t’
     variable.

 -- Macro: AC_TYPE_MODE_T
     Define ‘mode_t’ to a suitable type, if standard headers do not
     define it.

     This macro caches its result in the ‘ac_cv_type_mode_t’ variable.

 -- Macro: AC_TYPE_OFF_T
     Define ‘off_t’ to a suitable type, if standard headers do not
     define it.

     This macro caches its result in the ‘ac_cv_type_off_t’ variable.

 -- Macro: AC_TYPE_PID_T
     Define ‘pid_t’ to a suitable type, if standard headers do not
     define it.

     This macro caches its result in the ‘ac_cv_type_pid_t’ variable.

 -- Macro: AC_TYPE_SIZE_T
     Define ‘size_t’ to a suitable type, if standard headers do not
     define it.

     This macro caches its result in the ‘ac_cv_type_size_t’ variable.

 -- Macro: AC_TYPE_SSIZE_T
     Define ‘ssize_t’ to a suitable type, if standard headers do not
     define it.

     This macro caches its result in the ‘ac_cv_type_ssize_t’ variable.

 -- Macro: AC_TYPE_UID_T
     Define ‘uid_t’ and ‘gid_t’ to suitable types, if standard headers
     do not define them.

     This macro caches its result in the ‘ac_cv_type_uid_t’ variable.

 -- Macro: AC_TYPE_UINT8_T
     If ‘stdint.h’ or ‘inttypes.h’ does not define the type ‘uint8_t’,
     define ‘uint8_t’ to an unsigned integer type that is exactly 8 bits
     wide, if such a type exists.  This is like ‘AC_TYPE_INT8_T’, except
     for unsigned integers.

 -- Macro: AC_TYPE_UINT16_T
     This is like ‘AC_TYPE_UINT8_T’, except for 16-bit integers.

 -- Macro: AC_TYPE_UINT32_T
     This is like ‘AC_TYPE_UINT8_T’, except for 32-bit integers.

 -- Macro: AC_TYPE_UINT64_T
     This is like ‘AC_TYPE_UINT8_T’, except for 64-bit integers.

 -- Macro: AC_TYPE_UINTMAX_T
     If ‘stdint.h’ or ‘inttypes.h’ defines the type ‘uintmax_t’, define
     ‘HAVE_UINTMAX_T’.  Otherwise, define ‘uintmax_t’ to the widest
     unsigned integer type.

 -- Macro: AC_TYPE_UINTPTR_T
     If ‘stdint.h’ or ‘inttypes.h’ defines the type ‘uintptr_t’, define
     ‘HAVE_UINTPTR_T’.  Otherwise, define ‘uintptr_t’ to an unsigned
     integer type wide enough to hold a pointer, if such a type exists.

 -- Macro: AC_TYPE_UNSIGNED_LONG_LONG_INT
     If the C compiler supports a working ‘unsigned long long int’ type,
     define ‘HAVE_UNSIGNED_LONG_LONG_INT’.  However, this test does not
     test ‘unsigned long long int’ values in preprocessor ‘#if’
     expressions, because too many compilers mishandle such expressions.
     *Note Preprocessor Arithmetic::.

     This macro caches its result in the
     ‘ac_cv_type_unsigned_long_long_int’ variable.