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() | |||