JehanneOS/newlib
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

stdlib: remove TRAD_SYNOPSIS

Browse Source 
Signed-off-by: Yaakov Selkowitz <yselkowi@redhat.com>
This commit is contained in:
Yaakov Selkowitz 2017-11-30 02:17:18 -06:00
parent a60026253d
commit a38fc79ee9
50 changed files with 51 additions and 607 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
newlib/libc/stdlib/_Exit.c
View File

@ -5,15 +5,10 @@ FUNCTION
INDEX INDEX
_Exit _Exit
ANSI_SYNOPSIS SYNOPSIS
#include <stdlib.h> #include <stdlib.h>
void _Exit(int <[code]>); void _Exit(int <[code]>);
TRAD_SYNOPSIS
#include <stdlib.h>
void _Exit(<[code]>)
int <[code]>;
DESCRIPTION DESCRIPTION
Use <<_Exit>> to return control from a program to the host operating Use <<_Exit>> to return control from a program to the host operating
environment. Use the argument <[code]> to pass an exit status to the environment. Use the argument <[code]> to pass an exit status to the

10
newlib/libc/stdlib/a64l.c
View File

@ -7,19 +7,11 @@ INDEX
INDEX INDEX
l64a l64a
ANSI_SYNOPSIS SYNOPSIS
#include <stdlib.h> #include <stdlib.h>
long a64l(const char *<[input]>); long a64l(const char *<[input]>);
char *l64a(long <[input]>); char *l64a(long <[input]>);
TRAD_SYNOPSIS
#include <stdlib.h>
long a64l(<[input]>)
const char *<[input]>;
char *l64a(<[input]>)
long <[input]>;
DESCRIPTION DESCRIPTION
Conversion is performed between long and radix-64 characters. The Conversion is performed between long and radix-64 characters. The
<<l64a>> routine transforms up to 32 bits of input value starting from <<l64a>> routine transforms up to 32 bits of input value starting from

6
newlib/libc/stdlib/abort.c
View File

@ -15,14 +15,10 @@ FUNCTION
INDEX INDEX
abort abort
ANSI_SYNOPSIS SYNOPSIS
#include <stdlib.h> #include <stdlib.h>
void abort(void); void abort(void);
TRAD_SYNOPSIS
#include <stdlib.h>
void abort();
DESCRIPTION DESCRIPTION
Use <<abort>> to signal that your program has detected a condition it Use <<abort>> to signal that your program has detected a condition it
cannot deal with. Normally, <<abort>> ends your program's execution. cannot deal with. Normally, <<abort>> ends your program's execution.

7
newlib/libc/stdlib/abs.c
View File

@ -5,15 +5,10 @@ FUNCTION
INDEX INDEX
abs abs
ANSI_SYNOPSIS SYNOPSIS
#include <stdlib.h> #include <stdlib.h>
int abs(int <[i]>); int abs(int <[i]>);
TRAD_SYNOPSIS
#include <stdlib.h>
int abs(<[i]>)
int <[i]>;
DESCRIPTION DESCRIPTION
<<abs>> returns <<abs>> returns
@tex @tex

2
newlib/libc/stdlib/assert.c
View File

@ -5,7 +5,7 @@ FUNCTION
INDEX INDEX
assert assert
ANSI_SYNOPSIS SYNOPSIS
#include <assert.h> #include <assert.h>
void assert(int <[expression]>); void assert(int <[expression]>);

7
newlib/libc/stdlib/atexit.c
View File

