stdlib.h File Reference

#include <stddef.h>
#include <stdint.h>
#include <wctype.h>

Include dependency graph for stdlib.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	div_t
	Division type for integers. More...
struct	ldiv_t
	Division type for long integers. More...
struct	lldiv_t
	Division type for long long integers. More...
struct	imaxdiv_t
	Division type for maximal integer storage. More...

Macros
#define	EXIT_FAILURE   1
#define	EXIT_SUCCESS   0
#define	RAND_MAX   (0x7fffffff)
#define	MB_CUR_MAX   sizeof(wchar_t)

Functions
void	abort (void) __attribute__((noreturn))
int	atexit (void(*)(void))
void	exit (int) __attribute__((noreturn))
void	_Exit (int) __attribute__((noreturn))
int	at_quick_exit (void(*)(void))
void	quick_exit (int) __attribute__((noreturn))
int	cxa_atexit (void(*)(void *), void *, void *)
char *	getenv (const char *)
int	system (const char *)
int	mblen (const char *, size_t)
int	mbtowc (wchar_t *__restrict, const char *__restrict, size_t)
int	wctomb (char *, wchar_t)
size_t	mbstowcs (wchar_t *__restrict, const char *__restrict, size_t)
size_t	wcstombs (char *__restrict, const wchar_t *__restrict, size_t)
int	atoi (const char *str)
	Interprets an integer value in a byte string pointed to by str. More...
long	atol (const char *str)
	Interprets a Long value in a byte string pointed to by str. More...
long long	atoll (const char *str)
	Interprets a Long Long value in a byte string pointed to by str. More...
double	atof (const char *str)
	Interprets a floating-point value in a byte string pointed to by str. More...
float	strtof (const char *__restrict str, char **__restrict str_end)
	Interprets a floating-point value in a byte string pointed to by str. More...
double	strtod (const char *__restrict str, char **__restrict str_end)
	Interprets a floating-point value in a byte string pointed to by str. More...
long	strtol (const char *__restrict str, char **__restrict str_end, int base)
	Interprets an long value in a byte string pointed to by str. More...
unsigned long	strtoul (const char *__restrict str, char **__restrict str_end, int base)
	Interprets an unsigned long value in a byte string pointed to by str. More...
long long	strtoll (const char *__restrict str, char **__restrict str_end, int base)
	Interprets an long long value in a byte string pointed to by str. More...
unsigned long long	strtoull (const char *__restrict str, char **__restrict str_end, int base)
	Interprets an unsigned long long value in a byte string pointed to by str. More...
long double	strtold (const char *__restrict, char **__restrict)
int	abs (int n)
	Computes the absolute value of an integer number. More...
long	labs (long n)
	Computes the absolute value of an long number. More...
long long	llabs (long long n)
	Computes the absolute value of an long long number. More...
intmax_t	imaxabs (intmax_t j)
	Computes the absolute value of an intmax_t number. More...
div_t	div (int x, int y)
	Computes both the quotient and the remainder of the division of the numerator x by the denominator y. More...
ldiv_t	ldiv (long x, long y)
	Computes both the quotient and the remainder of the division of the numerator x by the denominator y. More...
lldiv_t	lldiv (long long x, long long y)
	Computes both the quotient and the remainder of the division of the numerator x by the denominator y. More...
imaxdiv_t	imaxdiv (intmax_t numer, intmax_t denom)
	Computes both the quotient and the remainder of the division of the numerator x by the denominator y. More...
int	rand_r (unsigned int *ctx)
int	rand (void)
	Returns a pseudo-random integer value between ​0​ and. More...
void	srand (unsigned seed)
	Seeds the pseudo-random number generator used by. More...
int	heapsort (void *vbase, size_t nmemb, size_t size, int(*compar)(const void *, const void *))
	Sorts the given array pointed to by vbase in ascending order. More...
int	heapsort_r (void *vbase, size_t nmemb, size_t size, void *thunk, int(*compar)(void *, const void *, const void *))
	Sorts the given array pointed to by vbase in ascending order. More...
void *	bsearch (const void *key, const void *ptr, size_t count, size_t size, int(*comp)(const void *, const void *))
	Finds an element equal to element pointed to by key in an array pointed to by ptr. More...
void	qsort_r (void *a, size_t n, size_t es, void *thunk, int(*cmp)(void *, const void *, const void *))
	Sorts the given array pointed to by ptr in ascending order. More...
void	qsort (void *a, size_t n, size_t es, int(*compar)(const void *, const void *))
	Sorts the given array pointed to by ptr in ascending order. More...
void *	malloc (size_t size)
	Allocates size bytes of uninitialized storage. More...
void	free (void *ptr)
	Deallocates allocated memory space. More...
void *	calloc (size_t num, size_t size)
	Allocates memory for an array of given number objects of size and initializes all bytes in the allocated storage to zero. More...
void *	realloc (void *ptr, size_t size)
	Reallocates the given area of memory. More...
void *	reallocf (void *ptr, size_t size)
	Reallocates the given area of memory. More...

---

Class Documentation

div_t

struct div_t

Division type for integers.

Definition at line 15 of file stdlib.h.

Collaboration diagram for div_t:

Class Members
int	quot	The quotient
int	rem	The remainder

ldiv_t

struct ldiv_t

Division type for long integers.

Definition at line 22 of file stdlib.h.

Collaboration diagram for ldiv_t:

Class Members
long	quot	The quotient
long	rem	The remainder

