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 0xffffffffffffffffffffffffffffffffULL
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 /* -------------------------------------------------------------------------- */
113 /* Note that, for the "standard" widths of 8, 16, 32 and 64 bit, the "LEAST" */
114 /* types are identical to the "exact-width" types, by definition. */
116 /* Setting 'int8_t', its limits, its literal, and conversion macros. */
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_8_CONV hh
125 #error Unsupported width of char (not 8 bits).
128 /* Setting 'int16_t', its limits, its literal, and conversion macros. */
129 #if _PDCLIB_INT_BYTES == 2
130 typedef signed int _PDCLIB_int16_t;
131 typedef unsigned int _PDCLIB_uint16_t;
132 #define _PDCLIB_INT16_MAX _PDCLIB_INT_MAX
133 #define _PDCLIB_INT16_MIN _PDCLIB_INT_MIN
134 #define _PDCLIB_UINT16_MAX _PDCLIB_UINT_MAX
135 #define _PDCLIB_16_CONV
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_16_CONV h
144 #error Neither 'short' nor 'int' are 16-bit.
147 /* Setting 'int32_t', its limits, its literal, and conversion macros. */
148 #if _PDCLIB_INT_BYTES == 4
149 typedef signed int _PDCLIB_int32_t;
150 typedef unsigned int _PDCLIB_uint32_t;
151 #define _PDCLIB_INT32_MAX _PDCLIB_INT_MAX
152 #define _PDCLIB_INT32_MIN _PDCLIB_INT_MIN
153 #define _PDCLIB_UINT32_MAX _PDCLIB_UINT_MAX
154 #define _PDCLIB_INT32_LITERAL
155 #define _PDCLIB_UINT32_LITERAL
156 #define _PDCLIB_32_CONV
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 #define _PDCLIB_32_CONV l
167 #error Neither 'int' nor 'long' are 32-bit.
170 /* Setting 'int64_t', its limits, its literal, and conversion macros. */
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 #define _PDCLIB_64_CONV l
180 #elif _PDCLIB_LLONG_BYTES == 8
181 typedef signed long long _PDCLIB_int64_t;
182 typedef unsigned long long _PDCLIB_uint64_t;
183 #define _PDCLIB_INT64_MAX _PDCLIB_LLONG_MAX
184 #define _PDCLIB_INT64_MIN _PDCLIB_LLONG_MIN
185 #define _PDCLIB_UINT64_MAX _PDCLIB_ULLONG_MAX
186 #define _PDCLIB_INT64_LITERAL ll
187 #define _PDCLIB_UINT64_LITERAL ull
188 #define _PDCLIB_64_CONV ll
190 #error Neither 'long' nor 'long long' are 64-bit.
193 /* -------------------------------------------------------------------------- */
194 /* <stdint.h> "fastest" types and their limits */
195 /* -------------------------------------------------------------------------- */
196 /* This is, admittedly, butt-ugly. But at least it's ugly where the average */
197 /* user of PDCLib will never see it, and makes <_PDCLIB_config.h> much */
199 /* -------------------------------------------------------------------------- */
201 typedef _PDCLIB_fast8 _PDCLIB_int_fast8_t;
202 typedef unsigned _PDCLIB_fast8 _PDCLIB_uint_fast8_t;
203 #define _PDCLIB_INT_FAST8_MIN _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_FAST8 ), _MIN )
204 #define _PDCLIB_INT_FAST8_MAX _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_FAST8 ), _MAX )
205 #define _PDCLIB_UINT_FAST8_MAX _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_U, _PDCLIB_FAST8 ), _MAX )
207 typedef _PDCLIB_fast16 _PDCLIB_int_fast16_t;
208 typedef unsigned _PDCLIB_fast16 _PDCLIB_uint_fast16_t;
209 #define _PDCLIB_INT_FAST16_MIN _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_FAST16 ), _MIN )
210 #define _PDCLIB_INT_FAST16_MAX _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_FAST16 ), _MAX )
211 #define _PDCLIB_UINT_FAST16_MAX _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_U, _PDCLIB_FAST16 ), _MAX )
213 typedef _PDCLIB_fast32 _PDCLIB_int_fast32_t;
214 typedef unsigned _PDCLIB_fast32 _PDCLIB_uint_fast32_t;
215 #define _PDCLIB_INT_FAST32_MIN _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_FAST32 ), _MIN )
216 #define _PDCLIB_INT_FAST32_MAX _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_FAST32 ), _MAX )
217 #define _PDCLIB_UINT_FAST32_MAX _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_U, _PDCLIB_FAST32 ), _MAX )
219 typedef _PDCLIB_fast64 _PDCLIB_int_fast64_t;
220 typedef unsigned _PDCLIB_fast64 _PDCLIB_uint_fast64_t;
221 #define _PDCLIB_INT_FAST64_MIN _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_FAST64 ), _MIN )
222 #define _PDCLIB_INT_FAST64_MAX _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_FAST64 ), _MAX )
223 #define _PDCLIB_UINT_FAST64_MAX _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_U, _PDCLIB_FAST64 ), _MAX )
225 /* -------------------------------------------------------------------------- */
226 /* Various <stddef.h> typedefs and limits */
227 /* -------------------------------------------------------------------------- */
229 typedef _PDCLIB_ptrdiff _PDCLIB_ptrdiff_t;
230 #define _PDCLIB_PTRDIFF_MIN _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_PTRDIFF ), _MIN )
231 #define _PDCLIB_PTRDIFF_MAX _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_PTRDIFF ), _MAX )
233 #define _PDCLIB_SIG_ATOMIC_MIN _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_SIG_ATOMIC ), _MIN )
234 #define _PDCLIB_SIG_ATOMIC_MAX _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_SIG_ATOMIC ), _MAX )
236 typedef _PDCLIB_size _PDCLIB_size_t;
237 #define _PDCLIB_SIZE_MAX _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_SIZE ), _MAX )
239 typedef _PDCLIB_wchar _PDCLIB_wchar_t;
240 #define _PDCLIB_WCHAR_MIN _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_WCHAR ), _MIN )
241 #define _PDCLIB_WCHAR_MAX _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_WCHAR ), _MAX )
243 typedef _PDCLIB_intptr _PDCLIB_intptr_t;
244 typedef unsigned _PDCLIB_intptr _PDCLIB_uintptr_t;
245 #define _PDCLIB_INTPTR_MIN _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_INTPTR ), _MIN )
246 #define _PDCLIB_INTPTR_MAX _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_INTPTR ), _MAX )
247 #define _PDCLIB_UINTPTR_MAX _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_U, _PDCLIB_INTPTR ), _MAX )
249 typedef _PDCLIB_intmax _PDCLIB_intmax_t;
250 typedef unsigned _PDCLIB_intmax _PDCLIB_uintmax_t;
251 #define _PDCLIB_INTMAX_MIN _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_INTMAX ), _MIN )
252 #define _PDCLIB_INTMAX_MAX _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_, _PDCLIB_INTMAX ), _MAX )
253 #define _PDCLIB_UINTMAX_MAX _PDCLIB_concat( _PDCLIB_concat( _PDCLIB_U, _PDCLIB_INTMAX ), _MAX )
254 #define _PDCLIB_INTMAX_C( value ) _PDCLIB_concat( value, _PDCLIB_INTMAX_LITERAL )
255 #define _PDCLIB_UINTMAX_C( value ) _PDCLIB_concat( value, _PDCLIB_concat( u, _PDCLIB_INTMAX_LITERAL ) )
257 /* -------------------------------------------------------------------------- */
258 /* Various <stdio.h> internals */
259 /* -------------------------------------------------------------------------- */
261 /* Flags for representing mode (see fopen()). Note these must fit the same
262 status field as the _IO?BF flags in <stdio.h> and the internal flags below.
264 #define _PDCLIB_FREAD 8u
265 #define _PDCLIB_FWRITE 16u
266 #define _PDCLIB_FAPPEND 32u
267 #define _PDCLIB_FRW 64u
268 #define _PDCLIB_FBIN 128u
270 /* Internal flags, made to fit the same status field as the flags above. */
271 /* -------------------------------------------------------------------------- */
272 /* free() the buffer memory on closing (false for user-supplied buffer) */
273 #define _PDCLIB_FREEBUFFER 512u
274 /* stream has encountered error / EOF */
275 #define _PDCLIB_ERRORFLAG 1024u
276 #define _PDCLIB_EOFFLAG 2048u
277 /* stream is wide-oriented */
278 #define _PDCLIB_WIDESTREAM 4096u
279 /* stream is byte-oriented */
280 #define _PDCLIB_BYTESTREAM 8192u
281 /* file associated with stream should be remove()d on closing (tmpfile()) */
282 #define _PDCLIB_DELONCLOSE 16384u
283 /* stream handle should not be free()d on close (stdin, stdout, stderr) */
284 #define _PDCLIB_STATIC 32768u
286 /* Position / status structure for getpos() / fsetpos(). */
287 struct _PDCLIB_fpos_t
289 _PDCLIB_uint64_t offset; /* File position offset */
290 int status; /* Multibyte parsing state (unused, reserved) */
294 struct _PDCLIB_file_t
296 _PDCLIB_fd_t handle; /* OS file handle */
297 char * buffer; /* Pointer to buffer memory */
298 _PDCLIB_size_t bufsize; /* Size of buffer */
299 _PDCLIB_size_t bufidx; /* Index of current position in buffer */
300 _PDCLIB_size_t bufend; /* Index of last pre-read character in buffer */
301 struct _PDCLIB_fpos_t pos; /* Offset and multibyte parsing state */
302 _PDCLIB_size_t ungetidx; /* Number of ungetc()'ed characters */
303 unsigned char * ungetbuf; /* ungetc() buffer */
304 unsigned int status; /* Status flags; see above */
305 /* multibyte parsing status to be added later */
306 char * filename; /* Name the current stream has been opened with */
307 struct _PDCLIB_file_t * next; /* Pointer to next struct (internal) */
310 /* -------------------------------------------------------------------------- */
311 /* Internal data types */
312 /* -------------------------------------------------------------------------- */
314 /* Structure required by both atexit() and exit() for handling atexit functions */
315 struct _PDCLIB_exitfunc_t
317 struct _PDCLIB_exitfunc_t * next;
318 void (*func)( void );
321 /* Structures required by malloc(), realloc(), and free(). */
322 struct _PDCLIB_headnode_t
324 struct _PDCLIB_memnode_t * first;
325 struct _PDCLIB_memnode_t * last;
328 struct _PDCLIB_memnode_t
331 struct _PDCLIB_memnode_t * next;
334 /* Status structure required by _PDCLIB_print(). */
335 struct _PDCLIB_status_t
337 int base; /* base to which the value shall be converted */
338 _PDCLIB_int_fast32_t flags; /* flags and length modifiers */
339 _PDCLIB_size_t n; /* print: maximum characters to be written */
340 /* scan: number matched conversion specifiers */
341 _PDCLIB_size_t i; /* number of characters read/written */
342 _PDCLIB_size_t current;/* chars read/written in the CURRENT conversion */
343 char * s; /* *sprintf(): target buffer */
344 /* *sscanf(): source string */
345 _PDCLIB_size_t width; /* specified field width */
346 _PDCLIB_size_t prec; /* specified field precision */
347 struct _PDCLIB_file_t * stream; /* *fprintf() / *fscanf() stream */
348 _PDCLIB_va_list arg; /* argument stack */
351 /* -------------------------------------------------------------------------- */
352 /* Declaration of helper functions (implemented in functions/_PDCLIB). */
353 /* -------------------------------------------------------------------------- */
355 /* This is the main function called by atoi(), atol() and atoll(). */
356 _PDCLIB_intmax_t _PDCLIB_atomax( const char * s );
358 /* Two helper functions used by strtol(), strtoul() and long long variants. */
359 const char * _PDCLIB_strtox_prelim( const char * p, char * sign, int * base );
360 _PDCLIB_uintmax_t _PDCLIB_strtox_main( const char ** p, unsigned int base, _PDCLIB_uintmax_t error, _PDCLIB_uintmax_t limval, int limdigit, char * sign );
362 /* Digits arrays used by various integer conversion functions */
363 extern char _PDCLIB_digits[];
364 extern char _PDCLIB_Xdigits[];
366 /* The worker for all printf() type of functions. The pointer spec should point
367 to the introducing '%' of a conversion specifier. The status structure is to
368 be that of the current printf() function, of which the members n, s, stream
369 and arg will be preserved; i will be updated; and all others will be trashed
371 Returns a pointer to the first character not parsed as conversion specifier.
373 const char * _PDCLIB_print( const char * spec, struct _PDCLIB_status_t * status );
375 /* The worker for all scanf() type of functions. The pointer spec should point
376 to the introducing '%' of a conversion specifier. The status structure is to
377 be that of the current scanf() function, of which the member stream will be
378 preserved; n, i, and s will be updated; and all others will be trashed by
380 Returns a pointer to the first character not parsed as conversion specifier,
381 or NULL in case of error.
382 FIXME: Should distinguish between matching and input error
384 const char * _PDCLIB_scan( const char * spec, struct _PDCLIB_status_t * status );
386 /* Parsing any fopen() style filemode string into a number of flags. */
387 unsigned int _PDCLIB_filemode( const char * mode );
389 /* Sanity checking and preparing of read buffer, should be called first thing
390 by any stdio read-data function.
391 Returns 0 on success, EOF on error.
392 On error, EOF / error flags and errno are set appropriately.
394 int _PDCLIB_prepread( struct _PDCLIB_file_t * stream );
396 /* Sanity checking, should be called first thing by any stdio write-data
398 Returns 0 on success, EOF on error.
399 On error, error flags and errno are set appropriately.
401 int _PDCLIB_prepwrite( struct _PDCLIB_file_t * stream );
403 /* Closing all streams on program exit */
404 void _PDCLIB_closeall( void );
406 /* -------------------------------------------------------------------------- */
408 /* -------------------------------------------------------------------------- */
410 /* If PDCLib would call its error number "errno" directly, there would be no way
411 to catch its value from underlying system calls that also use it (i.e., POSIX
412 operating systems). That is why we use an internal name, providing a means to
413 access it through <errno.h>.
415 extern int _PDCLIB_errno;
417 /* A mechanism for delayed evaluation. (Not sure if this is really necessary, so
418 no detailed documentation on the "why".)
420 int * _PDCLIB_errno_func( void );
422 /* -------------------------------------------------------------------------- */
423 /* <ctype.h> lookup tables */
424 /* -------------------------------------------------------------------------- */
426 #define _PDCLIB_CTYPE_ALPHA 1
427 #define _PDCLIB_CTYPE_BLANK 2
428 #define _PDCLIB_CTYPE_CNTRL 4
429 #define _PDCLIB_CTYPE_GRAPH 8
430 #define _PDCLIB_CTYPE_PUNCT 16
431 #define _PDCLIB_CTYPE_SPACE 32
432 #define _PDCLIB_CTYPE_LOWER 64
433 #define _PDCLIB_CTYPE_UPPER 128
434 #define _PDCLIB_CTYPE_DIGIT 256
435 #define _PDCLIB_CTYPE_XDIGT 512
437 struct _PDCLIB_ctype_t
439 _PDCLIB_uint16_t flags;
442 unsigned char collation;