@ -12,15 +12,10 @@ FUNCTION
INDEX INDEX
atexit atexit
ANSI_SYNOPSIS SYNOPSIS
#include <stdlib.h> #include <stdlib.h>
int atexit (void (*<[function]>)(void)); int atexit (void (*<[function]>)(void));
TRAD_SYNOPSIS
#include <stdlib.h>
int atexit ((<[function]>)
void (*<[function]>)();
DESCRIPTION DESCRIPTION
You can use <<atexit>> to enroll functions in a list of functions that You can use <<atexit>> to enroll functions in a list of functions that
will be called when your program terminates normally. The argument is will be called when your program terminates normally. The argument is

10
newlib/libc/stdlib/atof.c
View File

@ -7,19 +7,11 @@ INDEX
INDEX INDEX
atoff atoff
ANSI_SYNOPSIS SYNOPSIS
#include <stdlib.h> #include <stdlib.h>
double atof(const char *<[s]>); double atof(const char *<[s]>);
float atoff(const char *<[s]>); float atoff(const char *<[s]>);
TRAD_SYNOPSIS
#include <stdlib.h>
double atof(<[s]>)
char *<[s]>;
float atoff(<[s]>)
char *<[s]>;
DESCRIPTION DESCRIPTION
<<atof>> converts the initial portion of a string to a <<double>>. <<atof>> converts the initial portion of a string to a <<double>>.
<<atoff>> converts the initial portion of a string to a <<float>>. <<atoff>> converts the initial portion of a string to a <<float>>.

19
newlib/libc/stdlib/atoi.c
View File

@ -11,30 +11,13 @@ INDEX
INDEX INDEX
_atol_r _atol_r
ANSI_SYNOPSIS SYNOPSIS
#include <stdlib.h> #include <stdlib.h>
int atoi(const char *<[s]>); int atoi(const char *<[s]>);
long atol(const char *<[s]>); long atol(const char *<[s]>);
int _atoi_r(struct _reent *<[ptr]>, const char *<[s]>); int _atoi_r(struct _reent *<[ptr]>, const char *<[s]>);
long _atol_r(struct _reent *<[ptr]>, const char *<[s]>); long _atol_r(struct _reent *<[ptr]>, const char *<[s]>);
TRAD_SYNOPSIS
#include <stdlib.h>
int atoi(<[s]>)
char *<[s]>;
long atol(<[s]>)
char *<[s]>;
int _atoi_r(<[ptr]>, <[s]>)
struct _reent *<[ptr]>;
char *<[s]>;
long _atol_r(<[ptr]>, <[s]>)
struct _reent *<[ptr]>;
char *<[s]>;
DESCRIPTION DESCRIPTION
<<atoi>> converts the initial portion of a string to an <<int>>. <<atoi>> converts the initial portion of a string to an <<int>>.
<<atol>> converts the initial portion of a string to a <<long>>. <<atol>> converts the initial portion of a string to a <<long>>.

11
newlib/libc/stdlib/atoll.c
View File

@ -7,20 +7,11 @@ INDEX
INDEX INDEX
_atoll_r _atoll_r
ANSI_SYNOPSIS SYNOPSIS
#include <stdlib.h> #include <stdlib.h>
long long atoll(const char *<[str]>); long long atoll(const char *<[str]>);
long long _atoll_r(struct _reent *<[ptr]>, const char *<[str]>); long long _atoll_r(struct _reent *<[ptr]>, const char *<[str]>);
TRAD_SYNOPSIS
#include <stdlib.h>
long long atoll(<[str]>)
const char *<[str]>;
long long _atoll_r(<[ptr]>, <[str]>)
struct _reent *<[ptr]>;
const char *<[str]>;
DESCRIPTION DESCRIPTION
The function <<atoll>> converts the initial portion of the string The function <<atoll>> converts the initial portion of the string
pointed to by <<*<[str]>>> to a type <<long long>>. A call to pointed to by <<*<[str]>>> to a type <<long long>>. A call to

14
newlib/libc/stdlib/calloc.c
View File

@ -11,23 +11,11 @@ INDEX
INDEX INDEX
_calloc_r _calloc_r
ANSI_SYNOPSIS SYNOPSIS
#include <stdlib.h> #include <stdlib.h>
void *calloc(size_t <[n]>, size_t <[s]>); void *calloc(size_t <[n]>, size_t <[s]>);
void *_calloc_r(void *<[reent]>, size_t <[n]>, size_t <[s]>); void *_calloc_r(void *<[reent]>, size_t <[n]>, size_t <[s]>);
TRAD_SYNOPSIS
#include <stdlib.h>
char *calloc(<[n]>, <[s]>)
size_t <[n]>, <[s]>;
char *_calloc_r(<[reent]>, <[n]>, <[s]>)
char *<[reent]>;
size_t <[n]>;
size_t <[s]>;
DESCRIPTION DESCRIPTION
Use <<calloc>> to request a block of memory sufficient to hold an Use <<calloc>> to request a block of memory sufficient to hold an
array of <[n]> elements, each of which has size <[s]>. array of <[n]> elements, each of which has size <[s]>.

7
newlib/libc/stdlib/div.c
View File

@ -5,15 +5,10 @@ FUNCTION
INDEX INDEX
div div
ANSI_SYNOPSIS SYNOPSIS
#include <stdlib.h> #include <stdlib.h>
div_t div(int <[n]>, int <[d]>); div_t div(int <[n]>, int <[d]>);
TRAD_SYNOPSIS
#include <stdlib.h>
div_t div(<[n]>, <[d]>)
int <[n]>, <[d]>;
DESCRIPTION DESCRIPTION
Divide Divide
@tex @tex

19
newlib/libc/stdlib/ecvtbuf.c
View File

@ -7,7 +7,7 @@ INDEX
INDEX INDEX
fcvtbuf fcvtbuf
ANSI_SYNOPSIS SYNOPSIS
#include <stdio.h> #include <stdio.h>
char *ecvtbuf(double <[val]>, int <[chars]>, int *<[decpt]>, char *ecvtbuf(double <[val]>, int <[chars]>, int *<[decpt]>,
@ -16,23 +16,6 @@ ANSI_SYNOPSIS
char *fcvtbuf(double <[val]>, int <[decimals]>, int *<[decpt]>, char *fcvtbuf(double <[val]>, int <[decimals]>, int *<[decpt]>,
int *<[sgn]>, char *<[buf]>); int *<[sgn]>, char *<[buf]>);
TRAD_SYNOPSIS
#include <stdio.h>
char *ecvtbuf(<[val]>, <[chars]>, <[decpt]>, <[sgn]>, <[buf]>);
double <[val]>;
int <[chars]>;
int *<[decpt]>;
int *<[sgn]>;
char *<[buf]>;
char *fcvtbuf(<[val]>, <[decimals]>, <[decpt]>, <[sgn]>, <[buf]>);
double <[val]>;
int <[decimals]>;
int *<[decpt]>;
int *<[sgn]>;
char *<[buf]>;
DESCRIPTION DESCRIPTION
<<ecvtbuf>> and <<fcvtbuf>> produce (null-terminated) strings <<ecvtbuf>> and <<fcvtbuf>> produce (null-terminated) strings
of digits representating the <<double>> number <[val]>. of digits representating the <<double>> number <[val]>.

41
newlib/libc/stdlib/efgcvt.c
View File

@ -11,7 +11,7 @@ INDEX
INDEX INDEX
fcvtf fcvtf
ANSI_SYNOPSIS SYNOPSIS
#include <stdlib.h> #include <stdlib.h>
char *ecvt(double <[val]>, int <[chars]>, int *<[decpt]>, int *<[sgn]>); char *ecvt(double <[val]>, int <[chars]>, int *<[decpt]>, int *<[sgn]>);
@ -22,31 +22,6 @@ ANSI_SYNOPSIS
char *fcvtf(float <[val]>, int <[decimals]>, char *fcvtf(float <[val]>, int <[decimals]>,
int *<[decpt]>, int *<[sgn]>); int *<[decpt]>, int *<[sgn]>);
TRAD_SYNOPSIS
#include <stdlib.h>
char *ecvt(<[val]>, <[chars]>, <[decpt]>, <[sgn]>);
double <[val]>;
int <[chars]>;
int *<[decpt]>;
int *<[sgn]>;
char *ecvtf(<[val]>, <[chars]>, <[decpt]>, <[sgn]>);
float <[val]>;
int <[chars]>;
int *<[decpt]>;
int *<[sgn]>;
char *fcvt(<[val]>, <[decimals]>, <[decpt]>, <[sgn]>);
double <[val]>;
int <[decimals]>;
int *<[decpt]>;
int *<[sgn]>;
char *fcvtf(<[val]>, <[decimals]>, <[decpt]>, <[sgn]>);
float <[val]>;
int <[decimals]>;
int *<[decpt]>;
int *<[sgn]>;
DESCRIPTION DESCRIPTION
<<ecvt>> and <<fcvt>> produce (null-terminated) strings of digits <<ecvt>> and <<fcvt>> produce (null-terminated) strings of digits
representating the <<double>> number <[val]>. representating the <<double>> number <[val]>.
@ -91,24 +66,12 @@ INDEX
INDEX INDEX
gcvtf gcvtf
ANSI_SYNOPSIS SYNOPSIS
#include <stdlib.h> #include <stdlib.h>
char *gcvt(double <[val]>, int <[precision]>, char *<[buf]>); char *gcvt(double <[val]>, int <[precision]>, char *<[buf]>);
char *gcvtf(float <[val]>, int <[precision]>, char *<[buf]>); char *gcvtf(float <[val]>, int <[precision]>, char *<[buf]>);
TRAD_SYNOPSIS
#include <stdlib.h>
char *gcvt(<[val]>, <[precision]>, <[buf]>);
double <[val]>;
int <[precision]>;
char *<[buf]>;
char *gcvtf(<[val]>, <[precision]>, <[buf]>);
float <[val]>;
int <[precision]>;
char *<[buf]>;
DESCRIPTION DESCRIPTION
<<gcvt>> writes a fully formatted number as a null-terminated <<gcvt>> writes a fully formatted number as a null-terminated
string in the buffer <<*<[buf]>>>. <<gcvtf>> produces corresponding string in the buffer <<*<[buf]>>>. <<gcvtf>> produces corresponding

9
newlib/libc/stdlib/envlock.c
View File

@ -7,18 +7,11 @@ INDEX
INDEX INDEX
__env_unlock __env_unlock
ANSI_SYNOPSIS SYNOPSIS
#include <envlock.h> #include <envlock.h>
void __env_lock (struct _reent *<[reent]>); void __env_lock (struct _reent *<[reent]>);
void __env_unlock (struct _reent *<[reent]>); void __env_unlock (struct _reent *<[reent]>);
TRAD_SYNOPSIS
void __env_lock(<[reent]>)
struct _reent *<[reent]>;
void __env_unlock(<[reent]>)
struct _reent *<[reent]>;
DESCRIPTION DESCRIPTION
The <<setenv>> family of routines call these functions when they need to The <<setenv>> family of routines call these functions when they need to
modify the environ variable. The version of these routines supplied in the modify the environ variable. The version of these routines supplied in the

7
newlib/libc/stdlib/exit.c
View File

@ -12,15 +12,10 @@ FUNCTION
INDEX INDEX
exit exit
ANSI_SYNOPSIS SYNOPSIS
#include <stdlib.h> #include <stdlib.h>
void exit(int <[code]>); void exit(int <[code]>);
TRAD_SYNOPSIS
#include <stdlib.h>
void exit(<[code]>)
int <[code]>;
DESCRIPTION DESCRIPTION
Use <<exit>> to return control from a program to the host operating Use <<exit>> to return control from a program to the host operating
environment. Use the argument <[code]> to pass an exit status to the environment. Use the argument <[code]> to pass an exit status to the

7
newlib/libc/stdlib/getenv.c
View File

@ -7,15 +7,10 @@ INDEX
INDEX INDEX
environ environ
ANSI_SYNOPSIS SYNOPSIS
#include <stdlib.h> #include <stdlib.h>
char *getenv(const char *<[name]>); char *getenv(const char *<[name]>);
TRAD_SYNOPSIS
#include <stdlib.h>
char *getenv(<[name]>)
char *<[name]>;
DESCRIPTION DESCRIPTION
<<getenv>> searches the list of environment variable names and values <<getenv>> searches the list of environment variable names and values
(using the global pointer ``<<char **environ>>'') for a variable whose (using the global pointer ``<<char **environ>>'') for a variable whose

8
newlib/libc/stdlib/getenv_r.c
View File

@ -7,16 +7,10 @@ INDEX
INDEX INDEX
environ environ
ANSI_SYNOPSIS SYNOPSIS
#include <stdlib.h> #include <stdlib.h>
char *_getenv_r(struct _reent *<[reent_ptr]>, const char *<[name]>); char *_getenv_r(struct _reent *<[reent_ptr]>, const char *<[name]>);
TRAD_SYNOPSIS
#include <stdlib.h>
char *_getenv_r(<[reent_ptr]>, <[name]>)
struct _reent *<[reent_ptr]>;
char *<[name]>;
DESCRIPTION DESCRIPTION
<<_getenv_r>> searches the list of environment variable names and values <<_getenv_r>> searches the list of environment variable names and values
(using the global pointer ``<<char **environ>>'') for a variable whose (using the global pointer ``<<char **environ>>'') for a variable whose

2
newlib/libc/stdlib/itoa.c
View File

@ -5,7 +5,7 @@ FUNCTION
INDEX INDEX
itoa itoa
ANSI_SYNOPSIS SYNOPSIS
#include <stdlib.h> #include <stdlib.h>
char *itoa(int <[value]>, char *<[str]>, int <[base]>); char *itoa(int <[value]>, char *<[str]>, int <[base]>);
char *__itoa(int <[value]>, char *<[str]>, int <[base]>); char *__itoa(int <[value]>, char *<[str]>, int <[base]>);

7
newlib/libc/stdlib/labs.c
View File

@ -5,15 +5,10 @@ FUNCTION
INDEX INDEX
labs labs
ANSI_SYNOPSIS SYNOPSIS
#include <stdlib.h> #include <stdlib.h>
long labs(long <[i]>); long labs(long <[i]>);
TRAD_SYNOPSIS
#include <stdlib.h>
long labs(<[i]>)
long <[i]>;
DESCRIPTION DESCRIPTION
<<labs>> returns <<labs>> returns
@tex @tex

7
newlib/libc/stdlib/ldiv.c
View File

@ -5,15 +5,10 @@ FUNCTION
INDEX INDEX
ldiv ldiv
ANSI_SYNOPSIS SYNOPSIS
#include <stdlib.h> #include <stdlib.h>
ldiv_t ldiv(long <[n]>, long <[d]>); ldiv_t ldiv(long <[n]>, long <[d]>);
TRAD_SYNOPSIS
#include <stdlib.h>
ldiv_t ldiv(<[n]>, <[d]>)
long <[n]>, <[d]>;
DESCRIPTION DESCRIPTION
Divide Divide
@tex @tex

7
newlib/libc/stdlib/llabs.c
View File

@ -5,15 +5,10 @@ FUNCTION
INDEX INDEX
llabs llabs
ANSI_SYNOPSIS SYNOPSIS
#include <stdlib.h> #include <stdlib.h>
long long llabs(long long <[j]>); long long llabs(long long <[j]>);
TRAD_SYNOPSIS
#include <stdlib.h>
long long llabs(<[j]>)
long long <[j]>;
DESCRIPTION DESCRIPTION
The <<llabs>> function computes the absolute value of the long long integer The <<llabs>> function computes the absolute value of the long long integer
argument <[j]> (also called the magnitude of <[j]>). argument <[j]> (also called the magnitude of <[j]>).

7
newlib/libc/stdlib/lldiv.c
View File

@ -5,15 +5,10 @@ FUNCTION
INDEX INDEX
lldiv lldiv
ANSI_SYNOPSIS SYNOPSIS
#include <stdlib.h> #include <stdlib.h>
lldiv_t lldiv(long long <[n]>, long long <[d]>); lldiv_t lldiv(long long <[n]>, long long <[d]>);
TRAD_SYNOPSIS
#include <stdlib.h>
lldiv_t lldiv(<[n]>, <[d]>)
long long <[n]>, <[d]>;
DESCRIPTION DESCRIPTION
Divide Divide
@tex @tex

52
newlib/libc/stdlib/malloc.c
View File

@ -43,7 +43,7 @@ INDEX
INDEX INDEX
_malloc_usable_size_r _malloc_usable_size_r
ANSI_SYNOPSIS SYNOPSIS
#include <stdlib.h> #include <stdlib.h>
void *malloc(size_t <[nbytes]>); void *malloc(size_t <[nbytes]>);
void *realloc(void *<[aptr]>, size_t <[nbytes]>); void *realloc(void *<[aptr]>, size_t <[nbytes]>);
@ -66,56 +66,6 @@ ANSI_SYNOPSIS
size_t _malloc_usable_size_r(void *<[reent]>, void *<[aptr]>); size_t _malloc_usable_size_r(void *<[reent]>, void *<[aptr]>);
TRAD_SYNOPSIS
#include <stdlib.h>
char *malloc(<[nbytes]>)
size_t <[nbytes]>;
char *realloc(<[aptr]>, <[nbytes]>)
char *<[aptr]>;
size_t <[nbytes]>;
char *reallocf(<[aptr]>, <[nbytes]>)
char *<[aptr]>;
size_t <[nbytes]>;
void free(<[aptr]>)
char *<[aptr]>;
char *memalign(<[align]>, <[nbytes]>)
size_t <[align]>;
size_t <[nbytes]>;
size_t malloc_usable_size(<[aptr]>)
char *<[aptr]>;
char *_malloc_r(<[reent]>,<[nbytes]>)
char *<[reent]>;
size_t <[nbytes]>;
char *_realloc_r(<[reent]>, <[aptr]>, <[nbytes]>)
char *<[reent]>;
char *<[aptr]>;
size_t <[nbytes]>;
char *_reallocf_r(<[reent]>, <[aptr]>, <[nbytes]>)
char *<[reent]>;
char *<[aptr]>;
size_t <[nbytes]>;
void _free_r(<[reent]>, <[aptr]>)
char *<[reent]>;
char *<[aptr]>;
char *_memalign_r(<[reent]>, <[align]>, <[nbytes]>)
char *<[reent]>;
size_t <[align]>;
size_t <[nbytes]>;
size_t malloc_usable_size(<[reent]>, <[aptr]>)
char *<[reent]>;
char *<[aptr]>;
DESCRIPTION DESCRIPTION
These functions manage a pool of system memory. These functions manage a pool of system memory.

8
newlib/libc/stdlib/mblen.c
View File

@ -5,16 +5,10 @@ FUNCTION
INDEX INDEX
mblen mblen
ANSI_SYNOPSIS SYNOPSIS
#include <stdlib.h> #include <stdlib.h>
int mblen(const char *<[s]>, size_t <[n]>); int mblen(const char *<[s]>, size_t <[n]>);
TRAD_SYNOPSIS
#include <stdlib.h>
int mblen(<[s]>, <[n]>)
const char *<[s]>;
size_t <[n]>;
DESCRIPTION DESCRIPTION
When _MB_CAPABLE is not defined, this is a minimal ANSI-conforming When _MB_CAPABLE is not defined, this is a minimal ANSI-conforming
implementation of <<mblen>>. In this case, the implementation of <<mblen>>. In this case, the

10
newlib/libc/stdlib/mblen_r.c
View File

@ -5,18 +5,10 @@ FUNCTION
INDEX INDEX
_mblen_r _mblen_r
ANSI_SYNOPSIS SYNOPSIS
#include <stdlib.h> #include <stdlib.h>
int _mblen_r(struct _reent *<[r]>, const char *<[s]>, size_t <[n]>, int *<[state]>); int _mblen_r(struct _reent *<[r]>, const char *<[s]>, size_t <[n]>, int *<[state]>);
TRAD_SYNOPSIS
#include <stdlib.h>
int _mblen_r(<[r]>, <[s]>, <[n]>, <[state]>)
struct _reent *<[r]>;
const char *<[s]>;
size_t <[n]>;
int *<[state]>;
DESCRIPTION DESCRIPTION
When _MB_CAPABLE is not defined, this is a minimal ANSI-conforming When _MB_CAPABLE is not defined, this is a minimal ANSI-conforming
implementation of <<_mblen_r>>. In this case, the implementation of <<_mblen_r>>. In this case, the

35
newlib/libc/stdlib/mbsnrtowcs.c
View File

@ -11,7 +11,7 @@ INDEX
INDEX INDEX
_mbsnrtowcs_r _mbsnrtowcs_r
ANSI_SYNOPSIS SYNOPSIS
#include <wchar.h> #include <wchar.h>
size_t mbsrtowcs(wchar_t *__restrict <[dst]>, size_t mbsrtowcs(wchar_t *__restrict <[dst]>,
const char **__restrict <[src]>, const char **__restrict <[src]>,
@ -33,39 +33,6 @@ ANSI_SYNOPSIS
const char **<[src]>, size_t <[nms]>, const char **<[src]>, size_t <[nms]>,
size_t <[len]>, mbstate_t *<[ps]>); size_t <[len]>, mbstate_t *<[ps]>);
TRAD_SYNOPSIS
#include <wchar.h>
size_t mbsrtowcs(<[dst]>, <[src]>, <[len]>, <[ps]>)
wchar_t *__restrict <[dst]>;
const char **__restrict <[src]>;
size_t <[len]>;
mbstate_t *__restrict <[ps]>;
#include <wchar.h>
size_t _mbsrtowcs_r(<[ptr]>, <[dst]>, <[src]>, <[len]>, <[ps]>)
struct _reent *<[ptr]>;
wchar_t *<[dst]>;
const char **<[src]>;
size_t <[len]>;
mbstate_t *<[ps]>;
#include <wchar.h>
size_t mbsnrtowcs(<[dst]>, <[src]>, <[nms]>, <[len]>, <[ps]>)
wchar_t *__restrict <[dst]>;
const char **__restrict <[src]>;
size_t <[nms]>;
size_t <[len]>;
mbstate_t *__restrict <[ps]>;
#include <wchar.h>
size_t _mbsnrtowcs_r(<[ptr]>, <[dst]>, <[src]>, <[nms]>, <[len]>, <[ps]>)
struct _reent *<[ptr]>;
wchar_t *<[dst]>;
const char **<[src]>;
size_t <[nms]>;
size_t <[len]>;
mbstate_t *<[ps]>;
DESCRIPTION DESCRIPTION
The <<mbsrtowcs>> function converts a sequence of multibyte characters The <<mbsrtowcs>> function converts a sequence of multibyte characters
pointed to indirectly by <[src]> into a sequence of corresponding wide pointed to indirectly by <[src]> into a sequence of corresponding wide

9
newlib/libc/stdlib/mbstowcs.c
View File

@ -5,17 +5,10 @@ FUNCTION
INDEX INDEX
mbstowcs mbstowcs
ANSI_SYNOPSIS SYNOPSIS
#include <stdlib.h> #include <stdlib.h>
int mbstowcs(wchar_t *restrict <[pwc]>, const char *restrict <[s]>, size_t <[n]>); int mbstowcs(wchar_t *restrict <[pwc]>, const char *restrict <[s]>, size_t <[n]>);
TRAD_SYNOPSIS
#include <stdlib.h>
int mbstowcs(<[pwc]>, <[s]>, <[n]>)
wchar_t *<[pwc]>;
const char *<[s]>;
size_t <[n]>;
DESCRIPTION DESCRIPTION
When _MB_CAPABLE is not defined, this is a minimal ANSI-conforming When _MB_CAPABLE is not defined, this is a minimal ANSI-conforming
implementation of <<mbstowcs>>. In this case, the implementation of <<mbstowcs>>. In this case, the

9
newlib/libc/stdlib/mbtowc.c
View File

@ -5,17 +5,10 @@ FUNCTION
INDEX INDEX
mbtowc mbtowc
ANSI_SYNOPSIS SYNOPSIS
#include <stdlib.h> #include <stdlib.h>
int mbtowc(wchar_t *restrict <[pwc]>, const char *restrict <[s]>, size_t <[n]>); int mbtowc(wchar_t *restrict <[pwc]>, const char *restrict <[s]>, size_t <[n]>);
TRAD_SYNOPSIS
#include <stdlib.h>
int mbtowc(<[pwc]>, <[s]>, <[n]>)
wchar_t *<[pwc]>;
const char *<[s]>;
size_t <[n]>;
DESCRIPTION DESCRIPTION
When _MB_CAPABLE is not defined, this is a minimal ANSI-conforming When _MB_CAPABLE is not defined, this is a minimal ANSI-conforming
implementation of <<mbtowc>>. In this case, implementation of <<mbtowc>>. In this case,

9
newlib/libc/stdlib/mlock.c
View File

@ -8,18 +8,11 @@ INDEX
INDEX INDEX
__malloc_unlock __malloc_unlock
ANSI_SYNOPSIS SYNOPSIS
#include <malloc.h> #include <malloc.h>
void __malloc_lock (struct _reent *<[reent]>); void __malloc_lock (struct _reent *<[reent]>);
void __malloc_unlock (struct _reent *<[reent]>); void __malloc_unlock (struct _reent *<[reent]>);
TRAD_SYNOPSIS
void __malloc_lock(<[reent]>)
struct _reent *<[reent]>;
void __malloc_unlock(<[reent]>)
struct _reent *<[reent]>;
DESCRIPTION DESCRIPTION
The <<malloc>> family of routines call these functions when they need to lock The <<malloc>> family of routines call these functions when they need to lock
the memory pool. The version of these routines supplied in the library use the memory pool. The version of these routines supplied in the library use

23
newlib/libc/stdlib/mstats.c
View File

@ -25,7 +25,7 @@ INDEX
INDEX INDEX
_mallopt_r _mallopt_r
ANSI_SYNOPSIS SYNOPSIS
#include <malloc.h> #include <malloc.h>
struct mallinfo mallinfo(void); struct mallinfo mallinfo(void);
void malloc_stats(void); void malloc_stats(void);
@ -35,27 +35,6 @@ ANSI_SYNOPSIS
void _malloc_stats_r(void *<[reent]>); void _malloc_stats_r(void *<[reent]>);
int _mallopt_r(void *<[reent]>, int <[parameter]>, <[value]>); int _mallopt_r(void *<[reent]>, int <[parameter]>, <[value]>);
TRAD_SYNOPSIS
#include <malloc.h>
struct mallinfo mallinfo();
void malloc_stats();
int mallopt(<[parameter]>, <[value]>)
int <[parameter]>;
int <[value]>;
struct mallinfo _mallinfo_r(<[reent]>);
char *<[reent]>;
void _malloc_stats_r(<[reent]>);
char *<[reent]>;
int _mallopt_r(<[reent]>, <[parameter]>, <[value]>)
char *<[reent]>;
int <[parameter]>;
int <[value]>;
DESCRIPTION DESCRIPTION
<<mallinfo>> returns a structure describing the current state of <<mallinfo>> returns a structure describing the current state of
memory allocation. The structure is defined in malloc.h. The memory allocation. The structure is defined in malloc.h. The

8
newlib/libc/stdlib/on_exit.c
View File

@ -14,16 +14,10 @@ FUNCTION
INDEX INDEX
on_exit on_exit
ANSI_SYNOPSIS SYNOPSIS
#include <stdlib.h> #include <stdlib.h>
int on_exit (void (*<[function]>)(int, void *), void *<[arg]>); int on_exit (void (*<[function]>)(int, void *), void *<[arg]>);
TRAD_SYNOPSIS
#include <stdlib.h>
int on_exit ((<[function]>, <[arg]>)
void (*<[function]>)(int, void *);
void *<[arg]>;
DESCRIPTION DESCRIPTION
You can use <<on_exit>> to enroll functions in a list of functions that You can use <<on_exit>> to enroll functions in a list of functions that
will be called when your program terminates normally. The argument is will be called when your program terminates normally. The argument is

13
newlib/libc/stdlib/rand.c
View File

@ -9,23 +9,12 @@ INDEX
INDEX INDEX
rand_r rand_r
ANSI_SYNOPSIS SYNOPSIS
#include <stdlib.h> #include <stdlib.h>
int rand(void); int rand(void);
void srand(unsigned int <[seed]>); void srand(unsigned int <[seed]>);
int rand_r(unsigned int *<[seed]>); int rand_r(unsigned int *<[seed]>);
TRAD_SYNOPSIS
#include <stdlib.h>
int rand();
void srand(<[seed]>)
unsigned int <[seed]>;
void rand_r(<[seed]>)
unsigned int *<[seed]>;
DESCRIPTION DESCRIPTION
<<rand>> returns a different integer each time it is called; each <<rand>> returns a different integer each time it is called; each
integer is chosen by an algorithm designed to be unpredictable, so integer is chosen by an algorithm designed to be unpredictable, so

28
newlib/libc/stdlib/rand48.c
View File

@ -36,7 +36,7 @@ INDEX
INDEX INDEX
lcong48 lcong48
ANSI_SYNOPSIS SYNOPSIS
#include <stdlib.h> #include <stdlib.h>
double drand48(void); double drand48(void);
double erand48(unsigned short <[xseed]>[3]); double erand48(unsigned short <[xseed]>[3]);
@ -48,32 +48,6 @@ ANSI_SYNOPSIS
unsigned short *seed48(unsigned short <[xseed]>[3]); unsigned short *seed48(unsigned short <[xseed]>[3]);
void lcong48(unsigned short <[p]>[7]); void lcong48(unsigned short <[p]>[7]);
TRAD_SYNOPSIS
#include <stdlib.h>
double drand48();
double erand48(<[xseed]>)
unsigned short <[xseed]>[3];
long lrand48();
long nrand48(<[xseed]>)
unsigned short <[xseed]>[3];
long mrand48();
long jrand48(<[xseed]>)
unsigned short <[xseed]>[3];
void srand48(<[seed]>)
long <[seed]>;
unsigned short *seed48(<[xseed]>)
unsigned short <[xseed]>[3];
void lcong48(<[p]>)
unsigned short <[p]>[7];
DESCRIPTION DESCRIPTION
The <<rand48>> family of functions generates pseudo-random numbers The <<rand48>> family of functions generates pseudo-random numbers
using a linear congruential algorithm working on integers 48 bits in size. using a linear congruential algorithm working on integers 48 bits in size.

2
newlib/libc/stdlib/random.c
View File

@ -7,7 +7,7 @@ INDEX
INDEX INDEX
srandom srandom
ANSI_SYNOPSIS SYNOPSIS
#define _XOPEN_SOURCE 500 #define _XOPEN_SOURCE 500
#include <stdlib.h> #include <stdlib.h>
long int random(void); long int random(void);

7
newlib/libc/stdlib/rpmatch.c
View File

@ -5,15 +5,10 @@ FUNCTION
INDEX INDEX
rpmatch rpmatch
ANSI_SYNOPSIS SYNOPSIS
#include <stdlib.h> #include <stdlib.h>
int rpmatch(const char *<[response]>); int rpmatch(const char *<[response]>);
TRAD_SYNOPSIS
#include <stdlib.h>
int rpmatch(<[response]>)
const char *<[response]>;
DESCRIPTION DESCRIPTION
The <<rpmatch>> function determines whether <[response]> is an affirmative The <<rpmatch>> function determines whether <[response]> is an affirmative
or negative response to a question according to the current locale. or negative response to a question according to the current locale.

17
newlib/libc/stdlib/strtod.c
View File

@ -23,7 +23,7 @@ INDEX
INDEX INDEX
_strtod_r _strtod_r
ANSI_SYNOPSIS SYNOPSIS
#include <stdlib.h> #include <stdlib.h>
double strtod(const char *restrict <[str]>, char **restrict <[tail]>); double strtod(const char *restrict <[str]>, char **restrict <[tail]>);
float strtof(const char *restrict <[str]>, char **restrict <[tail]>); float strtof(const char *restrict <[str]>, char **restrict <[tail]>);
@ -42,21 +42,6 @@ ANSI_SYNOPSIS
double _strtod_r(void *<[reent]>, double _strtod_r(void *<[reent]>,
const char *restrict <[str]>, char **restrict <[tail]>); const char *restrict <[str]>, char **restrict <[tail]>);
TRAD_SYNOPSIS
#include <stdlib.h>
double strtod(<[str]>,<[tail]>)
char *<[str]>;
char **<[tail]>;
float strtof(<[str]>,<[tail]>)
char *<[str]>;
char **<[tail]>;
double _strtod_r(<[reent]>,<[str]>,<[tail]>)
char *<[reent]>;
char *<[str]>;
char **<[tail]>;
DESCRIPTION DESCRIPTION
<<strtod>>, <<strtof>>, <<strtold>> parse the character string <<strtod>>, <<strtof>>, <<strtold>> parse the character string
<[str]>, producing a substring which can be converted to a double, <[str]>, producing a substring which can be converted to a double,

15
newlib/libc/stdlib/strtol.c
View File

@ -11,7 +11,7 @@ INDEX
INDEX INDEX
_strtol_r _strtol_r
ANSI_SYNOPSIS SYNOPSIS
#include <stdlib.h> #include <stdlib.h>
long strtol(const char *restrict <[s]>, char **restrict <[ptr]>, long strtol(const char *restrict <[s]>, char **restrict <[ptr]>,
int <[base]>); int <[base]>);
@ -23,19 +23,6 @@ ANSI_SYNOPSIS
long _strtol_r(void *<[reent]>, const char *restrict <[s]>, long _strtol_r(void *<[reent]>, const char *restrict <[s]>,
char **restrict <[ptr]>,int <[base]>); char **restrict <[ptr]>,int <[base]>);
TRAD_SYNOPSIS
#include <stdlib.h>
long strtol (<[s]>, <[ptr]>, <[base]>)
char *<[s]>;
char **<[ptr]>;
int <[base]>;
long _strtol_r (<[reent]>, <[s]>, <[ptr]>, <[base]>)
char *<[reent]>;
char *<[s]>;
char **<[ptr]>;
int <[base]>;
DESCRIPTION DESCRIPTION
The function <<strtol>> converts the string <<*<[s]>>> to The function <<strtol>> converts the string <<*<[s]>>> to
a <<long>>. First, it breaks down the string into three parts: a <<long>>. First, it breaks down the string into three parts:

15
newlib/libc/stdlib/strtoll.c
View File

@ -11,7 +11,7 @@ INDEX
INDEX INDEX
_strtoll_r _strtoll_r
ANSI_SYNOPSIS SYNOPSIS
#include <stdlib.h> #include <stdlib.h>
long long strtoll(const char *restrict <[s]>, char **restrict <[ptr]>, long long strtoll(const char *restrict <[s]>, char **restrict <[ptr]>,
int <[base]>); int <[base]>);
@ -25,19 +25,6 @@ ANSI_SYNOPSIS
const char *restrict <[s]>, const char *restrict <[s]>,
char **restrict <[ptr]>, int <[base]>); char **restrict <[ptr]>, int <[base]>);
TRAD_SYNOPSIS
#include <stdlib.h>
long long strtoll (<[s]>, <[ptr]>, <[base]>)
const char *<[s]>;
char **<[ptr]>;
int <[base]>;
long long _strtoll_r (<[reent]>, <[s]>, <[ptr]>, <[base]>)
char *<[reent]>;
const char *<[s]>;
char **<[ptr]>;
int <[base]>;
DESCRIPTION DESCRIPTION
The function <<strtoll>> converts the string <<*<[s]>>> to The function <<strtoll>> converts the string <<*<[s]>>> to
a <<long long>>. First, it breaks down the string into three parts: a <<long long>>. First, it breaks down the string into three parts:

15
newlib/libc/stdlib/strtoul.c
View File

@ -11,7 +11,7 @@ INDEX
INDEX INDEX
_strtoul_r _strtoul_r
ANSI_SYNOPSIS SYNOPSIS
#include <stdlib.h> #include <stdlib.h>
unsigned long strtoul(const char *restrict <[s]>, unsigned long strtoul(const char *restrict <[s]>,
char **restrict <[ptr]>, int <[base]>); char **restrict <[ptr]>, int <[base]>);
@ -24,19 +24,6 @@ ANSI_SYNOPSIS
unsigned long _strtoul_r(void *<[reent]>, const char *restrict <[s]>, unsigned long _strtoul_r(void *<[reent]>, const char *restrict <[s]>,
char **restrict <[ptr]>, int <[base]>); char **restrict <[ptr]>, int <[base]>);
TRAD_SYNOPSIS
#include <stdlib.h>
unsigned long strtoul(<[s]>, <[ptr]>, <[base]>)
char *<[s]>;
char **<[ptr]>;
int <[base]>;
unsigned long _strtoul_r(<[reent]>, <[s]>, <[ptr]>, <[base]>)
char *<[reent]>;
char *<[s]>;
char **<[ptr]>;
int <[base]>;
DESCRIPTION DESCRIPTION
The function <<strtoul>> converts the string <<*<[s]>>> to The function <<strtoul>> converts the string <<*<[s]>>> to
an <<unsigned long>>. First, it breaks down the string into three parts: an <<unsigned long>>. First, it breaks down the string into three parts:

15
newlib/libc/stdlib/strtoull.c
View File

@ -8,7 +8,7 @@ INDEX
INDEX INDEX
strtoull_l strtoull_l
ANSI_SYNOPSIS SYNOPSIS
#include <stdlib.h> #include <stdlib.h>
unsigned long long strtoull(const char *restrict <[s]>, unsigned long long strtoull(const char *restrict <[s]>,
char **restrict <[ptr]>, int <[base]>); char **restrict <[ptr]>, int <[base]>);
@ -22,19 +22,6 @@ ANSI_SYNOPSIS
const char *restrict <[s]>, const char *restrict <[s]>,
char **restrict <[ptr]>, int <[base]>); char **restrict <[ptr]>, int <[base]>);
TRAD_SYNOPSIS
#include <stdlib.h>
unsigned long long strtoull(<[s]>, <[ptr]>, <[base]>)
char *<[s]>;
char **<[ptr]>;
int <[base]>;
unsigned long long _strtoull_r(<[reent]>, <[s]>, <[ptr]>, <[base]>)
char *<[reent]>;
char *<[s]>;
char **<[ptr]>;
int <[base]>;
DESCRIPTION DESCRIPTION
The function <<strtoull>> converts the string <<*<[s]>>> to The function <<strtoull>> converts the string <<*<[s]>>> to
an <<unsigned long long>>. First, it breaks down the string into three parts: an <<unsigned long long>>. First, it breaks down the string into three parts:

11
newlib/libc/stdlib/system.c
View File

@ -7,21 +7,12 @@ INDEX
INDEX INDEX
_system_r _system_r
ANSI_SYNOPSIS SYNOPSIS
#include <stdlib.h> #include <stdlib.h>
int system(char *<[s]>); int system(char *<[s]>);
int _system_r(void *<[reent]>, char *<[s]>); int _system_r(void *<[reent]>, char *<[s]>);
TRAD_SYNOPSIS
#include <stdlib.h>
int system(<[s]>)
char *<[s]>;
int _system_r(<[reent]>, <[s]>)
char *<[reent]>;
char *<[s]>;
DESCRIPTION DESCRIPTION
Use <<system>> to pass a command string <<*<[s]>>> to <</bin/sh>> on Use <<system>> to pass a command string <<*<[s]>>> to <</bin/sh>> on

2
newlib/libc/stdlib/utoa.c
View File

@ -5,7 +5,7 @@ FUNCTION
INDEX INDEX
utoa utoa
ANSI_SYNOPSIS SYNOPSIS
#include <stdlib.h> #include <stdlib.h>
char *utoa(unsigned <[value]>, char *<[str]>, int <[base]>); char *utoa(unsigned <[value]>, char *<[str]>, int <[base]>);
char *__utoa(unsigned <[value]>, char *<[str]>, int <[base]>); char *__utoa(unsigned <[value]>, char *<[str]>, int <[base]>);