lldiv_t

struct lldiv_t

Division type for long long integers.

Definition at line 29 of file stdlib.h.

Collaboration diagram for lldiv_t:

Class Members
long long	quot	The quotient
long long	rem	The remainder

imaxdiv_t

struct imaxdiv_t

Division type for maximal integer storage.

Definition at line 36 of file stdlib.h.

Collaboration diagram for imaxdiv_t:

Class Members
intmax_t	quot	The quotient
intmax_t	rem	The remainder

Macro Definition Documentation

EXIT_FAILURE

#define EXIT_FAILURE   1

Expands to 1. Indicates program execution execution status.

Definition at line 43 of file stdlib.h.

EXIT_SUCCESS

#define EXIT_SUCCESS   0

Expands to 0. indicates program execution execution status.

Definition at line 46 of file stdlib.h.

MB_CUR_MAX

#define MB_CUR_MAX   sizeof(wchar_t)

Length of the current locale's multi-byte character. We are faking this for now, since we don't provide locale support.

Definition at line 55 of file stdlib.h.

RAND_MAX

#define RAND_MAX   (0x7fffffff)

Expands to an integer constant expression equal to the maximum value returned by the function

See also

rand() It's guaranteed that this value is at least 32767

Definition at line 51 of file stdlib.h.

Function Documentation

_Exit()

void _Exit

(

int

)

TODO: CLEANUP DOC Terminates the process normally by returning control to the host environment, but without performing any of the regular cleanup tasks for terminating processes (as function exit does). No object destructors, nor functions registered by atexit or at_quick_exit are called

Referenced by __attribute__().

abort()

void abort

(

void

)

Referenced by __attribute__().

abs()

int abs

(

int

n

)

Computes the absolute value of an integer number.

Computes the absolute value of an integer number. The behavior is undefined if the result cannot be represented by the return type.

Parameters

n	integer value

Returns

The absolute value of n (i.e. |n|), if it is representable.

Definition at line 32 of file abs.c.

{
    return (j < 0 ? -j : j);
}

at_quick_exit()

int at_quick_exit

(

void(*)(void)

)

atexit()

int atexit

(

void(*)(void)

)

atof()

double atof

(

const char *

str

)

Interprets a floating-point value in a byte string pointed to by str.

Interprets a floating-point value in a byte string pointed to by str. Function discards any whitespace characters (as determined by

See also

isspace() until first non-whitespace character is found. Then it takes as many characters as possible to form a valid floating-point representation and converts them to a floating-point value. The valid floating-point value can be one of the following: 1) decimal floating-point expression. It consists of the following parts: a) (optional) plus or minus sign b) nonempty sequence of decimal digits optionally containing decimal-point character c) (optional) e or E followed with optional minus or plus sign and nonempty sequence of decimal digits (defines exponent)

Parameters

str	pointer to the null-terminated byte string to be interpreted

Returns

double value corresponding to the contents of str on success. If the converted value falls out of range of corresponding return type, the return value is undefined. If no conversion can be performed, ​0​.0 is returned.

Definition at line 57 of file atof.c.

{
    return (strtod(ascii, NULL));
}

References NULL, and strtod().

atoi()

int atoi

(

const char *

str

)

Interprets an integer value in a byte string pointed to by str.

Interprets an integer value in a byte string pointed to by str. Discards any whitespace characters until the first non-whitespace character is found, then takes as many characters as possible to form a valid integer number representation and converts them to an integer value. The valid integer value consists of the following parts: a) (optional) plus or minus sign b) numeric digits

Parameters

str	pointer to the null-terminated byte string to be interpreted

Returns

Integer value corresponding to the contents of str on success. If the converted value falls out of range of corresponding return type, the return value is undefined. If no conversion can be performed, ​0​ is returned.

Definition at line 5 of file atoi.c.

{
    bool neg = false;
    int val = 0;

    switch(*str)
    {
        case '-':
            neg = true;
        // intentional fallthrough to advance str
        case '+':
            str++;
    }

    while(isdigit(*str))
    {
        val = (10 * val) + (*str++ - '0');
    }

    return (neg ? -val : val);
}

References isdigit().

atol()

long atol

(

const char *

str

)

Interprets a Long value in a byte string pointed to by str.

Interprets a Long value in a byte string pointed to by str. Discards any whitespace characters until the first non-whitespace character is found, then takes as many characters as possible to form a valid long number representation and converts them to an long value. The valid Long value consists of the following parts: a) (optional) plus or minus sign b) numeric digits

Parameters

str	pointer to the null-terminated byte string to be interpreted

Returns

long value corresponding to the contents of str on success. If the converted value falls out of range of corresponding return type, the return value is undefined. If no conversion can be performed, ​0​ is returned.

Definition at line 5 of file atol.c.

{
    long val = 0;
    bool neg = false;

    while(isspace(*str))
    {
        str++;
    }

    switch(*str)
    {
        case '-':
            neg = true;
        // intentional fallthrough
        case '+':
            str++;
    }

    while(isdigit(*str))
    {
        val = (10 * val) + (*str++ - '0');
    }

    return neg ? -val : val;
}

References isdigit(), and isspace().

atoll()

long long atoll

(

const char *

str

)

Interprets a Long Long value in a byte string pointed to by str.

Interprets a Long Long value in a byte string pointed to by str. Discards any whitespace characters until the first non-whitespace character is found, then takes as many characters as possible to form a valid long number representation and converts them to an long long value. The valid Long long value consists of the following parts: a) (optional) plus or minus sign b) numeric digits

