1 #ifndef _PDCLIB_CONFIG_H
2 #define _PDCLIB_CONFIG_H
4 /* Internal PDCLib configuration <_PDCLIB_config.h>
7 This file is part of the Public Domain C Library (PDCLib).
8 Permission is granted to use, modify, and / or redistribute at will.
11 /* -------------------------------------------------------------------------- */
13 /* -------------------------------------------------------------------------- */
15 /* The character (sequence) your platform uses as newline. */
16 #define _PDCLIB_endl "\r\n"
18 /* exit() can signal success to the host environment by the value of zero or */
19 /* the constant EXIT_SUCCESS. Failure is signaled by EXIT_FAILURE. Note that */
20 /* any other return value is "implementation-defined", i.e. your environment */
21 /* is not required to handle it gracefully. Set your definitions here. */
22 #define _PDCLIB_SUCCESS 0
23 #define _PDCLIB_FAILURE -1
25 /* qsort() in <stdlib.h> requires a function that swaps two memory areas. */
26 /* Below is a naive implementation that can be improved significantly for */
27 /* specific platforms, e.g. by swapping int instead of char. */
28 #define _PDCLIB_memswp( i, j, size ) char tmp; do { tmp = *i; *i++ = *j; *j++ = tmp; } while ( --size );
30 /* Define this to some compiler directive that can be written after the */
31 /* parameter list of a function declaration to indicate the function does */
32 /* never return. If your compiler does not support such a directive, define */
33 /* to nothing. (This is to avoid warnings with the exit functions under GCC.) */
34 #define _PDCLIB_NORETURN __attribute__(( noreturn ))
36 /* The maximum value that errno can be set to. This is used to set the size */
37 /* of the array in struct lconv (<locale.h>) holding error messages for the */
38 /* strerror() and perror() functions. (If you change this value because you */
39 /* are using additional errno values, you *HAVE* to provide appropriate error */
40 /* messages for *ALL* locales.) */
41 /* Default is 4 (0, ERANGE, EDOM, EILSEQ). */
42 #define _PDCLIB_ERRNO_MAX 4
44 /* -------------------------------------------------------------------------- */
46 /* -------------------------------------------------------------------------- */
47 /* Assuming 8-bit char, two's-complement architecture here. 'short' being */
48 /* 16 bit, 'int' being either 16, 32 or 64 bit, 'long' being either 32 or 64 */
49 /* bit (but 64 bit only if 'int' is 32 bit), and 'long long' being 64 bit if */
50 /* 'long' is not, 64 or 128 bit otherwise. */
51 /* Author is quite willing to support other systems but would like to hear of */
52 /* interest in such support and details on the to-be-supported architecture */
53 /* first, before going to lengths about it. */
54 /* -------------------------------------------------------------------------- */
56 /* Comment out (or delete) the line below if your 'char' type is unsigned. */
57 #define _PDCLIB_CHAR_SIGNED 1
59 /* Width of the integer types short, int, long, and long long, in bytes. */
60 /* SHRT == 2, INT >= SHRT, LONG >= INT >= 4, LLONG >= LONG - check your */
61 /* compiler manuals. */
62 #define _PDCLIB_SHRT_BYTES 2
63 #define _PDCLIB_INT_BYTES 4
64 #define _PDCLIB_LONG_BYTES 4
65 #define _PDCLIB_LLONG_BYTES 8
67 /* <stdlib.h> defines the div() function family that allows taking quotient */
68 /* and remainder of an integer division in one operation. Many platforms */
69 /* support this in hardware / opcode, and the standard permits ordering of */
70 /* the return structure in any way to fit the hardware. That is why those */
71 /* structs can be configured here. */
85 struct _PDCLIB_lldiv_t
91 /* -------------------------------------------------------------------------- */
92 /* <stdint.h> defines a set of integer types that are of a minimum width, and */
93 /* "usually fastest" on the system. (If, for example, accessing a single char */
94 /* requires the CPU to access a complete int and then mask out the char, the */
95 /* "usually fastest" type of at least 8 bits would be int, not char.) */
96 /* If you do not have information on the relative performance of the types, */
97 /* the standard allows you to define any type that meets minimum width and */
98 /* signedness requirements. */
99 /* The defines below are just configuration for the real typedefs and limit */
100 /* definitions done in <_PDCLIB_int.h>. The uppercase define shall be either */
101 /* SHRT, INT, LONG, or LLONG (telling which values to use for the *_MIN and */
102 /* *_MAX limits); the lowercase define either short, int, long, or long long */
103 /* (telling the actual type to use). */
104 /* The third define is the length modifier used for the type in printf() and */
105 /* scanf() functions (used in <inttypes.h>). */
106 /* If you require a non-standard datatype to define the "usually fastest" */
107 /* types, PDCLib as-is doesn't support that. Please contact the author with */
108 /* details on your platform in that case, so support can be added. */
109 /* -------------------------------------------------------------------------- */
111 #define _PDCLIB_FAST8 INT
112 #define _PDCLIB_fast8 int
113 #define _PDCLIB_FAST8_CONV
115 #define _PDCLIB_FAST16 INT
116 #define _PDCLIB_fast16 int
117 #define _PDCLIB_FAST16_CONV
119 #define _PDCLIB_FAST32 INT
120 #define _PDCLIB_fast32 int
121 #define _PDCLIB_FAST32_CONV
123 #define _PDCLIB_FAST64 LLONG
124 #define _PDCLIB_fast64 long long
125 #define _PDCLIB_FAST64_CONV ll
127 /* -------------------------------------------------------------------------- */
128 /* What follows are a couple of "special" typedefs and their limits. Again, */
129 /* the actual definition of the limits is done in <_PDCLIB_int.h>, and the */
130 /* defines here are merely "configuration". See above for details. */
131 /* -------------------------------------------------------------------------- */
133 /* The result type of substracting two pointers */
134 #if defined(__amd64__) || defined(_M_AMD64)
135 #define _PDCLIB_ptrdiff long long
136 #define _PDCLIB_PTRDIFF LLONG
137 #define _PDCLIB_PTR_CONV ll
139 #define _PDCLIB_ptrdiff int
140 #define _PDCLIB_PTRDIFF INT
141 #define _PDCLIB_PTR_CONV
144 /* An integer type that can be accessed as atomic entity (think asynchronous
145 interrupts). The type itself is not defined in a freestanding environment,
146 but its limits are. (Don't ask.)
148 #define _PDCLIB_sig_atomic int
149 #define _PDCLIB_SIG_ATOMIC INT
151 /* Result type of the 'sizeof' operator (must be unsigned) */
152 #if defined(__amd64__) || defined(_M_AMD64)
153 #define _PDCLIB_size unsigned long long
154 #define _PDCLIB_SIZE ULLONG
156 #define _PDCLIB_size unsigned int
157 #define _PDCLIB_SIZE UINT
160 /* Large enough an integer to hold all character codes of the largest supported
163 XX: Windows requires wchar_t be an unsigned short, but this is not compliant.
165 #define _PDCLIB_wchar unsigned short
166 #define _PDCLIB_WCHAR USHRT
168 #if defined(__amd64__) || defined(_M_AMD64)
169 #define _PDCLIB_intptr long long
170 #define _PDCLIB_INTPTR LLONG
172 #define _PDCLIB_intptr int
173 #define _PDCLIB_INTPTR INT
176 /* Largest supported integer type. Implementation note: see _PDCLIB_atomax(). */
177 #define _PDCLIB_intmax long long int
178 #define _PDCLIB_INTMAX LLONG
179 #define _PDCLIB_MAX_CONV ll
180 /* You are also required to state the literal suffix for the intmax type */
181 #define _PDCLIB_INTMAX_LITERAL ll
183 /* <inttypes.h> defines imaxdiv(), which is equivalent to the div() function */
184 /* family (see further above) with intmax_t as basis. */
186 struct _PDCLIB_imaxdiv_t
193 * The C standard doesn't define what representation of time is stored in
194 * time_t when returned by time() , but POSIX defines it to be seconds since the
195 * UNIX epoch and most appplications expect that.
197 * time_t is also used as the tv_sec member of struct timespec, which *is*
198 * defined as a linear count of seconds.
200 * time_t is defined as a "real type", so may be a floating point type, but with
201 * the presence of the nanosecond accurate struct timespec, and with the lack of
202 * any functions for manipulating more accurate values of time_t, this is
203 * probably not useful.
205 #define _PDCLIB_time unsigned long long
209 * A count of "clock ticks", where the length of a clock tick is unspecified by
210 * the standard. The implementation is required to provide a macro,
211 * CLOCKS_PER_SEC, which is the number of "clock ticks" which corresponds to one
214 * clock_t may be any real type (i.e. integral or floating), and its type on
215 * various systems differs.
217 * On XSI systems, CLOCKS_PER_SEC must be defined to 1000000
219 #define _PDCLIB_clock double
220 #define _PDCLIB_CLOCKS_PER_SEC 1000000
222 /* -------------------------------------------------------------------------- */
224 /* -------------------------------------------------------------------------- */
226 /* Whether the implementation rounds toward zero (0), to nearest (1), toward
227 positive infinity (2), or toward negative infinity (3). (-1) signifies
228 indeterminable rounding, any other value implementation-specific rounding.
230 #define _PDCLIB_FLT_ROUNDS -1
232 /* Whether the implementation uses exact-width precision (0), promotes float
233 to double (1), or promotes float and double to long double (2). (-1)
234 signifies indeterminable behaviour, any other value implementation-specific
237 #define _PDCLIB_FLT_EVAL_METHOD -1
239 /* "Number of the decimal digits (n), such that any floating-point number in the
240 widest supported floating type with p(max) radix (b) digits can be rounded to
241 a floating-point number with (n) decimal digits and back again without change
242 to the value p(max) log(10)b if (b) is a power of 10, [1 + p(max) log(10)b]
244 64bit IEC 60559 double format (53bit mantissa) is DECIMAL_DIG 17.
245 80bit IEC 60559 double-extended format (64bit mantissa) is DECIMAL_DIG 21.
247 #define _PDCLIB_DECIMAL_DIG 17
249 /* -------------------------------------------------------------------------- */
250 /* Platform-dependent macros defined by the standard headers. */
251 /* -------------------------------------------------------------------------- */
253 /* The offsetof macro
254 Contract: Expand to an integer constant expression of type size_t, which
255 represents the offset in bytes to the structure member from the beginning
256 of the structure. If the specified member is a bitfield, behaviour is
258 There is no standard-compliant way to do this.
259 This implementation casts an integer zero to 'pointer to type', and then
260 takes the address of member. This is undefined behaviour but should work on
264 #define _PDCLIB_offsetof( type, member ) __builtin_offsetof( type, member )
266 #define _PDCLIB_offsetof( type, member ) ( (size_t) &( ( (type *) 0 )->member ) )
269 /* Variable Length Parameter List Handling (<stdarg.h>)
270 The macros defined by <stdarg.h> are highly dependent on the calling
271 conventions used, and you probably have to replace them with builtins of
276 typedef char * _PDCLIB_va_list;
277 #define _PDCLIB_va_arg( ap, type ) (__builtin_va_arg( (ap), type ))
278 #define _PDCLIB_va_copy( dest, src ) (__builtin_va_copy( (dest), (src) ))
279 #define _PDCLIB_va_end( ap ) (__builtin_va_end( ap ) )
280 #define _PDCLIB_va_start( ap, parmN ) (__builtin_va_start( (ap), (parmN) ))
282 #error Compiler support please
285 /* -------------------------------------------------------------------------- */
286 /* OS "glue", part 1 */
287 /* These are values and data type definitions that you would have to adapt to */
288 /* the capabilities and requirements of your OS. */
289 /* The actual *functions* of the OS interface are declared in _PDCLIB_glue.h. */
290 /* -------------------------------------------------------------------------- */
292 /* Memory management -------------------------------------------------------- */
294 /* Set this to the page size of your OS. If your OS does not support paging, set
295 to an appropriate value. (Too small, and malloc() will call the kernel too
296 often. Too large, and you will waste memory.)
298 #define _PDCLIB_MALLOC_PAGESIZE 4096
299 #define _PDCLIB_MALLOC_ALIGN 16
300 #define _PDCLIB_MALLOC_GRANULARITY 64*1024
301 #define _PDCLIB_MALLOC_TRIM_THRESHOLD 2*1024*1024
302 #define _PDCLIB_MALLOC_MMAP_THRESHOLD 256*1024
303 #define _PDCLIB_MALLOC_RELEASE_CHECK_RATE 4095
305 /* TODO: Better document these */
307 /* I/O ---------------------------------------------------------------------- */
309 /* The type of the file descriptor returned by _PDCLIB_open(). */
310 typedef void * _PDCLIB_fd_t;
312 /* The value (of type _PDCLIB_fd_t) returned by _PDCLIB_open() if the operation
315 #define _PDCLIB_NOHANDLE NULL
317 /* The default size for file buffers. Must be at least 256. */
318 #define _PDCLIB_BUFSIZ 1024
320 /* The minimum number of files the implementation can open simultaneously. Must
321 be at least 8. Depends largely on how the bookkeeping is done by fopen() /
322 freopen() / fclose(). The example implementation limits the number of open
323 files only by available memory.
325 #define _PDCLIB_FOPEN_MAX 8
327 /* Length of the longest filename the implementation guarantees to support. */
328 #define _PDCLIB_FILENAME_MAX 128
330 /* Maximum length of filenames generated by tmpnam(). (See tmpfile.c.) */
331 #define _PDCLIB_L_tmpnam 46
333 /* Number of distinct file names that can be generated by tmpnam(). */
334 #define _PDCLIB_TMP_MAX 50
336 /* The values of SEEK_SET, SEEK_CUR and SEEK_END, used by fseek().
337 Since at least one platform (POSIX) uses the same symbols for its own "seek"
338 function, we use whatever the host defines (if it does define them).
340 Win32 note: Must match Win32 API values (FILE_BEGIN/FILE_CURRENT/FILE_END)
342 #define _PDCLIB_SEEK_SET 0
343 #define _PDCLIB_SEEK_CUR 1
344 #define _PDCLIB_SEEK_END 2
346 /* The number of characters that can be buffered with ungetc(). The standard
347 guarantees only one (1); anything larger would make applications relying on
348 this capability dependent on implementation-defined behaviour (not good).
350 #define _PDCLIB_UNGETCBUFSIZE 1
352 /* errno -------------------------------------------------------------------- */
354 /* These are the values that _PDCLIB_errno can be set to by the library.
356 By keeping PDCLib's errno in the _PDCLIB_* namespace, the library is capable
357 to "translate" between errno values used by the hosting operating system and
358 those used and passed out by the library.
360 Example: In the example platform, the remove() function uses the unlink()
361 system call as backend. Linux sets its errno to EISDIR if you try to unlink()
362 a directory, but POSIX demands EPERM. Within the remove() function, you can
363 catch the 'errno == EISDIR', and set '_PDCLIB_errno = _PDCLIB_EPERM'. Anyone
364 using PDCLib's <errno.h> will "see" EPERM instead of EISDIR (the _PDCLIB_*
365 prefix removed by <errno.h> mechanics).
367 If you do not want that kind of translation, you might want to "match" the
368 values used by PDCLib with those used by the host OS, as to avoid confusion.
370 The C standard only defines three distinct errno values: ERANGE, EDOM, and
371 EILSEQ. The standard leaves it up to "the implementation" whether there are
372 any more beyond those three. There is some controversy as to whether errno is
373 such a good idea at all, so you might want to come up with a different error
374 reporting facility for your platform.
376 Things used to say "Since errno values beyond the three defined by the
377 standard are not portable anyway (unless you look at POSIX), having your own
378 error reporting facility would not hurt anybody either." at this point.
379 However, then somebody birthed C++11 into the world, which copied POSIX's
380 errno values into C++. Yes, even EINTR. Therefore, this library defines
381 them. That said, thats nothing stopping you from using your own error
382 reporting facility for things outside the C library.
384 Sometimes the standard says to set errno to indicate an error, but does not
385 prescribe a value. We will use a value from the following list. If POSIX
386 defines a value, we use that; otherwise, we use as seems suitable.
388 If porting to a system which uses an errno-like reporting system (e.g. a
389 UNIX), you'll probably want to define them to match what the OS uses
392 #define _PDCLIB_ERANGE 1
393 #define _PDCLIB_EDOM 2
394 #define _PDCLIB_EILSEQ 3
396 /* C++11/POSIX errno values */
397 #define _PDCLIB_E2BIG 4
398 #define _PDCLIB_ECONNRESET 5
399 #define _PDCLIB_EISCONN 6
400 #define _PDCLIB_ENOENT 7
401 #define _PDCLIB_ENOTRECOVERABLE 8
402 #define _PDCLIB_EROFS 9
403 #define _PDCLIB_EACCES 10
404 #define _PDCLIB_EDEADLK 11
405 #define _PDCLIB_EISDIR 12
406 #define _PDCLIB_ENOEXEC 13
407 #define _PDCLIB_ENOTSOCK 14
408 #define _PDCLIB_ESPIPE 15
409 #define _PDCLIB_EADDRINUSE 16
410 #define _PDCLIB_EDESTADDRREQ 17
411 #define _PDCLIB_ELOOP 18
412 #define _PDCLIB_ENOLCK 19
413 #define _PDCLIB_ENOTSUPP 20
414 #define _PDCLIB_ESRCH 21
415 #define _PDCLIB_EADDRNOTAVAIL 22
416 #define _PDCLIB_EMFILE 23
417 #define _PDCLIB_ENOLINK 24
418 #define _PDCLIB_ENOTTY 25
419 #define _PDCLIB_ETIME 26
420 #define _PDCLIB_EAFNOSUPPORT 27
421 #define _PDCLIB_EEXIST 28
422 #define _PDCLIB_EMLINK 29
423 #define _PDCLIB_ENOMEM 30
424 #define _PDCLIB_ENXIO 31
425 #define _PDCLIB_ETIMEDOUT 32
426 #define _PDCLIB_EAGAIN 33
427 #define _PDCLIB_EFAULT 34
428 #define _PDCLIB_EMSGSIZE 35
429 #define _PDCLIB_ENOMSG 36
430 #define _PDCLIB_EOPNOTSUPP 37
431 #define _PDCLIB_ETXTBSY 38
432 #define _PDCLIB_EALREADY 39
433 #define _PDCLIB_EFBIG 40
434 #define _PDCLIB_ENAMETOOLONG 41
435 #define _PDCLIB_ENOPROTOOPT 42
436 #define _PDCLIB_EOVERFLOW 43
437 #define _PDCLIB_EWOULDBLOCK _PDCLIB_EAGAIN
438 #define _PDCLIB_EBADF 44
439 #define _PDCLIB_EHOSTUNREACH 45
440 #define _PDCLIB_ENETDOWN 46
441 #define _PDCLIB_ENOSPC 47
442 #define _PDCLIB_EOWNERDEAD 48
443 #define _PDCLIB_EXDEV 49
444 #define _PDCLIB_EBADMSG 50
445 #define _PDCLIB_EIDRM 51
446 #define _PDCLIB_ENETRESET 52
447 #define _PDCLIB_ENOSR 53
448 #define _PDCLIB_EPERM 54
449 #define _PDCLIB_EBUSY 55
450 #define _PDCLIB_ENETUNREACH 56
451 #define _PDCLIB_ENOSTR 57
452 #define _PDCLIB_EPIPE 58
453 #define _PDCLIB_ECANCELED 59
454 #define _PDCLIB_EINPROGRESS 60
455 #define _PDCLIB_ENFILE 61
456 #define _PDCLIB_ENOSYS 62
457 #define _PDCLIB_EPROTO 63
458 #define _PDCLIB_ECHILD 64
459 #define _PDCLIB_EINTR 65
460 #define _PDCLIB_ENOBUFS 66
461 #define _PDCLIB_ENOTCONN 67
462 #define _PDCLIB_EPROTONOSUPPORT 68
463 #define _PDCLIB_ECONNABORTED 69
464 #define _PDCLIB_EINVAL 70
465 #define _PDCLIB_ENODATA 71
466 #define _PDCLIB_ENOTDIR 72
467 #define _PDCLIB_EPROTOTYPE 73