35
newlib/libc/stdlib/wcsnrtombs.c
View File

@ -11,7 +11,7 @@ INDEX
INDEX INDEX
_wcsnrtombs_r _wcsnrtombs_r
ANSI_SYNOPSIS SYNOPSIS
#include <wchar.h> #include <wchar.h>
size_t wcsrtombs(char *__restrict <[dst]>, size_t wcsrtombs(char *__restrict <[dst]>,
const wchar_t **__restrict <[src]>, size_t <[len]>, const wchar_t **__restrict <[src]>, size_t <[len]>,
@ -33,39 +33,6 @@ ANSI_SYNOPSIS
const wchar_t **<[src]>, size_t <[nwc]>, const wchar_t **<[src]>, size_t <[nwc]>,
size_t <[len]>, mbstate_t *<[ps]>); size_t <[len]>, mbstate_t *<[ps]>);
TRAD_SYNOPSIS
#include <wchar.h>
size_t wcsrtombs(<[dst]>, <[src]>, <[len]>, <[ps]>)
char *__restrict <[dst]>;
const wchar_t **__restrict <[src]>;
size_t <[len]>;
mbstate_t *__restrict <[ps]>;
#include <wchar.h>
size_t _wcsrtombs_r(<[ptr]>, <[dst]>, <[src]>, <[len]>, <[ps]>)
struct _rent *<[ptr]>;
char *<[dst]>;
const wchar_t **<[src]>;
size_t <[len]>;
mbstate_t *<[ps]>;
#include <wchar.h>
size_t wcsnrtombs(<[dst]>, <[src]>, <[nwc]>, <[len]>, <[ps]>)
char *__restrict <[dst]>;
const wchar_t **__restrict <[src]>;
size_t <[nwc]>;
size_t <[len]>;
mbstate_t *__restrict <[ps]>;
#include <wchar.h>
size_t _wcsnrtombs_r(<[ptr]>, <[dst]>, <[src]>, <[nwc]>, <[len]>, <[ps]>)
struct _rent *<[ptr]>;
char *<[dst]>;
const wchar_t **<[src]>;
size_t <[nwc]>;
size_t <[len]>;
mbstate_t *<[ps]>;
DESCRIPTION DESCRIPTION
The <<wcsrtombs>> function converts a string of wide characters indirectly The <<wcsrtombs>> function converts a string of wide characters indirectly
pointed to by <[src]> to a corresponding multibyte character string stored in pointed to by <[src]> to a corresponding multibyte character string stored in

