134123a1862fa650a1bccb0be8bb8186c8f638fd
[pdclib.old] / internals / _PDCLIB_int.h
1 #ifndef __PDCLIB_INT_H
2 #define __PDCLIB_INT_H __PDCLIB_INT_H
3
4 /* PDCLib internal integer logic <_PDCLIB_int.h>
5
6    This file is part of the Public Domain C Library (PDCLib).
7    Permission is granted to use, modify, and / or redistribute at will.
8 */
9
10 /* -------------------------------------------------------------------------- */
11 /* You should not have to edit anything in this file; if you DO have to, it   */
12 /* would be considered a bug / missing feature: notify the author(s).         */
13 /* -------------------------------------------------------------------------- */
14
15 #include <_PDCLIB_config.h>
16 #include <_PDCLIB_aux.h>
17
18 /* null pointer constant */
19 #define _PDCLIB_NULL 0
20
21 /* -------------------------------------------------------------------------- */
22 /* Limits of native datatypes                                                 */
23 /* -------------------------------------------------------------------------- */
24 /* The definition of minimum limits for unsigned datatypes is done because    */
25 /* later on we will "construct" limits for other abstract types:              */
26 /* USHRT -> _PDCLIB_ + USHRT + _MIN -> _PDCLIB_USHRT_MIN -> 0                 */
27 /* INT -> _PDCLIB_ + INT + _MIN -> _PDCLIB_INT_MIN -> ... you get the idea.   */
28 /* -------------------------------------------------------------------------- */
29
30 /* Setting 'char' limits                                                      */
31 #define _PDCLIB_CHAR_BIT    8
32 #define _PDCLIB_UCHAR_MIN   0
33 #define _PDCLIB_UCHAR_MAX   0xff
34 #define _PDCLIB_SCHAR_MIN   (-0x7f - 1)
35 #define _PDCLIB_SCHAR_MAX   0x7f
36 #ifdef  _PDCLIB_CHAR_SIGNED
37 #define _PDCLIB_CHAR_MIN    _PDCLIB_SCHAR_MIN
38 #define _PDCLIB_CHAR_MAX    _PDCLIB_SCHAR_MAX
39 #else
40 #define _PDCLIB_CHAR_MIN    0
41 #define _PDCLIB_CHAR_MAX    _PDCLIB_UCHAR_MAX
42 #endif
43
44 /* Setting 'short' limits                                                     */
45 #if     _PDCLIB_SHRT_BYTES == 2
46 #define _PDCLIB_SHRT_MAX      0x7fff
47 #define _PDCLIB_SHRT_MIN      (-0x7fff - 1)
48 #define _PDCLIB_USHRT_MAX     0xffff
49 #else
50 #error Unsupported width of 'short' (not 16 bit).
51 #endif
52 #define _PDCLIB_USHRT_MIN 0
53
54 #if _PDCLIB_INT_BYTES < _PDCLIB_SHRT_BYTES
55 #error Bogus setting: short > int? Check _PDCLIB_config.h.
56 #endif
57
58 /* Setting 'int' limits                                                       */
59 #if     _PDCLIB_INT_BYTES == 2
60 #define _PDCLIB_INT_MAX   0x7fff
61 #define _PDCLIB_INT_MIN   (-0x7fff - 1)
62 #define _PDCLIB_UINT_MAX  0xffffU
63 #elif   _PDCLIB_INT_BYTES == 4
64 #define _PDCLIB_INT_MAX   0x7fffffff
65 #define _PDCLIB_INT_MIN   (-0x7fffffff - 1)
66 #define _PDCLIB_UINT_MAX  0xffffffffU
67 #elif _PDCLIB_INT_BYTES   == 8
68 #define _PDCLIB_INT_MAX   0x7fffffffffffffff
69 #define _PDCLIB_INT_MIN   (-0x7fffffffffffffff - 1)
70 #define _PDCLIB_UINT_MAX  0xffffffffffffffff
71 #else
72 #error Unsupported width of 'int' (neither 16, 32, nor 64 bit).
73 #endif
74 #define _PDCLIB_UINT_MIN 0
75
76 /* Setting 'long' limits                                                      */
77 #if   _PDCLIB_LONG_BYTES   == 4
78 #define _PDCLIB_LONG_MAX   0x7fffffffL
79 #define _PDCLIB_LONG_MIN   (-0x7fffffffL - 1L)
80 #define _PDCLIB_ULONG_MAX  0xffffffffUL
81 #elif   _PDCLIB_LONG_BYTES == 8
82 #define _PDCLIB_LONG_MAX   0x7fffffffffffffffL
83 #define _PDCLIB_LONG_MIN   (-0x7fffffffffffffffL - 1L)
84 #define _PDCLIB_ULONG_MAX  0xffffffffffffffffUL
85 #else
86 #error Unsupported width of 'long' (neither 32 nor 64 bit).
87 #endif
88 #define _PDCLIB_ULONG_MIN 0
89
90 /* Setting 'long long' limits                                                 */
91 #if _PDCLIB_LLONG_BYTES    == 8
92 #define _PDCLIB_LLONG_MAX  0x7fffffffffffffffLL
93 #define _PDCLIB_LLONG_MIN  (-0x7fffffffffffffffLL - 1LL)
94 #define _PDCLIB_ULLONG_MAX 0xffffffffffffffffULL
95 #elif _PDCLIB_LLONG_BYTES  == 16
96 #define _PDCLIB_LLONG_MAX  0x7fffffffffffffffffffffffffffffffLL
97 #define _PDCLIB_LLONG_MIN  (-0x7fffffffffffffffffffffffffffffffLL - 1LL)
98 #define _PDCLIB_ULLONG_MAX 0xffffffffffffffffffffffffffffffffULL
99 #else
100 #error Unsupported width of 'long long' (neither 64 nor 128 bit).
101 #endif
102 #define _PDCLIB_ULLONG_MIN 0
103
104 /* -------------------------------------------------------------------------- */
105 /* <stdint.h> exact-width types and their limits                              */
106 /* -------------------------------------------------------------------------- */
107 /* Note that, for the "standard" widths of 8, 16, 32 and 64 bit, the "LEAST"  */
108 /* types are identical to the "exact-width" types, by definition.             */
109
110 /* Setting 'int8_t', its limits, its literal, and conversion macros.          */
111 #if     _PDCLIB_CHAR_BIT == 8
112 typedef signed char        _PDCLIB_int8_t;
113 typedef unsigned char      _PDCLIB_uint8_t;
114 #define _PDCLIB_INT8_MAX   _PDCLIB_CHAR_MAX
115 #define _PDCLIB_INT8_MIN   _PDCLIB_CHAR_MIN
116 #define _PDCLIB_UINT8_MAX  _PDCLIB_UCHAR_MAX
117 #define _PDCLIB_8_CONV     hh
118 #else
119 #error Unsupported width of char (not 8 bits).
120 #endif
121
122 /* Setting 'int16_t', its limits, its literal, and conversion macros.         */
123 #if     _PDCLIB_INT_BYTES  == 2
124 typedef signed int         _PDCLIB_int16_t;
125 typedef unsigned int       _PDCLIB_uint16_t;
126 #define _PDCLIB_INT16_MAX  _PDCLIB_INT_MAX
127 #define _PDCLIB_INT16_MIN  _PDCLIB_INT_MIN
128 #define _PDCLIB_UINT16_MAX _PDCLIB_UINT_MAX
129 #define _PDCLIB_16_CONV
130 #elif   _PDCLIB_SHRT_BYTES == 2
131 typedef signed short       _PDCLIB_int16_t;
132 typedef unsigned short     _PDCLIB_uint16_t;
133 #define _PDCLIB_INT16_MAX  _PDCLIB_SHRT_MAX
134 #define _PDCLIB_INT16_MIN  _PDCLIB_SHRT_MIN
135 #define _PDCLIB_UINT16_MAX _PDCLIB_USHRT_MAX
136 #define _PDCLIB_16_CONV    h
137 #else
138 #error Neither 'short' nor 'int' are 16-bit.
139 #endif
140
141 /* Setting 'int32_t', its limits, its literal, and conversion macros.         */
142 #if     _PDCLIB_INT_BYTES  == 4
143 typedef signed int         _PDCLIB_int32_t;
144 typedef unsigned int       _PDCLIB_uint32_t;
145 #define _PDCLIB_INT32_MAX  _PDCLIB_INT_MAX
146 #define _PDCLIB_INT32_MIN  _PDCLIB_INT_MIN
147 #define _PDCLIB_UINT32_MAX _PDCLIB_UINT_MAX
148 #define _PDCLIB_INT32_LITERAL
149 #define _PDCLIB_UINT32_LITERAL
150 #define _PDCLIB_32_CONV
151 #elif   _PDCLIB_LONG_BYTES == 4
152 typedef signed long        _PDCLIB_int32_t;
153 typedef unsigned long      _PDCLIB_uint32_t;
154 #define _PDCLIB_INT32_MAX  _PDCLIB_LONG_MAX
155 #define _PDCLIB_INT32_MIN  _PDCLIB_LONG_MIN
156 #define _PDCLIB_UINT32_MAX _PDCLIB_LONG_MAX
157 #define _PDCLIB_INT32_LITERAL  l
158 #define _PDCLIB_UINT32_LITERAL ul
159 #define _PDCLIB_32_CONV        l
160 #else
161 #error Neither 'int' nor 'long' are 32-bit.
162 #endif
163
164 /* Setting 'int64_t', its limits, its literal, and conversion macros.         */
165 #if     _PDCLIB_LONG_BYTES == 8 && !defined(_PDCLIB_INT64_IS_LLONG)
166 typedef signed long        _PDCLIB_int64_t;
167 typedef unsigned long      _PDCLIB_uint64_t;
168 #define _PDCLIB_INT64_MAX  _PDCLIB_LONG_MAX
169 #define _PDCLIB_INT64_MIN  _PDCLIB_LONG_MIN
170 #define _PDCLIB_UINT64_MAX  _PDCLIB_ULONG_MAX
171 #define _PDCLIB_INT64_LITERAL  l
172 #define _PDCLIB_UINT64_LITERAL ul
173 #define _PDCLIB_64_CONV        l
174 #elif _PDCLIB_LLONG_BYTES  == 8
175 typedef signed long long   _PDCLIB_int64_t;
176 typedef unsigned long long _PDCLIB_uint64_t;
177 #define _PDCLIB_INT64_MAX  _PDCLIB_LLONG_MAX
178 #define _PDCLIB_INT64_MIN  _PDCLIB_LLONG_MIN
179 #define _PDCLIB_UINT64_MAX  _PDCLIB_ULLONG_MAX
180 #define _PDCLIB_INT64_LITERAL  ll
181 #define _PDCLIB_UINT64_LITERAL ull
182 #define _PDCLIB_64_CONV        ll
183 #else
184 #error Neither 'long' nor 'long long' are 64-bit.
185 #endif
186
187 /* -------------------------------------------------------------------------- */
188 /* <stdint.h> "fastest" types and their limits                                */
189 /* -------------------------------------------------------------------------- */
190 /* This is, admittedly, butt-ugly. But at least it's ugly where the average   */
191 /* user of PDCLib will never see it, and makes <_PDCLIB_config.h> much        */
192 /* cleaner.                                                                   */
193 /* -------------------------------------------------------------------------- */
194
195 typedef _PDCLIB_fast8          _PDCLIB_int_fast8_t;
196 typedef unsigned _PDCLIB_fast8 _PDCLIB_uint_fast8_t;
197 #define _PDCLIB_INT_FAST8_MIN  _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_FAST8 ), _MIN )
198 #define _PDCLIB_INT_FAST8_MAX  _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_FAST8 ), _MAX )
199 #define _PDCLIB_UINT_FAST8_MAX _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_U, _PDCLIB_FAST8 ), _MAX )
200
201 typedef _PDCLIB_fast16          _PDCLIB_int_fast16_t;
202 typedef unsigned _PDCLIB_fast16 _PDCLIB_uint_fast16_t;
203 #define _PDCLIB_INT_FAST16_MIN  _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_FAST16 ), _MIN )
204 #define _PDCLIB_INT_FAST16_MAX  _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_FAST16 ), _MAX )
205 #define _PDCLIB_UINT_FAST16_MAX _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_U, _PDCLIB_FAST16 ), _MAX )
206
207 typedef _PDCLIB_fast32          _PDCLIB_int_fast32_t;
208 typedef unsigned _PDCLIB_fast32 _PDCLIB_uint_fast32_t;
209 #define _PDCLIB_INT_FAST32_MIN  _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_FAST32 ), _MIN )
210 #define _PDCLIB_INT_FAST32_MAX  _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_FAST32 ), _MAX )
211 #define _PDCLIB_UINT_FAST32_MAX _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_U, _PDCLIB_FAST32 ), _MAX )
212
213 typedef _PDCLIB_fast64          _PDCLIB_int_fast64_t;
214 typedef unsigned _PDCLIB_fast64 _PDCLIB_uint_fast64_t;
215 #define _PDCLIB_INT_FAST64_MIN  _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_FAST64 ), _MIN )
216 #define _PDCLIB_INT_FAST64_MAX  _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_FAST64 ), _MAX )
217 #define _PDCLIB_UINT_FAST64_MAX _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_U, _PDCLIB_FAST64 ), _MAX )
218
219 /* -------------------------------------------------------------------------- */
220 /* Various <stddef.h> typedefs and limits                                     */
221 /* -------------------------------------------------------------------------- */
222
223 typedef _PDCLIB_ptrdiff     _PDCLIB_ptrdiff_t;
224 #define _PDCLIB_PTRDIFF_MIN _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_PTRDIFF ), _MIN )
225 #define _PDCLIB_PTRDIFF_MAX _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_PTRDIFF ), _MAX )
226
227 #define _PDCLIB_SIG_ATOMIC_MIN _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_SIG_ATOMIC ), _MIN )
228 #define _PDCLIB_SIG_ATOMIC_MAX _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_SIG_ATOMIC ), _MAX )
229
230 typedef _PDCLIB_size     _PDCLIB_size_t;
231 #define _PDCLIB_SIZE_MAX _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_SIZE ), _MAX )
232
233 typedef _PDCLIB_wint      _PDCLIB_wint_t;
234 #ifndef __cplusplus
235     typedef _PDCLIB_wchar     _PDCLIB_wchar_t;
236 #else
237     typedef wchar_t _PDCLIB_wchar_t;
238 #endif
239 #define _PDCLIB_WCHAR_MIN _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_WCHAR ), _MIN )
240 #define _PDCLIB_WCHAR_MAX _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_WCHAR ), _MAX )
241
242 typedef _PDCLIB_intptr          _PDCLIB_intptr_t;
243 typedef unsigned _PDCLIB_intptr _PDCLIB_uintptr_t;
244 #define _PDCLIB_INTPTR_MIN  _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_INTPTR ), _MIN )
245 #define _PDCLIB_INTPTR_MAX  _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_INTPTR ), _MAX )
246 #define _PDCLIB_UINTPTR_MAX _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_U, _PDCLIB_INTPTR ), _MAX )
247
248 typedef _PDCLIB_intmax          _PDCLIB_intmax_t;
249 typedef unsigned _PDCLIB_intmax _PDCLIB_uintmax_t;
250 #define _PDCLIB_INTMAX_MIN  _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_INTMAX ), _MIN )
251 #define _PDCLIB_INTMAX_MAX  _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_INTMAX ), _MAX )
252 #define _PDCLIB_UINTMAX_MAX _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_U, _PDCLIB_INTMAX ), _MAX )
253 #define _PDCLIB_INTMAX_C( value )  _PDCLIB_concat( value, _PDCLIB_INTMAX_LITERAL )
254 #define _PDCLIB_UINTMAX_C( value ) _PDCLIB_concat( value, _PDCLIB_concat( u, _PDCLIB_INTMAX_LITERAL ) )
255
256 /* -------------------------------------------------------------------------- */
257 /* Various <time.h> internals                                                 */
258 /* -------------------------------------------------------------------------- */
259
260 typedef _PDCLIB_time            _PDCLIB_time_t;
261 typedef _PDCLIB_clock           _PDCLIB_clock_t;
262
263 #if !defined(_PDCLIB_DEFINE_STRUCT_TIMESPEC)
264 #define _PDCLIB_DEFINE_STRUCT_TIMESPEC()    \
265     struct timespec {                       \
266         time_t tv_sec;                      \
267         long tv_nsec;                       \
268     };
269 #endif
270
271 #if !defined(_PDCLIB_DEFINE_STRUCT_TM)
272 #define _PDCLIB_DEFINE_STRUCT_TM()          \
273     struct tm {                             \
274         int tm_sec;                         \
275         int tm_min;                         \
276         int tm_hour;                        \
277         int tm_mday;                        \
278         int tm_mon;                         \
279         int tm_year;                        \
280         int tm_wday;                        \
281         int tm_yday;                        \
282         int tm_isdst;                       \
283     };
284 #endif
285
286 /* -------------------------------------------------------------------------- */
287 /* Internal data types                                                        */
288 /* -------------------------------------------------------------------------- */
289
290 /* Structure required by both atexit() and exit() for handling atexit functions */
291 struct _PDCLIB_exitfunc_t
292 {
293     struct _PDCLIB_exitfunc_t * next;
294     void (*func)( void );
295 };
296
297 /* -------------------------------------------------------------------------- */
298 /* Declaration of helper functions (implemented in functions/_PDCLIB).        */
299 /* -------------------------------------------------------------------------- */
300
301 /* This is the main function called by atoi(), atol() and atoll().            */
302 _PDCLIB_intmax_t _PDCLIB_atomax( const char * s );
303
304 /* Two helper functions used by strtol(), strtoul() and long long variants.   */
305 const char * _PDCLIB_strtox_prelim( const char * p, char * sign, int * base );
306 _PDCLIB_uintmax_t _PDCLIB_strtox_main( const char ** p, unsigned int base, _PDCLIB_uintmax_t error, _PDCLIB_uintmax_t limval, int limdigit, char * sign );
307
308 /* Digits arrays used by various integer conversion functions */
309 extern char _PDCLIB_digits[];
310 extern char _PDCLIB_Xdigits[];
311
312 /* -------------------------------------------------------------------------- */
313 /* locale / wchar / uchar                                                     */
314 /* -------------------------------------------------------------------------- */
315
316 #ifndef __cplusplus
317 typedef _PDCLIB_uint16_t        _PDCLIB_char16_t;
318 typedef _PDCLIB_uint32_t        _PDCLIB_char32_t;
319 #else
320 typedef char16_t                _PDCLIB_char16_t;
321 typedef char32_t                _PDCLIB_char32_t;
322 #endif
323
324 typedef struct _PDCLIB_mbstate {
325     union {
326         /* Is this the best way to represent this? Is this big enough? */
327         _PDCLIB_uint64_t _St64[15];
328         _PDCLIB_uint32_t _St32[31];
329         _PDCLIB_uint16_t _St16[62];
330         unsigned char    _StUC[124];
331         signed   char    _StSC[124];
332                  char    _StC [124];
333     };
334
335     /* c16/related functions: Surrogate storage
336      *
337      * If zero, no surrogate pending. If nonzero, surrogate.
338      */
339     _PDCLIB_uint16_t     _Surrogate;
340
341     /* In cases where the underlying codec is capable of regurgitating a 
342      * character without consuming any extra input (e.g. a surrogate pair in a
343      * UCS-4 to UTF-16 conversion) then these fields are used to track that 
344      * state. In particular, they are used to buffer/fake the input for mbrtowc
345      * and similar functions.
346      *
347      * See _PDCLIB_encoding.h for values of _PendState and the resultant value 
348      * in _PendChar.
349      */
350     unsigned char _PendState;
351              char _PendChar;
352 } _PDCLIB_mbstate_t;
353
354 typedef struct _PDCLIB_charcodec *_PDCLIB_charcodec_t;
355 typedef struct _PDCLIB_locale    *_PDCLIB_locale_t;
356 typedef struct lconv              _PDCLIB_lconv_t;
357
358 _PDCLIB_size_t _PDCLIB_mb_cur_max( void );
359
360 /* -------------------------------------------------------------------------- */
361 /* stdio                                                                      */
362 /* -------------------------------------------------------------------------- */
363
364 /* Position / status structure for getpos() / fsetpos(). */
365 typedef struct _PDCLIB_fpos
366 {
367     _PDCLIB_int_fast64_t offset; /* File position offset */
368     _PDCLIB_mbstate_t    mbs;    /* Multibyte parsing state */
369 } _PDCLIB_fpos_t;
370
371 typedef struct _PDCLIB_fileops  _PDCLIB_fileops_t;
372 typedef union  _PDCLIB_fd       _PDCLIB_fd_t;
373 typedef struct _PDCLIB_file     _PDCLIB_file_t; // Rename to _PDCLIB_FILE?
374
375 /* Status structure required by _PDCLIB_print(). */
376 struct _PDCLIB_status_t
377 {
378     int              base;   /* base to which the value shall be converted   */
379     _PDCLIB_int_fast32_t flags; /* flags and length modifiers                */
380     unsigned         n;      /* print: maximum characters to be written      */
381                              /* scan:  number matched conversion specifiers  */
382     unsigned         i;      /* number of characters read/written            */
383     unsigned         current;/* chars read/written in the CURRENT conversion */
384     char *           s;      /* *sprintf(): target buffer                    */
385                              /* *sscanf():  source string                    */
386     unsigned         width;  /* specified field width                        */
387     int              prec;   /* specified field precision                    */
388     _PDCLIB_file_t * stream; /* *fprintf() / *fscanf() stream         */
389     _PDCLIB_va_list  arg;    /* argument stack                               */
390 };
391
392 #endif