stdlib: remove TRAD_SYNOPSIS
Signed-off-by: Yaakov Selkowitz <yselkowi@redhat.com>
This commit is contained in:
Yaakov Selkowitz
parent
a60026253d
commit
a38fc79ee9
|
|
@ -5,15 +5,10 @@ FUNCTION
|
|||
INDEX
|
||||
_Exit
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
void _Exit(int <[code]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
void _Exit(<[code]>)
|
||||
int <[code]>;
|
||||
|
||||
DESCRIPTION
|
||||
Use <<_Exit>> to return control from a program to the host operating
|
||||
environment. Use the argument <[code]> to pass an exit status to the
|
||||
|
|
|
|||
|
|
@ -7,19 +7,11 @@ INDEX
|
|||
INDEX
|
||||
l64a
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
long a64l(const char *<[input]>);
|
||||
char *l64a(long <[input]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
long a64l(<[input]>)
|
||||
const char *<[input]>;
|
||||
|
||||
char *l64a(<[input]>)
|
||||
long <[input]>;
|
||||
|
||||
DESCRIPTION
|
||||
Conversion is performed between long and radix-64 characters. The
|
||||
<<l64a>> routine transforms up to 32 bits of input value starting from
|
||||
|
|
|
|||
|
|
@ -15,14 +15,10 @@ FUNCTION
|
|||
INDEX
|
||||
abort
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
void abort(void);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
void abort();
|
||||
|
||||
DESCRIPTION
|
||||
Use <<abort>> to signal that your program has detected a condition it
|
||||
cannot deal with. Normally, <<abort>> ends your program's execution.
|
||||
|
|
|
|||
|
|
@ -5,15 +5,10 @@ FUNCTION
|
|||
INDEX
|
||||
abs
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
int abs(int <[i]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
int abs(<[i]>)
|
||||
int <[i]>;
|
||||
|
||||
DESCRIPTION
|
||||
<<abs>> returns
|
||||
@tex
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ FUNCTION
|
|||
INDEX
|
||||
assert
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <assert.h>
|
||||
void assert(int <[expression]>);
|
||||
|
||||
|
|
|
|||
|
|
@ -12,15 +12,10 @@ FUNCTION
|
|||
INDEX
|
||||
atexit
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
int atexit (void (*<[function]>)(void));
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
int atexit ((<[function]>)
|
||||
void (*<[function]>)();
|
||||
|
||||
DESCRIPTION
|
||||
You can use <<atexit>> to enroll functions in a list of functions that
|
||||
will be called when your program terminates normally. The argument is
|
||||
|
|
|
|||
|
|
@ -7,19 +7,11 @@ INDEX
|
|||
INDEX
|
||||
atoff
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
double atof(const char *<[s]>);
|
||||
float atoff(const char *<[s]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
double atof(<[s]>)
|
||||
char *<[s]>;
|
||||
|
||||
float atoff(<[s]>)
|
||||
char *<[s]>;
|
||||
|
||||
DESCRIPTION
|
||||
<<atof>> converts the initial portion of a string to a <<double>>.
|
||||
<<atoff>> converts the initial portion of a string to a <<float>>.
|
||||
|
|
|
|||
|
|
@ -11,30 +11,13 @@ INDEX
|
|||
INDEX
|
||||
_atol_r
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
int atoi(const char *<[s]>);
|
||||
long atol(const char *<[s]>);
|
||||
int _atoi_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
|
||||
<<atoi>> converts the initial portion of a string to an <<int>>.
|
||||
<<atol>> converts the initial portion of a string to a <<long>>.
|
||||
|
|
|
|||
|
|
@ -7,20 +7,11 @@ INDEX
|
|||
INDEX
|
||||
_atoll_r
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
long long atoll(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
|
||||
The function <<atoll>> converts the initial portion of the string
|
||||
pointed to by <<*<[str]>>> to a type <<long long>>. A call to
|
||||
|
|
|
|||
|
|
@ -11,22 +11,10 @@ INDEX
|
|||
INDEX
|
||||
_calloc_r
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
void *calloc(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
|
||||
Use <<calloc>> to request a block of memory sufficient to hold an
|
||||
|
|
|
|||
|
|
@ -5,15 +5,10 @@ FUNCTION
|
|||
INDEX
|
||||
div
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
div_t div(int <[n]>, int <[d]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
div_t div(<[n]>, <[d]>)
|
||||
int <[n]>, <[d]>;
|
||||
|
||||
DESCRIPTION
|
||||
Divide
|
||||
@tex
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ INDEX
|
|||
INDEX
|
||||
fcvtbuf
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <stdio.h>
|
||||
|
||||
char *ecvtbuf(double <[val]>, int <[chars]>, int *<[decpt]>,
|
||||
|
|
@ -16,23 +16,6 @@ ANSI_SYNOPSIS
|
|||
char *fcvtbuf(double <[val]>, int <[decimals]>, int *<[decpt]>,
|
||||
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
|
||||
<<ecvtbuf>> and <<fcvtbuf>> produce (null-terminated) strings
|
||||
of digits representating the <<double>> number <[val]>.
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ INDEX
|
|||
INDEX
|
||||
fcvtf
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
|
||||
char *ecvt(double <[val]>, int <[chars]>, int *<[decpt]>, int *<[sgn]>);
|
||||
|
|
@ -22,31 +22,6 @@ ANSI_SYNOPSIS
|
|||
char *fcvtf(float <[val]>, int <[decimals]>,
|
||||
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
|
||||
<<ecvt>> and <<fcvt>> produce (null-terminated) strings of digits
|
||||
representating the <<double>> number <[val]>.
|
||||
|
|
@ -91,24 +66,12 @@ INDEX
|
|||
INDEX
|
||||
gcvtf
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
|
||||
char *gcvt(double <[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
|
||||
<<gcvt>> writes a fully formatted number as a null-terminated
|
||||
string in the buffer <<*<[buf]>>>. <<gcvtf>> produces corresponding
|
||||
|
|
|
|||
|
|
@ -7,18 +7,11 @@ INDEX
|
|||
INDEX
|
||||
__env_unlock
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <envlock.h>
|
||||
void __env_lock (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
|
||||
The <<setenv>> family of routines call these functions when they need to
|
||||
modify the environ variable. The version of these routines supplied in the
|
||||
|
|
|
|||
|
|
@ -12,15 +12,10 @@ FUNCTION
|
|||
INDEX
|
||||
exit
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
void exit(int <[code]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
void exit(<[code]>)
|
||||
int <[code]>;
|
||||
|
||||
DESCRIPTION
|
||||
Use <<exit>> to return control from a program to the host operating
|
||||
environment. Use the argument <[code]> to pass an exit status to the
|
||||
|
|
|
|||
|
|
@ -7,15 +7,10 @@ INDEX
|
|||
INDEX
|
||||
environ
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
char *getenv(const char *<[name]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
char *getenv(<[name]>)
|
||||
char *<[name]>;
|
||||
|
||||
DESCRIPTION
|
||||
<<getenv>> searches the list of environment variable names and values
|
||||
(using the global pointer ``<<char **environ>>'') for a variable whose
|
||||
|
|
|
|||
|
|
@ -7,16 +7,10 @@ INDEX
|
|||
INDEX
|
||||
environ
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
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
|
||||
<<_getenv_r>> searches the list of environment variable names and values
|
||||
(using the global pointer ``<<char **environ>>'') for a variable whose
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ FUNCTION
|
|||
INDEX
|
||||
itoa
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
char *itoa(int <[value]>, char *<[str]>, int <[base]>);
|
||||
char *__itoa(int <[value]>, char *<[str]>, int <[base]>);
|
||||
|
|
|
|||
|
|
@ -5,15 +5,10 @@ FUNCTION
|
|||
INDEX
|
||||
labs
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
long labs(long <[i]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
long labs(<[i]>)
|
||||
long <[i]>;
|
||||
|
||||
DESCRIPTION
|
||||
<<labs>> returns
|
||||
@tex
|
||||
|
|
|
|||
|
|
@ -5,15 +5,10 @@ FUNCTION
|
|||
INDEX
|
||||
ldiv
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
ldiv_t ldiv(long <[n]>, long <[d]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
ldiv_t ldiv(<[n]>, <[d]>)
|
||||
long <[n]>, <[d]>;
|
||||
|
||||
DESCRIPTION
|
||||
Divide
|
||||
@tex
|
||||
|
|
|
|||
|
|
@ -5,15 +5,10 @@ FUNCTION
|
|||
INDEX
|
||||
llabs
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
long long llabs(long long <[j]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
long long llabs(<[j]>)
|
||||
long long <[j]>;
|
||||
|
||||
DESCRIPTION
|
||||
The <<llabs>> function computes the absolute value of the long long integer
|
||||
argument <[j]> (also called the magnitude of <[j]>).
|
||||
|
|
|
|||
|
|
@ -5,15 +5,10 @@ FUNCTION
|
|||
INDEX
|
||||
lldiv
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
lldiv_t lldiv(long long <[n]>, long long <[d]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
lldiv_t lldiv(<[n]>, <[d]>)
|
||||
long long <[n]>, <[d]>;
|
||||
|
||||
DESCRIPTION
|
||||
Divide
|
||||
@tex
|
||||
|
|
|
|||
|
|
@ -43,7 +43,7 @@ INDEX
|
|||
INDEX
|
||||
_malloc_usable_size_r
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
void *malloc(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]>);
|
||||
|
||||
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
|
||||
These functions manage a pool of system memory.
|
||||
|
||||
|
|
|
|||
|
|
@ -5,16 +5,10 @@ FUNCTION
|
|||
INDEX
|
||||
mblen
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
int mblen(const char *<[s]>, size_t <[n]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
int mblen(<[s]>, <[n]>)
|
||||
const char *<[s]>;
|
||||
size_t <[n]>;
|
||||
|
||||
DESCRIPTION
|
||||
When _MB_CAPABLE is not defined, this is a minimal ANSI-conforming
|
||||
implementation of <<mblen>>. In this case, the
|
||||
|
|
|
|||
|
|
@ -5,18 +5,10 @@ FUNCTION
|
|||
INDEX
|
||||
_mblen_r
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
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
|
||||
When _MB_CAPABLE is not defined, this is a minimal ANSI-conforming
|
||||
implementation of <<_mblen_r>>. In this case, the
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ INDEX
|
|||
INDEX
|
||||
_mbsnrtowcs_r
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <wchar.h>
|
||||
size_t mbsrtowcs(wchar_t *__restrict <[dst]>,
|
||||
const char **__restrict <[src]>,
|
||||
|
|
@ -33,39 +33,6 @@ ANSI_SYNOPSIS
|
|||
const char **<[src]>, size_t <[nms]>,
|
||||
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
|
||||
The <<mbsrtowcs>> function converts a sequence of multibyte characters
|
||||
pointed to indirectly by <[src]> into a sequence of corresponding wide
|
||||
|
|
|
|||
|
|
@ -5,17 +5,10 @@ FUNCTION
|
|||
INDEX
|
||||
mbstowcs
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
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
|
||||
When _MB_CAPABLE is not defined, this is a minimal ANSI-conforming
|
||||
implementation of <<mbstowcs>>. In this case, the
|
||||
|
|
|
|||
|
|
@ -5,17 +5,10 @@ FUNCTION
|
|||
INDEX
|
||||
mbtowc
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
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
|
||||
When _MB_CAPABLE is not defined, this is a minimal ANSI-conforming
|
||||
implementation of <<mbtowc>>. In this case,
|
||||
|
|
|
|||
|
|
@ -8,18 +8,11 @@ INDEX
|
|||
INDEX
|
||||
__malloc_unlock
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <malloc.h>
|
||||
void __malloc_lock (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
|
||||
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
|
||||
|
|
|
|||
|
|
@ -25,7 +25,7 @@ INDEX
|
|||
INDEX
|
||||
_mallopt_r
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <malloc.h>
|
||||
struct mallinfo mallinfo(void);
|
||||
void malloc_stats(void);
|
||||
|
|
@ -35,27 +35,6 @@ ANSI_SYNOPSIS
|
|||
void _malloc_stats_r(void *<[reent]>);
|
||||
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
|
||||
<<mallinfo>> returns a structure describing the current state of
|
||||
memory allocation. The structure is defined in malloc.h. The
|
||||
|
|
|
|||
|
|
@ -14,16 +14,10 @@ FUNCTION
|
|||
INDEX
|
||||
on_exit
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
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
|
||||
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
|
||||
|
|
|
|||
|
|
@ -9,23 +9,12 @@ INDEX
|
|||
INDEX
|
||||
rand_r
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
int rand(void);
|
||||
void srand(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
|
||||
<<rand>> returns a different integer each time it is called; each
|
||||
integer is chosen by an algorithm designed to be unpredictable, so
|
||||
|
|
|
|||
|
|
@ -36,7 +36,7 @@ INDEX
|
|||
INDEX
|
||||
lcong48
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
double drand48(void);
|
||||
double erand48(unsigned short <[xseed]>[3]);
|
||||
|
|
@ -48,32 +48,6 @@ ANSI_SYNOPSIS
|
|||
unsigned short *seed48(unsigned short <[xseed]>[3]);
|
||||
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
|
||||
The <<rand48>> family of functions generates pseudo-random numbers
|
||||
using a linear congruential algorithm working on integers 48 bits in size.
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ INDEX
|
|||
INDEX
|
||||
srandom
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#define _XOPEN_SOURCE 500
|
||||
#include <stdlib.h>
|
||||
long int random(void);
|
||||
|
|
|
|||
|
|
@ -5,15 +5,10 @@ FUNCTION
|
|||
INDEX
|
||||
rpmatch
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
int rpmatch(const char *<[response]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
int rpmatch(<[response]>)
|
||||
const char *<[response]>;
|
||||
|
||||
DESCRIPTION
|
||||
The <<rpmatch>> function determines whether <[response]> is an affirmative
|
||||
or negative response to a question according to the current locale.
|
||||
|
|
|
|||
|
|
@ -23,7 +23,7 @@ INDEX
|
|||
INDEX
|
||||
_strtod_r
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
double strtod(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]>,
|
||||
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
|
||||
<<strtod>>, <<strtof>>, <<strtold>> parse the character string
|
||||
<[str]>, producing a substring which can be converted to a double,
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ INDEX
|
|||
INDEX
|
||||
_strtol_r
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
long strtol(const char *restrict <[s]>, char **restrict <[ptr]>,
|
||||
int <[base]>);
|
||||
|
|
@ -23,19 +23,6 @@ ANSI_SYNOPSIS
|
|||
long _strtol_r(void *<[reent]>, const char *restrict <[s]>,
|
||||
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
|
||||
The function <<strtol>> converts the string <<*<[s]>>> to
|
||||
a <<long>>. First, it breaks down the string into three parts:
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ INDEX
|
|||
INDEX
|
||||
_strtoll_r
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
long long strtoll(const char *restrict <[s]>, char **restrict <[ptr]>,
|
||||
int <[base]>);
|
||||
|
|
@ -25,19 +25,6 @@ ANSI_SYNOPSIS
|
|||
const char *restrict <[s]>,
|
||||
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
|
||||
The function <<strtoll>> converts the string <<*<[s]>>> to
|
||||
a <<long long>>. First, it breaks down the string into three parts:
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ INDEX
|
|||
INDEX
|
||||
_strtoul_r
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
unsigned long strtoul(const char *restrict <[s]>,
|
||||
char **restrict <[ptr]>, int <[base]>);
|
||||
|
|
@ -24,19 +24,6 @@ ANSI_SYNOPSIS
|
|||
unsigned long _strtoul_r(void *<[reent]>, const char *restrict <[s]>,
|
||||
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
|
||||
The function <<strtoul>> converts the string <<*<[s]>>> to
|
||||
an <<unsigned long>>. First, it breaks down the string into three parts:
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@ INDEX
|
|||
INDEX
|
||||
strtoull_l
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
unsigned long long strtoull(const char *restrict <[s]>,
|
||||
char **restrict <[ptr]>, int <[base]>);
|
||||
|
|
@ -22,19 +22,6 @@ ANSI_SYNOPSIS
|
|||
const char *restrict <[s]>,
|
||||
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
|
||||
The function <<strtoull>> converts the string <<*<[s]>>> to
|
||||
an <<unsigned long long>>. First, it breaks down the string into three parts:
|
||||
|
|
|
|||
|
|
@ -7,21 +7,12 @@ INDEX
|
|||
INDEX
|
||||
_system_r
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
int system(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
|
||||
|
||||
Use <<system>> to pass a command string <<*<[s]>>> to <</bin/sh>> on
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ FUNCTION
|
|||
INDEX
|
||||
utoa
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
char *utoa(unsigned <[value]>, char *<[str]>, int <[base]>);
|
||||
char *__utoa(unsigned <[value]>, char *<[str]>, int <[base]>);
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ INDEX
|
|||
INDEX
|
||||
_wcsnrtombs_r
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <wchar.h>
|
||||
size_t wcsrtombs(char *__restrict <[dst]>,
|
||||
const wchar_t **__restrict <[src]>, size_t <[len]>,
|
||||
|
|
@ -33,39 +33,6 @@ ANSI_SYNOPSIS
|
|||
const wchar_t **<[src]>, size_t <[nwc]>,
|
||||
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
|
||||
The <<wcsrtombs>> function converts a string of wide characters indirectly
|
||||
pointed to by <[src]> to a corresponding multibyte character string stored in
|
||||
|
|
|
|||
|
|
@ -26,7 +26,7 @@ INDEX
|
|||
INDEX
|
||||
_wcstof_r
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
double wcstod(const wchar_t *__restrict <[str]>,
|
||||
wchar_t **__restrict <[tail]>);
|
||||
|
|
@ -49,26 +49,6 @@ ANSI_SYNOPSIS
|
|||
float _wcstof_r(void *<[reent]>,
|
||||
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
|
||||
<<wcstod>>, <<wcstof>>, <<wcstold>> parse the wide-character string
|
||||
<[str]>, producing a substring which can be converted to a double,
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ INDEX
|
|||
INDEX
|
||||
_wcstol_r
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <wchar.h>
|
||||
long wcstol(const wchar_t *__restrict <[s]>,
|
||||
wchar_t **__restrict <[ptr]>, int <[base]>);
|
||||
|
|
@ -24,19 +24,6 @@ ANSI_SYNOPSIS
|
|||
long _wcstol_r(void *<[reent]>, const wchar_t *<[s]>,
|
||||
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
|
||||
The function <<wcstol>> converts the wide string <<*<[s]>>> to
|
||||
a <<long>>. First, it breaks down the string into three parts:
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ INDEX
|
|||
INDEX
|
||||
_wcstoll_r
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <wchar.h>
|
||||
long long wcstoll(const wchar_t *__restrict <[s]>,
|
||||
wchar_t **__restrict <[ptr]>,int <[base]>);
|
||||
|
|
@ -24,19 +24,6 @@ ANSI_SYNOPSIS
|
|||
long long _wcstoll_r(void *<[reent]>, const wchar_t *<[s]>,
|
||||
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
|
||||
The function <<wcstoll>> converts the wide string <<*<[s]>>> to
|
||||
a <<long long>>. First, it breaks down the string into three parts:
|
||||
|
|
|
|||
|
|
@ -5,17 +5,10 @@ FUNCTION
|
|||
INDEX
|
||||
wcstombs
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
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
|
||||
When _MB_CAPABLE is not defined, this is a minimal ANSI-conforming
|
||||
implementation of <<wcstombs>>. In this case,
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ INDEX
|
|||
INDEX
|
||||
_wcstoul_r
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <wchar.h>
|
||||
unsigned long wcstoul(const wchar_t *__restrict <[s]>,
|
||||
wchar_t **__restrict <[ptr]>, int <[base]>);
|
||||
|
|
@ -24,19 +24,6 @@ ANSI_SYNOPSIS
|
|||
unsigned long _wcstoul_r(void *<[reent]>, const wchar_t *<[s]>,
|
||||
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
|
||||
The function <<wcstoul>> converts the wide string <<*<[s]>>> to
|
||||
an <<unsigned long>>. First, it breaks down the string into three parts:
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ INDEX
|
|||
INDEX
|
||||
_wcstoull_r
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <wchar.h>
|
||||
unsigned long long wcstoull(const wchar_t *__restrict <[s]>,
|
||||
wchar_t **__restrict <[ptr]>,
|
||||
|
|
@ -26,19 +26,6 @@ ANSI_SYNOPSIS
|
|||
unsigned long long _wcstoull_r(void *<[reent]>, const wchar_t *<[s]>,
|
||||
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
|
||||
The function <<wcstoull>> converts the wide string <<*<[s]>>> to
|
||||
an <<unsigned long long>>. First, it breaks down the string into three parts:
|
||||
|
|
|
|||
|
|
@ -5,16 +5,10 @@ FUNCTION
|
|||
INDEX
|
||||
wctomb
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
int wctomb(char *<[s]>, wchar_t <[wchar]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <stdlib.h>
|
||||
int wctomb(<[s]>, <[wchar]>)
|
||||
char *<[s]>;
|
||||
wchar_t <[wchar]>;
|
||||
|
||||
DESCRIPTION
|
||||
When _MB_CAPABLE is not defined, this is a minimal ANSI-conforming
|
||||
implementation of <<wctomb>>. The
|
||||
|
|
|
|||
Loading…
Reference in New Issue