22
newlib/libc/stdlib/wcstod.c
View File

@ -26,7 +26,7 @@ INDEX
INDEX INDEX
_wcstof_r _wcstof_r
ANSI_SYNOPSIS SYNOPSIS
#include <stdlib.h> #include <stdlib.h>
double wcstod(const wchar_t *__restrict <[str]>, double wcstod(const wchar_t *__restrict <[str]>,
wchar_t **__restrict <[tail]>); wchar_t **__restrict <[tail]>);
@ -49,26 +49,6 @@ ANSI_SYNOPSIS
float _wcstof_r(void *<[reent]>, float _wcstof_r(void *<[reent]>,
const wchar_t *<[str]>, wchar_t **<[tail]>); const wchar_t *<[str]>, wchar_t **<[tail]>);
TRAD_SYNOPSIS
#include <stdlib.h>
double wcstod(<[str]>,<[tail]>)
wchar_t *__restrict <[str]>;
wchar_t **__restrict <[tail]>;
float wcstof(<[str]>,<[tail]>)
wchar_t *__restrict <[str]>;
wchar_t **__restrict <[tail]>;
double _wcstod_r(<[reent]>,<[str]>,<[tail]>)
wchar_t *<[reent]>;
wchar_t *<[str]>;
wchar_t **<[tail]>;
float _wcstof_r(<[reent]>,<[str]>,<[tail]>)
wchar_t *<[reent]>;
wchar_t *<[str]>;
wchar_t **<[tail]>;
DESCRIPTION DESCRIPTION
<<wcstod>>, <<wcstof>>, <<wcstold>> parse the wide-character string <<wcstod>>, <<wcstof>>, <<wcstold>> parse the wide-character string
<[str]>, producing a substring which can be converted to a double, <[str]>, producing a substring which can be converted to a double,