Parameters

str	pointer to the null-terminated byte string to be interpreted

Returns

long value corresponding to the contents of str on success. If the converted value falls out of range of corresponding return type, the return value is undefined. If no conversion can be performed, ​0​ is returned.

Definition at line 5 of file atoll.c.

{
    long long val = 0;
    bool neg = false;

    while(isspace(*str))
    {
        str++;
    }

    switch(*str)
    {
        case '-':
            neg = true;
        // Intentional fallthrough
        case '+':
            str++;
    }

    while(isdigit(*str))
    {
        val = (10 * val) + (*str++ - '0');
    }
    return neg ? -val : val;
}

References isdigit(), and isspace().

bsearch()

void* bsearch	(	const void *	key,
		const void *	ptr,
		size_t	count,
		size_t	size,
		int(*)(const void *, const void *)	comp
	)

Finds an element equal to element pointed to by key in an array pointed to by ptr.

Parameters

key	pointer to the element to search for
ptr	pointer to the array to examine
count	number of element in the array
size	size of each element in the array in bytes
comp	comparison function which returns ​a negative integer value if the first argument is less than the second,a positive integer value if the first argument is greater than the second and zero if the arguments are equal. key is passed as the first argument, an element from the array as the second. The signature of the comparison function should be equivalent to the following: int cmp(const void *a, const void *b); The function must not modify the objects passed to it and must return consistent results when called for the same objects, regardless of their positions in the array.

Returns

Pointer to an element in the array that compares equal to *key, or null pointer if such element has not been found.

calloc()

void* calloc	(	size_t	num,
		size_t	size
	)

Allocates memory for an array of given number objects of size and initializes all bytes in the allocated storage to zero.

Allocates memory for an array of num objects of size size and initializes all bytes in the allocated storage to zero.

Parameters

num	number of objects
size	size of the array

Returns

(None)

Definition at line 11 of file calloc.c.

{
    /* num * size unsigned integer wrapping check */
    if((num >= MUL_NO_OVERFLOW || size >= MUL_NO_OVERFLOW) && num > 0 && SIZE_MAX / num < size)
    {
        return NULL;
    }

    size_t total_size = num * size;
    void* ptr = malloc(total_size);

    if(ptr)
    {
        memset(ptr, 0, total_size);
    }

    return ptr;
}

References malloc(), memset(), MUL_NO_OVERFLOW, NULL, and SIZE_MAX.

cxa_atexit()

int cxa_atexit	(	void(*)(void *)	,
		void *	,
		void *
	)

div()

div_t div	(	int	x,
		int	y
	)

Computes both the quotient and the remainder of the division of the numerator x by the denominator y.

Computes both the quotient and the remainder of the division of the numerator x by the denominator y.

Parameters

x	integer values
y	integer values

Returns

If both the remainder and the quotient can be represented as objects of the corresponding type (int, long, long long, imaxdiv_t, respectively), returns both as an object of type

See also

div_t,

ldiv_t,

lldiv_t,

imaxdiv_t.

If either the remainder or the quotient cannot be represented, the behavior is undefined.

Definition at line 35 of file div.c.

{
    div_t r;

    r.quot = num / denom;
    r.rem = num % denom;
    /*
     * The ANSI standard says that |r.quot| <= |n/d|, where
     * n/d is to be computed in infinite precision.  In other
     * words, we should always truncate the quotient towards
     * 0, never -infinity.
     *
     * Machine division and remainer may work either way when
     * one or both of n or d is negative.  If only one is
     * negative and r.quot has been truncated towards -inf,
     * r.rem will have the same sign as denom and the opposite
     * sign of num; if both are negative and r.quot has been
     * truncated towards -inf, r.rem will be positive (will
     * have the opposite sign of num).  These are considered
     * `wrong'.
     *
     * If both are num and denom are positive, r will always
     * be positive.
     *
     * This all boils down to:
     *  if num >= 0, but r.rem < 0, we got the wrong answer.
     * In that case, to get the right answer, add 1 to r.quot and
     * subtract denom from r.rem.
     */
    if(num >= 0 && r.rem < 0)
    {
        r.quot++;
        r.rem -= denom;
    }
    return (r);
}

References div_t::quot, and div_t::rem.

exit()

void exit

(

int

)

free()

void free

(

void *

ptr

)

Deallocates allocated memory space.

Deallocates the space previously allocated by

See also

malloc,

calloc,

realloc. If ptr is a null pointer, the function does nothing.

The behavior is undefined if the value of ptr does not equal a value returned earlier by

See also

malloc,

calloc,

realloc.

The behavior is undefined if the memory area referred to by ptr has already been deallocated, that is, free() or realloc has already been called with ptr as the argument and no calls to malloc, calloc or realloc resulted in a pointer equal to ptr afterwards.

The behavior is undefined if after free returns, an access is made through the pointer ptr (unless another allocation function happened to result in a pointer value equal to ptr)

Parameters

ptr	pointer to the memory to deallocate

Referenced by heapsort(), heapsort_r(), realloc(), and reallocf().

getenv()

char* getenv

(

const char *

)

heapsort()

int heapsort	(	void *	vbase,
		size_t	nmemb,
		size_t	size,
		int(*)(const void *, const void *)	compar
	)

Sorts the given array pointed to by vbase in ascending order.

