hello world from initrd

3 files changed, 0 insertions, 585 deletions

diff --git a/src/pdclib/platform/example/include/float.h b/src/pdclib/platform/example/include/float.h
deleted file mode 100644
index 538d69e..0000000
--- a/src/pdclib/platform/example/include/float.h
+++ /dev/null
@@ -1,75 +0,0 @@
-/* Characteristics of floating types <float.h>
-
-   This file is part of the Public Domain C Library (PDCLib).
-   Permission is granted to use, modify, and / or redistribute at will.
-*/
-
-#ifndef _PDCLIB_FLOAT_H
-#define _PDCLIB_FLOAT_H _PDCLIB_FLOAT_H
-
-#include "pdclib/_PDCLIB_config.h"
-
-#define FLT_ROUNDS      _PDCLIB_FLT_ROUNDS
-#define FLT_EVAL_METHOD _PDCLIB_FLT_EVAL_METHOD
-#define DECIMAL_DIG     _PDCLIB_DECIMAL_DIG
-
-   /* Radix of exponent representation */
-#define FLT_RADIX      __FLT_RADIX__
-   /* Number of base-FLT_RADIX digits in the significand of a float */
-#define FLT_MANT_DIG   __FLT_MANT_DIG__
-   /* Number of decimal digits of precision in a float */
-#define FLT_DIG        __FLT_DIG__
-   /* Difference between 1.0 and the minimum float greater than 1.0 */
-#define FLT_EPSILON    __FLT_EPSILON__
-   /* Minimum int x such that FLT_RADIX**(x-1) is a normalised float */
-#define FLT_MIN_EXP    __FLT_MIN_EXP__
-   /* Minimum normalised float */
-#define FLT_MIN        __FLT_MIN__
-   /* Minimum int x such that 10**x is a normalised float */
-#define FLT_MIN_10_EXP __FLT_MIN_10_EXP__
-   /* Maximum int x such that FLT_RADIX**(x-1) is a representable float */
-#define FLT_MAX_EXP    __FLT_MAX_EXP__
-   /* Maximum float */
-#define FLT_MAX        __FLT_MAX__
-   /* Maximum int x such that 10**x is a representable float */
-#define FLT_MAX_10_EXP __FLT_MAX_10_EXP__
-
-   /* Number of base-FLT_RADIX digits in the significand of a double */
-#define DBL_MANT_DIG   __DBL_MANT_DIG__
-   /* Number of decimal digits of precision in a double */
-#define DBL_DIG        __DBL_DIG__
-   /* Difference between 1.0 and the minimum double greater than 1.0 */
-#define DBL_EPSILON    __DBL_EPSILON__
-   /* Minimum int x such that FLT_RADIX**(x-1) is a normalised double */
-#define DBL_MIN_EXP    __DBL_MIN_EXP__
-   /* Minimum normalised double */
-#define DBL_MIN        __DBL_MIN__
-   /* Minimum int x such that 10**x is a normalised double */
-#define DBL_MIN_10_EXP __DBL_MIN_10_EXP__
-   /* Maximum int x such that FLT_RADIX**(x-1) is a representable double */
-#define DBL_MAX_EXP    __DBL_MAX_EXP__
-   /* Maximum double */
-#define DBL_MAX        __DBL_MAX__
-   /* Maximum int x such that 10**x is a representable double */
-#define DBL_MAX_10_EXP __DBL_MAX_10_EXP__
-
-   /* Number of base-FLT_RADIX digits in the significand of a long double */
-#define LDBL_MANT_DIG   __LDBL_MANT_DIG__
-   /* Number of decimal digits of precision in a long double */
-#define LDBL_DIG        __LDBL_DIG__
-   /* Difference between 1.0 and the minimum long double greater than 1.0 */
-#define LDBL_EPSILON    __LDBL_EPSILON__
-   /* Minimum int x such that FLT_RADIX**(x-1) is a normalised long double */
-#define LDBL_MIN_EXP    __LDBL_MIN_EXP__
-   /* Minimum normalised long double */
-#define LDBL_MIN        __LDBL_MIN__
-   /* Minimum int x such that 10**x is a normalised long double */
-#define LDBL_MIN_10_EXP __LDBL_MIN_10_EXP__
-   /* Maximum int x such that FLT_RADIX**(x-1) is a representable long double */
-#define LDBL_MAX_EXP    __LDBL_MAX_EXP__
-   /* Maximum long double */
-#define LDBL_MAX        __LDBL_MAX__
-   /* Maximum int x such that 10**x is a representable long double */
-#define LDBL_MAX_10_EXP __LDBL_MAX_10_EXP__
-
-#endif
diff --git a/src/pdclib/platform/example/include/pdclib/_PDCLIB_config.h b/src/pdclib/platform/example/include/pdclib/_PDCLIB_config.h
deleted file mode 100644
index 9731f86..0000000
--- a/src/pdclib/platform/example/include/pdclib/_PDCLIB_config.h
+++ /dev/null
@@ -1,426 +0,0 @@
-/* Internal PDCLib configuration <_PDCLIB_config.h>
-   (Generic Template)
-
-   This file is part of the Public Domain C Library (PDCLib).
-   Permission is granted to use, modify, and / or redistribute at will.
-*/
-
-#ifndef _PDCLIB_CONFIG_H
-#define _PDCLIB_CONFIG_H _PDCLIB_CONFIG_H
-
-/* -------------------------------------------------------------------------- */
-/* Misc                                                                       */
-/* -------------------------------------------------------------------------- */
-
-/* The character (sequence) your platform uses as newline.                    */
-#define _PDCLIB_endl "\n"
-
-/* exit() can signal success to the host environment by the value of zero or  */
-/* the constant EXIT_SUCCESS. Failure is signaled by EXIT_FAILURE. Note that  */
-/* any other return value is "implementation-defined", i.e. your environment  */
-/* is not required to handle it gracefully. Set your definitions here.        */
-#define _PDCLIB_SUCCESS 0
-#define _PDCLIB_FAILURE -1
-
-/* qsort() in <stdlib.h> requires a function that swaps two memory areas.     */
-/* Below is a naive implementation that can be improved significantly for     */
-/* specific platforms, e.g. by swapping int instead of char.                  */
-#define _PDCLIB_memswp( i, j, size ) char tmp; do { tmp = *i; *i++ = *j; *j++ = tmp; } while ( --size );
-
-/* Define this to some compiler directive that can be written after the       */
-/* parameter list of a function declaration to indicate the function does     */
-/* never return. If your compiler does not support such a directive, define   */
-/* to nothing. (This is to avoid warnings with the exit functions under GCC.) */
-#define _PDCLIB_NORETURN __attribute__(( noreturn ))
-
-/* -------------------------------------------------------------------------- */
-/* Integers                                                                   */
-/* -------------------------------------------------------------------------- */
-/* Assuming 8-bit char, two's-complement architecture here. 'short' being     */
-/* 16 bit, 'int' being either 16, 32 or 64 bit, 'long' being either 32 or 64  */
-/* bit (but 64 bit only if 'int' is 32 bit), and 'long long' being 64 bit if  */
-/* 'long' is not, 64 or 128 bit otherwise.                                    */
-/* Author is quite willing to support other systems but would like to hear of */
-/* interest in such support and details on the to-be-supported architecture   */
-/* first, before going to lengths about it.                                   */
-/* -------------------------------------------------------------------------- */
-
-/* Set to 0 if your 'char' type is unsigned.                                  */
-#ifdef __CHAR_UNSIGNED__
-#define _PDCLIB_CHAR_SIGNED 0
-#else
-#define _PDCLIB_CHAR_SIGNED 1
-#endif
-
-/* Width of the integer types short, int, long, and long long, in bytes.      */
-/* SHRT == 2, INT >= SHRT, LONG >= INT >= 4, LLONG >= LONG - check your       */
-/* 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
-
-/* <stdlib.h> defines the div() function family that allows taking quotient   */
-/* and remainder of an integer division in one operation. Many platforms      */
-/* support this in hardware / opcode, and the standard permits ordering of    */
-/* the return structure in any way to fit the hardware. That is why those     */
-/* structs can be configured here.                                            */
-
-struct _PDCLIB_div_t
-{
-    int quot;
-    int rem;
-};
-
-struct _PDCLIB_ldiv_t
-{
-    long int quot;
-    long int rem;
-};
-
-struct _PDCLIB_lldiv_t
-{
-    long long int quot;
-    long long int rem;
-};
-
-/* -------------------------------------------------------------------------- */
-/* <stdint.h> defines a set of integer types that are of a minimum width, and */
-/* "usually fastest" on the system. (If, for example, accessing a single char */
-/* requires the CPU to access a complete int and then mask out the char, the  */
-/* "usually fastest" type of at least 8 bits would be int, not char.)         */
-/* If you do not have information on the relative performance of the types,   */
-/* the standard allows you to define any type that meets minimum width and    */
-/* signedness requirements.                                                   */
-/* The defines below are just configuration for the real typedefs and limit   */
-/* definitions done in <_PDCLIB_int.h>. The uppercase define shall be either  */
-/* 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 <inttypes.h>).                                  */
-/* 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.            */
-/* -------------------------------------------------------------------------- */
-
-#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 LONG
-#define _PDCLIB_fast64 long
-#define _PDCLIB_FAST64_CONV l
-
-/* -------------------------------------------------------------------------- */
-/* What follows are a couple of "special" typedefs and their limits. Again,   */
-/* the actual definition of the limits is done in <_PDCLIB_int.h>, and the    */
-/* defines here are merely "configuration". See above for details.            */
-/* -------------------------------------------------------------------------- */
-
-/* The result type of substracting two pointers */
-#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,
-   but its limits are. (Don't ask.)
-*/
-#define _PDCLIB_sig_atomic int
-#define _PDCLIB_SIG_ATOMIC INT
-
-/* Result type of the 'sizeof' operator (must be unsigned) */
-#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 int
-#define _PDCLIB_WCHAR UINT
-
-/* Large enough an integer to hold all character codes of the largest supported
-   locale plus WEOF (which needs not to be equal to EOF, nor needs to be of
-   negative value).
-*/
-#define _PDCLIB_wint unsigned int
-#define _PDCLIB_WINT UINT
-
-/* (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 LLONG
-#define _PDCLIB_MAX_CONV ll
-/* You are also required to state the literal suffix for the intmax type      */
-#define _PDCLIB_INTMAX_LITERAL ll
-
-/* <inttypes.h> 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                                                                 */
-/* -------------------------------------------------------------------------- */
-
-/* See <time.h> for a couple of comments on these types and their semantics. */
-
-#define _PDCLIB_time long
-
-#define _PDCLIB_clock long
-#define _PDCLIB_CLOCKS_PER_SEC 1000000
-
-#define _PDCLIB_TIME_UTC 1
-
-/* -------------------------------------------------------------------------- */
-/* Floating Point                                                             */
-/* -------------------------------------------------------------------------- */
-
-/* Whether the implementation rounds toward zero (0), to nearest (1), toward
-   positive infinity (2), or toward negative infinity (3). (-1) signifies
-   indeterminable rounding, any other value implementation-specific rounding.
-*/
-#define _PDCLIB_FLT_ROUNDS -1
-
-/* Whether the implementation uses exact-width precision (0), promotes float
-   to double (1), or promotes float and double to long double (2). (-1)
-   signifies indeterminable behaviour, any other value implementation-specific
-   behaviour.
-*/
-#define _PDCLIB_FLT_EVAL_METHOD -1
-
-/* "Number of the decimal digits (n), such that any floating-point number in the
-   widest supported floating type with p(max) radix (b) digits can be rounded to
-   a floating-point number with (n) decimal digits and back again without change
-   to the value p(max) log(10)b if (b) is a power of 10, [1 + p(max) log(10)b]
-   otherwise."
-   64bit IEC 60559 double format (53bit mantissa) is DECIMAL_DIG 17.
-   80bit IEC 60559 double-extended format (64bit mantissa) is DECIMAL_DIG 21.
-*/
-#define _PDCLIB_DECIMAL_DIG 17
-
-/* -------------------------------------------------------------------------- */
-/* Platform-dependent macros defined by the standard headers.                 */
-/* -------------------------------------------------------------------------- */
-
-/* The offsetof macro
-   Contract: Expand to an integer constant expression of type size_t, which
-   represents the offset in bytes to the structure member from the beginning
-   of the structure. If the specified member is a bitfield, behaviour is
-   undefined.
-   There is no standard-compliant way to do this.
-   This implementation casts an integer zero to 'pointer to type', and then
-   takes the address of member. This is undefined behaviour but should work on
-   most compilers.
-*/
-#define _PDCLIB_offsetof( type, member ) ( (size_t) &( ( (type *) 0 )->member ) )
-
-/* Variable Length Parameter List Handling (<stdarg.h>)
-   The macros defined by <stdarg.h> are highly dependent on the calling
-   conventions used, and you probably have to replace them with builtins of
-   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.
-*/
-
-/* Internal helper macro. va_round is not part of <stdarg.h>. */
-#define _PDCLIB_va_round( type ) ( (sizeof(type) + sizeof(void *) - 1) & ~(sizeof(void *) - 1) )
-
-typedef char * _PDCLIB_va_list;
-#define _PDCLIB_va_arg( ap, type ) ( (ap) += (_PDCLIB_va_round(type)), ( *(type*) ( (ap) - (_PDCLIB_va_round(type)) ) ) )
-#define _PDCLIB_va_copy( dest, src ) ( (dest) = (src), (void)0 )
-#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 ) || defined( __arm__ )
-
-/* No way to cover x86_64 or arm with a generic implementation, as it uses
-    register-based parameter passing. Using compiler 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 */
-/* the capabilities and requirements of your OS.                              */
-/* The actual *functions* of the OS interface are declared in _PDCLIB_glue.h. */
-/* -------------------------------------------------------------------------- */
-
-/* Memory management -------------------------------------------------------- */
-
-/* Set this to the page size of your OS. If your OS does not support paging, set
-   to an appropriate value. (Too small, and malloc() will call the kernel too
-   often. Too large, and you will waste memory.)
-*/
-#define _PDCLIB_PAGESIZE 4096
-
-/* Set this to the minimum memory node size. Any malloc() for a smaller size
-   will be satisfied by a malloc() of this size instead (to avoid excessive
-   fragmentation).
-*/
-#define _PDCLIB_MINALLOC 8
-
-/* I/O ---------------------------------------------------------------------- */
-
-/* The type of the file descriptor returned by _PDCLIB_open(). */
-typedef int _PDCLIB_fd_t;
-
-/* The value (of type _PDCLIB_fd_t) returned by _PDCLIB_open() if the operation
-   failed.
-*/
-#define _PDCLIB_NOHANDLE ( (_PDCLIB_fd_t) -1 )
-
-/* 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(). 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
-
-/* 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 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 <errno.h> will "see" EPERM instead of EISDIR (the _PDCLIB_*
-   prefix removed by <errno.h> 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_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 <errno.h> 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_ERROR  4
-
-/* The maximum value that errno can be set to. This is used to set the size   */
-/* of the array in struct _PDCLIB_lc_text_t 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
-
-/* locale data -------------------------------------------------------------- */
-
-/* The default path where PDCLib should look for its locale data.             */
-/* Must end with the appropriate separator character.                         */
-#define _PDCLIB_LOCALE_PATH "/usr/share/pdclib/i18n"
-
-/* The name of the environment variable that can be used to override that     */
-/* path setting.                                                              */
-#define _PDCLIB_LOCALE_PATH_ENV PDCLIB_I18N
-
-#ifdef __CYGWIN__
-typedef unsigned int wint_t;
-#endif
-
-
-#endif
diff --git a/src/pdclib/platform/example/include/signal.h b/src/pdclib/platform/example/include/signal.h
deleted file mode 100644
index c5f6f28..0000000
--- a/src/pdclib/platform/example/include/signal.h
+++ /dev/null
@@ -1,84 +0,0 @@
-/* Signal handling <string.h>
-
-   This file is part of the Public Domain C Library (PDCLib).
-   Permission is granted to use, modify, and / or redistribute at will.
-*/
-
-#ifndef _PDCLIB_SIGNAL_H
-#define _PDCLIB_SIGNAL_H _PDCLIB_SIGNAL_H
-
-#include "pdclib/_PDCLIB_config.h"
-
-/* Signals ------------------------------------------------------------------ */
-
-/* A word on signals, to the people using PDCLib in their OS projects.
-
-   The definitions of the C standard leave about everything that *could* be
-   useful to be "implementation defined". Without additional, non-standard
-   arrangements, it is not possible to turn them into a useful tool.
-
-   This example implementation chose to "not generate any of these signals,
-   except as a result of explicit calls to the raise function", which is
-   allowed by the standard but of course does nothing for the usefulness of
-   <signal.h>.
-
-   A useful signal handling would:
-   1) make signal() a system call that registers the signal handler with the OS
-   2) make raise() a system call triggering an OS signal to the running process
-   3) make provisions that further signals of the same type are blocked until
-      the signal handler returns (optional for SIGILL)
-*/
-
-/* These are the values used by Linux. */
-
-/* Abnormal termination / abort() */
-#define SIGABRT 6
-/* Arithmetic exception / division by zero / overflow */
-#define SIGFPE  8
-/* Illegal instruction */
-#define SIGILL  4
-/* Interactive attention signal */
-#define SIGINT  2
-/* Invalid memory access */
-#define SIGSEGV 11
-/* Termination request */
-#define SIGTERM 15
-
-/* The following should be defined to pointer values that could NEVER point to
-   a valid signal handler function. (They are used as special arguments to
-   signal().) Again, these are the values used by Linux.
-*/
-#define SIG_DFL (void (*)( int ))0
-#define SIG_ERR (void (*)( int ))-1
-#define SIG_IGN (void (*)( int ))1
-
-typedef _PDCLIB_sig_atomic sig_atomic_t;
-
-/* Installs a signal handler "func" for the given signal.
-   A signal handler is a function that takes an integer as argument (the signal
-   number) and returns void.
-
-   Note that a signal handler can do very little else than:
-   1) assign a value to a static object of type "volatile sig_atomic_t",
-   2) call signal() with the value of sig equal to the signal received,
-   3) call _Exit(),
-   4) call abort().
-   Virtually everything else is undefind.
-
-   The signal() function returns the previous installed signal handler, which
-   at program start may be SIG_DFL or SIG_ILL. (This implementation uses
-   SIG_DFL for all handlers.) If the request cannot be honored, SIG_ERR is
-   returned and errno is set to an unspecified positive value.
-*/
-void (*signal( int sig, void (*func)( int ) ) )( int );
-
-/* Raises the given signal (executing the registered signal handler with the
-   given signal number as parameter).
-   This implementation does not prevent further signals of the same time from
-   occuring, but executes signal( sig, SIG_DFL ) before entering the signal
-   handler (i.e., a second signal before the signal handler re-registers itself
-   or SIG_IGN will end the program).
-   Returns zero if successful, nonzero otherwise. */
-int raise( int sig );
-
-#endif