3 /* PDCLib internal integer logic <_PDCLIB_int.h>
5 This file is part of the Public Domain C Library (PDCLib).
6 Permission is granted to use, modify, and / or redistribute at will.
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 /* -------------------------------------------------------------------------- */
14 #ifndef _PDCLIB_CONFIG_H
15 #define _PDCLIB_CONFIG_H _PDCLIB_CONFIG_H
16 #include <_PDCLIB_config.h>
20 #define _PDCLIB_AUX_H _PDCLIB_AUX_H
21 #include <_PDCLIB_aux.h>
24 /* null pointer constant */
25 #define _PDCLIB_NULL 0
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 /* -------------------------------------------------------------------------- */
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
46 #define _PDCLIB_CHAR_MIN 0
47 #define _PDCLIB_CHAR_MAX _PDCLIB_UCHAR_MAX
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
56 #error Unsupported width of 'short' (not 16 bit).
58 #define _PDCLIB_USHRT_MIN 0
60 #if _PDCLIB_INT_BYTES < _PDCLIB_SHRT_BYTES
61 #error Bogus setting: short > int? Check _PDCLIB_config.h.
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
78 #error Unsupported width of 'int' (neither 16, 32, nor 64 bit).
80 #define _PDCLIB_UINT_MIN 0
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
92 #error Unsupported width of 'long' (neither 32 nor 64 bit).
94 #define _PDCLIB_ULONG_MIN 0
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
106 #error Unsupported width of 'long long' (neither 64 nor 128 bit).
108 #define _PDCLIB_ULLONG_MIN 0
110 /* -------------------------------------------------------------------------- */
111 /* <stdint.h> exact-width types and their limits */
112 /* -------------------------------------------------------------------------- */
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
122 #error Unsupported width of char (not 8 bits).
125 /* Setting 'int16_t', its limits, and its literal */
126 #if _PDCLIB_INT_BYTES == 2
127 typedef signed int _PDCLIB_int16_t;
128 typedef unsigned int _PDCLIB_uint16_t;
129 #define _PDCLIB_INT16_MAX _PDCLIB_INT_MAX
130 #define _PDCLIB_INT16_MIN _PDCLIB_INT_MIN
131 #define _PDCLIB_UINT16_MAX _PDCLIB_UINT_MAX
132 #elif _PDCLIB_SHRT_BYTES == 2
133 typedef signed short _PDCLIB_int16_t;
134 typedef unsigned short _PDCLIB_uint16_t;
135 #define _PDCLIB_INT16_MAX _PDCLIB_SHRT_MAX
136 #define _PDCLIB_INT16_MIN _PDCLIB_SHRT_MIN
137 #define _PDCLIB_UINT16_MAX _PDCLIB_USHRT_MAX
139 #error Neither 'short' nor 'int' are 16-bit.
142 /* Setting 'int32_t', its limits, and its literal */
143 #if _PDCLIB_INT_BYTES == 4
144 typedef signed int _PDCLIB_int32_t;
145 typedef unsigned int _PDCLIB_uint32_t;
146 #define _PDCLIB_INT32_MAX _PDCLIB_INT_MAX
147 #define _PDCLIB_INT32_MIN _PDCLIB_INT_MIN
148 #define _PDCLIB_UINT32_MAX _PDCLIB_UINT_MAX
149 #define _PDCLIB_INT32_LITERAL
150 #define _PDCLIB_UINT32_LITERAL
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
160 #error Neither 'int' nor 'long' are 32-bit.
163 #if _PDCLIB_LONG_BYTES == 8
164 typedef signed long _PDCLIB_int64_t;
165 typedef unsigned long _PDCLIB_uint64_t;
166 #define _PDCLIB_INT64_MAX _PDCLIB_LONG_MAX
167 #define _PDCLIB_INT64_MIN _PDCLIB_LONG_MIN
168 #define _PDCLIB_UINT64_MAX _PDCLIB_ULONG_MAX
169 #define _PDCLIB_INT64_LITERAL l
170 #define _PDCLIB_UINT64_LITERAL ul
171 #elif _PDCLIB_LLONG_BYTES == 8
172 typedef signed long long _PDCLIB_int64_t;
173 typedef unsigned long long _PDCLIB_uint64_t;
174 #define _PDCLIB_INT64_MAX _PDCLIB_LLONG_MAX
175 #define _PDCLIB_INT64_MIN _PDCLIB_LLONG_MIN
176 #define _PDCLIB_UINT64_MAX _PDCLIB_ULLONG_MAX
177 #define _PDCLIB_INT64_LITERAL ll
178 #define _PDCLIB_UINT64_LITERAL ull
180 #error Neither 'long' nor 'long long' are 64-bit.
183 /* -------------------------------------------------------------------------- */
184 /* <stdint.h> "fastest" types and their limits */
185 /* -------------------------------------------------------------------------- */
186 /* This is, admittedly, butt-ugly. But at least it's ugly where the average */
187 /* user of PDCLib will never see it, and makes <_PDCLIB_config.h> much */
189 /* -------------------------------------------------------------------------- */
191 typedef _PDCLIB_fast8 _PDCLIB_int_fast8_t;
192 typedef unsigned _PDCLIB_fast8 _PDCLIB_uint_fast8_t;
193 #define _PDCLIB_INT_FAST8_MIN _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_FAST8 ), _MIN )
194 #define _PDCLIB_INT_FAST8_MAX _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_FAST8 ), _MAX )
195 #define _PDCLIB_UINT_FAST8_MAX _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_U, _PDCLIB_FAST8 ), _MAX )
197 typedef _PDCLIB_fast16 _PDCLIB_int_fast16_t;
198 typedef unsigned _PDCLIB_fast16 _PDCLIB_uint_fast16_t;
199 #define _PDCLIB_INT_FAST16_MIN _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_FAST16 ), _MIN )
200 #define _PDCLIB_INT_FAST16_MAX _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_FAST16 ), _MAX )
201 #define _PDCLIB_UINT_FAST16_MAX _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_U, _PDCLIB_FAST16 ), _MAX )
203 typedef _PDCLIB_fast32 _PDCLIB_int_fast32_t;
204 typedef unsigned _PDCLIB_fast32 _PDCLIB_uint_fast32_t;
205 #define _PDCLIB_INT_FAST32_MIN _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_FAST32 ), _MIN )
206 #define _PDCLIB_INT_FAST32_MAX _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_FAST32 ), _MAX )
207 #define _PDCLIB_UINT_FAST32_MAX _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_U, _PDCLIB_FAST32 ), _MAX )
209 typedef _PDCLIB_fast64 _PDCLIB_int_fast64_t;
210 typedef unsigned _PDCLIB_fast64 _PDCLIB_uint_fast64_t;
211 #define _PDCLIB_INT_FAST64_MIN _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_FAST64 ), _MIN )
212 #define _PDCLIB_INT_FAST64_MAX _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_FAST64 ), _MAX )
213 #define _PDCLIB_UINT_FAST64_MAX _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_U, _PDCLIB_FAST64 ), _MAX )
215 /* -------------------------------------------------------------------------- */
216 /* Various <stddef.h> typedefs and limits */
217 /* -------------------------------------------------------------------------- */
219 typedef _PDCLIB_ptrdiff _PDCLIB_ptrdiff_t;
220 #define _PDCLIB_PTRDIFF_MIN _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_PTRDIFF ), _MIN )
221 #define _PDCLIB_PTRDIFF_MAX _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_PTRDIFF ), _MAX )
223 #define _PDCLIB_SIG_ATOMIC_MIN _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_SIG_ATOMIC ), _MIN )
224 #define _PDCLIB_SIG_ATOMIC_MAX _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_SIG_ATOMIC ), _MAX )
226 typedef _PDCLIB_size _PDCLIB_size_t;
227 #define _PDCLIB_SIZE_MAX _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_SIZE ), _MAX )
229 typedef _PDCLIB_wchar _PDCLIB_wchar_t;
230 #define _PDCLIB_WCHAR_MIN _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_WCHAR ), _MIN )
231 #define _PDCLIB_WCHAR_MAX _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_WCHAR ), _MAX )
233 typedef _PDCLIB_intptr _PDCLIB_intptr_t;
234 typedef unsigned _PDCLIB_intptr _PDCLIB_uintptr_t;
235 #define _PDCLIB_INTPTR_MIN _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_INTPTR ), _MIN )
236 #define _PDCLIB_INTPTR_MAX _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_INTPTR ), _MAX )
237 #define _PDCLIB_UINTPTR_MAX _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_U, _PDCLIB_INTPTR ), _MAX )
239 typedef _PDCLIB_intmax _PDCLIB_intmax_t;
240 typedef unsigned _PDCLIB_intmax _PDCLIB_uintmax_t;
241 #define _PDCLIB_INTMAX_MIN _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_INTMAX ), _MIN )
242 #define _PDCLIB_INTMAX_MAX _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_INTMAX ), _MAX )
243 #define _PDCLIB_UINTMAX_MAX _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_U, _PDCLIB_INTMAX ), _MAX )
244 #define _PDCLIB_INTMAX_C( value ) _PDCLIB_concat( value, _PDCLIB_INTMAX_LITERAL )
245 #define _PDCLIB_UINTMAX_C( value ) _PDCLIB_concat( value, _PDCLIB_concat( u, _PDCLIB_INTMAX_LITERAL ) )
247 /* -------------------------------------------------------------------------- */
248 /* Various <stdio.h> internals */
249 /* -------------------------------------------------------------------------- */
251 /* Flags for representing mode (see fopen()). Note these must fit the same
252 status field as the _IO?BF flags in <stdio.h> and the internal flags below.
254 #define _PDCLIB_FREAD 8u
255 #define _PDCLIB_FWRITE 16u
256 #define _PDCLIB_FAPPEND 32u
257 #define _PDCLIB_FRW 64u
258 #define _PDCLIB_FBIN 128u
260 /* Internal flags, made to fit the same status field as the flags above. */
261 #define _PDCLIB_FREEBUFFER 512u
262 #define _PDCLIB_ERRORFLAG 1024u
263 #define _PDCLIB_EOFFLAG 2048u
264 #define _PDCLIB_WIDESTREAM 4096u
265 #define _PDCLIB_BYTESTREAM 8192u
266 #define _PDCLIB_DELONCLOSE 16384u
268 /* Position / status structure for getpos() / fsetpos(). */
269 struct _PDCLIB_fpos_t
271 _PDCLIB_uint64_t offset; /* File position offset */
272 int status; /* Multibyte parsing state (unused, reserved) */
276 struct _PDCLIB_file_t
278 _PDCLIB_fd_t handle; /* OS file handle */
279 char * buffer; /* Pointer to buffer memory */
280 _PDCLIB_size_t bufsize; /* Size of buffer */
281 _PDCLIB_size_t bufidx; /* Index of current position in buffer */
282 _PDCLIB_size_t bufend; /* Index of last pre-read character in buffer */
283 struct _PDCLIB_fpos_t pos; /* Offset and multibyte parsing state */
284 _PDCLIB_size_t ungetidx; /* Number of ungetc()'ed characters */
285 unsigned char * ungetbuf; /* ungetc() buffer */
286 unsigned int status; /* Status flags; see above */
287 /* multibyte parsing status to be added later */
288 char * filename; /* Name the current stream has been opened with */
289 struct _PDCLIB_file_t * next; /* Pointer to next struct (internal) */
292 /* -------------------------------------------------------------------------- */
293 /* Internal data types */
294 /* -------------------------------------------------------------------------- */
296 /* Structure required by both atexit() and exit() for handling atexit functions */
297 struct _PDCLIB_exitfunc_t
299 struct _PDCLIB_exitfunc_t * next;
300 void (*func)( void );
303 /* Structures required by malloc(), realloc(), and free(). */
304 struct _PDCLIB_headnode_t
306 struct _PDCLIB_memnode_t * first;
307 struct _PDCLIB_memnode_t * last;
310 struct _PDCLIB_memnode_t
313 struct _PDCLIB_memnode_t * next;
316 /* Status structure required by _PDCLIB_print(). */
317 struct _PDCLIB_status_t
319 int base; /* base to which the value shall be converted */
320 _PDCLIB_int_fast32_t flags; /* flags and length modifiers */
321 _PDCLIB_size_t n; /* print: maximum characters to be written */
322 /* scan: number matched conversion specifiers */
323 _PDCLIB_size_t i; /* number of characters read/written */
324 _PDCLIB_size_t current;/* chars read/written in the CURRENT conversion */
325 char * s; /* *sprintf(): target buffer */
326 /* *sscanf(): source string */
327 _PDCLIB_size_t width; /* specified field width */
328 _PDCLIB_size_t prec; /* specified field precision */
329 struct _PDCLIB_file_t * stream; /* *fprintf() / *fscanf() stream */
330 _PDCLIB_va_list arg; /* argument stack */
333 /* -------------------------------------------------------------------------- */
334 /* Declaration of helper functions (implemented in functions/_PDCLIB). */
335 /* -------------------------------------------------------------------------- */
337 /* This is the main function called by atoi(), atol() and atoll(). */
338 _PDCLIB_intmax_t _PDCLIB_atomax( const char * s );
340 /* Two helper functions used by strtol(), strtoul() and long long variants. */
341 const char * _PDCLIB_strtox_prelim( const char * p, char * sign, int * base );
342 _PDCLIB_uintmax_t _PDCLIB_strtox_main( const char ** p, unsigned int base, _PDCLIB_uintmax_t error, _PDCLIB_uintmax_t limval, int limdigit, char * sign );
344 /* Digits arrays used by various integer conversion functions */
345 extern char _PDCLIB_digits[];
346 extern char _PDCLIB_Xdigits[];
348 /* The worker for all printf() type of functions. The pointer spec should point
349 to the introducing '%' of a conversion specifier. The status structure is to
350 be that of the current printf() function, of which the members n, s, stream
351 and arg will be preserved; i will be updated; and all others will be trashed
353 Returns a pointer to the first character not parsed as conversion specifier.
355 const char * _PDCLIB_print( const char * spec, struct _PDCLIB_status_t * status );
357 /* The worker for all scanf() type of functions. The pointer spec should point
358 to the introducing '%' of a conversion specifier. The status structure is to
359 be that of the current scanf() function, of which the member stream will be
360 preserved; n, i, and s will be updated; and all others will be trashed by
362 Returns a pointer to the first character not parsed as conversion specifier,
363 or NULL in case of error.
364 FIXME: Should distinguish between matching and input error
366 const char * _PDCLIB_scan( const char * spec, struct _PDCLIB_status_t * status );
368 /* Parsing any fopen() style filemode string into a number of flags. */
369 unsigned int _PDCLIB_filemode( const char * mode );
371 /* Sanity checking and preparing of read buffer, should be called first thing
372 by any stdio read-data function.
373 Returns 0 on success, EOF on error.
374 On error, EOF / error flags and errno are set appropriately.
376 int _PDCLIB_prepread( struct _PDCLIB_file_t * stream );
378 /* Sanity checking, should be called first thing by any stdio write-data
380 Returns 0 on success, EOF on error.
381 On error, error flags and errno are set appropriately.
383 int _PDCLIB_prepwrite( struct _PDCLIB_file_t * stream );
385 /* Closing all streams on program exit */
386 void _PDCLIB_closeall( void );
388 /* -------------------------------------------------------------------------- */
390 /* -------------------------------------------------------------------------- */
392 extern int _PDCLIB_errno;
393 int * _PDCLIB_errno_func( void );
395 /* ERANGE and EDOM are specified by the standard. */
396 #define _PDCLIB_ERANGE 1
397 #define _PDCLIB_EDOM 2
398 /* Used in the example implementation for any kind of I/O error. */
399 #define _PDCLIB_EIO 3
400 /* Used in the example implementation for "unknown error". */
401 #define _PDCLIB_EUNKNOWN 4
402 /* Used in the example implementation for "invalid parameter value". */
403 #define _PDCLIB_EINVAL 5
404 /* Used in the example implementation for "I/O retries exceeded". */
405 #define _PDCLIB_ERETRY 6
406 /* One larger than the largest used errno */
407 #define _PDCLIB_EMAX 7
409 /* TODO: Doing this via a static array is not the way to do it. */
410 char const * _PDCLIB_errno_texts[ _PDCLIB_EMAX ];