intprops.h File Reference

#include <limits.h>

Include dependency graph for intprops.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	_GL_INT_CONVERT(e, v)   (0 * (e) + (v))
#define	_GL_INT_NEGATE_CONVERT(e, v)   (0 * (e) - (v))
#define	TYPE_IS_INTEGER(t)   ((t) 1.5 == 1)
#define	TYPE_SIGNED(t)   (! ((t) 0 < (t) -1))
#define	EXPR_SIGNED(e)   (_GL_INT_NEGATE_CONVERT (e, 1) < 0)
#define	TYPE_WIDTH(t)   (sizeof (t) * CHAR_BIT)
#define	TYPE_MINIMUM(t)   ((t) ~ TYPE_MAXIMUM (t))
#define	TYPE_MAXIMUM(t)
#define	_GL_INT_MINIMUM(e)
#define	_GL_INT_MAXIMUM(e)
#define	_GL_SIGNED_INT_MAXIMUM(e)   (((_GL_INT_CONVERT (e, 1) << (TYPE_WIDTH ((e) + 0) - 2)) - 1) * 2 + 1)
#define	_GL_HAVE___TYPEOF__   0
#define	_GL_SIGNED_TYPE_OR_EXPR(t)   1
#define	INT_BITS_STRLEN_BOUND(b)   (((b) * 146 + 484) / 485)
#define	INT_STRLEN_BOUND(t)
#define	INT_BUFSIZE_BOUND(t)   (INT_STRLEN_BOUND (t) + 1)
#define	INT_ADD_RANGE_OVERFLOW(a, b, min, max)
#define	INT_SUBTRACT_RANGE_OVERFLOW(a, b, min, max)
#define	INT_NEGATE_RANGE_OVERFLOW(a, min, max)
#define	INT_MULTIPLY_RANGE_OVERFLOW(a, b, min, max)
#define	INT_DIVIDE_RANGE_OVERFLOW(a, b, min, max)   ((min) < 0 && (b) == -1 && (a) < - (max))
#define	INT_REMAINDER_RANGE_OVERFLOW(a, b, min, max)   INT_DIVIDE_RANGE_OVERFLOW (a, b, min, max)
#define	INT_LEFT_SHIFT_RANGE_OVERFLOW(a, b, min, max)
#define	_GL_HAS_BUILTIN_OVERFLOW   0
#define	_GL_HAS_BUILTIN_OVERFLOW_P   (7 <= __GNUC__)
#define	_GL_ADD_OVERFLOW(a, b, min, max)
#define	_GL_SUBTRACT_OVERFLOW(a, b, min, max)
#define	_GL_MULTIPLY_OVERFLOW(a, b, min, max)
#define	_GL_DIVIDE_OVERFLOW(a, b, min, max)
#define	_GL_REMAINDER_OVERFLOW(a, b, min, max)
#define	_GL_UNSIGNED_NEG_MULTIPLE(a, b, max)
#define	INT_ADD_OVERFLOW(a, b)   _GL_BINARY_OP_OVERFLOW (a, b, _GL_ADD_OVERFLOW)
#define	INT_SUBTRACT_OVERFLOW(a, b)   _GL_BINARY_OP_OVERFLOW (a, b, _GL_SUBTRACT_OVERFLOW)
#define	INT_NEGATE_OVERFLOW(a)   INT_NEGATE_RANGE_OVERFLOW (a, _GL_INT_MINIMUM (a), _GL_INT_MAXIMUM (a))
#define	INT_MULTIPLY_OVERFLOW(a, b)   _GL_BINARY_OP_OVERFLOW (a, b, _GL_MULTIPLY_OVERFLOW)
#define	INT_DIVIDE_OVERFLOW(a, b)   _GL_BINARY_OP_OVERFLOW (a, b, _GL_DIVIDE_OVERFLOW)
#define	INT_REMAINDER_OVERFLOW(a, b)   _GL_BINARY_OP_OVERFLOW (a, b, _GL_REMAINDER_OVERFLOW)
#define	INT_LEFT_SHIFT_OVERFLOW(a, b)
#define	_GL_BINARY_OP_OVERFLOW(a, b, op_result_overflow)
#define	INT_ADD_WRAPV(a, b, r)   _GL_INT_OP_WRAPV (a, b, r, +, __builtin_add_overflow, INT_ADD_OVERFLOW)
#define	INT_SUBTRACT_WRAPV(a, b, r)   _GL_INT_OP_WRAPV (a, b, r, -, __builtin_sub_overflow, INT_SUBTRACT_OVERFLOW)
#define	INT_MULTIPLY_WRAPV(a, b, r)   _GL_INT_OP_WRAPV (a, b, r, *, __builtin_mul_overflow, INT_MULTIPLY_OVERFLOW)
#define	_GL__GENERIC_BOGUS   0
#define	_GL_INT_OP_WRAPV(a, b, r, op, builtin, overflow)
#define	_GL_INT_OP_WRAPV_LONGISH(a, b, r, op, overflow)
#define	_GL_INT_OP_CALC(a, b, r, op, overflow, ut, t, tmin, tmax)
#define	_GL_INT_OP_CALC1(a, b, r, op, overflow, ut, t, tmin, tmax)
#define	_GL_INT_OP_WRAPV_VIA_UNSIGNED(a, b, op, ut, t)   ((t) ((ut) (a) op (ut) (b)))