15
newlib/libc/stdlib/wcstol.c
View File

@ -11,7 +11,7 @@ INDEX
INDEX INDEX
_wcstol_r _wcstol_r
ANSI_SYNOPSIS SYNOPSIS
#include <wchar.h> #include <wchar.h>
long wcstol(const wchar_t *__restrict <[s]>, long wcstol(const wchar_t *__restrict <[s]>,
wchar_t **__restrict <[ptr]>, int <[base]>); wchar_t **__restrict <[ptr]>, int <[base]>);
@ -24,19 +24,6 @@ ANSI_SYNOPSIS
long _wcstol_r(void *<[reent]>, const wchar_t *<[s]>, long _wcstol_r(void *<[reent]>, const wchar_t *<[s]>,
wchar_t **<[ptr]>, int <[base]>); wchar_t **<[ptr]>, int <[base]>);
TRAD_SYNOPSIS
#include <stdlib.h>
long wcstol (<[s]>, <[ptr]>, <[base]>)
wchar_t *__restrict <[s]>;
wchar_t **__restrict <[ptr]>;
int <[base]>;
long _wcstol_r (<[reent]>, <[s]>, <[ptr]>, <[base]>)
struct _reent *<[reent]>;
wchar_t *<[s]>;
wchar_t **<[ptr]>;
int <[base]>;
DESCRIPTION DESCRIPTION
The function <<wcstol>> converts the wide string <<*<[s]>>> to The function <<wcstol>> converts the wide string <<*<[s]>>> to
a <<long>>. First, it breaks down the string into three parts: a <<long>>. First, it breaks down the string into three parts:

15
newlib/libc/stdlib/wcstoll.c
View File

@ -11,7 +11,7 @@ INDEX
INDEX INDEX
_wcstoll_r _wcstoll_r
ANSI_SYNOPSIS SYNOPSIS
#include <wchar.h> #include <wchar.h>
long long wcstoll(const wchar_t *__restrict <[s]>, long long wcstoll(const wchar_t *__restrict <[s]>,
wchar_t **__restrict <[ptr]>,int <[base]>); wchar_t **__restrict <[ptr]>,int <[base]>);
@ -24,19 +24,6 @@ ANSI_SYNOPSIS
long long _wcstoll_r(void *<[reent]>, const wchar_t *<[s]>, long long _wcstoll_r(void *<[reent]>, const wchar_t *<[s]>,
wchar_t **<[ptr]>, int <[base]>); wchar_t **<[ptr]>, int <[base]>);
TRAD_SYNOPSIS
#include <stdlib.h>
long long wcstoll (<[s]>, <[ptr]>, <[base]>)
const wchar_t *__restrict <[s]>;
wchar_t **__restrict <[ptr]>;
int <[base]>;
long long _wcstoll_r (<[reent]>, <[s]>, <[ptr]>, <[base]>)
wchar_t *<[reent]>;
const wchar_t *<[s]>;
wchar_t **<[ptr]>;
int <[base]>;
DESCRIPTION DESCRIPTION
The function <<wcstoll>> converts the wide string <<*<[s]>>> to The function <<wcstoll>> converts the wide string <<*<[s]>>> to
a <<long long>>. First, it breaks down the string into three parts: a <<long long>>. First, it breaks down the string into three parts:

9
newlib/libc/stdlib/wcstombs.c
View File

@ -5,17 +5,10 @@ FUNCTION
INDEX INDEX
wcstombs wcstombs
ANSI_SYNOPSIS SYNOPSIS
#include <stdlib.h> #include <stdlib.h>
size_t wcstombs(char *restrict <[s]>, const wchar_t *restrict <[pwc]>, size_t <[n]>); size_t wcstombs(char *restrict <[s]>, const wchar_t *restrict <[pwc]>, size_t <[n]>);
TRAD_SYNOPSIS
#include <stdlib.h>
size_t wcstombs(<[s]>, <[pwc]>, <[n]>)
char *<[s]>;
const wchar_t *<[pwc]>;
size_t <[n]>;
DESCRIPTION DESCRIPTION
When _MB_CAPABLE is not defined, this is a minimal ANSI-conforming When _MB_CAPABLE is not defined, this is a minimal ANSI-conforming
implementation of <<wcstombs>>. In this case, implementation of <<wcstombs>>. In this case,

15
newlib/libc/stdlib/wcstoul.c
View File

@ -11,7 +11,7 @@ INDEX
INDEX INDEX
_wcstoul_r _wcstoul_r
ANSI_SYNOPSIS SYNOPSIS
#include <wchar.h> #include <wchar.h>
unsigned long wcstoul(const wchar_t *__restrict <[s]>, unsigned long wcstoul(const wchar_t *__restrict <[s]>,
wchar_t **__restrict <[ptr]>, int <[base]>); wchar_t **__restrict <[ptr]>, int <[base]>);
@ -24,19 +24,6 @@ ANSI_SYNOPSIS
unsigned long _wcstoul_r(void *<[reent]>, const wchar_t *<[s]>, unsigned long _wcstoul_r(void *<[reent]>, const wchar_t *<[s]>,
wchar_t **<[ptr]>, int <[base]>); wchar_t **<[ptr]>, int <[base]>);
TRAD_SYNOPSIS
#include <wchar.h>
unsigned long wcstoul(<[s]>, <[ptr]>, <[base]>)
wchar_t *__restrict <[s]>;
wchar_t **__restrict <[ptr]>;
int <[base]>;
unsigned long _wcstoul_r(<[reent]>, <[s]>, <[ptr]>, <[base]>)
wchar_t *<[reent]>;
wchar_t *<[s]>;
wchar_t **<[ptr]>;
int <[base]>;
DESCRIPTION DESCRIPTION
The function <<wcstoul>> converts the wide string <<*<[s]>>> to The function <<wcstoul>> converts the wide string <<*<[s]>>> to
an <<unsigned long>>. First, it breaks down the string into three parts: an <<unsigned long>>. First, it breaks down the string into three parts:

15
newlib/libc/stdlib/wcstoull.c
View File

@ -11,7 +11,7 @@ INDEX
INDEX INDEX
_wcstoull_r _wcstoull_r
ANSI_SYNOPSIS SYNOPSIS
#include <wchar.h> #include <wchar.h>
unsigned long long wcstoull(const wchar_t *__restrict <[s]>, unsigned long long wcstoull(const wchar_t *__restrict <[s]>,
wchar_t **__restrict <[ptr]>, wchar_t **__restrict <[ptr]>,
@ -26,19 +26,6 @@ ANSI_SYNOPSIS
unsigned long long _wcstoull_r(void *<[reent]>, const wchar_t *<[s]>, unsigned long long _wcstoull_r(void *<[reent]>, const wchar_t *<[s]>,
wchar_t **<[ptr]>, int <[base]>); wchar_t **<[ptr]>, int <[base]>);
TRAD_SYNOPSIS
#include <wchar.h>
unsigned long long wcstoull(<[s]>, <[ptr]>, <[base]>)
wchar_t *__restrict <[s]>;
wchar_t **__restrict <[ptr]>;
int <[base]>;
unsigned long long _wcstoull_r(<[reent]>, <[s]>, <[ptr]>, <[base]>)
wchar_t *<[reent]>;
wchar_t *<[s]>;
wchar_t **<[ptr]>;
int <[base]>;
DESCRIPTION DESCRIPTION
The function <<wcstoull>> converts the wide string <<*<[s]>>> to The function <<wcstoull>> converts the wide string <<*<[s]>>> to
an <<unsigned long long>>. First, it breaks down the string into three parts: an <<unsigned long long>>. First, it breaks down the string into three parts:

8
newlib/libc/stdlib/wctomb.c
View File

@ -5,16 +5,10 @@ FUNCTION
INDEX INDEX
wctomb wctomb
ANSI_SYNOPSIS SYNOPSIS
#include <stdlib.h> #include <stdlib.h>
int wctomb(char *<[s]>, wchar_t <[wchar]>); int wctomb(char *<[s]>, wchar_t <[wchar]>);
TRAD_SYNOPSIS
#include <stdlib.h>
int wctomb(<[s]>, <[wchar]>)
char *<[s]>;
wchar_t <[wchar]>;
DESCRIPTION DESCRIPTION
When _MB_CAPABLE is not defined, this is a minimal ANSI-conforming When _MB_CAPABLE is not defined, this is a minimal ANSI-conforming
implementation of <<wctomb>>. The implementation of <<wctomb>>. The