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 extern int _PDCLIB_errno;
411 int * _PDCLIB_errno_func( void );
413 /* ERANGE and EDOM are specified by the standard. */
414 #define _PDCLIB_ERANGE 1
415 #define _PDCLIB_EDOM 2
416 /* Used in the example implementation for any kind of I/O error. */
417 #define _PDCLIB_EIO 3
418 /* Used in the example implementation for "unknown error". */
419 #define _PDCLIB_EUNKNOWN 4
420 /* Used in the example implementation for "invalid parameter value". */
421 #define _PDCLIB_EINVAL 5
422 /* Used in the example implementation for "I/O retries exceeded". */
423 #define _PDCLIB_ERETRY 6
424 /* One larger than the largest used errno */
425 #define _PDCLIB_EMAX 7
427 /* TODO: Doing this via a static array is not the way to do it. */
428 char const * _PDCLIB_errno_texts[ _PDCLIB_EMAX ];