Macro Definition Documentation

_GL__GENERIC_BOGUS

#define _GL__GENERIC_BOGUS   0

_GL_ADD_OVERFLOW

#define _GL_ADD_OVERFLOW	(		a,
			b,
			min,
			max
	)

Value:

((min) < 0 ? INT_ADD_RANGE_OVERFLOW (a, b, min, max)                  \
    : (a) < 0 ? (b) <= (a) + (b)                                         \
    : (b) < 0 ? (a) <= (a) + (b)                                         \
    : (a) + (b) < (b))

_GL_BINARY_OP_OVERFLOW

#define _GL_BINARY_OP_OVERFLOW	(		a,
			b,
			op_result_overflow
	)

Value:

op_result_overflow (a, b,                                     \
                      _GL_INT_MINIMUM (0 * (b) + (a)),          \
                      _GL_INT_MAXIMUM (0 * (b) + (a)))

_GL_DIVIDE_OVERFLOW

#define _GL_DIVIDE_OVERFLOW	(		a,
			b,
			min,
			max
	)

Value:

((min) < 0 ? (b) == _GL_INT_NEGATE_CONVERT (min, 1) && (a) < - (max)  \
   : (a) < 0 ? (b) <= (a) + (b) - 1                                     \
   : (b) < 0 && (a) + (b) <= (a))

_GL_HAS_BUILTIN_OVERFLOW

#define _GL_HAS_BUILTIN_OVERFLOW   0

_GL_HAS_BUILTIN_OVERFLOW_P

#define _GL_HAS_BUILTIN_OVERFLOW_P   (7 <= __GNUC__)

_GL_HAVE___TYPEOF__

#define _GL_HAVE___TYPEOF__   0

_GL_INT_CONVERT

#define _GL_INT_CONVERT	(		e,
			v
	)		(0 * (e) + (v))

_GL_INT_MAXIMUM

#define _GL_INT_MAXIMUM

(

e

)

Value:

(EXPR_SIGNED (e)                                                      \
   ? _GL_SIGNED_INT_MAXIMUM (e)                                         \
   : _GL_INT_NEGATE_CONVERT (e, 1))

_GL_INT_MINIMUM

#define _GL_INT_MINIMUM

(

e

)

Value:

(EXPR_SIGNED (e)                                                      \
   ? ~ _GL_SIGNED_INT_MAXIMUM (e)                                       \
   : _GL_INT_CONVERT (e, 0))

_GL_INT_NEGATE_CONVERT

#define _GL_INT_NEGATE_CONVERT	(		e,
			v
	)		(0 * (e) - (v))

_GL_INT_OP_CALC

#define _GL_INT_OP_CALC	(		a,
			b,
			r,
			op,
			overflow,
			ut,
			t,
			tmin,
			tmax
	)

Value:

(sizeof ((a) op (b)) < sizeof (t) \
   ? _GL_INT_OP_CALC1 ((t) (a), (t) (b), r, op, overflow, ut, t, tmin, tmax) \
   : _GL_INT_OP_CALC1 (a, b, r, op, overflow, ut, t, tmin, tmax))

_GL_INT_OP_CALC1

#define _GL_INT_OP_CALC1	(		a,
			b,
			r,
			op,
			overflow,
			ut,
			t,
			tmin,
			tmax
	)

Value:

((overflow (a, b) \
    || (EXPR_SIGNED ((a) op (b)) && ((a) op (b)) < (tmin)) \
    || (tmax) < ((a) op (b))) \
   ? (*(r) = _GL_INT_OP_WRAPV_VIA_UNSIGNED (a, b, op, ut, t), 1) \
   : (*(r) = _GL_INT_OP_WRAPV_VIA_UNSIGNED (a, b, op, ut, t), 0))

_GL_INT_OP_WRAPV

#define _GL_INT_OP_WRAPV	(		a,
			b,
			r,
			op,
			builtin,
			overflow
	)

Value:

(sizeof *(r) == sizeof (signed char) \
    ? _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned int, \
                       signed char, SCHAR_MIN, SCHAR_MAX) \
    : sizeof *(r) == sizeof (short int) \
    ? _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned int, \
                       short int, SHRT_MIN, SHRT_MAX) \
    : sizeof *(r) == sizeof (int) \
    ? _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned int, \
                       int, INT_MIN, INT_MAX) \
    : _GL_INT_OP_WRAPV_LONGISH(a, b, r, op, overflow))

_GL_INT_OP_WRAPV_LONGISH

#define _GL_INT_OP_WRAPV_LONGISH	(		a,
			b,
			r,
			op,
			overflow
	)

Value:

_GL_INT_OP_CALC (a, b, r, op, overflow, unsigned long int, \
                     long int, LONG_MIN, LONG_MAX)

_GL_INT_OP_WRAPV_VIA_UNSIGNED

#define _GL_INT_OP_WRAPV_VIA_UNSIGNED	(		a,
			b,
			op,
			ut,
			t
	)		((t) ((ut) (a) op (ut) (b)))

_GL_MULTIPLY_OVERFLOW

#define _GL_MULTIPLY_OVERFLOW	(		a,
			b,
			min,
			max
	)

Value:

(((min) == 0 && (((a) < 0 && 0 < (b)) || ((b) < 0 && 0 < (a))))       \
    || INT_MULTIPLY_RANGE_OVERFLOW (a, b, min, max))

_GL_REMAINDER_OVERFLOW

#define _GL_REMAINDER_OVERFLOW	(		a,
			b,
			min,
			max
	)

Value:

((min) < 0 ? (b) == _GL_INT_NEGATE_CONVERT (min, 1) && (a) < - (max)  \
   : (a) < 0 ? (a) % (b) != ((max) - (b) + 1) % (b)                     \
   : (b) < 0 && ! _GL_UNSIGNED_NEG_MULTIPLE (a, b, max))

_GL_SIGNED_INT_MAXIMUM

#define _GL_SIGNED_INT_MAXIMUM

(

e

)

(((_GL_INT_CONVERT (e, 1) << (TYPE_WIDTH ((e) + 0) - 2)) - 1) * 2 + 1)

_GL_SIGNED_TYPE_OR_EXPR

#define _GL_SIGNED_TYPE_OR_EXPR

(

t

)

1

_GL_SUBTRACT_OVERFLOW

#define _GL_SUBTRACT_OVERFLOW	(		a,
			b,
			min,
			max
	)

Value:

((min) < 0 ? INT_SUBTRACT_RANGE_OVERFLOW (a, b, min, max)             \
    : (a) < 0 ? 1                                                        \
    : (b) < 0 ? (a) - (b) <= (a)                                         \
    : (a) < (b))

_GL_UNSIGNED_NEG_MULTIPLE

#define _GL_UNSIGNED_NEG_MULTIPLE	(		a,
			b,
			max
	)

Value:

(((b) < -_GL_SIGNED_INT_MAXIMUM (b)                                   \
    ? (_GL_SIGNED_INT_MAXIMUM (b) == (max)                              \
       ? (a)                                                            \
       : (a) % (_GL_INT_CONVERT (a, _GL_SIGNED_INT_MAXIMUM (b)) + 1))   \
    : (a) % - (b))                                                      \
   == 0)

EXPR_SIGNED

#define EXPR_SIGNED

(

e

)

(_GL_INT_NEGATE_CONVERT (e, 1) < 0)

INT_ADD_OVERFLOW

#define INT_ADD_OVERFLOW	(		a,
			b
	)		_GL_BINARY_OP_OVERFLOW (a, b, _GL_ADD_OVERFLOW)

INT_ADD_RANGE_OVERFLOW

#define INT_ADD_RANGE_OVERFLOW	(		a,
			b,
			min,
			max
	)

Value:

((b) < 0                                              \
   ? (a) < (min) - (b)                                  \
   : (max) - (b) < (a))

INT_ADD_WRAPV

#define INT_ADD_WRAPV	(		a,
			b,
			r
	)		_GL_INT_OP_WRAPV (a, b, r, +, __builtin_add_overflow, INT_ADD_OVERFLOW)

INT_BITS_STRLEN_BOUND

#define INT_BITS_STRLEN_BOUND

(

b

)

(((b) * 146 + 484) / 485)

INT_BUFSIZE_BOUND

#define INT_BUFSIZE_BOUND

(

t

)

(INT_STRLEN_BOUND (t) + 1)

INT_DIVIDE_OVERFLOW

#define INT_DIVIDE_OVERFLOW	(		a,
			b
	)		_GL_BINARY_OP_OVERFLOW (a, b, _GL_DIVIDE_OVERFLOW)

INT_DIVIDE_RANGE_OVERFLOW

#define INT_DIVIDE_RANGE_OVERFLOW	(		a,
			b,
			min,
			max
	)		((min) < 0 && (b) == -1 && (a) < - (max))

