DetailedDescription

#include <stdlib.h>
This file declares some basic C macros and functions as defined by the ISO standard, plus
some AVR-specific extensions.

MacroDefinitionDocumentation

#defineDTOSTR_ALWAYS_SIGN0x01/*put'+'or''forpositives*/
Bit value that can be passed in flags to dtostre().
#defineDTOSTR_PLUS_SIGN0x02/*put'+'ratherthan''*/
Bit value that can be passed in flags to dtostre().
#defineDTOSTR_UPPERCASE0x04/*put'E'rather'e'*/
Bit value that can be passed in flags to dtostre().
#defineRAND_MAX0x7FFF
Highest number that can be generated by rand().
#defineRANDOM_MAX0x7FFFFFFF
Highest number that can be generated by random().

TypedefDocumentation

typedefint(*__compar_fn_t)(constvoid*,constvoid*)
Comparision function type for qsort(), just for convenience.

FunctionDocumentation

voidabort(void)
The abort() function causes abnormal program termination to occur. This realization
disables interrupts and jumps to _exit() function with argument equal to 1. In the limited
AVR environment, execution is effectively halted by entering an infinite loop.
intabs(int__i)
The abs() function computes the absolute value of the integer i.
Note:
The abs() and labs() functions are builtins of gcc.
doubleatof(constchar*nptr)
The atof() function converts the initial portion of the string pointed to by nptr to
double representation.
It is equivalent to calling
strtod(nptr, (char **)0);
intatoi(constchar*s)
Convert a string to an integer. The atoi() function converts the initial portion of the
string pointed to by s to integer representation. In contrast to
(int)strtol(s, (char **)NULL, 10);
this function does not detect overflow (errno is not changed and the result value is not
predictable), uses smaller memory (flash and stack) and works more quickly.
longatol(constchar*s)
Convert a string to a long integer. The atol() function converts the initial portion of
the string pointed to by s to long integer representation. In contrast to
strtol(s, (char **)NULL, 10);
this function does not detect overflow (errno is not changed and the result value is not
predictable), uses smaller memory (flash and stack) and works more quickly.
void*bsearch(constvoid*__key,constvoid*__base,size_t__nmemb,size_t__size,int(*)(constvoid*,constvoid*)__compar)
The bsearch() function searches an array of nmemb objects, the initial member of which is
pointed to by base, for a member that matches the object pointed to by key. The size of
each member of the array is specified by size.
The contents of the array should be in ascending sorted order according to the comparison
function referenced by compar. The compar routine is expected to have two arguments which
point to the key object and to an array member, in that order, and should return an
integer less than, equal to, or greater than zero if the key object is found,
respectively, to be less than, to match, or be greater than the array member.
The bsearch() function returns a pointer to a matching member of the array, or a null
pointer if no match is found. If two members compare as equal, which member is matched is
unspecified.
void*calloc(size_t__nele,size_t__size)
Allocate nele elements of size each. Identical to calling malloc()usingnele*sizeasargument,excepttheallocatedmemorywillbeclearedtozero.div_tdiv(int__num,int__denom)
The div() function computes the value num/denom and returns the quotient and remainder in
a structure named div_tthatcontainstwointmembersnamedquotandrem.char*dtostre(double__val,char*__s,unsignedchar__prec,unsignedchar__flags)
The dtostre() function converts the double value passed in val into an ASCII
representation that will be stored under s. The caller is responsible for providing
sufficient storage in s.
Conversion is done in the format '[-]d.ddde±dd' where there is one digit before the
decimal-point character and the number of digits after it is equal to the precision prec;
if the precision is zero, no decimal-point character appears. If flags has the
DTOSTRE_UPPERCASE bit set, the letter 'E' (rather than 'e' ) will be used to introduce the
exponent. The exponent always contains two digits; if the value is zero, the exponent is
'00'.
If flags has the DTOSTRE_ALWAYS_SIGN bit set, a space character will be placed into the
leading position for positive numbers.
If flags has the DTOSTRE_PLUS_SIGN bit set, a plus sign will be used instead of a space
character in this case.
The dtostre() function returns the pointer to the converted string s.
char*dtostrf(double__val,signedchar__width,unsignedchar__prec,char*__s)
The dtostrf() function converts the double value passed in val into an ASCII
representationthat will be stored under s. The caller is responsible for providing
sufficient storage in s.
Conversion is done in the format '[-]d.ddd'. The minimum field width of the output string
(including the '.' and the possible sign for negative values) is given in width, and prec
determines the number of digits after the decimal sign. width is signed value, negative
for left adjustment.
The dtostrf() function returns the pointer to the converted string s.
voidexit(int__status)
The exit() function terminates the application. Since there is no environment to return
to, status is ignored, and code execution will eventually reach an infinite loop, thereby
effectively halting all code processing. Before entering the infinite loop, interrupts are
globally disabled.
In a C++ context, global destructors will be called before halting execution.
voidfree(void*__ptr)
The free() function causes the allocated memory referenced by ptr to be made available for
future allocations. If ptr is NULL, no action occurs.
char*itoa(int__val,char*__s,int__radix)
Convert an integer to a string. The function itoa() converts the integer value from val
into an ASCII representation that will be stored under s. The caller is responsible for
providing sufficient storage in s.
Note:
The minimal size of the buffer s depends on the choice of radix. For example, if the
radix is 2 (binary), you need to supply a buffer with a minimal length of 8 * sizeof
(int) + 1 characters, i.e. one character for each bit plus one for the string
terminator. Using a larger radix will require a smaller minimal buffer size.
Warning:
If the buffer is too small, you risk a buffer overflow.
Conversion is done using the radix as base, which may be a number between 2 (binary
conversion) and up to 36. If radix is greater than 10, the next digit after '9' will be
the letter 'a'.
If radix is 10 and val is negative, a minus sign will be prepended.
The itoa() function returns the pointer passed as s.
longlabs(long__i)
The labs() function computes the absolute value of the long integer i.
Note:
The abs() and labs() functions are builtins of gcc.
ldiv_tldiv(long__num,long__denom)
The ldiv() function computes the value num/denom and returns the quotient and remainder in
a structure named ldiv_tthatcontainstwolongintegermembersnamedquotandrem.char*ltoa(longint__val,char*__s,int__radix)
Convert a long integer to a string. The function ltoa() converts the long integer value
from val into an ASCII representation that will be stored under s. The caller is
responsible for providing sufficient storage in s.
Note:
The minimal size of the buffer s depends on the choice of radix. For example, if the
radix is 2 (binary), you need to supply a buffer with a minimal length of 8 * sizeof
(long int) + 1 characters, i.e. one character for each bit plus one for the string
terminator. Using a larger radix will require a smaller minimal buffer size.
Warning:
If the buffer is too small, you risk a buffer overflow.
Conversion is done using the radix as base, which may be a number between 2 (binary
conversion) and up to 36. If radix is greater than 10, the next digit after '9' will be
the letter 'a'.
If radix is 10 and val is negative, a minus sign will be prepended.
The ltoa() function returns the pointer passed as s.
void*malloc(size_t__size)
The malloc() function allocates size bytes of memory. If malloc() fails, a NULL pointer is
returned.
Note that malloc() does not initialize the returned memory to zero bytes.
See the chapter about malloc()usage for implementation details.
voidqsort(void*__base,size_t__nmemb,size_t__size,__compar_fn_t__compar)
The qsort() function is a modified partition-exchange sort, or quicksort.
The qsort() function sorts an array of nmemb objects, the initial member of which is
pointed to by base. 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.
The comparison function must return an integer less than, equal to, or greater than zero
if the first argument is considered to be respectively less than, equal to, or greater
than the second.
intrand(void)
The rand() function computes a sequence of pseudo-random integers in the range of 0 to
RAND_MAX (as defined by the header file <stdlib.h>).
The srand() function sets its argument seed as the seed for a new sequence of pseudo-
random numbers to be returned by rand(). These sequences are repeatable by calling srand()
with the same seed value.
If no seed value is provided, the functions are automatically seeded with a value of 1.
In compliance with the C standard, these functions operate on int arguments. Since the
underlying algorithm already uses 32-bit calculations, this causes a loss of precision.
See random()foranalternatesetoffunctionsthatretainsfull32-bitprecision.intrand_r(unsignedlong*__ctx)
Variant of rand() that stores the context in the user-supplied variable located at ctx
instead of a static library variable so the function becomes re-entrant.
longrandom(void)
The random() function computes a sequence of pseudo-random integers in the range of 0 to
RANDOM_MAX (as defined by the header file <stdlib.h>).
The srandom() function sets its argument seed as the seed for a new sequence of pseudo-
random numbers to be returned by rand(). These sequences are repeatable by calling
srandom() with the same seed value.
If no seed value is provided, the functions are automatically seeded with a value of 1.
longrandom_r(unsignedlong*__ctx)
Variant of random() that stores the context in the user-supplied variable located at ctx
instead of a static library variable so the function becomes re-entrant.
void*realloc(void*__ptr,size_t__size)
The realloc() function tries to change the size of the region allocated at ptr to the new
size value. It returns a pointer to the new region. The returned pointer might be the same
as the old pointer, or a pointer to a completely different region.
The contents of the returned region up to either the old or the new size value (whatever
is less) will be identical to the contents of the old region, even in case a new region
had to be allocated.
It is acceptable to pass ptr as NULL, in which case realloc() will behave identical to
malloc().
If the new memory cannot be allocated, realloc() returns NULL, and the region at ptr will
not be changed.
voidsrand(unsignedint__seed)
Pseudo-random number generator seeding; see rand().
voidsrandom(unsignedlong__seed)
Pseudo-random number generator seeding; see random().
doublestrtod(constchar*nptr,char**endptr)
The strtod() function converts the initial portion of the string pointed to by nptr to
double representation.
The expected form of the string is an optional plus ( '+' ) or minus sign ( '-' ) followed
by a sequence of digits optionally containing a decimal-point character, optionally
followed by an exponent. An exponent consists of an 'E' or 'e', followed by an optional
plus or minus sign, followed by a sequence of digits.
Leading white-space characters in the string are skipped.
The strtod() function returns the converted value, if any.
If endptr is not NULL, a pointer to the character after the last character used in the
conversion is stored in the location referenced by endptr.
If no conversion is performed, zero is returned and the value of nptr is stored in the
location referenced by endptr.
If the correct value would cause overflow, plus or minus INFINITY is returned (according
to the sign of the value), and ERANGE is stored in errno. If the correct value would cause
underflow, zero is returned and ERANGE is stored in errno.
longstrtol(constchar*__nptr,char**__endptr,int__base)
The strtol() function converts the string in nptr to a long value. The conversion is done
according to the given base, which must be between 2 and 36 inclusive, or be the special
value 0.
The string may begin with an arbitrary amount of white space (as determined by isspace())
followed by a single optional '+' or '-' sign. If base is zero or 16, the string may then
include a '0x' prefix, and the number will be read in base 16; otherwise, a zero base is
taken as 10 (decimal) unless the next character is '0', in which case it is taken as 8
(octal).
The remainder of the string is converted to a long value in the obvious manner, stopping
at the first character which is not a valid digit in the given base. (In bases above 10,
the letter 'A' in either upper or lower case represents 10, 'B' represents 11, and so
forth, with 'Z' representing 35.)
If endptr is not NULL, strtol() stores the address of the first invalid character in
*endptr. If there were no digits at all, however, strtol() stores the original value of
nptr in endptr. (Thus, if *nptr is not '\0' but **endptr is '\0' on return, the entire
string was valid.)
The strtol() function returns the result of the conversion, unless the value would
underflow or overflow. If no conversion could be performed, 0 is returned. If an overflow
or underflow occurs, errno is set to ERANGE and the function return value is clamped to
LONG_MIN or LONG_MAX, respectively.
unsignedlongstrtoul(constchar*__nptr,char**__endptr,int__base)
The strtoul() function converts the string in nptr to an unsigned long value. The
conversion is done according to the given base, which must be between 2 and 36 inclusive,
or be the special value 0.
The string may begin with an arbitrary amount of white space (as determined by isspace())
followed by a single optional '+' or '-' sign. If base is zero or 16, the string may then
include a '0x' prefix, and the number will be read in base 16; otherwise, a zero base is
taken as 10 (decimal) unless the next character is '0', in which case it is taken as 8
(octal).
The remainder of the string is converted to an unsigned long value in the obvious manner,
stopping at the first character which is not a valid digit in the given base. (In bases
above 10, the letter 'A' in either upper or lower case represents 10, 'B' represents 11,
and so forth, with 'Z' representing 35.)
If endptr is not NULL, strtoul() stores the address of the first invalid character in
*endptr. If there were no digits at all, however, strtoul() stores the original value of
nptr in endptr. (Thus, if *nptr is not '\0' but **endptr is '\0' on return, the entire
string was valid.)
The strtoul() function return either the result of the conversion or, if there was a
leading minus sign, the negation of the result of the conversion, unless the original
(non-negated) value would overflow; in the latter case, strtoul() returns ULONG_MAX, and
errno is set to ERANGE. If no conversion could be performed, 0 is returned.
char*ultoa(unsignedlongint__val,char*__s,int__radix)
Convert an unsigned long integer to a string. The function ultoa() converts the unsigned
long integer value from val into an ASCII representation that will be stored under s. The
caller is responsible for providing sufficient storage in s.
Note:
The minimal size of the buffer s depends on the choice of radix. For example, if the
radix is 2 (binary), you need to supply a buffer with a minimal length of 8 * sizeof
(unsigned long int) + 1 characters, i.e. one character for each bit plus one for the
string terminator. Using a larger radix will require a smaller minimal buffer size.
Warning:
If the buffer is too small, you risk a buffer overflow.
Conversion is done using the radix as base, which may be a number between 2 (binary
conversion) and up to 36. If radix is greater than 10, the next digit after '9' will be
the letter 'a'.
The ultoa() function returns the pointer passed as s.
char*utoa(unsignedint__val,char*__s,int__radix)
Convert an unsigned integer to a string. The function utoa() converts the unsigned integer
value from val into an ASCII representation that will be stored under s. The caller is
responsible for providing sufficient storage in s.
Note:
The minimal size of the buffer s depends on the choice of radix. For example, if the
radix is 2 (binary), you need to supply a buffer with a minimal length of 8 * sizeof
(unsigned int) + 1 characters, i.e. one character for each bit plus one for the string
terminator. Using a larger radix will require a smaller minimal buffer size.
Warning:
If the buffer is too small, you risk a buffer overflow.
Conversion is done using the radix as base, which may be a number between 2 (binary
conversion) and up to 36. If radix is greater than 10, the next digit after '9' will be
the letter 'a'.
The utoa() function returns the pointer passed as s.