The heapsort() function is a modified selection sort. It sorts an array of nmemb objects, the initial member of which is pointed to by vbase. The size of each object is specified by size.

The contents of the array base are sorted in ascending order according to a comparison function pointed to by compar, which requires two arguments pointing to the objects being compared.

Parameters

vbase	a pointer to the array to sort
nmemb	the number of objects to sort
size	the size of each object in the array
compar	comparison function which returns ​a negative integer value if the first argument is less than the second,a positive integer value if the first argument is greater than the second and zero if the arguments are equal. key is passed as the first argument, an element from the array as the second. The signature of the comparison function should be equivalent to the following: int cmp(const void *a, const void *b);

Returns

the value 0 if successful; otherwise the value -1 is returned and the global variable errno is set to indicate the error.

Referenced by _qsort().

heapsort_r()

int heapsort_r	(	void *	vbase,
		size_t	nmemb,
		size_t	size,
		void *	thunk,
		int(*)(void *, const void *, const void *)	compar
	)

Sorts the given array pointed to by vbase in ascending order.

It sorts an array of nmemb objects, the initial member of which is pointed to by vbase. The size of each object is specified by size. The heapsort_r() function behaves identically to

See also

heapsort(), except that it takes an additional argument, thunk, which is passed unchanged as the first argument to function pointed to compar. This allows the comparison function to access additional data without using global variables, and thus heapsort_r() is suitable for use in functions which must be reentrant. And is therefore reentrant and safe to use in threads.

The contents of the array base are sorted in ascending order according to a comparison function pointed to by compar, which requires two arguments pointing to the objects being compared.

Parameters

vbase	a pointer to the array to sort
nmemb	the number of objects to sort
size	the size of each object in the array
thunk	additional data(variable) for compar
compar	comparison function which returns ​a negative integer value if the first argument is less than the second,a positive integer value if the first argument is greater than the second and zero if the arguments are equal. key is passed as the first argument, an element from the array as the second. The signature of the comparison function should be equivalent to the following: int cmp(const void *a, const void *b);

Returns

the value 0 if successful; otherwise the value -1 is returned and the global variable errno is set to indicate the error.

Referenced by _qsort().

imaxabs()

intmax_t imaxabs

(

intmax_t

j

)

Computes the absolute value of an intmax_t number.

Computes the absolute value of an intmax_t number. The behavior is undefined if the result cannot be represented by the return type.

Parameters

j

value

Returns

The absolute value of n (i.e. |n|), if it is representable.

Definition at line 29 of file imaxabs.c.

{
    return (j < 0 ? -j : j);
}

imaxdiv()

imaxdiv_t imaxdiv	(	intmax_t	numer,
		intmax_t	denom
	)

Computes both the quotient and the remainder of the division of the numerator x by the denominator y.

Computes both the quotient and the remainder of the division of the numerator x by the denominator y. Computes quotient and remainder simultaneously. The quotient is the algebraic quotient with any fractional part discarded (truncated towards zero). The remainder is such that quot * y + rem == x.

Computes the quotient (the result of the expression x/y) and remainder (the result of the expression xy) simultaneously.

Parameters

numer	intmax_t values (numerator)
denom	intmax_t values (denominator)

Returns

If both the remainder and the quotient can be represented as objects of the corresponding type (int, long, long long, imaxdiv_t, respectively), returns both as an object of type

See also

div_t,

ldiv_t,

lldiv_t,

imaxdiv_t.

If either the remainder or the quotient cannot be represented, the behavior is undefined.

Definition at line 30 of file imaxdiv.c.

{
    imaxdiv_t retval;

    retval.quot = numer / denom;
    retval.rem = numer % denom;
    if(numer >= 0 && retval.rem < 0)
    {
        retval.quot++;
        retval.rem -= denom;
    }
    return (retval);
}

References imaxdiv_t::quot, and imaxdiv_t::rem.

labs()

long labs

(

long

n

)

Computes the absolute value of an long number.

Computes the absolute value of an long number. The behavior is undefined if the result cannot be represented by the return type.

Parameters

n	long value

Returns

The absolute value of n (i.e. |n|), if it is representable.

Definition at line 32 of file labs.c.

{
    return (j < 0 ? -j : j);
}

ldiv()

ldiv_t ldiv	(	long	x,
		long	y
	)

Computes both the quotient and the remainder of the division of the numerator x by the denominator y.

Computes both the quotient and the remainder of the division of the numerator x by the denominator y. Computes quotient and remainder simultaneously. The quotient is the algebraic quotient with any fractional part discarded (truncated towards zero). The remainder is such that quot * y + rem == x.

Computes the quotient (the result of the expression x/y) and remainder (the result of the expression xy) simultaneously.

Parameters

x	integer values
y	integer values

Returns

If both the remainder and the quotient can be represented as objects of the corresponding type (int, long, long long, imaxdiv_t, respectively), returns both as an object of type

See also

div_t,

ldiv_t,

lldiv_t,

imaxdiv_t.

If either the remainder or the quotient cannot be represented, the behavior is undefined.

Definition at line 35 of file ldiv.c.

{
    ldiv_t r;

    /* see div.c for comments */

    r.quot = num / denom;
    r.rem = num % denom;
    if(num >= 0 && r.rem < 0)
    {
        r.quot++;
        r.rem -= denom;
    }
    return (r);
}

References ldiv_t::quot, and ldiv_t::rem.

llabs()

long long llabs

