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. See 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.horinttypes.hdoes 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 in C89-or-later code as follows:#if HAVE_STDINT_H # include <stdint.h> #endif #if defined INT8_MAX || defined int8_tcode using int8_t#elsecomplicated alternative using >8-bit 'signed char'#endifThis macro caches the type in the

`ac_cv_c_int8_t`

variable.

— Macro: **AC_TYPE_INTMAX_T**

If

stdint.horinttypes.hdefines 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.horinttypes.hdefines 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. See 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`<wchar.h>`

declares the`mbstate_t`

type. Also, define`mbstate_t`

to be a type if`<wchar.h>`

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.horinttypes.hdoes 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_UINTMAX_T**

If

stdint.horinttypes.hdefines 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.horinttypes.hdefines 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. See Preprocessor Arithmetic.This macro caches its result in the

`ac_cv_type_unsigned_long_long_int`

variable.