pd.if.org Git - pdclib/blob - _PDCLIB_int.h

   1 /* $Id$ */
   2
   3 /* Release $Name$ */
   4
   5 /* PDCLib internal integer logic <_PDCLIB_int.h>
   6
   7    This file is part of the Public Domain C Library (PDCLib).
   8    Permission is granted to use, modify, and / or redistribute at will.
   9 */
  10
  11 /* -------------------------------------------------------------------------- */
  12 /* You should not have to edit anything in this file; if you DO have to, it   */
  13 /* would be considered a bug / missing feature: notify the author(s).         */
  14 /* -------------------------------------------------------------------------- */
  15
  16 #ifndef _PDCLIB_CONFIG_H
  17 #define _PDCLIB_CONFIG_H _PDCLIB_CONFIG_H
  18 #include <_PDCLIB_config.h>
  19 #endif
  20
  21 #ifndef _PDCLIB_AUX_H
  22 #define _PDCLIB_AUX_H _PDCLIB_AUX_H
  23 #include <_PDCLIB_aux.h>
  24 #endif
  25
  26 /* null pointer constant */
  27 #define _PDCLIB_NULL 0
  28
  29 /* -------------------------------------------------------------------------- */
  30 /* Limits of native datatypes                                                 */
  31 /* -------------------------------------------------------------------------- */
  32 /* The definition of minimum limits for unsigned datatypes is done because    */
  33 /* later on we will "construct" limits for other abstract types:              */
  34 /* USHRT -> _PDCLIB_ + USHRT + _MIN -> _PDCLIB_USHRT_MIN -> 0                 */
  35 /* INT -> _PDCLIB_ + INT + _MIN -> _PDCLIB_INT_MIN -> ... you get the idea.   */
  36 /* -------------------------------------------------------------------------- */
  37
  38 /* Setting 'char' limits                                                      */
  39 #define _PDCLIB_CHAR_BIT    8
  40 #define _PDCLIB_UCHAR_MIN   0
  41 #define _PDCLIB_UCHAR_MAX   0xff
  42 #define _PDCLIB_SCHAR_MIN   (-0x7f - 1)
  43 #define _PDCLIB_SCHAR_MAX   0x7f
  44 #ifdef  _PDCLIB_CHAR_SIGNED
  45 #define _PDCLIB_CHAR_MIN    _PDCLIB_SCHAR_MIN
  46 #define _PDCLIB_CHAR_MAX    _PDCLIB_SCHAR_MAX
  47 #else
  48 #define _PDCLIB_CHAR_MIN    0
  49 #define _PDCLIB_CHAR_MAX    _PDCLIB_UCHAR_MAX
  50 #endif
  51
  52 /* Setting 'short' limits                                                     */
  53 #if     _PDCLIB_SHRT_BYTES == 2
  54 #define _PDCLIB_SHRT_MAX      0x7fff
  55 #define _PDCLIB_SHRT_MIN      (-0x7fff - 1)
  56 #define _PDCLIB_USHRT_MAX     0xffff
  57 #else
  58 #error Unsupported width of 'short' (not 16 bit).
  59 #endif
  60 #define _PDCLIB_USHRT_MIN 0
  61
  62 #if _PDCLIB_INT_BYTES < _PDCLIB_SHRT_BYTES
  63 #error Bogus setting: short > int? Check _PDCLIB_config.h.
  64 #endif
  65
  66 /* Setting 'int' limits                                                       */
  67 #if     _PDCLIB_INT_BYTES == 2
  68 #define _PDCLIB_INT_MAX   0x7fff
  69 #define _PDCLIB_INT_MIN   (-0x7fff - 1)
  70 #define _PDCLIB_UINT_MAX  0xffffU
  71 #elif   _PDCLIB_INT_BYTES == 4
  72 #define _PDCLIB_INT_MAX   0x7fffffff
  73 #define _PDCLIB_INT_MIN   (-0x7fffffff - 1)
  74 #define _PDCLIB_UINT_MAX  0xffffffffU
  75 #elif _PDCLIB_INT_BYTES   == 8
  76 #define _PDCLIB_INT_MAX   0x7fffffffffffffff
  77 #define _PDCLIB_INT_MIN   (-0x7fffffffffffffff - 1)
  78 #define _PDCLIB_UINT_MAX  0xffffffffffffffff
  79 #else
  80 #error Unsupported width of 'int' (neither 16, 32, nor 64 bit).
  81 #endif
  82 #define _PDCLIB_UINT_MIN 0
  83
  84 /* Setting 'long' limits                                                      */
  85 #if   _PDCLIB_LONG_BYTES   == 4
  86 #define _PDCLIB_LONG_MAX   0x7fffffffL
  87 #define _PDCLIB_LONG_MIN   (-0x7fffffffL - 1L)
  88 #define _PDCLIB_ULONG_MAX   0xffffffffUL
  89 #elif   _PDCLIB_LONG_BYTES == 8
  90 #define _PDCLIB_LONG_MAX   0x7fffffffffffffffL
  91 #define _PDCLIB_LONG_MIN   (-0x7fffffffffffffffL - 1L)
  92 #define _PDCLIB_ULONG_MAX  0xffffffffffffffffUL
  93 #else
  94 #error Unsupported width of 'long' (neither 32 nor 64 bit).
  95 #endif
  96 #define _PDCLIB_ULONG_MIN 0
  97
  98 /* Setting 'long long' limits                                                 */
  99 #if _PDCLIB_LLONG_BYTES    == 8
 100 #define _PDCLIB_LLONG_MAX  0x7fffffffffffffffLL
 101 #define _PDCLIB_LLONG_MIN  (-0x7fffffffffffffffLL - 1LL)
 102 #define _PDCLIB_ULLONG_MAX 0xffffffffffffffffULL
 103 #elif _PDCLIB_LLONG_BYTES  == 16
 104 #define _PDCLIB_LLONG_MAX  0x7fffffffffffffffffffffffffffffffLL
 105 #define _PDCLIB_LLONG_MIN  (-0x7fffffffffffffffffffffffffffffffLL - 1LL)
 106 #define _PDCLIB_ULLONG_MAX 0xffffffffffffffffffffffffffffffffLL
 107 #else
 108 #error Unsupported width of 'long long' (neither 64 nor 128 bit).
 109 #endif
 110 #define _PDCLIB_ULLONG_MIN 0
 111
 112 /* -------------------------------------------------------------------------- */
 113 /* <stdint.h> exact-width types and their limits                              */
 114 /* -------------------------------------------------------------------------- */
 115
 116 /* Setting 'int8_t', its limits, and its literal.                             */
 117 #if     _PDCLIB_CHAR_BIT == 8
 118 typedef signed char        _PDCLIB_int8_t;
 119 typedef unsigned char      _PDCLIB_uint8_t;
 120 #define _PDCLIB_INT8_MAX   _PDCLIB_CHAR_MAX
 121 #define _PDCLIB_INT8_MIN   _PDCLIB_CHAR_MIN
 122 #define _PDCLIB_UINT8_MAX  _PDCLIB_UCHAR_MAX
 123 #define _PDCLIB_INT8_LITERAL
 124 #define _PDCLIB_UINT8_LITERAL
 125 #else
 126 #error Unsupported width of char (not 8 bits).
 127 #endif
 128
 129 /* Setting 'int16_t', its limits, and its literal                             */
 130 #if     _PDCLIB_INT_BYTES  == 2
 131 typedef signed int         _PDCLIB_int16_t;
 132 typedef unsigned int       _PDCLIB_uint16_t;
 133 #define _PDCLIB_INT16_MAX  _PDCLIB_INT_MAX
 134 #define _PDCLIB_INT16_MIN  _PDCLIB_INT_MIN
 135 #define _PDCLIB_UINT16_MAX _PDCLIB_UINT_MAX
 136 #define _PDCLIB_INT16_LITERAL
 137 #define _PDCLIB_UINT16_LITERAL
 138 #elif   _PDCLIB_SHRT_BYTES == 2
 139 typedef signed short       _PDCLIB_int16_t;
 140 typedef unsigned short     _PDCLIB_uint16_t;
 141 #define _PDCLIB_INT16_MAX  _PDCLIB_SHRT_MAX
 142 #define _PDCLIB_INT16_MIN  _PDCLIB_SHRT_MIN
 143 #define _PDCLIB_UINT16_MAX _PDCLIB_USHRT_MAX
 144 #define _PDCLIB_INT16_LITERAL  s
 145 #define _PDCLIB_UINT16_LITERAL us
 146 #else
 147 #error Neither 'short' nor 'int' are 16-bit.
 148 #endif
 149
 150 /* Setting 'int32_t', its limits, and its literal                             */
 151 #if     _PDCLIB_INT_BYTES  == 4
 152 typedef signed int         _PDCLIB_int32_t;
 153 typedef unsigned int       _PDCLIB_uint32_t;
 154 #define _PDCLIB_INT32_MAX  _PDCLIB_INT_MAX
 155 #define _PDCLIB_INT32_MIN  _PDCLIB_INT_MIN
 156 #define _PDCLIB_UINT32_MAX _PDCLIB_UINT_MAX
 157 #define _PDCLIB_INT32_LITERAL
 158 #define _PDCLIB_UINT32_LITERAL
 159 #elif   _PDCLIB_LONG_BYTES == 4
 160 typedef signed long        _PDCLIB_int32_t;
 161 typedef unsigned long      _PDCLIB_uint32_t;
 162 #define _PDCLIB_INT32_MAX  _PDCLIB_LONG_MAX
 163 #define _PDCLIB_INT32_MIN  _PDCLIB_LONG_MIN
 164 #define _PDCLIB_UINT32_MAX _PDCLIB_LONG_MAX
 165 #define _PDCLIB_INT32_LITERAL  l
 166 #define _PDCLIB_UINT32_LITERAL ul
 167 #else
 168 #error Neither 'int' nor 'long' are 32-bit.
 169 #endif
 170
 171 #if     _PDCLIB_LONG_BYTES == 8
 172 typedef signed long        _PDCLIB_int64_t;
 173 typedef unsigned long      _PDCLIB_uint64_t;
 174 #define _PDCLIB_INT64_MAX  _PDCLIB_LONG_MAX
 175 #define _PDCLIB_INT64_MIN  _PDCLIB_LONG_MIN
 176 #define _PDCLIB_UINT64_MAX  _PDCLIB_ULONG_MAX
 177 #define _PDCLIB_INT64_LITERAL  l
 178 #define _PDCLIB_UINT64_LITERAL ul
 179 #elif _PDCLIB_LLONG_BYTES  == 8
 180 typedef signed long long   _PDCLIB_int64_t;
 181 typedef unsigned long long _PDCLIB_uint64_t;
 182 #define _PDCLIB_INT64_MAX  _PDCLIB_LLONG_MAX
 183 #define _PDCLIB_INT64_MIN  _PDCLIB_LLONG_MIN
 184 #define _PDCLIB_UINT64_MAX  _PDCLIB_ULLONG_MAX
 185 #define _PDCLIB_INT64_LITERAL  ll
 186 #define _PDCLIB_UINT64_LITERAL ull
 187 #else
 188 #error Neither 'long' nor 'long long' are 64-bit.
 189 #endif
 190
 191 /* -------------------------------------------------------------------------- */
 192 /* <stdint.h> "fastest" types and their limits                                */
 193 /* -------------------------------------------------------------------------- */
 194 /* This is, admittedly, butt-ugly. But at least it's ugly where the average   */
 195 /* user of PDCLib will never see it, and makes <_PDCLIB_config.h> much        */
 196 /* cleaner.                                                                   */
 197 /* -------------------------------------------------------------------------- */
 198
 199 typedef _PDCLIB_fast8          _PDCLIB_int_fast8_t;
 200 typedef unsigned _PDCLIB_fast8 _PDCLIB_uint_fast8_t;
 201 #define _PDCLIB_INT_FAST8_MIN  concat( concat( _PDCLIB_, _PDCLIB_FAST8 ), _MIN )
 202 #define _PDCLIB_INT_FAST8_MAX  concat( concat( _PDCLIB_, _PDCLIB_FAST8 ), _MAX )
 203 #define _PDCLIB_UINT_FAST8_MAX concat( concat( _PDCLIB_U, _PDCLIB_FAST8 ), _MAX )
 204
 205 typedef _PDCLIB_fast16          _PDCLIB_int_fast16_t;
 206 typedef unsigned _PDCLIB_fast16 _PDCLIB_uint_fast16_t;
 207 #define _PDCLIB_INT_FAST16_MIN  concat( concat( _PDCLIB_, _PDCLIB_FAST16 ), _MIN )
 208 #define _PDCLIB_INT_FAST16_MAX  concat( concat( _PDCLIB_, _PDCLIB_FAST16 ), _MAX )
 209 #define _PDCLIB_UINT_FAST16_MAX concat( concat( _PDCLIB_U, _PDCLIB_FAST16 ), _MAX )
 210
 211 typedef _PDCLIB_fast32          _PDCLIB_int_fast32_t;
 212 typedef unsigned _PDCLIB_fast32 _PDCLIB_uint_fast32_t;
 213 #define _PDCLIB_INT_FAST32_MIN  concat( concat( _PDCLIB_, _PDCLIB_FAST32 ), _MIN )
 214 #define _PDCLIB_INT_FAST32_MAX  concat( concat( _PDCLIB_, _PDCLIB_FAST32 ), _MAX )
 215 #define _PDCLIB_UINT_FAST32_MAX concat( concat( _PDCLIB_U, _PDCLIB_FAST32 ), _MAX )
 216
 217 typedef _PDCLIB_fast64          _PDCLIB_int_fast64_t;
 218 typedef unsigned _PDCLIB_fast64 _PDCLIB_uint_fast64_t;
 219 #define _PDCLIB_INT_FAST64_MIN  concat( concat( _PDCLIB_, _PDCLIB_FAST64 ), _MIN )
 220 #define _PDCLIB_INT_FAST64_MAX  concat( concat( _PDCLIB_, _PDCLIB_FAST64 ), _MAX )
 221 #define _PDCLIB_UINT_FAST64_MAX concat( concat( _PDCLIB_U, _PDCLIB_FAST64 ), _MAX )
 222
 223 /* -------------------------------------------------------------------------- */
 224 /* Various <stddef.h> typedefs and limits                                     */
 225 /* -------------------------------------------------------------------------- */
 226
 227 typedef _PDCLIB_ptrdiff     _PDCLIB_ptrdiff_t;
 228 #define _PDCLIB_PTRDIFF_MIN concat( concat( _PDCLIB_, _PDCLIB_PTRDIFF ), _MIN )
 229 #define _PDCLIB_PTRDIFF_MAX concat( concat( _PDCLIB_, _PDCLIB_PTRDIFF ), _MAX )
 230
 231 #define _PDCLIB_SIG_ATOMIC_MIN concat( concat( _PDCLIB_, _PDCLIB_SIG_ATOMIC ), _MIN )
 232 #define _PDCLIB_SIG_ATOMIC_MAX concat( concat( _PDCLIB_, _PDCLIB_SIG_ATOMIC ), _MAX )
 233
 234 typedef _PDCLIB_size     _PDCLIB_size_t;
 235 #define _PDCLIB_SIZE_MAX concat( concat( _PDCLIB_, _PDCLIB_SIZE ), _MAX )
 236
 237 typedef _PDCLIB_wchar     _PDCLIB_wchar_t;
 238 #define _PDCLIB_WCHAR_MIN concat( concat( _PDCLIB_, _PDCLIB_WCHAR ), _MIN )
 239 #define _PDCLIB_WCHAR_MAX concat( concat( _PDCLIB_, _PDCLIB_WCHAR ), _MAX )
 240
 241 typedef _PDCLIB_intptr          _PDCLIB_intptr_t;
 242 typedef unsigned _PDCLIB_intptr _PDCLIB_uintptr_t;
 243 #define _PDCLIB_INTPTR_MIN  concat( concat( _PDCLIB_, _PDCLIB_INTPTR ), _MIN )
 244 #define _PDCLIB_INTPTR_MAX  concat( concat( _PDCLIB_, _PDCLIB_INTPTR ), _MAX )
 245 #define _PDCLIB_UINTPTR_MAX concat( concat( _PDCLIB_U, _PDCLIB_INTPTR ), _MAX )
 246
 247 typedef _PDCLIB_intmax          _PDCLIB_intmax_t;
 248 typedef unsigned _PDCLIB_intmax _PDCLIB_uintmax_t;
 249 #define _PDCLIB_INTMAX_MIN  concat( concat( _PDCLIB_, _PDCLIB_INTMAX ), _MIN )
 250 #define _PDCLIB_INTMAX_MAX  concat( concat( _PDCLIB_, _PDCLIB_INTMAX ), _MAX )
 251 #define _PDCLIB_UINTMAX_MAX concat( concat( _PDCLIB_U, _PDCLIB_INTMAX ), _MAX )
 252 #define _PDCLIB_INTMAX_C( value )  concat( value, _PDCLIB_INTMAX_LITERAL )
 253 #define _PDCLIB_UINTMAX_C( value ) concat( value, concat( u, _PDCLIB_INTMAX_LITERAL ) )