(

long long

n

)

Computes the absolute value of an long long number.

Computes the absolute value of an long long number. The behavior is undefined if the result cannot be represented by the return type.

Parameters

n	long long value

Returns

The absolute value of n (i.e. |n|), if it is representable.

Definition at line 29 of file llabs.c.

{
    return (j < 0 ? -j : j);
}

lldiv()

lldiv_t lldiv	(	long long	x,
		long long	y
	)

Computes both the quotient and the remainder of the division of the numerator x by the denominator y.

Computes both the quotient and the remainder of the division of the numerator x by the denominator y. Computes quotient and remainder simultaneously. The quotient is the algebraic quotient with any fractional part discarded (truncated towards zero). The remainder is such that quot * y + rem == x.

Computes the quotient (the result of the expression x/y) and remainder (the result of the expression xy) simultaneously.

Parameters

x	integer values
y	integer values

Returns

If both the remainder and the quotient can be represented as objects of the corresponding type (int, long, long long, imaxdiv_t, respectively), returns both as an object of type

See also

div_t,

ldiv_t,

lldiv_t,

imaxdiv_t.

If either the remainder or the quotient cannot be represented, the behavior is undefined.

Definition at line 30 of file lldiv.c.

{
    lldiv_t retval;

    retval.quot = numer / denom;
    retval.rem = numer % denom;
    if(numer >= 0 && retval.rem < 0)
    {
        retval.quot++;
        retval.rem -= denom;
    }
    return (retval);
}

References lldiv_t::quot, and lldiv_t::rem.

malloc()

void* malloc

(

size_t

size

)

Allocates size bytes of uninitialized storage.

If size is zero, the behavior is implementation defined (null pointer may be returned, or some non-null pointer may be returned that may not be used to access storage, but has to be passed to

See also

free). malloc is thread-safe: it behaves as though only accessing the memory locations visible through its argument, and not any static storage.

Parameters

size	number of bytes to allocate

Returns

On success, returns the pointer to the beginning of newly allocated memory. The returned pointer must be deallocated with

See also

free() or

realloc(). On failure, returns a null pointer.

Referenced by calloc(), heapsort(), heapsort_r(), realloc(), strdup(), strndup(), and vasprintf().

mblen()

int mblen	(	const char *	,
		size_t
	)

mbstowcs()

size_t mbstowcs	(	wchar_t *	__restrict,
		const char *	__restrict,
		size_t
	)

mbtowc()

int mbtowc	(	wchar_t *	__restrict,
		const char *	__restrict,
		size_t
	)

qsort()

void qsort	(	void *	a,
		size_t	n,
		size_t	es,
		int(*)(const void *, const void *)	compar
	)

Sorts the given array pointed to by ptr in ascending order.

Sorts the given array pointed to by ptr in ascending order. The array contains count elements of size bytes. Function pointed to by comp is used for object comparison.

Parameters

a	pointer to the element to sort
n	number of element in the array
es	size of each element in the array in bytes
compar	comparison function which returns ​a negative integer value if the first argument is less than the second,a positive integer value if the first argument is greater than the second and zero if the arguments are equal. key is passed as the first argument, an element from the array as the second. The signature of the comparison function should be equivalent to the following: int cmp(const void *a, const void *b); The function must not modify the objects passed to it and must return consistent

qsort_r()

void qsort_r	(	void *	a,
		size_t	n,
		size_t	es,
		void *	thunk,
		int(*)(void *, const void *, const void *)	cmp
	)

Sorts the given array pointed to by ptr in ascending order.

The qsort_r() function behaves identically to

See also

qsort(), except that it takes an additional argument, thunk, which is passed unchanged as the first argument to function pointed to compar. This allows the comparison function to access additional data without using global variables, and thus qsort_r() is suitable for use in functions which must be reentrant. And is therefore reentrant and safe to use in threads.

Parameters

a	pointer to the element to sort
n	number of element in the array
es	size of each element in the array in bytes
thunk	additional data(variable) for cmp
cmp	comparison function which returns ​a negative integer value if the first argument is less than the second,a positive integer value if the first argument is greater than the second and zero if the arguments are equal. key is passed as the first argument, an element from the array as the second. The signature of the comparison function should be equivalent to the following: int cmp(const void *a, const void *b); The function must not modify the objects passed to it and must return consistent

quick_exit()

void quick_exit

(

int

)

rand()

int rand

(

void

)

Returns a pseudo-random integer value between ​0​ and.

See also

RAND_MAX (0 and

RAND_MAX included).

Returns a pseudo-random integer value between ​0​ and

See also

RAND_MAX (0 and

RAND_MAX included).

srand() seeds the pseudo-random number generator used by rand. If rand is used before any calls to

srand, rand behaves as if it was seeded with

srand. Each time rand is seeded with srand, it must produce the same sequence of values.

rand is not guaranteed to be thread-safe.

Returns

Pseudo-random integer value between ​0​ and RAND_MAX, inclusive.

rand_r()

int rand_r

(

unsigned int *

ctx

)

realloc()

void* realloc	(	void *	ptr,
		size_t	size
	)

Reallocates the given area of memory.

Reallocates the given area of memory. It must be previously allocated by

See also

malloc,

calloc or

realloc and not yet freed with a call to

free or

realloc. Otherwise, the results are undefined.

