You can set some search pattern!
header | X | ||
macros for error reporting | |||
EDOM | |||
macro, int, const, #if | A | ||
domain error | |||
ERANGE | |||
macro, int, const, #if | A | ||
range error | |||
E[A-Z0-9][a-zA-Z0-9_]* | |||
macro, int, const, #if | X | ||
reserved for future use | |||
errno | |||
lvalue, int | I | ||
is set to non-zero by library functions on error; E* values can be assigned | |||
EILSEQ | |||
macro, int | A | ||
"ill sequence" error while encoding MBCs to Wcs |
header | R | ||
compiler depend limits of ranges of scalar types | |||
Due to the fact that teh "sizeof" operator is not to be used within preprocessor tokens, these values cannot be determined at compile-time. For now the assumed values should work for all DOS -based real-mode (16bit) environments. | |||
CHAR_BIT | |||
macro, const, #if | CIR | ||
number of bits for smallest object (byte) [>= 8] | |||
Unless the other defines this value can never be determined at compile-time; the user must take care of this value himself. There should not exist a DOS-based environment with a setting != 8. | |||
SCHAR_MIN | |||
macro, const, #if | CI | ||
minimum value for (signed char) [<= -127] | |||
SCHAR_MAX | |||
macro, const, #if | CI | ||
maximum value for (signed char) [>= +127] | |||
UCHAR_MAX | |||
macro, const, #if | CI | ||
maximum value for (unsigned char) [>= 255] | |||
CHAR_MIN | |||
macro, const, #if | CI | ||
minimum value for (char); either SCHAR_MIN or 0 | |||
CHAR_MAX | |||
macro, const, #if | CI | ||
maximum value for (char); either SCHAR_MAX or UCHAR_MAX | |||
MB_LEN_MAX | |||
macro, const, #if | N | ||
maximum number of bytes in a multibyte character [>= 1] | |||
SHRT_MIN | |||
macro, const, #if | I | ||
minimum value for (signed short int) [<= -32767] | |||
SHRT_MAX | |||
macro, const, #if | CI | ||
maximum value for (signed short int) [>= +32767] | |||
USHRT_MAX | |||
macro, const, #if | CI | ||
maximum value for (unsigned short int) [>= 65535] | |||
INT_MIN | |||
macro, const, #if | CI | ||
minimum value for (signed int) [<= -32767] | |||
INT_MAX | |||
macro, const, #if | CI | ||
maximum value for (signed int) [>= +32767] | |||
UINT_MAX | |||
macro, const, #if | CI | ||
maximum value for (unsigned int) [>= 65535] | |||
LONG_MIN | |||
macro, const, #if | CI | ||
minimum value for (signed int) [<= -2147483647] | |||
LONG_MAX | |||
macro, const, #if | CI | ||
maximum value for (signed int) [>= +2147483647] | |||
ULONG_MAX | |||
macro, const, #if | CI | ||
maximum value for (unsigned int) [>= 429467295] |
header | X | ||
compiler depend limits of ranges of floating point numbers | |||
FLT_RADIX | |||
macro, const, #if | N | ||
{b}: base or radix of exponent [>= 2] | |||
FLT_ROUNDS | |||
macro | X | ||
rounding mode | |||
FLT_MANT_DIG | |||
macro | N | ||
size of mantisse: base-{b} digits for (float) | |||
DBL_MANT_DIG | |||
macro | N | ||
size of mantisse: base-{b} digits for (double) | |||
LDBL_MANT_DIG | |||
macro | N | ||
size of mantisse: base-{b} digits for (long double) | |||
FLT_DIG | |||
macro | N | ||
number of base-10 digits, that survive transformation to base-{b} unchanged, for (float) | |||
DLB_DIG | |||
macro | N | ||
number of base-10 digits, that survive transformation to base-{b} unchanged, for (double) | |||
LDLB_DIG | |||
macro | N | ||
number of base-10 digits, that survive transformation to base-{b} unchanged, for (long double) | |||
FLT_MIN_EXP | |||
macro | N | ||
minimum value of {e} for (float) [< 0] | |||
DBL_MIN_EXP | |||
macro | N | ||
minimum value of {e} for (double) [< 0] | |||
LDBL_MIN_EXP | |||
macro | N | ||
minimum value of {e} for (long double) [< 0] | |||
FLT_MIN_10_EXP | |||
macro | N | ||
minimum value of base-10 exponents (float) [<= -37] | |||
DBL_MIN_10_EXP | |||
macro | N | ||
minimum value of base-10 exponents (double) [<= -37] | |||
LDBL_MIN_10_EXP | |||
macro | N | ||
minimum value of base-10 exponents (long double) [<= -37] | |||
FLT_MAX_EXP | |||
macro | N | ||
maximum value of {e} for (float) [> 0] | |||
DBL_MAX_EXP | |||
macro | N | ||
maximum value of {e} for (double) [> 0] | |||
LDBL_MAX_EXP | |||
macro | N | ||
maximum value of {e} for (long double) [> 0] | |||
FLT_MAX_10_EXP | |||
macro | N | ||
maximum value of base-10 exponents (float) [>= +37] | |||
DBL_MAX_10_EXP | |||
macro | N | ||
maximum value of base-10 exponents (double) [>= +37] | |||
LDBL_MAX_10_EXP | |||
macro | N | ||
maximum value of base-10 exponents (long double) [>= +37] | |||
FLT_MAX | |||
macro | N | ||
maximum finite value for (float) [>= 1E+37] | |||
DBL_MAX | |||
macro | N | ||
maximum finite value for (double) [>= 1E+37] | |||
LDBL_MAX | |||
macro | N | ||
maximum finite value for (long double) [>= 1E+37] | |||
FLT_EPSILON | |||
macro | N | ||
difference between 1 and the least value >1 for (float) [<= 1E-5] | |||
DBL_EPSILON | |||
macro | N | ||
difference between 1 and the least value >1 for (double) [<= 1E-9] | |||
LDBL_EPSILON | |||
macro | N | ||
difference between 1 and the least value >1 for (long double) [<= 1E-9] | |||
FLT_MIN | |||
macro | N | ||
minimum postive number for (float) [<= 1E-37] | |||
DBL_MIN | |||
macro | N | ||
minimum postive number for (double) [<= 1E-37] | |||
LDBL_MIN | |||
macro | N | ||
minimum postive number for (long double) [<= 1E-37] |
header | X | ||
common definitions | |||
ptrdiff_t | |||
type, int | I | ||
signed, difference of two pointer | |||
size_t | |||
type, int | I | ||
unsigned, return of sizeof() operator | |||
wchar_t | |||
type, int | I | ||
can hold any character of supported locales | |||
NULL | |||
macro, const | I | ||
implementor-defined null pointer constant; a pointer that never can address an object of an C program | |||
size_t offsetof(type, member) | |||
macro, int, const | IR | ||
offset in bytes of the member from the beginning of the structure | |||
Relys on the assumption that the compiler calculates the address of (void*)0 based structures, this leads to undefined behaviour according ISO9899 |
header | X | ||
diagnostics | |||
void assert(int expression) | |||
macro | I | ||
if NDEBUG is not defined, terminate program with errmsg if expression == 0 |
header | R | ||
character handling; locale depended | |||
Currently most of the functions are implemented as macros only. | |||
int isalnum(int c) | |||
function | F | ||
isalpha(c) || isdigit(c) | |||
int isalpha(int c) | |||
function | F | ||
c is an alphabetic character (letter) | |||
int iscntrl(int c) | |||
function | F | ||
c is a control character | |||
int isdigit(int c) | |||
function | F | ||
c is decimal digit | |||
int isgraph(int c) | |||
function | F | ||
c is printable except space ' ' | |||
int islower(int c) | |||
function | F | ||
c is a lowercase letter | |||
int isprint(int c) | |||
function | F | ||
c is printable incl space ' ' | |||
int ispunct(int c) | |||
function | F | ||
isprint(c) && !isalnum(c) | |||
int isspace(int c) | |||
function | F | ||
whitespace characters, e.g.: " \f\t\n\r\v" | |||
int isupper(int c) | |||
function | F | ||
c is an uppercase letter | |||
int isxdigit(int c) | |||
function | F | ||
is is a hexadecimal digit | |||
int tolower(int c) | |||
function | F | ||
convert uppercase to lowercase letter | |||
int toupper(int c) | |||
function | F | ||
convert lowercase to uppercase letter | |||
is[a-z][a-zA-Z0-9_]* | |||
function | X | ||
reserved for future use | |||
to[a-z][a-zA-Z0-9_]* | |||
function | X | ||
reserved for future use |
header | N | ||
localization; locale support | |||
lconv | |||
struct | N | ||
contains all localized settings | |||
NULL | |||
macro, int, const | X | ||
null pointer definition | |||
char *setlocale(int category, const char *locale) | |||
function | N | ||
sets the locale of the specified category | |||
LC_ALL | |||
macro, int, const | N | ||
affects the entire locale | |||
LC_COLLATE | |||
macro, int, const | N | ||
affects strcoll() & strxfrm() only | |||
LC_CTYPE | |||
macro, int, const | N | ||
affects character handling & multibyte functions only | |||
LC_MONETARY | |||
macro, int, const | N | ||
affects monetary formatting information only | |||
LC_NUMERIC | |||
macro, int, const | N | ||
affects nonmonetary formatting information only | |||
LC_TIME | |||
macro, int, const | N | ||
affects strftime() only | |||
LC_[A-Z][a-zA-Z0-9_]* | |||
macro, int, const | N | ||
reserved for future use | |||
struct lconv *localeconv(void) | |||
function, noCLib | N | ||
aquire the current locale | |||
char *decimal_point | |||
member | N | ||
decimal-point; != ""; != NULL | |||
char *thousends_sep | |||
member | N | ||
separate groups of digits before the decimal-point; != NULL | |||
char *grouping | |||
member | N | ||
indicate the size of each group of digits; != NULL | |||
char *int_curr_symbol | |||
member | N | ||
international currency string acc. ISO 4217:1987; != NULL | |||
char *currency_symbol | |||
member | N | ||
local currency symbol; != NULL | |||
char *mon_decimal_point | |||
member | N | ||
decimal-point for monteray numbers; != ""; != NULL | |||
char *mon_thousends_sep | |||
member | N | ||
separate groups of digits before the decimal-point in monetary numbers; != NULL | |||
char *mon_grouping | |||
member | N | ||
indicate the size of each group of digits in monetary numbers; != NULL | |||
char *positive_sign | |||
member | N | ||
sign preceeding nonnegative monetary numbers; != NULL | |||
char *negative_sign | |||
member | N | ||
sign preceeding negative monetary numbers; != NULL | |||
char *int_frac_digits | |||
member | N | ||
number of fraction digits in a internally formatted monetary number; != NULL | |||
char *frac_digits | |||
member | N | ||
number of fraction digits in a formatted monetary number; != NULL | |||
char *p_cs_precedes | |||
member | N | ||
true if currency_symbol preceeds nonnegative numbers; != NULL | |||
char *p_sep_by_space | |||
member | N | ||
true if currency-symbol is separated by a single space from a nonnegative number; != NULL | |||
char p_sign_posn | |||
member | N | ||
how to position positive_sign in monetary numbers | |||
char *n_cs_precedes | |||
member | N | ||
true if currency_symbol preceeds negative numbers; != NULL | |||
char *n_sep_by_space | |||
member | N | ||
true if currency-symbol is separated by a single space from a negative number; != NULL | |||
char n_sign_posn | |||
member | N | ||
how to position negative_sign in monetary numbers |
header | N | ||
mathematics; (double) only | |||
double HUGE_VAL | |||
macro, const | N | ||
error value returned as infinite with the same sign as the function normally would return | |||
ERANGE | |||
macro, int, const | X | ||
value stored into errno on failure | |||
double acos(double x) | |||
function | N | ||
arc cosine of x; x in [-1, +1], otherwise EDOM | |||
double asin(double x) | |||
function | N | ||
arc sine of x; x in [-1, +1], otherwise EDOM | |||
double atan(double x) | |||
function | N | ||
arc tangent of x | |||
double atan2(double y, double x) | |||
function | N | ||
atan(y/x); EDOM if x==0.0 && y==0.0 | |||
double cos(double x) | |||
function | N | ||
cosine of x (in radians) | |||
double sin(double x) | |||
function | N | ||
sine of x (in radians) | |||
double tan(double x) | |||
function | N | ||
tangent of x (in radians) | |||
double cosh(double x) | |||
function | N | ||
hyberbolic cosine of x; ERANGE if magnitude of x too large | |||
double sinh(double x) | |||
function | N | ||
hyberbolic sine of x; ERANGE if magnitude of x too large | |||
double tanh(double x) | |||
function | N | ||
hyberbolic tangent of x | |||
double exp(double x) | |||
function | N | ||
e^x; ERANGE if magnitude of x too large | |||
double frexp(double x, int *exp) | |||
function | N | ||
break number into mantisse and base-2 exponent; frexp() == x / 2^(*exp) | |||
double ldexp(double x, int exp) | |||
function | N | ||
join mantisse and exponent into number; ldexp() == x * 2^exp; ERANGE may occure | |||
double log(double x) | |||
function | N | ||
natural logarithm of x; EDOM if x<0.0; ERANGE if x==0.0 | |||
double log10(double x) | |||
function | N | ||
base-10 logarithm of x; EDOM if x<0.0; ERANGE if x==0.0 | |||
double modf(double x, double *iptr) | |||
function | N | ||
break x into integral part (--> *iptr) and fraction (return value); both have the same sign as x | |||
double pow(double x, double y) | |||
function | N | ||
x^y; EDOM if x<0.0 && y is not integral; EDOM if x==0.0 && y<=0.0; ERANGE possible | |||
double sqrt(double x) | |||
function | N | ||
nonnegative square root of x; EDOM if x<0.0 | |||
double ceil(double) | |||
function | N | ||
smallest integral value >= x | |||
double fabs(double x) | |||
function | N | ||
absolue value of x | |||
double floor(double x) | |||
function | N | ||
largest integral value <= x | |||
double fmod(double x, double y) | |||
function | N | ||
remainder of x/y; if y==0.0: either EDOM or fmod()==0 | |||
float f*() | |||
function | N | ||
reserved for functions with the original name prefixed with 'f' but use (float) instead of (double) for all numeric values; e.g. float ffabs(float x) | |||
long double f*() | |||
function | N | ||
reserved for functions with the original name prefixed with 'l' but use (long double) instead of (double) for all numeric values; e.g. long double lfabs(long double x) |
header | N | ||
nonlocal jumps / long jumps | |||
jmp_buf | |||
struct | N | ||
structure of argument passed to *jmp() | |||
int setjmp(jmp_buf env) | |||
macro | N | ||
saves environment to be restored by longjmp(); returns 0 if returning from setjmp(); else if returning from longjmp() | |||
void longjmp(jmp_buf env, int val) | |||
function | N | ||
restores the environment stored by setjmp(); if val==0, setjmp() returns 1 |
header | N | ||
signal handling | |||
sig_atomic_t | |||
type | N | ||
integral type of objects that can be accessed as an atomic entity, even in the presence of asynchronous interrupts | |||
SIG_DFL | |||
macro, const | N | ||
restore default behaviour, when passed as 2nd paramter to signal() | |||
SIG_ERR | |||
macro, const | N | ||
return value of signal() on failure | |||
SIG_IGN | |||
macro, const | N | ||
ignore interrupt, when passed as 2nd paramter to signal() | |||
SIG_[A-Z][a-zA-Z0-9_]* | |||
macro, const | N | ||
reserved for future use | |||
SIGABRT | |||
macro, int, const | N | ||
"abnormal termination" signal [> 0] | |||
SIGFPE | |||
macro, int, const | N | ||
"erroreous arithmetic operation" signal [> 0] | |||
SIGILL | |||
macro, int, const | N | ||
"invalid code" signal [> 0] | |||
SIGINT | |||
macro, int, const | N | ||
"interactive attention" signal (^Break) [> 0] | |||
SIGSEGV | |||
macro, int, const | N | ||
"invalid access to memory" signal [> 0] | |||
SIGTERM | |||
macro, int, const | N | ||
"termination request" signal [> 0] | |||
SIG[A-Z][a-zA-Z0-9_] | |||
macro, int, const | N | ||
reserved for future use [> 0] | |||
void (*signal(int sig, void (*func)(int)))(int) | |||
function | N | ||
sets a new signal handler; if the 2nd parameter is SIG_DFL, the default handler is activated. | |||
int raise(int sig) | |||
function | N | ||
0 on success; send a signal to the running process |
header | ICR | ||
variable arguments | |||
Because the way how variables are passed to a function, incl their order and if they are promoted, is highly compiler-dependent, the user must take care if the settings apply to his compiler. | |||
va_list | |||
type | IR | ||
type to hold the information needed by va_start(), va_arg(),& va_end() | |||
It is assumed that data pointers (void*) can point into the stack. | |||
void va_start(va_list ap, parmN) | |||
macro | IC | ||
initialize ap to be used in va_arg(); parmN is the rightmost non-variable argument | |||
type va_arg(va_list ap, type) | |||
macro | IC | ||
extracts the next argument with the specified type; ap is modified so that successive arguments are returned in turn | |||
void va_end(va_list ap) | |||
macro | I | ||
indicate that ap is no longer in use |
header | X | ||
input/output | |||
size_t | |||
type | I | ||
type returned by sizeof() | |||
FILE | |||
type | I | ||
type to indentify a stream | |||
fpos_t | |||
type | N | ||
type to uniquely identify a position within a stream | |||
NULL | |||
macro | I | ||
null pointer constant | |||
_IOFBF | |||
macro, int, const | I | ||
full buffering; passed to setvbuf() | |||
_IOLBF | |||
macro, int, const | I | ||
line buffering; passed to setvbuf() | |||
_IONBF | |||
macro, int, const | I | ||
no buffering; passed to setvbuf() | |||
BUFSIZ | |||
macro, int, const | I | ||
size of buffer created by setbuf() [>= 256] | |||
EOF | |||
macro, int, const | I | ||
returned to indicate the end-of-file condition [< 0] | |||
FOPEN_MAX | |||
macro, int, const | I | ||
minimum number of files that can be opened simultaneously [>= 8] | |||
FILENAME_MAX | |||
macro, int, const | I | ||
minimum _or_ _recommended_ size of string to hold a filename the system can open | |||
L_tmpnam | |||
macro, int, const | I | ||
minimum size of string to hold a filename generated by tmpnam() | |||
SEEK_CUR | |||
macro, int, const | I | ||
seek from current position; passed to fseek() | |||
SEEK_END | |||
macro, int, const | I | ||
seek from end of stream; passed to fseek() | |||
SEEK_SET | |||
macro, int, const | I | ||
seek from begin of stream; passed to fseek() | |||
TMP_MAX | |||
macro, int, const | I | ||
minimum number of unique filenames generated by tmpnam() | |||
FILE *stderr | |||
expression | I | ||
stream connected to the standard error output | |||
FILE *stdout | |||
expression | I | ||
stream connected to the standard output | |||
FILE *stdin | |||
expression | I | ||
stream connected to the standard input | |||
int remove(const char *filename) | |||
function | I | ||
remove/delete/unlink file | |||
int rename(const char *old, const char *new) | |||
function | I | ||
rename file from old to new | |||
FILE *tmpfile(void) | |||
function | N | ||
create & open a file in "wb+" mode, it's removed on close | |||
char *tmpnam(char *s) | |||
function, noCLib | N | ||
create a currently not existing filename up to TMP_MAX times | |||
int fclose(FILE *stream) | |||
function | I | ||
close the stream | |||
int fflush(FILE *stream) | |||
function | I | ||
commit the write-buffer of the stream; if stream==NULL, commit all write-buffers | |||
FILE *fopen(const char *filename, const char *mode) | |||
function | F | ||
open/create a stream; support mode flags "rwab+" | |||
FILE *freopen(const char *filename, const char *mode, FILE *stream) | |||
function | F | ||
open/create file and associate it with the stream | |||
void setbuf(FILE *stream, char *buf) | |||
function | F | ||
associate the stream with a buffer | |||
int setvbuf(FILE *stream, char *buf, int mode, size_t size) | |||
function | I | ||
associate the stream with a buffer | |||
int fprintf(FILE *stream, const char *fmt, ...) | |||
function | P | ||
formatted output into a stream | |||
int fscanf(FILE *stream, const char *fmt, ...) | |||
function | P | ||
formatted input from a stream | |||
int printf(const char *fmt, ...) | |||
function | P | ||
formatted output into stdout | |||
int scanf(const char *fmt, ...) | |||
function | P | ||
formatted input from stdin | |||
int sprintf(char *s, const char *fmt, ...) | |||
function | P | ||
formatted output into a string | |||
int sscanf(char *s, const char *fmt, ...) | |||
function | P | ||
formatted input from a string | |||
int vfprintf(FILE *stream, const char *fmt, va_list ap) | |||
function | P | ||
formatted output into a stream | |||
int vprintf(const char *fmt, va_list ap) | |||
function | P | ||
formatted output into stdout | |||
int vsprintf(char *s, const char *fmt, va_list ap) | |||
function | P | ||
formatted output into a string | |||
int fgetc(FILE *stream) | |||
function | I | ||
get the next (unsigned char) character from stream | |||
char *fgets(char *s, int n, FILE *stream) | |||
function | X | ||
read a line from the stream | |||
int fputc(int c, FILE *stream) | |||
function | X | ||
put (unsigned char)c into the stream | |||
int fputs(const char *s, FILE *stream) | |||
function | I | ||
put a string into the stream | |||
int getc(FILE *stream) | |||
macro | I | ||
get the next (unsigned char) character from stream | |||
int getchar(void) | |||
macro | I | ||
get the next (unsigned char) character from stdin | |||
char *gets(char *s) | |||
function | I | ||
read the next line from stdin; '\n' is discarded | |||
int putc(int c, FILE *stream) | |||
macro | I | ||
put (unsigned char)c into the stream | |||
int putchar(int c) | |||
macro | I | ||
put (unsigned char)c into stdout | |||
int puts(const char *s) | |||
function | I | ||
put a string into the stream and append a single '\n' | |||
int ungetc(int c, FILE *stream) | |||
function | I | ||
push back one character to the input stream | |||
size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream) | |||
function | I | ||
read nmemb * size bytes from the stream | |||
size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream) | |||
function | I | ||
write nmemb * size bytes into the stream | |||
int fgetpos(FILE *stream, fpos_t *pos) | |||
function | N | ||
store the current file position indicator into *pos | |||
int fseek(FILE *stream, long int offset, int whence) | |||
function | I | ||
manipulate the file position indicator of the stream | |||
int fsetpos(FILE *stream, const fpos_t *pos) | |||
function | N | ||
restore the current file position indicator from *pos | |||
long int ftell(FILE *stream) | |||
function | I | ||
obtain the current file position indicator | |||
void rewind(FILE *stream) | |||
function | I | ||
seek to the beginning of the file and reset the error flag | |||
void clearerr(FILE *stream) | |||
function | F | ||
clear the end-of-file and error flag of the stream | |||
int feof(FILE *stream) | |||
function | F | ||
tests the end-of-file flag of stream | |||
int ferror(FILE *stream) | |||
function | F | ||
tests the error flag of stream | |||
void perror(const char *s) | |||
function | N | ||
equal to: fprintf(stderr, "%s:%s\n", s, strerror(errno)) |
header | X | ||
general utilities | |||
size_t | |||
type | I | ||
type of return value of sizeof() | |||
wchar_t | |||
type | I | ||
type of an object capable of holding a single wide-charater | |||
div_t | |||
type | N | ||
type of the return value of div() | |||
ldiv_t | |||
type | N | ||
type of the return value of ldiv() | |||
int quot | |||
member | N | ||
containing the quotient of the result of div() | |||
int rem | |||
member | N | ||
containing the remainder of the result of div() | |||
long quot | |||
member | N | ||
containing the quotient of the result of ldiv() | |||
long rem | |||
member | N | ||
containing the remainder of the result of ldiv() | |||
NULL | |||
macro, const | I | ||
the null pointer constant | |||
EXIT_FAILURE | |||
macro, int | I | ||
indicate unsuccessful state; passed to exit() | |||
EXIT_SUCCESS | |||
macro, int | I | ||
indicate successful state; passed to exit() | |||
RAND_MAX | |||
macro, int, const | N | ||
maximum value returned by rand() [>= 32767] | |||
MB_CUR_MAX | |||
macro, int | N | ||
maximum number of bytes a multibyte character of the current locale may use [>= 1] [<= MB_LEN_MAX] | |||
double atof(const char *s) | |||
function | N | ||
convert the initial portion of s into (double) | |||
int atoi(const char *s) | |||
function | N | ||
convert the initial portion of s into (int) | |||
long atol(const char *s) | |||
function | N | ||
convert the initial portion of s into (long) | |||
double strtod(const char *s, char **endptr) | |||
function | N | ||
convert the initial part of s into (double) and mark the end of the converted string ERANGE if number exceeds (double) limits |
|||
long strtol(const char *s, char **endptr, int base) | |||
function | N | ||
convert the initial part of s into (long) and mark the end of the converted string ERANGE if number exceeds (long) limits |
|||
unsigned long strtoul(const char *s, char **endptr, int base) | |||
function | N | ||
convert the initial part of s into (unsigned long) and mark the end of the converted string ERANGE if number exceeds (unsigned long) limits |
|||
int rand(void) | |||
function, noCLib | N | ||
computes a pseudo-random integer in the range of 0..RAND_MAX | |||
void srand(unsigned seed) | |||
function | N | ||
initializes the rand() with the seed; setting the same seed results in the same sequence of rand() values; unless set, defaults to 1 | |||
void *calloc(size_t nmemb, size_t size) | |||
function | I | ||
allocate nmemb*size bytes; initializes all bytes to zero (0) | |||
int free(void *ptr) | |||
function | D | ||
deallocated a previously allocated area; ptr==NULL is to be ignoreed | |||
free() is normally void. CLib returns a successful state | |||
void *malloc(size_t size) | |||
function | I | ||
allocate an area of size bytes | |||
size==0 -> an unique pointer is returned that has no data area associated | |||
void *realloc(void *ptr, size_t size) | |||
function | I | ||
change the size of a previously allocated area | |||
ptr==NULL && size==0 -> malloc(0) | |||
void abort(void) | |||
function | D | ||
equal to raise(SIGABRT); unsuccessful & abnormal termination of the current process; no atexit() functions are called | |||
abort() will quit with exit(3); at_exit() functions _are_ called | |||
int atexit(void (*func)(void)) | |||
function | I | ||
register a function to be called in FIFO-order upon exit [>= 32] | |||
void exit(int status) | |||
function | I | ||
normal process termination: call atexit() functions; close/flush all open streams; remove files create dby tmpfile(); return the exit code to the system | |||
char *getenv(const char *name) | |||
function, noCLib | N | ||
return a pointer to the value of the environment variable name; contents may be overwritten by subsequent calls | |||
int system(const char *str) | |||
function | N | ||
invoke the string through the system's command processor *shell) | |||
void *bsearch(const void *key, const void *base, size_t nmemb, size_t size, int (*compare)(const void *, const void *)) | |||
function | N | ||
binary search; the array must be in order as specified by the compare function | |||
void qsort(void *base, size_t nmemb, size_t size, int (*compare)(const void *, const void *)) | |||
function | N | ||
sort the array according the compare function; items witht the same key _shall_ remain in the original order | |||
int abs(int x) | |||
function | N | ||
absolute value of x, if representable | |||
div_t div(int numer, int denom) | |||
function | N | ||
compute quotient and remainder of the expression numer/denom | |||
long labs(long x) | |||
function | N | ||
absolute value of x, if representable | |||
ldiv_t ldiv(long numer, long denom) | |||
function | N | ||
compute quotient and remainder of the expression numer/denom | |||
int mblen(const char *s, size_t n) | |||
function | N | ||
determine the number of bytes contained in the multibyte s; s==NULL -> return if MBC's have state-dependent encodings; othwerwise, s must form a complete MBC | |||
int mbtowc(wchar_t *pwc, const char *s, size_t n) | |||
function | N | ||
convert one MBC to widecharacter s==NULL -> return if MBC encoding is state-dependent n>MB_CUR_MAX -> n:=MB_CUR_MAX |
|||
int wctomb(char *s, wchar_t *wchar) | |||
function, noCLib | N | ||
convert one widecharacter to MBC; at most MB_CUR_MAX bytes are written | |||
size_t mbstowcs(wchar_t *pwcs, const char *s, size_t n) | |||
function | N | ||
convert a sequence of MBCs into widecharacters | |||
size_t wcstombs(char *s, const wchar_t *pwcs, size_t n) | |||
function | N | ||
convert a sequence of widecharacters into MBCs | |||
str[a-z][a-zA-Z0-9_]* | |||
function | X | ||
reserved for future use |
header | X | ||
string & memory handling | |||
size_t | |||
type | I | ||
type returned by sizeof() | |||
NULL | |||
macro | I | ||
null pointer constant | |||
void *memcpy(void *s1, const void *s2, size_t n) | |||
function | I | ||
copies n objects with sizeof(object)==1 from s2 to s1; both regions may not overlap | |||
void *memmove(void *s1, const void *s2, size_t n) | |||
function | I | ||
as memcpy() but regions may overlap | |||
char *strcpy(char *s1, const char *s2) | |||
function | I | ||
copy string s2 to s2; regions may not overlap | |||
char *strncpy(char *s1, const char *s2, size_t n) | |||
function | D | ||
copy string s2 to s1 but not more than n characters; regions may not overlap; strlen(s2)<n -> n-strlen(s2) '\0' characters are appended | |||
won't erase space after '\0', will always append '\0' | |||
char *strcat(char *s1, const char *s2) | |||
function | I | ||
append s2 to s1; regions may not overlap | |||
char *strncat(char *s1, const char *s2, size_t n) | |||
function | I | ||
append s2 to s1 but not more than n characters; regions may not overlap; '\0' is always appended to the result | |||
int memcmp(const void *s1, const void *s2, size_t n) | |||
function | I | ||
compare both regions byte-by-byte | |||
int strcmp(const char *s1, const char *s2) | |||
function | I | ||
compare both strings character-by-character | |||
int strcoll(const char *s1, const char *s2) | |||
function | N | ||
compare both strings according the current locale | |||
int strncmp(const char *s1, const char *s2, size_t n) | |||
function | I | ||
as strcmp() but not more than n characters | |||
size_t strxfrm(char *s1, const char *s2, size_t n) | |||
function | N | ||
transform string s2 into a form that strcmp() behaves like strcoll() onto two tranformed strings s1==NULL -> return the required buffer size to hold the transformed string |
|||
void *memchr(const void *s, int ch, size_t n) | |||
function | I | ||
search for (unsigned char)ch within a memory area | |||
char *strchr(const char *s , int ch) | |||
function | I | ||
search for (char)ch within the string; ch may be 0 and matches the end-of-string character | |||
size_t strcspn(const char *s1, const char *s2) | |||
function | I | ||
compute the maximum length of the initial string s1 that consists entirely of characters _not_ in s2 | |||
char *strpbrk(const char *s1, const char *s2) | |||
function | I | ||
locate the first occurence in the string s1 of a character in s2 | |||
char *strrchr(const char *s , int ch) | |||
function | I | ||
search the rightmost character (char)ch in the string | |||
size_t strspn(const char *s1, const char *s2) | |||
function | I | ||
compute the length of the maximum initial string s1 that consists entirely of characters of s2 | |||
char *strstr(const char *s1, const char *s2) | |||
function | I | ||
locate the first occurence of s2 within s1 | |||
char *strtok(char *s1, const char *s2) | |||
function, noCLib | I | ||
return the first token within s1 delimited by character(s) of s2; subsequent calls with s1==NULL return the remaining parts; s1 is destroyed | |||
void *memset(void *s, int ch, size_t n) | |||
function | I | ||
fill the memory area with (unsigned char)ch | |||
char *strerror(int errnum) | |||
function, noCLib | N | ||
return the error message string associated with the errnum (usually from errno); subsequent calls may discard previously returned pointers | |||
size_t strlen(const char *s) | |||
function | I | ||
compute the length of the string without the '\0' terminator | |||
str[a-z][a-zA-Z0-9_]* | |||
function | X | ||
reserved for future use strings, terminated by '\0' |
|||
mem[a-z][a-zA-Z0-9_]* | |||
function | X | ||
reserved for future use memory access |
|||
wcs[a-z][a-zA-Z0-9_]* | |||
function | X | ||
reserved for future use widecharacter string |
header | N | ||
date and time | |||
NULL | |||
macro | I | ||
null pointer constant | |||
CLOCKS_PER_SEC | |||
expression | N | ||
number of ticks per second; ticks is the unit returned by clock() | |||
size_t | |||
type | I | ||
type returned by sizeof() | |||
clock_t | |||
type, int | N | ||
arethmetic type to represent times | |||
time_t | |||
type, int | N | ||
arethmetic type to represent times | |||
tm | |||
struct | N | ||
can hold the broken-down form of a calender time; on input the members can have values outside of the specified range, nevertheless these values count when calcualting the exact calendar time | |||
tm_sec | |||
member | N | ||
seconds after the minute [>= 0] [<= 61] | |||
tm_min | |||
member | N | ||
minute after the hour [>= 0] [<= 59] | |||
tm_hour | |||
member | N | ||
hours since midnight [>= 0] [<= 23] | |||
tm_mday | |||
member | N | ||
day of month [>= 1] [<= 31] | |||
tm_mon | |||
member | N | ||
months since January [>= 0] [<= 11] | |||
tm_year | |||
member | N | ||
years since 1900 | |||
tm_wday | |||
member | N | ||
days since Sunday [>= 0] [<= 6] | |||
tm_yday | |||
member | N | ||
days since January 1st [>= 0] [<= 365] | |||
tm_isdst | |||
member | N | ||
Daylight Saving Time flag; <0 -> n/a; ==0 -> no DST; >0 -> DST active | |||
clock_t clock(void) | |||
function | N | ||
determine the used processor time; (clock_t)-1 -> n/a or value cannot be represented | |||
double difftime(time_t time1, time_t time0) | |||
function | N | ||
computes the difference between two calendar times time1-time0 in seconds | |||
time_t mktime(struct tm *timeptr) | |||
function | N | ||
normalize *timeptr; convert the broken-down calender time into a value of the same format as time() | |||
time_t time(time_t *timer) | |||
function | N | ||
determine the current calendar time; the format is implementor-defined | |||
char *asctime(const struct tm *timeptr) | |||
function, noCLib | N | ||
convert a broken-down calender time into a string of the format: Sun Sep 16 01:03:52 19973\n\0 the return value points to an internal static buffer #1 |
|||
char *ctime(const time_t *timer) | |||
function, noCLib | N | ||
equal to asctime(localtime(timer)) | |||
struct tm *gmtime(const time_t *timer) | |||
function, noCLib | N | ||
convert the calendar time into a broken-down format expressed as Coordinated Universal Time (UTC) also known as "+0000" or GMT without DST return pointer to internal static buffer #2 |
|||
struct tm *localtime(const time_t *timer) | |||
function, noCLib | N | ||
convert the calendar time into the broken-down format expressed as local time (according the local timezone incl DST if active) return pointer to internal static buffer #2 |
|||
size_t strftime(char *s, size_t maxsize, const char *format, const struct tm *timeptr) | |||
function | N | ||
convert the broken-down calender time into character(s) controlled by the format string |
header | I | ||
alternative spelling | |||
and | |||
macro | I | ||
&& operator | |||
and_eq | |||
macro | I | ||
&= operator | |||
bitand | |||
macro | I | ||
& operator | |||
bitor | |||
macro | I | ||
| operator | |||
compl | |||
macro | I | ||
~ operator | |||
not | |||
macro | I | ||
! operator | |||
not_eq | |||
macro | I | ||
!= operator | |||
or | |||
macro | I | ||
|| operator | |||
or_eq | |||
macro | I | ||
|= operator | |||
xor | |||
macro | I | ||
^ operator | |||
xor_eq | |||
macro | I | ||
^= operator |
header | N | ||
widecharacter classification & mapping utilities | |||
wint_t | |||
type, int | N | ||
unchanged by any argument promotions; capable to hold any WC and at least one character more (WEOF) | |||
wctrans_t | |||
type | N | ||
capable to hold locale-specific character mappings | |||
wctype_t | |||
type | N | ||
capable to hold locale-specific character classifications | |||
wint_t WEOF | |||
macro | N | ||
same as EOF for WC streams, a value that can never stand for a valid WC | |||
int iswalnum(wint_t wc) | |||
function | N | ||
iswalpha(wc) || iswdigit(wc) | |||
int iswalpha(wint_t wc) | |||
function | N | ||
uppercase or lowercase letter | |||
int iswcntrl(wint_t wc) | |||
function | N | ||
control character | |||
int iswdigit(wint_t wc) | |||
function | N | ||
a decimal digit | |||
int iswgraph(wint_t wc) | |||
function | N | ||
iswprint(wc) && !iswspace(wc) | |||
int iswlower(wint_t wc) | |||
function | N | ||
lowercase character | |||
int iswprint(wint_t wc) | |||
function | N | ||
any printable character | |||
int iswpunct(wint_t wc) | |||
function | N | ||
!iswspace(wc) && !iswalnum(wc) | |||
int iswspace(wint_t wc) | |||
function | N | ||
any whitespace character | |||
int iswupper(wint_t wc) | |||
function | N | ||
any uppercase letter | |||
int iswxdigit(wint_t wc) | |||
function | N | ||
any hexadecimal digit | |||
wctype_t wctype(const char *property) | |||
function | N | ||
identifies a valid class of WCs according the current locale at least following properties must be supported by all locales: "alnum", "alpha", "contrl", "digit", "graph", "lower", "print", "punct", "space", "upper", "xdigit" |
|||
int iswctype(wint_t wc, wctype_t desc) | |||
function | N | ||
test if wc is member of the WC class 'desc' e.g. iswctype(wc, wctype("alnum"))==iswalnum(wc) |
|||
wint_t towlower(wint_t wc) | |||
function | N | ||
convert uppercase to lowercase letter | |||
wint_t towupper(wint_t wc) | |||
function | N | ||
convert lowercase to uppercase letter | |||
wctrans_t wctrans(const char *property) | |||
function | N | ||
identifies a valid transformation class according the current locale at least the following properties must be supported: "tolower", "toupper" |
|||
wint_t towctrans(wint_t wc, wctrans_t desc) | |||
function | N | ||
perform transformation according the transformation class 'desc' e.g. towctrans(wc, wctrans("tolower"))==towlower(wc) |
header | N | ||
extended multibyte and widecharacter utilities | |||
wchar_t | |||
type | I | ||
capable to hold a WC | |||
size_t | |||
type | I | ||
type returned by sizeof() | |||
mbstate_t | |||
type, int | N | ||
capable to hold conversation state information necessary tp convert between sequences of MBCs and WCs | |||
wint_t | |||
type | N | ||
capable to hold any WC and at least one value more | |||
tm | |||
struct | N | ||
broken-down form a calendar time | |||
NULL | |||
macro, int | I | ||
implementor-defined null pointer constant | |||
WCHAR_MAX | |||
macro, int, const | N | ||
maximum value representable as (wchar_t) | |||
WCHAR_MIN | |||
macro, int, const | N | ||
minimum value representable as (wchar_t) | |||
wint_t WEOF | |||
macro | N | ||
same as EOF for WC streams, a value that can never stand for a valid WC | |||
int fwprintf(FILE *stream, const wchar_t *fmt, ...) | |||
function | N | ||
fmt in (wchar_t*), also supports WC extensions within format string req. #include <stdio.h> |
|||
int fwscanf(FILE *stream, const wchar_t *fmt, ...) | |||
function | N | ||
fmt in (wchar_t*), also supports WC extensions within format string req. #include <stdio.h> |
|||
int wprintf(const wchar_t*fmt, ...) | |||
function | N | ||
equal to fwprintf(stdout, fmt, ...) | |||
int wscanf(const wchar_t*fmt, ...) | |||
function | N | ||
equal to fwscanf(stdout, fmt, ...) | |||
int swprintf(const wchar_t*fmt, ...) | |||
function | N | ||
as wprintf() except that the string s with at maximum n WCs is written | |||
int swscanf(wchar_t *s, size_t n, const wchar_t*fmt, ...) | |||
function | N | ||
as wscanf() except that the string s with at maximum n WCs is read | |||
int vfwprintf(FILE *stream, const wchar_t *fmt, va_list ap) | |||
function | N | ||
as fwprintf() but use the variable parameterlsit req. #include <stdio.h> and #include <stdarg.h> |
|||
int vwprintf(const wchar_t*fmt, va_list ap) | |||
function | N | ||
equal to wprintf(fmt, ...) except that the variable argumentlist req. #include <stdarg.h> |
|||
int vswprintf(const wchar_t*fmt, va_list ap) | |||
function | N | ||
as vwprintf() except that the string s with at maximum n WCs is written | |||
wint_t fgetwc(FILE *stream) | |||
function | N | ||
return the next WC from the stream; as fgetc() EILSEQ on encoding error |
|||
wchar_t *fgetws(wchar_t *s, int n, FILE *stream) | |||
function | N | ||
read the next, at most (n-1) WCs; as fgets() | |||
wint_t fputwc(wint_t ch, FILE *stream) | |||
function | N | ||
put the WC wc into the stream; as fputc() EILSEQ on encoding error |
|||
int fputws(const wint_t *s, FILE *stream) | |||
function | N | ||
put a string of WCs into the stream; as fputs() | |||
wint_t getwc(FILE *stream) | |||
macro | N | ||
as fgetwc() | |||
wint_t getwchar(void) | |||
macro | N | ||
as getwc(stdin) | |||
wint_t putwc(wchar_t ch, FILE *stream) | |||
macro | N | ||
as fputwc() | |||
wint_t putwchar(wchar_t ch) | |||
macro | N | ||
as putwc(stdout) | |||
wint_t ungetwc(wint_t ch, FILE *stream) | |||
function | N | ||
push back one WC into a read stream; at least one push back is guaranteed | |||
int fwide(FILE *stream, int mode) | |||
function | N | ||
aquire or change the orientation: (char) or WC <0 -> (char) oriented; >0 -> WC; ==0 don't change just aquire current orientation |
|||
double wcstod(const wchar_t *nptr, wchar_t **endptr) | |||
function | N | ||
convert a (double) value from string format into numeric; as strtod() | |||
long wcstol(const wchar_t *nptr, wchar_t **endptr, int base) | |||
function | N | ||
convert string to (long); as strtol() | |||
unsigned long wcstoul(const wchar_t *nptr, wchar_t **endptr, int base) | |||
function | N | ||
convert string to (unsigned long); as strtoul() | |||
wchar_t *wcscpy(wchar_t *s1, const wchar_t *s2) | |||
function | N | ||
copy WC string; as strcpy() | |||
wchar_t *wcsncpy(wchar_t *s1, const wchar_t *s2, size_t n) | |||
function | N | ||
copy WC string but not more than n WCs; as strncpy() | |||
wchar_t *wcscat(wchar_t *s1, const wchar_t *s2) | |||
function | N | ||
append s2 to s1; as strcat() | |||
wchar_t *wcsncat(wchar_t *s1, const wchar_t *s2, size_t n) | |||
function | N | ||
append s2 to s1, but not more than n WCs; as strncat() | |||
int wcscmp(const wchar_t *s1, const wchar_t *s2) | |||
function | N | ||
compare two WC strings; as strcmp() | |||
int wcscoll(const wchar_t *s1, const wchar_t *s2) | |||
function | N | ||
compare two WC strings according the collating sequence of the current locale; as strcoll() | |||
int wcsncmp(const wchar_t *s1, const wchar_t *s2, size_t n) | |||
function | N | ||
compare two WC strings, but not more than n WCs; as strcmp() | |||
size_t wcsxfrm(wchar_t *s1, const wchar_t *s2, size_t n) | |||
function | N | ||
transform a WC string into a string that wcscmp() acts on two tranformed WC strings as wcscoll() on non-transformed ones; as strxfrm() | |||
wchar_t *wcschr(const wchar_t *s, wchar_t ch) | |||
function | N | ||
find WC ch; as strchr() | |||
size_t wcsspn(const wchar_t *s1, const wchar_t *s2) | |||
function | N | ||
compute the length of the maximum initial segment of WCs from s2; as strcspn() | |||
wchar_t *wcspbrk(const wchar_t *s1, const wchar_t *s2) | |||
function | N | ||
locate the first occurence of any WC from s2 within s1; as strpbrk() | |||
wchar_t *wcsrchr(const wchar_t *s, wchar_t ch) | |||
function | N | ||
locate the rightmost occurence of ch within s; as strrchr() | |||
size_t wcsspn(const wchar_t *s1, const wchar_t *s2) | |||
function | N | ||
compute the length of the maximum initial segment of characters from s2; as strspn() | |||
wchar_t *wcsstr(const wchar_t *s1, const wchar_t *s2) | |||
function | N | ||
locate the first occurrence of s2 within s1; as strstr() | |||
wchar_t *wcstok(wchar_t *s1, const wchar_t *s2, wchar_t **ptr) | |||
function | N | ||
as strtok() except that "continue scanning information" is stored within the third argument rather than an internal variable | |||
size_t wcslen(const wchar_t *s) | |||
function | N | ||
compute the number of WCs within the string; as strlen() | |||
wchar_t *wmemchr(const wchar_t *s, wchar_t ch, size_t n) | |||
function | N | ||
locate the first occurrence of the WC; as memchr() | |||
int wmemcmp(const wchar_t *s1, const wchar_t *s2, size_t n) | |||
function | N | ||
compare two WC regions; as memcmp() | |||
wchar_t *wmemcpy(wchar_t *s1, const wchar_t *s2, size_t n) | |||
function | N | ||
copy two memory regions; as memcpy() | |||
wchar_t *wmemmove(wchar_t *s1, const wchar_t *s2, size_t n) | |||
function | N | ||
copy two memory regions; as memmove() | |||
wchar_t *wmemset(wchar_t *s, wchar_t ch, size_t n) | |||
function | N | ||
fill a memory region; as memset() | |||
size_t wcsftime(wchar_t *s, size_t maxsize, const wchar_t *fmt, const struct tm *timeptr) | |||
function | N | ||
as strftime() except that WC extensions are supported | |||
wint_t btowc(int ch) | |||
function | N | ||
convert the (unsigned char)ch one-byte MBC into a WC; return WEOF if ch==EOF || ch is no valid MBC | |||
int wctob(wint_t ch) | |||
function | N | ||
convert a WC into a one-byte MBC if possible | |||
int mbsinit(const mbstate_t *ps) | |||
function | N | ||
check if ps describes an initial conversation state | |||
size_t mbrlen(const char *s, size_t n, mbstate_t *ps) | |||
function | N | ||
restartable mblen() | |||
size_t mbrtowc(wchar_t *pwc, const char *s, size_t n, mbstate_t *ps) | |||
function | N | ||
restartable mbtowc() | |||
size_t wcrtomb(char *s, wchar_t wc, mbstate_t *ps) | |||
function | N | ||
restartable wctomb() | |||
size_t mbsrtowcs(wchar_t *dst, const char **src, size_t len, mbstate_t *ps) | |||
function | N | ||
restartable mbstowcs() | |||
size_t wcsrtombs(char *dst, const wchar_t **src, size_t len, mbstate_t *ps) | |||
function | N | ||
restartable wcstombs() |