X-Git-Url: https://pd.if.org/git/?p=pdclib;a=blobdiff_plain;f=platform%2Fexample%2Finternals%2F_PDCLIB_config.h;h=4dd5e3a125d4b07df9af0876f50549ef290116d6;hp=0df16791cd26f98afbd8f5c53343585d73a2295a;hb=761281caf431d264d568aec797095ef2c28f3910;hpb=f93d55176e4db9edfb1840054169003bcca4d1fb diff --git a/platform/example/internals/_PDCLIB_config.h b/platform/example/internals/_PDCLIB_config.h old mode 100644 new mode 100755 index 0df1679..4dd5e3a --- a/platform/example/internals/_PDCLIB_config.h +++ b/platform/example/internals/_PDCLIB_config.h @@ -1,5 +1,3 @@ -/* $Id$ */ - /* Internal PDCLib configuration <_PDCLIB_config.h> (Generic Template) @@ -7,18 +5,13 @@ Permission is granted to use, modify, and / or redistribute at will. */ +#ifndef _PDCLIB_CONFIG_H +#define _PDCLIB_CONFIG_H _PDCLIB_CONFIG_H + /* -------------------------------------------------------------------------- */ /* Misc */ /* -------------------------------------------------------------------------- */ -/* By default, PDCLib does some rather strict checking of function usage, */ -/* especially in . Things that are undefined by the standard - for */ -/* example, mixing byte / wide operations or read / write operations without */ -/* resetting the stream beforehand - are caught and handled graciously. This */ -/* adds some complexity, and eats a couple of clock cycles. If you want to */ -/* disable these checks, define _PDCLIB_STRICT to zero. */ -#define _PDCLIB_STRICT 1 - /* The character (sequence) your platform uses as newline. */ #define _PDCLIB_endl "\n" @@ -60,7 +53,11 @@ /* compiler manuals. */ #define _PDCLIB_SHRT_BYTES 2 #define _PDCLIB_INT_BYTES 4 +#ifdef __LP64__ +#define _PDCLIB_LONG_BYTES 8 +#else #define _PDCLIB_LONG_BYTES 4 +#endif #define _PDCLIB_LLONG_BYTES 8 /* defines the div() function family that allows taking quotient */ @@ -100,6 +97,8 @@ struct _PDCLIB_lldiv_t /* SHRT, INT, LONG, or LLONG (telling which values to use for the *_MIN and */ /* *_MAX limits); the lowercase define either short, int, long, or long long */ /* (telling the actual type to use). */ +/* The third define is the length modifier used for the type in printf() and */ +/* scanf() functions (used in ). */ /* If you require a non-standard datatype to define the "usually fastest" */ /* types, PDCLib as-is doesn't support that. Please contact the author with */ /* details on your platform in that case, so support can be added. */ @@ -107,15 +106,19 @@ struct _PDCLIB_lldiv_t #define _PDCLIB_FAST8 INT #define _PDCLIB_fast8 int +#define _PDCLIB_FAST8_CONV #define _PDCLIB_FAST16 INT #define _PDCLIB_fast16 int +#define _PDCLIB_FAST16_CONV #define _PDCLIB_FAST32 INT #define _PDCLIB_fast32 int +#define _PDCLIB_FAST32_CONV -#define _PDCLIB_FAST64 LLONG -#define _PDCLIB_fast64 long long +#define _PDCLIB_FAST64 LONG +#define _PDCLIB_fast64 long +#define _PDCLIB_FAST64_CONV l /* -------------------------------------------------------------------------- */ /* What follows are a couple of "special" typedefs and their limits. Again, */ @@ -124,8 +127,9 @@ struct _PDCLIB_lldiv_t /* -------------------------------------------------------------------------- */ /* The result type of substracting two pointers */ -#define _PDCLIB_ptrdiff int -#define _PDCLIB_PTRDIFF INT +#define _PDCLIB_ptrdiff long +#define _PDCLIB_PTRDIFF LONG +#define _PDCLIB_PTR_CONV l /* An integer type that can be accessed as atomic entity (think asynchronous interrupts). The type itself is not defined in a freestanding environment, @@ -135,24 +139,48 @@ struct _PDCLIB_lldiv_t #define _PDCLIB_SIG_ATOMIC INT /* Result type of the 'sizeof' operator (must be unsigned) */ -#define _PDCLIB_size unsigned int -#define _PDCLIB_SIZE UINT +#define _PDCLIB_size unsigned long +#define _PDCLIB_SIZE ULONG /* Large enough an integer to hold all character codes of the largest supported locale. */ -#define _PDCLIB_wchar unsigned short -#define _PDCLIB_WCHAR USHRT +#define _PDCLIB_wchar unsigned int +#define _PDCLIB_WCHAR UINT -#define _PDCLIB_intptr int -#define _PDCLIB_INTPTR INT +/* (Signed) integer type capable of taking the (cast) value of a void *, and + having the value cast back to void *, comparing equal to the original. +*/ +#define _PDCLIB_intptr long +#define _PDCLIB_INTPTR LONG /* Largest supported integer type. Implementation note: see _PDCLIB_atomax(). */ #define _PDCLIB_intmax long long int -#define _PDCLIB_INTMAX LLINT +#define _PDCLIB_INTMAX LLONG +#define _PDCLIB_MAX_CONV ll /* You are also required to state the literal suffix for the intmax type */ #define _PDCLIB_INTMAX_LITERAL ll +/* defines imaxdiv(), which is equivalent to the div() function */ +/* family (see further above) with intmax_t as basis. */ + +struct _PDCLIB_imaxdiv_t +{ + _PDCLIB_intmax quot; + _PDCLIB_intmax rem; +}; + +/* -------------------------------------------------------------------------- */ +/* Time types */ +/* -------------------------------------------------------------------------- */ + +#define _PDCLIB_time long + +#define _PDCLIB_clock long +#define _PDCLIB_CLOCKS_PER_SEC 1000000 + +#define _PDCLIB_TIME_UTC 1 + /* -------------------------------------------------------------------------- */ /* Floating Point */ /* -------------------------------------------------------------------------- */ @@ -199,7 +227,12 @@ struct _PDCLIB_lldiv_t /* Variable Length Parameter List Handling () The macros defined by are highly dependent on the calling conventions used, and you probably have to replace them with builtins of - your compiler. The following generic implementation works only for pure + your compiler. +*/ + +#if defined( __i386 ) + +/* The following generic implementation works only for pure stack-based architectures, and only if arguments are aligned to pointer type. Credits to Michael Moody, who contributed this to the Public Domain. */ @@ -213,6 +246,23 @@ typedef char * _PDCLIB_va_list; #define _PDCLIB_va_end( ap ) ( (ap) = (void *)0, (void)0 ) #define _PDCLIB_va_start( ap, parmN ) ( (ap) = (char *) &parmN + ( _PDCLIB_va_round(parmN) ), (void)0 ) +#elif defined( __x86_64 ) + +/* No way to cover x86_64 with a generic implementation, as it uses register- + based parameter passing. Using the GCC builtins here. +*/ +typedef __builtin_va_list _PDCLIB_va_list; +#define _PDCLIB_va_arg( ap, type ) ( __builtin_va_arg( ap, type ) ) +#define _PDCLIB_va_copy( dest, src ) ( __builtin_va_copy( dest, src ) ) +#define _PDCLIB_va_end( ap ) ( __builtin_va_end( ap ) ) +#define _PDCLIB_va_start( ap, parmN ) ( __builtin_va_start( ap, parmN ) ) + +#else + +#error Please create your own _PDCLIB_config.h. Using the existing one as-is will not work. + +#endif + /* -------------------------------------------------------------------------- */ /* OS "glue", part 1 */ /* These are values and data type definitions that you would have to adapt to */ @@ -244,40 +294,110 @@ typedef int _PDCLIB_fd_t; */ #define _PDCLIB_NOHANDLE ( (_PDCLIB_fd_t) -1 ) -/* A type in which to store file offsets. See fgetpos() / fsetpos(). */ -/* FIXME: The 'int' types here are placeholders. When changed, check out - stdinit.c, too. */ -typedef struct -{ - int position; - int mbstate; -} _PDCLIB_fpos_t; - /* The default size for file buffers. Must be at least 256. */ #define _PDCLIB_BUFSIZ 1024 /* The minimum number of files the implementation can open simultaneously. Must be at least 8. Depends largely on how the bookkeeping is done by fopen() / - freopen() / fclose(). + freopen() / fclose(). The example implementation limits the number of open + files only by available memory. */ #define _PDCLIB_FOPEN_MAX 8 /* Length of the longest filename the implementation guarantees to support. */ #define _PDCLIB_FILENAME_MAX 128 -/* Buffer size for tmpnam(). */ -#define _PDCLIB_L_tmpnam 100 +/* Maximum length of filenames generated by tmpnam(). (See tmpfile.c.) */ +#define _PDCLIB_L_tmpnam 46 /* Number of distinct file names that can be generated by tmpnam(). */ #define _PDCLIB_TMP_MAX 50 -/* The number of times fflush() tries to write a file buffer before giving up - if no characters can be written. +/* The values of SEEK_SET, SEEK_CUR and SEEK_END, used by fseek(). + Since at least one platform (POSIX) uses the same symbols for its own "seek" + function, we use whatever the host defines (if it does define them). +*/ +#define _PDCLIB_SEEK_SET 0 +#define _PDCLIB_SEEK_CUR 1 +#define _PDCLIB_SEEK_END 2 + +/* The number of characters that can be buffered with ungetc(). The standard + guarantees only one (1); anything larger would make applications relying on + this capability dependent on implementation-defined behaviour (not good). +*/ +#define _PDCLIB_UNGETCBUFSIZE 1 + +/* errno -------------------------------------------------------------------- */ + +/* These are the values that _PDCLIB_errno can be set to by the library. + + By keeping PDCLib's errno in the _PDCLIB_* namespace, the library is capable + to "translate" between errno values used by the hosting operating system and + those used and passed out by the library. + + Example: In the example platform, the remove() function uses the unlink() + system call as backend. Linux sets its errno to EISDIR if you try to unlink() + a directory, but POSIX demands EPERM. Within the remove() function, you can + catch the 'errno == EISDIR', and set '_PDCLIB_errno = _PDCLIB_EPERM'. Anyone + using PDCLib's will "see" EPERM instead of EISDIR (the _PDCLIB_* + prefix removed by mechanics). + + If you do not want that kind of translation, you might want to "match" the + values used by PDCLib with those used by the host OS, as to avoid confusion. + + The standard only defines three distinct errno values: ERANGE, EDOM, and + EILSEQ. The standard leaves it up to "the implementation" whether there are + any more beyond those three. There is some controversy as to whether errno is + such a good idea at all, so you might want to come up with a different error + reporting facility for your platform. Since errno values beyond the three + defined by the standard are not portable anyway (unless you look at POSIX), + having your own error reporting facility would not hurt anybody either. */ -#define _PDCLIB_FLUSH_RETRIES 3 -/* This macro is executed after each try to write characters that results in - no characters being written. You can define this to be empty, wait a short - period of time, or whatever suits your environment. +#define _PDCLIB_ERANGE 1 +#define _PDCLIB_EDOM 2 +#define _PDCLIB_EILSEQ 3 + +/* The following is not strictly "configuration", but there is no better place + to explain it than here. + + PDCLib strives to be as generic as possible, so by default it does NOT define + any values beyond the three standard ones above, even where it would have + been prudent and convenient to do so. Any errno "caught" from the host OS, + and some internal error conditions as well, are all lumped together into the + value of '_PDCLIB_ERROR'. + + '_PDCLIB_ERROR' is STRICLY meant as a PLACEHOLDER only. + + You should NEVER ship an adaption of PDCLib still using that particular + value. You should NEVER write code that *tests* for that value. Indeed it is + not even conforming, since errno values should be defined as beginning with + an uppercase 'E', and there is no mechanics in to unmask that + particular value (for exactly that reason). + + There also is no error message available for this value through either the + strerror() or perror() functions. It is being reported as "unknown" error. + + The idea is that you scan the source of PDCLib for occurrences of this macro + and replace _PDCLIB_ERROR with whatever additional errno value you came up + with for your platform. + + If you cannot find it within you to do that, tell your clients to check for + an errno value larger than zero. That, at least, would be standard compliant + (and fully portable). */ -#define _PDCLIB_FLUSH_RETRY_PREP +#define _PDCLIB_ERROR 4 + +/* The maximum value that errno can be set to. This is used to set the size */ +/* of the array in struct lconv () holding error messages for the */ +/* strerror() and perror() functions. (If you change this value because you */ +/* are using additional errno values, you *HAVE* to provide appropriate error */ +/* messages for *ALL* locales.) */ +/* Default is 4 (0, ERANGE, EDOM, EILSEQ). */ +#define _PDCLIB_ERRNO_MAX 4 + +#ifdef __CYGWIN__ +typedef unsigned int wint_t; +#endif + +#endif