The reallocation is done by either: 1) expanding or contracting the existing area pointed to by ptr, if possible. The contents of the area remain unchanged up to the lesser of the new and old sizes. If the area is expanded, the contents of the new part of the array are undefined. 2) allocating a new memory block of size size bytes, copying memory area with size equal the lesser of the new and the old sizes, and freeing the old block.

If there is not enough memory, the old memory block is not freed and null pointer is returned. If ptr is NULL, the behavior is the same as calling malloc(size).

Parameters

ptr	pointer to the memory area to be reallocated
size	new size of the array

Returns

pointer to new memory allocation. If size is zero (e.g. realloc(ptr,0)) then returns NULL

Definition at line 4 of file realloc.c.

{
    void* new_data = NULL;

    if(size)
    {
        if(!ptr)
        {
            return malloc(size);
        }

        new_data = malloc(size);
        if(new_data)
        {
            memcpy(new_data, ptr, size); // TODO: unsafe copy...
            free(ptr); // we always move the data. free.
        }
    }

    return new_data;
}

References free(), malloc(), memcpy(), and NULL.

Referenced by reallocf().

Here is the caller graph for this function:

reallocf()

void* reallocf	(	void *	ptr,
		size_t	size
	)

Reallocates the given area of memory.

Reallocates the given area of memory. It must be previously allocated by

See also

malloc,

calloc or

realloc and not yet freed with a call to

free or

realloc. Otherwise, the results are undefined.

reallocf is a FreeBSD extension to realloc that frees the input pointer if an error occurrs

This library does not handle the BSD case where realloc(ptr,0) frees the ptr

Parameters

ptr	pointer to the memory area to be reallocated
size	new size of the array

Returns

pointer to new memory allocation. If size is zero (e.g. realloc(ptr,0)) then returns NULL

Definition at line 26 of file realloc.c.

{
    void* p = realloc(ptr, size);

    if((p == NULL) && (ptr != NULL))
    {
        free(ptr);
    }

    return p;
}

References free(), NULL, and realloc().

srand()

void srand

(

unsigned

seed

)

Seeds the pseudo-random number generator used by.

See also

rand with the value seed.

Seeds the pseudo-random number generator used by

See also

rand with the value seed. If rand() is used before any calls to srand,

rand behaves as if it was seeded with srand. Each time rand is seeded with the same seed, it must produce the same sequence of values.

srand() is not guaranteed to be thread-safe.

Parameters

seed	the seed value

strtod()

double strtod	(	const char *__restrict	str,
		char **__restrict	str_end
	)

Interprets a floating-point value in a byte string pointed to by str.

Interprets a floating-point value in a byte string pointed to by str. Function discards any whitespace characters (as determined by

See also

isspace()) until first non-whitespace character is found. Then it takes as many characters as possible to form a valid floating-point representation and converts them to a floating-point value. The valid floating-point value can be one of the following: a) decimal floating-point expression. It consists of the following parts: 1) (optional) plus or minus sign 2) nonempty sequence of decimal digits optionally containing decimal-point character (as determined by the current C locale) (defines significand) 3) (optional) e or E followed with optional minus or plus sign and nonempty sequence of decimal digits (defines exponent) b) binary floating-point expression. It consists of the following parts: 1) (optional) plus or minus sign 2) 0x or 0X c) infinity expression. It consists of the following parts: 1) (optional) plus or minus sign 2) INF or INFINITY ignoring case d) not-a-number expression. It consists of the following parts: 1) (optional) plus or minus sign 2) NAN or NAN(char_sequence) ignoring case of the NAN part. char_sequence can only contain digits, Latin letters, and underscores. The result is a quiet NaN floating-point value.

The functions sets the pointer pointed to by str_end to point to the character past the last character interpreted. If str_end is NULL, it is ignored.

Parameters

str	a pointer to the null-terminated byte string to be interpreted
str_end	pointer to a pointer to character

Returns

Floating-point value corresponding to the contents of str on success. If the converted value falls out of range of corresponding return type, range error occurs and HUGE_VAL, HUGE_VALF or HUGE_VALL is returned. If no conversion can be performed, ​0​ is returned.

Referenced by atof(), and strtold().

strtof()

float strtof	(	const char *__restrict	str,
		char **__restrict	str_end
	)

Interprets a floating-point value in a byte string pointed to by str.

Interprets a floating-point value in a byte string pointed to by str. Function discards any whitespace characters (as determined by

See also

isspace()) until first non-whitespace character is found. Then it takes as many characters as possible to form a valid floating-point representation and converts them to a floating-point value. The valid floating-point value can be one of the following: a) decimal floating-point expression. It consists of the following parts: 1) (optional) plus or minus sign 2) nonempty sequence of decimal digits optionally containing decimal-point character (as determined by the current C locale) (defines significand) 3) (optional) e or E followed with optional minus or plus sign and nonempty sequence of decimal digits (defines exponent) b) binary floating-point expression. It consists of the following parts: 1) (optional) plus or minus sign 2) 0x or 0X c) infinity expression. It consists of the following parts: 1) (optional) plus or minus sign 2) INF or INFINITY ignoring case d) not-a-number expression. It consists of the following parts: 1) (optional) plus or minus sign 2) NAN or NAN(char_sequence) ignoring case of the NAN part. char_sequence can only contain digits, Latin letters, and underscores. The result is a quiet NaN floating-point value.

The functions sets the pointer pointed to by str_end to point to the character past the last character interpreted. If str_end is NULL, it is ignored.

Parameters

str	a pointer to the null-terminated byte string to be interpreted
str_end	pointer to a pointer to character

