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

   1 /* $Id$ */
   2
   3 /* PDCLib internal integer logic <_PDCLIB_int.h>
   4
   5    This file is part of the Public Domain C Library (PDCLib).
   6    Permission is granted to use, modify, and / or redistribute at will.
   7 */
   8
   9 /* -------------------------------------------------------------------------- */
  10 /* You should not have to edit anything in this file; if you DO have to, it   */
  11 /* would be considered a bug / missing feature: notify the author(s).         */
  12 /* -------------------------------------------------------------------------- */
  13
  14 #ifndef _PDCLIB_CONFIG_H
  15 #define _PDCLIB_CONFIG_H _PDCLIB_CONFIG_H
  16 #include <_PDCLIB_config.h>
  17 #endif
  18
  19 #ifndef _PDCLIB_AUX_H
  20 #define _PDCLIB_AUX_H _PDCLIB_AUX_H
  21 #include <_PDCLIB_aux.h>
  22 #endif
  23
  24 /* null pointer constant */
  25 #define _PDCLIB_NULL 0
  26
  27 /* -------------------------------------------------------------------------- */
  28 /* Limits of native datatypes                                                 */
  29 /* -------------------------------------------------------------------------- */
  30 /* The definition of minimum limits for unsigned datatypes is done because    */
  31 /* later on we will "construct" limits for other abstract types:              */
  32 /* USHRT -> _PDCLIB_ + USHRT + _MIN -> _PDCLIB_USHRT_MIN -> 0                 */
  33 /* INT -> _PDCLIB_ + INT + _MIN -> _PDCLIB_INT_MIN -> ... you get the idea.   */
  34 /* -------------------------------------------------------------------------- */
  35
  36 /* Setting 'char' limits                                                      */
  37 #define _PDCLIB_CHAR_BIT    8
  38 #define _PDCLIB_UCHAR_MIN   0
  39 #define _PDCLIB_UCHAR_MAX   0xff
  40 #define _PDCLIB_SCHAR_MIN   (-0x7f - 1)
  41 #define _PDCLIB_SCHAR_MAX   0x7f
  42 #ifdef  _PDCLIB_CHAR_SIGNED
  43 #define _PDCLIB_CHAR_MIN    _PDCLIB_SCHAR_MIN
  44 #define _PDCLIB_CHAR_MAX    _PDCLIB_SCHAR_MAX
  45 #else
  46 #define _PDCLIB_CHAR_MIN    0
  47 #define _PDCLIB_CHAR_MAX    _PDCLIB_UCHAR_MAX
  48 #endif
  49
  50 /* Setting 'short' limits                                                     */
  51 #if     _PDCLIB_SHRT_BYTES == 2
  52 #define _PDCLIB_SHRT_MAX      0x7fff
  53 #define _PDCLIB_SHRT_MIN      (-0x7fff - 1)
  54 #define _PDCLIB_USHRT_MAX     0xffff
  55 #else
  56 #error Unsupported width of 'short' (not 16 bit).
  57 #endif
  58 #define _PDCLIB_USHRT_MIN 0
  59
  60 #if _PDCLIB_INT_BYTES < _PDCLIB_SHRT_BYTES
  61 #error Bogus setting: short > int? Check _PDCLIB_config.h.
  62 #endif
  63
  64 /* Setting 'int' limits                                                       */
  65 #if     _PDCLIB_INT_BYTES == 2
  66 #define _PDCLIB_INT_MAX   0x7fff
  67 #define _PDCLIB_INT_MIN   (-0x7fff - 1)
  68 #define _PDCLIB_UINT_MAX  0xffffU
  69 #elif   _PDCLIB_INT_BYTES == 4
  70 #define _PDCLIB_INT_MAX   0x7fffffff
  71 #define _PDCLIB_INT_MIN   (-0x7fffffff - 1)
  72 #define _PDCLIB_UINT_MAX  0xffffffffU
  73 #elif _PDCLIB_INT_BYTES   == 8
  74 #define _PDCLIB_INT_MAX   0x7fffffffffffffff
  75 #define _PDCLIB_INT_MIN   (-0x7fffffffffffffff - 1)
  76 #define _PDCLIB_UINT_MAX  0xffffffffffffffff
  77 #else
  78 #error Unsupported width of 'int' (neither 16, 32, nor 64 bit).
  79 #endif
  80 #define _PDCLIB_UINT_MIN 0
  81
  82 /* Setting 'long' limits                                                      */
  83 #if   _PDCLIB_LONG_BYTES   == 4
  84 #define _PDCLIB_LONG_MAX   0x7fffffffL
  85 #define _PDCLIB_LONG_MIN   (-0x7fffffffL - 1L)
  86 #define _PDCLIB_ULONG_MAX  0xffffffffUL
  87 #elif   _PDCLIB_LONG_BYTES == 8
  88 #define _PDCLIB_LONG_MAX   0x7fffffffffffffffL
  89 #define _PDCLIB_LONG_MIN   (-0x7fffffffffffffffL - 1L)
  90 #define _PDCLIB_ULONG_MAX  0xffffffffffffffffUL
  91 #else
  92 #error Unsupported width of 'long' (neither 32 nor 64 bit).
  93 #endif
  94 #define _PDCLIB_ULONG_MIN 0
  95
  96 /* Setting 'long long' limits                                                 */
  97 #if _PDCLIB_LLONG_BYTES    == 8
  98 #define _PDCLIB_LLONG_MAX  0x7fffffffffffffffLL
  99 #define _PDCLIB_LLONG_MIN  (-0x7fffffffffffffffLL - 1LL)
 100 #define _PDCLIB_ULLONG_MAX 0xffffffffffffffffULL
 101 #elif _PDCLIB_LLONG_BYTES  == 16
 102 #define _PDCLIB_LLONG_MAX  0x7fffffffffffffffffffffffffffffffLL
 103 #define _PDCLIB_LLONG_MIN  (-0x7fffffffffffffffffffffffffffffffLL - 1LL)
 104 #define _PDCLIB_ULLONG_MAX 0xffffffffffffffffffffffffffffffffLL
 105 #else
 106 #error Unsupported width of 'long long' (neither 64 nor 128 bit).
 107 #endif
 108 #define _PDCLIB_ULLONG_MIN 0
 109
 110 /* -------------------------------------------------------------------------- */
 111 /* <stdint.h> exact-width types and their limits                              */
 112 /* -------------------------------------------------------------------------- */
 113
 114 /* Setting 'int8_t', its limits, and its literal.                             */
 115 #if     _PDCLIB_CHAR_BIT == 8
 116 typedef signed char        _PDCLIB_int8_t;
 117 typedef unsigned char      _PDCLIB_uint8_t;
 118 #define _PDCLIB_INT8_MAX   _PDCLIB_CHAR_MAX
 119 #define _PDCLIB_INT8_MIN   _PDCLIB_CHAR_MIN
 120 #define _PDCLIB_UINT8_MAX  _PDCLIB_UCHAR_MAX
 121 #define _PDCLIB_INT8_LITERAL
 122 #define _PDCLIB_UINT8_LITERAL
 123 #else
 124 #error Unsupported width of char (not 8 bits).
 125 #endif
 126
 127 /* Setting 'int16_t', its limits, and its literal                             */
 128 #if     _PDCLIB_INT_BYTES  == 2
 129 typedef signed int         _PDCLIB_int16_t;
 130 typedef unsigned int       _PDCLIB_uint16_t;
 131 #define _PDCLIB_INT16_MAX  _PDCLIB_INT_MAX
 132 #define _PDCLIB_INT16_MIN  _PDCLIB_INT_MIN
 133 #define _PDCLIB_UINT16_MAX _PDCLIB_UINT_MAX
 134 #define _PDCLIB_INT16_LITERAL
 135 #define _PDCLIB_UINT16_LITERAL
 136 #elif   _PDCLIB_SHRT_BYTES == 2
 137 typedef signed short       _PDCLIB_int16_t;
 138 typedef unsigned short     _PDCLIB_uint16_t;
 139 #define _PDCLIB_INT16_MAX  _PDCLIB_SHRT_MAX
 140 #define _PDCLIB_INT16_MIN  _PDCLIB_SHRT_MIN
 141 #define _PDCLIB_UINT16_MAX _PDCLIB_USHRT_MAX
 142 #define _PDCLIB_INT16_LITERAL  s
 143 #define _PDCLIB_UINT16_LITERAL us
 144 #else
 145 #error Neither 'short' nor 'int' are 16-bit.
 146 #endif
 147
 148 /* Setting 'int32_t', its limits, and its literal                             */
 149 #if     _PDCLIB_INT_BYTES  == 4
 150 typedef signed int         _PDCLIB_int32_t;
 151 typedef unsigned int       _PDCLIB_uint32_t;
 152 #define _PDCLIB_INT32_MAX  _PDCLIB_INT_MAX
 153 #define _PDCLIB_INT32_MIN  _PDCLIB_INT_MIN
 154 #define _PDCLIB_UINT32_MAX _PDCLIB_UINT_MAX
 155 #define _PDCLIB_INT32_LITERAL
 156 #define _PDCLIB_UINT32_LITERAL
 157 #elif   _PDCLIB_LONG_BYTES == 4
 158 typedef signed long        _PDCLIB_int32_t;
 159 typedef unsigned long      _PDCLIB_uint32_t;
 160 #define _PDCLIB_INT32_MAX  _PDCLIB_LONG_MAX
 161 #define _PDCLIB_INT32_MIN  _PDCLIB_LONG_MIN
 162 #define _PDCLIB_UINT32_MAX _PDCLIB_LONG_MAX
 163 #define _PDCLIB_INT32_LITERAL  l
 164 #define _PDCLIB_UINT32_LITERAL ul
 165 #else
 166 #error Neither 'int' nor 'long' are 32-bit.
 167 #endif
 168
 169 #if     _PDCLIB_LONG_BYTES == 8
 170 typedef signed long        _PDCLIB_int64_t;
 171 typedef unsigned long      _PDCLIB_uint64_t;
 172 #define _PDCLIB_INT64_MAX  _PDCLIB_LONG_MAX
 173 #define _PDCLIB_INT64_MIN  _PDCLIB_LONG_MIN
 174 #define _PDCLIB_UINT64_MAX  _PDCLIB_ULONG_MAX
 175 #define _PDCLIB_INT64_LITERAL  l
 176 #define _PDCLIB_UINT64_LITERAL ul
 177 #elif _PDCLIB_LLONG_BYTES  == 8
 178 typedef signed long long   _PDCLIB_int64_t;
 179 typedef unsigned long long _PDCLIB_uint64_t;
 180 #define _PDCLIB_INT64_MAX  _PDCLIB_LLONG_MAX
 181 #define _PDCLIB_INT64_MIN  _PDCLIB_LLONG_MIN
 182 #define _PDCLIB_UINT64_MAX  _PDCLIB_ULLONG_MAX
 183 #define _PDCLIB_INT64_LITERAL  ll
 184 #define _PDCLIB_UINT64_LITERAL ull
 185 #else
 186 #error Neither 'long' nor 'long long' are 64-bit.
 187 #endif
 188
 189 /* -------------------------------------------------------------------------- */
 190 /* <stdint.h> "fastest" types and their limits                                */
 191 /* -------------------------------------------------------------------------- */
 192 /* This is, admittedly, butt-ugly. But at least it's ugly where the average   */
 193 /* user of PDCLib will never see it, and makes <_PDCLIB_config.h> much        */
 194 /* cleaner.                                                                   */
 195 /* -------------------------------------------------------------------------- */
 196
 197 typedef _PDCLIB_fast8          _PDCLIB_int_fast8_t;
 198 typedef unsigned _PDCLIB_fast8 _PDCLIB_uint_fast8_t;
 199 #define _PDCLIB_INT_FAST8_MIN  concat( concat( _PDCLIB_, _PDCLIB_FAST8 ), _MIN )
 200 #define _PDCLIB_INT_FAST8_MAX  concat( concat( _PDCLIB_, _PDCLIB_FAST8 ), _MAX )
 201 #define _PDCLIB_UINT_FAST8_MAX concat( concat( _PDCLIB_U, _PDCLIB_FAST8 ), _MAX )
 202
 203 typedef _PDCLIB_fast16          _PDCLIB_int_fast16_t;
 204 typedef unsigned _PDCLIB_fast16 _PDCLIB_uint_fast16_t;
 205 #define _PDCLIB_INT_FAST16_MIN  concat( concat( _PDCLIB_, _PDCLIB_FAST16 ), _MIN )
 206 #define _PDCLIB_INT_FAST16_MAX  concat( concat( _PDCLIB_, _PDCLIB_FAST16 ), _MAX )
 207 #define _PDCLIB_UINT_FAST16_MAX concat( concat( _PDCLIB_U, _PDCLIB_FAST16 ), _MAX )
 208
 209 typedef _PDCLIB_fast32          _PDCLIB_int_fast32_t;
 210 typedef unsigned _PDCLIB_fast32 _PDCLIB_uint_fast32_t;
 211 #define _PDCLIB_INT_FAST32_MIN  concat( concat( _PDCLIB_, _PDCLIB_FAST32 ), _MIN )
 212 #define _PDCLIB_INT_FAST32_MAX  concat( concat( _PDCLIB_, _PDCLIB_FAST32 ), _MAX )
 213 #define _PDCLIB_UINT_FAST32_MAX concat( concat( _PDCLIB_U, _PDCLIB_FAST32 ), _MAX )
 214
 215 typedef _PDCLIB_fast64          _PDCLIB_int_fast64_t;
 216 typedef unsigned _PDCLIB_fast64 _PDCLIB_uint_fast64_t;
 217 #define _PDCLIB_INT_FAST64_MIN  concat( concat( _PDCLIB_, _PDCLIB_FAST64 ), _MIN )
 218 #define _PDCLIB_INT_FAST64_MAX  concat( concat( _PDCLIB_, _PDCLIB_FAST64 ), _MAX )
 219 #define _PDCLIB_UINT_FAST64_MAX concat( concat( _PDCLIB_U, _PDCLIB_FAST64 ), _MAX )
 220
 221 /* -------------------------------------------------------------------------- */
 222 /* Various <stddef.h> typedefs and limits                                     */
 223 /* -------------------------------------------------------------------------- */
 224
 225 typedef _PDCLIB_ptrdiff     _PDCLIB_ptrdiff_t;
 226 #define _PDCLIB_PTRDIFF_MIN concat( concat( _PDCLIB_, _PDCLIB_PTRDIFF ), _MIN )
 227 #define _PDCLIB_PTRDIFF_MAX concat( concat( _PDCLIB_, _PDCLIB_PTRDIFF ), _MAX )
 228
 229 #define _PDCLIB_SIG_ATOMIC_MIN concat( concat( _PDCLIB_, _PDCLIB_SIG_ATOMIC ), _MIN )
 230 #define _PDCLIB_SIG_ATOMIC_MAX concat( concat( _PDCLIB_, _PDCLIB_SIG_ATOMIC ), _MAX )
 231
 232 typedef _PDCLIB_size     _PDCLIB_size_t;
 233 #define _PDCLIB_SIZE_MAX concat( concat( _PDCLIB_, _PDCLIB_SIZE ), _MAX )
 234
 235 typedef _PDCLIB_wchar     _PDCLIB_wchar_t;
 236 #define _PDCLIB_WCHAR_MIN concat( concat( _PDCLIB_, _PDCLIB_WCHAR ), _MIN )
 237 #define _PDCLIB_WCHAR_MAX concat( concat( _PDCLIB_, _PDCLIB_WCHAR ), _MAX )
 238
 239 typedef _PDCLIB_intptr          _PDCLIB_intptr_t;
 240 typedef unsigned _PDCLIB_intptr _PDCLIB_uintptr_t;
 241 #define _PDCLIB_INTPTR_MIN  concat( concat( _PDCLIB_, _PDCLIB_INTPTR ), _MIN )
 242 #define _PDCLIB_INTPTR_MAX  concat( concat( _PDCLIB_, _PDCLIB_INTPTR ), _MAX )
 243 #define _PDCLIB_UINTPTR_MAX concat( concat( _PDCLIB_U, _PDCLIB_INTPTR ), _MAX )
 244
 245 typedef _PDCLIB_intmax          _PDCLIB_intmax_t;
 246 typedef unsigned _PDCLIB_intmax _PDCLIB_uintmax_t;
 247 #define _PDCLIB_INTMAX_MIN  concat( concat( _PDCLIB_, _PDCLIB_INTMAX ), _MIN )
 248 #define _PDCLIB_INTMAX_MAX  concat( concat( _PDCLIB_, _PDCLIB_INTMAX ), _MAX )
 249 #define _PDCLIB_UINTMAX_MAX concat( concat( _PDCLIB_U, _PDCLIB_INTMAX ), _MAX )
 250 #define _PDCLIB_INTMAX_C( value )  concat( value, _PDCLIB_INTMAX_LITERAL )
 251 #define _PDCLIB_UINTMAX_C( value ) concat( value, concat( u, _PDCLIB_INTMAX_LITERAL ) )
 252
 253 /* -------------------------------------------------------------------------- */
 254 /* Various <stdio.h> internals                                                */
 255 /* -------------------------------------------------------------------------- */
 256
 257 /* Flags for representing mode (see fopen()). */
 258 #define _PDCLIB_FREAD    1
 259 #define _PDCLIB_FWRITE   2
 260 #define _PDCLIB_FAPPEND  4
 261 #define _PDCLIB_FRW      8
 262 #define _PDCLIB_FBIN    16
 263
 264 struct
 265 {
 266     _PDCLIB_fd_t            handle;   /* OS-specific file descriptor */
 267     _PDCLIB_fpos_t          position; /* file position indicator */
 268     void *                  buffer;   /* file buffer */
 269     _PDCLIB_size_t          bufsize;  /* size of buffer */
 270     int                     status;   /* misc. status bits */
 271   /*mbstate_t               mbstate;    multibyte parse state - TODO: Unmask. */
 272     struct _PDCLIB_file_t * next;     /* provisions for linked list handling */
 273 } _PDCLIB_file_t;
 274
 275 /* -------------------------------------------------------------------------- */
 276 /* Declaration of helper functions (implemented in functions/_PDCLIB).        */
 277 /* -------------------------------------------------------------------------- */
 278
 279 /* This is the main function called by atoi(), atol() and atoll().            */
 280 _PDCLIB_intmax_t _PDCLIB_atomax( const char * s );
 281
 282 /* Two helper functions used by strtol(), strtoul() and long long variants.   */
 283 const char * _PDCLIB_strtox_prelim( const char * p, char * sign, int * base );
 284 _PDCLIB_uintmax_t _PDCLIB_strtox_main( const char ** p, unsigned int base, _PDCLIB_uintmax_t error, _PDCLIB_uintmax_t limval, _PDCLIB_uintmax_t limdigit, char * sign );
 285
 286 /* Digits array used by various integer conversion functions in <stdlib.h>    */
 287 extern char _PDCLIB_digits[];
 288
 289 /* -------------------------------------------------------------------------- */
 290 /* Internal data types                                                        */
 291 /* -------------------------------------------------------------------------- */
 292
 293 /* Structure required by both atexit() and exit() for handling atexit functions */
 294 struct _PDCLIB_exitfunc_t
 295 {
 296     struct _PDCLIB_exitfunc_t * next;
 297     void (*func)( void );
 298 };
 299
 300 /* Structures required by malloc(), realloc(), and free(). */
 301 struct _PDCLIB_headnode_t
 302 {
 303     struct _PDCLIB_memnode_t * first;
 304     struct _PDCLIB_memnode_t * last;
 305 };
 306
 307 struct _PDCLIB_memnode_t
 308 {
 309     _PDCLIB_size_t size;
 310     struct _PDCLIB_memnode_t * next;
 311 };
 312
 313 #if 0
 314
 315 /* fpos_t, an object type (not an array!) capable of storing any position
 316    information of a file.
 317 */
 318 typedef unsigned long long int  _PDCLIB_fpos_t;
 319
 320 /* file descriptor - a type used by the OS to identify a stream */
 321 typedef int                     _PDCLIB_fd_t;
 322
 323 #endif