INT_LEFT_SHIFT_OVERFLOW

#define INT_LEFT_SHIFT_OVERFLOW	(		a,
			b
	)

Value:

INT_LEFT_SHIFT_RANGE_OVERFLOW (a, b, \
                                 _GL_INT_MINIMUM (a), _GL_INT_MAXIMUM (a))

INT_LEFT_SHIFT_RANGE_OVERFLOW

#define INT_LEFT_SHIFT_RANGE_OVERFLOW	(		a,
			b,
			min,
			max
	)

Value:

((a) < 0                                              \
   ? (a) < (min) >> (b)                                 \
   : (max) >> (b) < (a))

INT_MULTIPLY_OVERFLOW

#define INT_MULTIPLY_OVERFLOW	(		a,
			b
	)		_GL_BINARY_OP_OVERFLOW (a, b, _GL_MULTIPLY_OVERFLOW)

INT_MULTIPLY_RANGE_OVERFLOW

#define INT_MULTIPLY_RANGE_OVERFLOW	(		a,
			b,
			min,
			max
	)

Value:

((b) < 0                                              \
   ? ((a) < 0                                           \
      ? (a) < (max) / (b)                               \
      : (b) == -1                                       \
      ? 0                                               \
      : (min) / (b) < (a))                              \
   : (b) == 0                                           \
   ? 0                                                  \
   : ((a) < 0                                           \
      ? (a) < (min) / (b)                               \
      : (max) / (b) < (a)))

INT_MULTIPLY_WRAPV

#define INT_MULTIPLY_WRAPV	(		a,
			b,
			r
	)		_GL_INT_OP_WRAPV (a, b, r, *, __builtin_mul_overflow, INT_MULTIPLY_OVERFLOW)

INT_NEGATE_OVERFLOW

#define INT_NEGATE_OVERFLOW

(

a

)

INT_NEGATE_RANGE_OVERFLOW (a, _GL_INT_MINIMUM (a), _GL_INT_MAXIMUM (a))

INT_NEGATE_RANGE_OVERFLOW

#define INT_NEGATE_RANGE_OVERFLOW	(		a,
			min,
			max
	)

Value:

((min) < 0                                            \
   ? (a) < - (max)                                      \
   : 0 < (a))

INT_REMAINDER_OVERFLOW

#define INT_REMAINDER_OVERFLOW	(		a,
			b
	)		_GL_BINARY_OP_OVERFLOW (a, b, _GL_REMAINDER_OVERFLOW)

INT_REMAINDER_RANGE_OVERFLOW

#define INT_REMAINDER_RANGE_OVERFLOW	(		a,
			b,
			min,
			max
	)		INT_DIVIDE_RANGE_OVERFLOW (a, b, min, max)

INT_STRLEN_BOUND

#define INT_STRLEN_BOUND

(

t

)

Value:

(INT_BITS_STRLEN_BOUND (TYPE_WIDTH (t) - _GL_SIGNED_TYPE_OR_EXPR (t)) \
   + _GL_SIGNED_TYPE_OR_EXPR (t))

Referenced by strerror().

INT_SUBTRACT_OVERFLOW

#define INT_SUBTRACT_OVERFLOW	(		a,
			b
	)		_GL_BINARY_OP_OVERFLOW (a, b, _GL_SUBTRACT_OVERFLOW)

INT_SUBTRACT_RANGE_OVERFLOW

#define INT_SUBTRACT_RANGE_OVERFLOW	(		a,
			b,
			min,
			max
	)

Value:

((b) < 0                                              \
   ? (max) + (b) < (a)                                  \
   : (a) < (min) + (b))

INT_SUBTRACT_WRAPV

#define INT_SUBTRACT_WRAPV	(		a,
			b,
			r
	)		_GL_INT_OP_WRAPV (a, b, r, -, __builtin_sub_overflow, INT_SUBTRACT_OVERFLOW)

TYPE_IS_INTEGER

#define TYPE_IS_INTEGER

(

t

)

((t) 1.5 == 1)

TYPE_MAXIMUM

#define TYPE_MAXIMUM

(

t

)

Value:

((t) (! TYPE_SIGNED (t)                                               \
        ? (t) -1                                                        \
        : ((((t) 1 << (TYPE_WIDTH (t) - 2)) - 1) * 2 + 1)))

TYPE_MINIMUM

#define TYPE_MINIMUM

(

t

)

((t) ~ TYPE_MAXIMUM (t))

TYPE_SIGNED

#define TYPE_SIGNED

(

t

)

(! ((t) 0 < (t) -1))

TYPE_WIDTH

#define TYPE_WIDTH

(

t

)

(sizeof (t) * CHAR_BIT)