Returns

Floating-point value corresponding to the contents of str on success. If the converted value falls out of range of corresponding return type, range error occurs and HUGE_VAL, HUGE_VALF or HUGE_VALL is returned. If no conversion can be performed, ​0​ is returned.

strtol()

long strtol	(	const char *__restrict	str,
		char **__restrict	str_end,
		int	base
	)

Interprets an long value in a byte string pointed to by str.

Interprets an long value in a byte string pointed to by str. Discards any whitespace characters (as identified by calling

See also

isspace()) until the first non-whitespace character is found, then takes as many characters as possible to form a valid base-n (where n=base) long number representation and converts them to an long value. The valid long value consists of the following parts:

 1) (optional) plus or minus sign
 2) (optional) prefix (0) indicating octal base (applies only when the base is 8 or ​0​)
 3) (optional) prefix (0x or 0X) indicating hexadecimal base (applies only when the base is

16 or ​0​) 4) a sequence of digits

The set of valid values for base is {0,2,3,...,36}. The set of valid digits for base-2 integers is {0,1}, for base-3 integers is {0,1,2}, and so on. For bases larger than 10, valid digits include alphabetic characters, starting from Aa for base-11 integer, to Zz for base-36 integer. The case of the characters is ignored.

If the value of base is ​0​, the numeric base is auto-detected: if the prefix is 0, the base is octal, if the prefix is 0x or 0X, the base is hexadecimal, otherwise the base is decimal.

If the minus sign was part of the input sequence, the numeric value calculated from the sequence of digits is negated as if by unary minus in the result type.

The functions sets the pointer pointed to by str_end to point to the character past the last character interpreted. If str_end is NULL, it is ignored.

If the str is empty or does not have the expected form, no conversion is performed, and (if str_end is not NULL) the value of str is stored in the object pointed to by str_end.

Parameters

str	pointer to the null-terminated byte string to be interpreted
str_end	pointer to a pointer to character.
base	base of the interpreted integer value

Returns

returns the result of the conversion, unless the value would underflow or overflow. If the converted value falls out of range of corresponding return type, a range error occurs (setting errno to ERANGE) and LONG_MAX, LONG_MIN, LLONG_MAX or LLONG_MIN is returned. If no conversion can be performed, ​0​ is returned.

strtold()

long double strtold	(	const char *	__restrict,
		char **	__restrict
	)

strtoll()

long long strtoll	(	const char *__restrict	str,
		char **__restrict	str_end,
		int	base
	)

Interprets an long long value in a byte string pointed to by str.

Interprets an long value in a byte string pointed to by str. Discards any whitespace characters (as identified by calling

See also

isspace()) until the first non-whitespace character is found, then takes as many characters as possible to form a valid base-n (where n=base) long number representation and converts them to an long long value. The valid long value consists of the following parts:

 1) (optional) plus or minus sign
 2) (optional) prefix (0) indicating octal base (applies only when the base is 8 or ​0​)
 3) (optional) prefix (0x or 0X) indicating hexadecimal base (applies only when the base is

16 or ​0​) 4) a sequence of digits

The set of valid values for base is {0,2,3,...,36}. The set of valid digits for base-2 integers is {0,1}, for base-3 integers is {0,1,2}, and so on. For bases larger than 10, valid digits include alphabetic characters, starting from Aa for base-11 integer, to Zz for base-36 integer. The case of the characters is ignored.

If the value of base is ​0​, the numeric base is auto-detected: if the prefix is 0, the base is octal, if the prefix is 0x or 0X, the base is hexadecimal, otherwise the base is decimal.

If the minus sign was part of the input sequence, the numeric value calculated from the sequence of digits is negated as if by unary minus in the result type.

The functions sets the pointer pointed to by str_end to point to the character past the last character interpreted. If str_end is NULL, it is ignored.

If the str is empty or does not have the expected form, no conversion is performed, and (if str_end is not NULL) the value of str is stored in the object pointed to by str_end.

Parameters

str	pointer to the null-terminated byte string to be interpreted
str_end	pointer to a pointer to character.
base	base of the interpreted integer value

Returns

returns the result of the conversion, unless the value would underflow or overflow. If the converted value falls out of range of corresponding return type, a range error occurs (setting errno to ERANGE) and LONG_MAX, LONG_MIN, LLONG_MAX or LLONG_MIN is returned. If no conversion can be performed, ​0​ is returned.

strtoul()

unsigned long strtoul	(	const char *__restrict	str,
		char **__restrict	str_end,
		int	base
	)

Interprets an unsigned long value in a byte string pointed to by str.

Interprets an unsigned long value in a byte string pointed to by str. Discards any whitespace characters (as identified by calling

See also

isspace()) until the first non-whitespace character is found, then takes as many characters as possible to form a valid base-n (where n=base) long number representation and converts them to an unsigned long value. The valid long value consists of the following parts:

 1) (optional) plus or minus sign
 2) (optional) prefix (0) indicating octal base (applies only when the base is 8 or ​0​)
 3) (optional) prefix (0x or 0X) indicating hexadecimal base (applies only when the base is

16 or ​0​) 4) a sequence of digits

The set of valid values for base is {0,2,3,...,36}. The set of valid digits for base-2 integers is {0,1}, for base-3 integers is {0,1,2}, and so on. For bases larger than 10, valid digits include alphabetic characters, starting from Aa for base-11 integer, to Zz for base-36 integer. The case of the characters is ignored.

