WCRT implements the following functions:

<assert.h>

void assert( int expression );

<ctype.h>

int isdigit( int c );
int isgraph( int c );
int islower( int c );
int isprint( int c );
int isupper( int c );

int isalnum( int c );
int isalpha( int c );
int iscntrl( int c );
int ispunct( int c );
int isspace( int c );
int isxdigit( int c );

int tolower( int c );
int toupper( int c );

<debugf.h>

void debugf(( const char *format, ... ));

<math.h>

double sin( double x );
double cos( double x );
double tan( double x );
double asin( double x );
double acos( double x );
double atan( double x );
double atan2( double y, double x );
double sinh( double x );
double cosh( double x );
double tanh( double x );
double exp( double x );
double exp2( double x );
double log( double x );
double log10( double x );
double log2( double x );
double pow( double x, double y );
double sqrt( double x );
double ceil( double x );
double floor( double x );
double round( double x );
double trunc( double x );
double fabs( double x );
double ldexp( double x, int n );

float sinf( float x );
float cosf( float x );
float tanf( float x );
float asinf( float x );
float acosf( float x );
float atanf( float x );
float atan2f( float y, float x );
float sinhf( float x );
float coshf( float x );
float tanhf( float x );
float expf( float x );
float exp2f( float x );
float logf( float x );
float log10f( float x );
float log2f( float x );
float powf( float x, float y );
float sqrtf( float x );
float ceilf( float x );
float floorf( float x );
float roundf( float x );
float truncf( float x );
float fabsf( float x );
float ldexpf( float x, int n );

<stdio.h>

FILE *freopen( const char *filename, const char *mode, FILE *stream );
FILE *fopen( const char *filename, const char *mode );
int fflush( FILE *stream );
int fclose( FILE *stream );
int remove( const char *filename );
int rename( const char *oldname, const char *newname );
char *tmpnam( char *s );

int fprintf( FILE *stream, const char *format, ... );
int printf( const char *format, ... );
int sprintf( char *s, const char *format, ... );
int snprintf( char *s, size_t n, const char *format, ... );

int vfprintf( FILE *stream, const char *format, va_list arg );
int vprintf( const char *format, va_list arg );
int vsprintf( char *s, const char *format, va_list arg );
int vsnprintf( char *s, size_t n, const char *format, va_list arg );

int fscanf( FILE *stream, const char *format, ... );
int scanf( const char *format, ... );
int sscanf( char *s, const char *format, ... );

int fgetc( FILE *stream );
char *fgets( char *s, int n, FILE *stream );
int fputc( int c, FILE *stream );
int fputs( const char *s, FILE *stream );
int getc( FILE *fp );
int getchar( void );
char *gets( char *s );
int putc( int c, FILE *fp );
int putchar( int c );
int puts( const char *s );
int ungetc( int c, FILE *stream );

unsigned int fread( void *ptr, unsigned int size, unsigned int nobj, FILE *stream );
unsigned int fwrite( const void *ptr, unsigned int size, unsigned int nobj, FILE *stream );
int fseek( FILE *stream, long offset, int origin );
long ftell( FILE *stream );
void rewind( FILE *stream );
int fgetpos( FILE *stream, fpos_t *ptr);
int fsetpos( FILE *stream, const fpos_t *ptr );

<stdlib.h>

double atof( const char *s );
int atoi( const char *s );
long atol( const char *s );

double strtod( const char *s, char **endp );
long strtol( const char *s, char **endp, int base );
unsigned long strtoul( const char *s, char **endp, int base );

int rand( void );
void srand( unsigned int seed );

void *calloc( unsigned int nobj, unsigned int size );
void *malloc( unsigned int size );
void *realloc( void *p, unsigned int size );
void free( void *p );

void abort( void );
void exit( int status );
int atexit( void (*fcn)(void) );

char *getenv( const char *name );

void *bsearch( const void *key, const void *base, size_t n, size_t size, int (*cmp)(const void *keyval, const void *datum) );

void qsort( void *base, size_t n, size_t size, int (*cmp)(const void *, const void *) );

int abs( int n );
long labs( long n );

div_t div( int num, int denom );
ldiv_t ldiv( long num, long denom );

int rand_r( unsigned int *seed );

int rand_s( void );

unsigned int _rotl( unsigned int val, int shift );
unsigned int _rotr( unsigned int val, int shift );
unsigned long _lrotl( unsigned long val, int shift );
unsigned long _lrotr( unsigned long val, int shift );

<string.h>

char *strcpy( char *s, const char *ct );
char *strncpy( char *s, const char *ct, unsigned int n );
char *strcat( char *s, const char *ct );
char *strncat( char *s, const char *ct, unsigned int n );
int strcmp( const char *cs, const char *ct );
int strncmp( const char *cs, const char *ct, unsigned int n );
int strcoll( const char *cs, const char *ct );
char *strchr( const char *cs, int c );
char *strrchr( const char *cs, int c );
unsigned int strspn( const char *cs, const char *ct );
unsigned int strcspn( const char *cs, const char *ct );
char *strpbrk( const char *cs, const char *ct );
char *strstr( const char *cs, const char *ct );
unsigned int strlen( const char *cs );

char *strtok( char *s, const char *ct );

void *memcpy( void *s, const char *ct, unsigned int n );
void *memmove( void *s, const char *ct, unsigned int n );
int memcmp( const void *cs, const char *ct, unsigned int n );
void *memchr( const void *cs, int c, unsigned int n );
void *memset( void *s, int c, unsigned int n );

char *strlwr( char *s );
char *strupr( char *s );

int stricmp( const char *cs, const char *ct );

char *strtok_r( char *s, const char *ct, char **t );

<time.h>

clock_t clock( void );
char *asctime( const struct tm *tp );

<wchar.h>

wchar_t *wcscpy( wchar_t *s, const wchar_t *ct );
wchar_t *wcsncpy( wchar_t *s, const wchar_t *ct, unsigned int n );
wchar_t *wcscat( wchar_t *s, const wchar_t *ct );
wchar_t *wcsncat( wchar_t *s, const wchar_t *ct, unsigned int n );
int wcscmp( const wchar_t *cs, const wchar_t *ct );
int wcsncmp( const wchar_t *cs, const wchar_t *ct, unsigned int n );
int wcscoll( const wchar_t *cs, const wchar_t *ct );
wchar_t *wcschr( const wchar_t *cs, wchar_t c );
unsigned int wcscspn( const wchar_t *cs, const wchar_t *ct );
wchar_t *wcspbrk( const wchar_t *cs, const wchar_t *ct );
wchar_t *wcsrchr( const wchar_t *cs, wchar_t c );
unsigned int wcsspn( const wchar_t *cs, const wchar_t *ct );
wchar_t *wcsstr( const wchar_t *cs, const wchar_t *ct );
wchar_t *wcstok( wchar_t *s, const wchar_t *ct, wchar_t **t );
unsigned int wcslen( const wchar_t *cs );

wchar_t *wmemcpy( wchar_t *s, const wchar_t *ct, unsigned int n );
wchar_t *wmemmove( wchar_t *s, const wchar_t *ct, unsigned int n );
int wmemcmp( const wchar_t *cs, const wchar_t *ct, unsigned int n );
wchar_t *wmemchr( const wchar_t *cs, wchar_t c, unsigned int n );
wchar_t *wmemset( wchar_t *s, wchar_t c, unsigned int n );