If the value of base is ​0​, the numeric base is auto-detected: if the prefix is 0, the base is octal, if the prefix is 0x or 0X, the base is hexadecimal, otherwise the base is decimal.

If the minus sign was part of the input sequence, the numeric value calculated from the sequence of digits is negated as if by unary minus in the result type.

If the str is empty or does not have the expected form, no conversion is performed, and (if str_end is not NULL) the value of str is stored in the object pointed to by str_end.

Parameters

str	pointer to the null-terminated byte string to be interpreted
str_end	pointer to a pointer to character.
base	base of the interpreted integer value

Returns

returns the result of the conversion, unless the value would underflow or overflow. If the converted value falls out of range of corresponding return type, a range error occurs (setting errno to ERANGE) and LONG_MAX, LONG_MIN, LLONG_MAX or LLONG_MIN is returned. If no conversion can be performed, ​0​ is returned.

strtoull()

unsigned long long strtoull	(	const char *__restrict	str,
		char **__restrict	str_end,
		int	base
	)

Interprets an unsigned long long value in a byte string pointed to by str.

Interprets an unsigned long long value in a byte string pointed to by str. Discards any whitespace characters (as identified by calling

See also

isspace()) until the first non-whitespace character is found, then takes as many characters as possible to form a valid base-n (where n=base) long number representation and converts them to an unsigned long long value. The valid long value consists of the following parts:

 1) (optional) plus or minus sign
 2) (optional) prefix (0) indicating octal base (applies only when the base is 8 or ​0​)
 3) (optional) prefix (0x or 0X) indicating hexadecimal base (applies only when the base is

16 or ​0​) 4) a sequence of digits

The set of valid values for base is {0,2,3,...,36}. The set of valid digits for base-2 integers is {0,1}, for base-3 integers is {0,1,2}, and so on. For bases larger than 10, valid digits include alphabetic characters, starting from Aa for base-11 integer, to Zz for base-36 integer. The case of the characters is ignored.

If the value of base is ​0​, the numeric base is auto-detected: if the prefix is 0, the base is octal, if the prefix is 0x or 0X, the base is hexadecimal, otherwise the base is decimal.

If the minus sign was part of the input sequence, the numeric value calculated from the sequence of digits is negated as if by unary minus in the result type.

If the str is empty or does not have the expected form, no conversion is performed, and (if str_end is not NULL) the value of str is stored in the object pointed to by str_end.

Parameters

str	pointer to the null-terminated byte string to be interpreted
str_end	pointer to a pointer to character.
base	base of the interpreted integer value

Returns

returns the result of the conversion, unless the value would underflow or overflow. If the converted value falls out of range of corresponding return type, a range error occurs (setting errno to ERANGE) and LONG_MAX, LONG_MIN, LLONG_MAX or LLONG_MIN is returned. If no conversion can be performed, ​0​ is returned.

Definition at line 44 of file strtoull.c.

{
    const char* s;
    unsigned long long acc;
    char c;
    unsigned long long cutoff;
    int neg, any, cutlim;

    /*
     * See strtoq for comments as to the logic used.
     */
    s = nptr;
    do
    {
        c = *s++;
    } while(isspace((unsigned char)c));
    if(c == '-')
    {
        neg = 1;
        c = *s++;
    }
    else
    {
        neg = 0;
        if(c == '+')
        {
            {
                c = *s++;
            }
        }
    }
    if((base == 0 || base == 16) && c == '0' && (*s == 'x' || *s == 'X'))
    {
        c = s[1];
        s += 2;
        base = 16;
    }
    if(base == 0)
    {
        {
            base = c == '0' ? 8 : 10;
        }
    }
    acc = any = 0;
    if(base < 2 || base > 36)
    {
        {
            goto noconv;
        }
    }

    cutoff = ULLONG_MAX / (unsigned long long)base;
    cutlim = (int)(ULLONG_MAX % (unsigned long long)base);
    for(;; c = *s++)
    {
        if(c >= '0' && c <= '9')
        {
            {
                c -= '0';
            }
        }
        else if(c >= 'A' && c <= 'Z')
        {
            {
                c -= 'A' - 10;
            }
        }
        else if(c >= 'a' && c <= 'z')
        {
            {
                c -= 'a' - 10;
            }
        }
        else
        {
            {
                break;
            }
        }
        if(c >= base)
        {
            {
                break;
            }
        }
        if(any < 0 || acc > cutoff || (acc == cutoff && c > cutlim))
        {
            {
                any = -1;
            }
        }
        else
        {
            any = 1;
            acc *= (unsigned long)base;
            acc += (unsigned long)c;
        }
    }
    if(any < 0)
    {
        acc = ULLONG_MAX;
        // errno = ERANGE;
    }
    else if(!any)
    {
    noconv:
        // PJ: nonstandard, but since no errno, acc = 0
        acc = 0;
        // errno = EINVAL;
    }
    else if(neg)
    {
        acc = -acc;
    }
    if(endptr != NULL)
    {
        *endptr = (char*)(uintptr_t)(any ? s - 1 : nptr);
    }
    return (acc);
}

References isspace(), NULL, and ULLONG_MAX.

system()

int system

(

const char *

)

wcstombs()

size_t wcstombs	(	char *	__restrict,
		const wchar_t *	__restrict,
		size_t
	)

wctomb()

int wctomb	(	char *	,
		wchar_t
	)