string: remove TRAD_SYNOPSIS
Signed-off-by: Yaakov Selkowitz <yselkowi@redhat.com>
This commit is contained in:
Yaakov Selkowitz
parent
a38fc79ee9
commit
352c8f2f0d
|
|
@ -5,17 +5,10 @@ FUNCTION
|
|||
INDEX
|
||||
bcmp
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <strings.h>
|
||||
int bcmp(const void *<[s1]>, const void *<[s2]>, size_t <[n]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <strings.h>
|
||||
int bcmp(<[s1]>, <[s2]>, <[n]>)
|
||||
const void *<[s1]>;
|
||||
const void *<[s2]>;
|
||||
size_t <[n]>;
|
||||
|
||||
DESCRIPTION
|
||||
This function compares not more than <[n]> bytes of the
|
||||
object pointed to by <[s1]> with the object pointed to by <[s2]>.
|
||||
|
|
|
|||
|
|
@ -2,16 +2,10 @@
|
|||
FUNCTION
|
||||
<<bcopy>>---copy memory regions
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <strings.h>
|
||||
void bcopy(const void *<[in]>, void *<[out]>, size_t <[n]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
void bcopy(<[in]>, <[out]>, <[n]>
|
||||
const void *<[in]>;
|
||||
void *<[out]>;
|
||||
size_t <[n]>;
|
||||
|
||||
DESCRIPTION
|
||||
This function copies <[n]> bytes from the memory region
|
||||
pointed to by <[in]> to the memory region pointed to by
|
||||
|
|
|
|||
|
|
@ -5,16 +5,10 @@ FUNCTION
|
|||
INDEX
|
||||
bzero
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <strings.h>
|
||||
void bzero(void *<[b]>, size_t <[length]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <strings.h>
|
||||
void bzero(<[b]>, <[length]>)
|
||||
void *<[b]>;
|
||||
size_t <[length]>;
|
||||
|
||||
DESCRIPTION
|
||||
<<bzero>> initializes <[length]> bytes of memory, starting at address
|
||||
<[b]>, to zero.
|
||||
|
|
|
|||
|
|
@ -5,16 +5,10 @@ FUNCTION
|
|||
INDEX
|
||||
index
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <strings.h>
|
||||
char * index(const char *<[string]>, int <[c]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <strings.h>
|
||||
char * index(<[string]>, <[c]>);
|
||||
char *<[string]>;
|
||||
int *<[c]>;
|
||||
|
||||
DESCRIPTION
|
||||
This function finds the first occurence of <[c]> (converted to
|
||||
a char) in the string pointed to by <[string]> (including the
|
||||
|
|
|
|||
|
|
@ -2,18 +2,11 @@
|
|||
FUNCTION
|
||||
<<memccpy>>---copy memory regions with end-token check
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <string.h>
|
||||
void* memccpy(void *restrict <[out]>, const void *restrict <[in]>,
|
||||
int <[endchar]>, size_t <[n]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
void *memccpy(<[out]>, <[in]>, <[endchar]>, <[n]>
|
||||
void *<[out]>;
|
||||
void *<[in]>;
|
||||
int <[endchar]>;
|
||||
size_t <[n]>;
|
||||
|
||||
DESCRIPTION
|
||||
This function copies up to <[n]> bytes from the memory region
|
||||
pointed to by <[in]> to the memory region pointed to by
|
||||
|
|
|
|||
|
|
@ -5,17 +5,10 @@ FUNCTION
|
|||
INDEX
|
||||
memchr
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <string.h>
|
||||
void *memchr(const void *<[src]>, int <[c]>, size_t <[length]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <string.h>
|
||||
void *memchr(<[src]>, <[c]>, <[length]>)
|
||||
void *<[src]>;
|
||||
void *<[c]>;
|
||||
size_t <[length]>;
|
||||
|
||||
DESCRIPTION
|
||||
This function searches memory starting at <<*<[src]>>> for the
|
||||
character <[c]>. The search only ends with the first
|
||||
|
|
|
|||
|
|
@ -5,17 +5,10 @@ FUNCTION
|
|||
INDEX
|
||||
memcmp
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <string.h>
|
||||
int memcmp(const void *<[s1]>, const void *<[s2]>, size_t <[n]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <string.h>
|
||||
int memcmp(<[s1]>, <[s2]>, <[n]>)
|
||||
void *<[s1]>;
|
||||
void *<[s2]>;
|
||||
size_t <[n]>;
|
||||
|
||||
DESCRIPTION
|
||||
This function compares not more than <[n]> characters of the
|
||||
object pointed to by <[s1]> with the object pointed to by <[s2]>.
|
||||
|
|
|
|||
|
|
@ -2,18 +2,11 @@
|
|||
FUNCTION
|
||||
<<memcpy>>---copy memory regions
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <string.h>
|
||||
void* memcpy(void *restrict <[out]>, const void *restrict <[in]>,
|
||||
size_t <[n]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <string.h>
|
||||
void *memcpy(<[out]>, <[in]>, <[n]>
|
||||
void *<[out]>;
|
||||
void *<[in]>;
|
||||
size_t <[n]>;
|
||||
|
||||
DESCRIPTION
|
||||
This function copies <[n]> bytes from the memory region
|
||||
pointed to by <[in]> to the memory region pointed to by
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ FUNCTION
|
|||
INDEX
|
||||
memmem
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <string.h>
|
||||
char *memmem(const void *<[s1]>, size_t <[l1]>, const void *<[s2]>,
|
||||
size_t <[l2]>);
|
||||
|
|
|
|||
|
|
@ -5,17 +5,10 @@ FUNCTION
|
|||
INDEX
|
||||
memmove
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <string.h>
|
||||
void *memmove(void *<[dst]>, const void *<[src]>, size_t <[length]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <string.h>
|
||||
void *memmove(<[dst]>, <[src]>, <[length]>)
|
||||
void *<[dst]>;
|
||||
void *<[src]>;
|
||||
size_t <[length]>;
|
||||
|
||||
DESCRIPTION
|
||||
This function moves <[length]> characters from the block of
|
||||
memory starting at <<*<[src]>>> to the memory starting at
|
||||
|
|
|
|||
|
|
@ -2,16 +2,10 @@
|
|||
FUNCTION
|
||||
<<mempcpy>>---copy memory regions and return end pointer
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <string.h>
|
||||
void* mempcpy(void *<[out]>, const void *<[in]>, size_t <[n]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
void *mempcpy(<[out]>, <[in]>, <[n]>
|
||||
void *<[out]>;
|
||||
void *<[in]>;
|
||||
size_t <[n]>;
|
||||
|
||||
DESCRIPTION
|
||||
This function copies <[n]> bytes from the memory region
|
||||
pointed to by <[in]> to the memory region pointed to by
|
||||
|
|
|
|||
|
|
@ -5,17 +5,10 @@ FUNCTION
|
|||
INDEX
|
||||
memrchr
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <string.h>
|
||||
void *memrchr(const void *<[src]>, int <[c]>, size_t <[length]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <string.h>
|
||||
void *memrchr(<[src]>, <[c]>, <[length]>)
|
||||
void *<[src]>;
|
||||
void *<[c]>;
|
||||
size_t <[length]>;
|
||||
|
||||
DESCRIPTION
|
||||
This function searches memory starting at <[length]> bytes
|
||||
beyond <<*<[src]>>> backwards for the character <[c]>.
|
||||
|
|
|
|||
|
|
@ -5,17 +5,10 @@ FUNCTION
|
|||
INDEX
|
||||
memset
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <string.h>
|
||||
void *memset(void *<[dst]>, int <[c]>, size_t <[length]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <string.h>
|
||||
void *memset(<[dst]>, <[c]>, <[length]>)
|
||||
void *<[dst]>;
|
||||
int <[c]>;
|
||||
size_t <[length]>;
|
||||
|
||||
DESCRIPTION
|
||||
This function converts the argument <[c]> into an unsigned
|
||||
char and fills the first <[length]> characters of the array
|
||||
|
|
|
|||
|
|
@ -5,16 +5,10 @@ FUNCTION
|
|||
INDEX
|
||||
rawmemchr
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <string.h>
|
||||
void *rawmemchr(const void *<[src]>, int <[c]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <string.h>
|
||||
void *rawmemchr(<[src]>, <[c]>)
|
||||
void *<[src]>;
|
||||
void *<[c]>;
|
||||
|
||||
DESCRIPTION
|
||||
This function searches memory starting at <<*<[src]>>> for the
|
||||
character <[c]>. The search only ends with the first occurrence
|
||||
|
|
|
|||
|
|
@ -5,16 +5,10 @@ FUNCTION
|
|||
INDEX
|
||||
rindex
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <string.h>
|
||||
char * rindex(const char *<[string]>, int <[c]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <strings.h>
|
||||
char * rindex(<[string]>, <[c]>);
|
||||
char *<[string]>;
|
||||
int *<[c]>;
|
||||
|
||||
DESCRIPTION
|
||||
This function finds the last occurence of <[c]> (converted to
|
||||
a char) in the string pointed to by <[string]> (including the
|
||||
|
|
|
|||
|
|
@ -5,16 +5,10 @@ FUNCTION
|
|||
INDEX
|
||||
stpcpy
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <string.h>
|
||||
char *stpcpy(char *restrict <[dst]>, const char *restrict <[src]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <string.h>
|
||||
char *stpcpy(<[dst]>, <[src]>)
|
||||
char *<[dst]>;
|
||||
char *<[src]>;
|
||||
|
||||
DESCRIPTION
|
||||
<<stpcpy>> copies the string pointed to by <[src]>
|
||||
(including the terminating null character) to the array
|
||||
|
|
|
|||
|
|
@ -5,18 +5,11 @@ FUNCTION
|
|||
INDEX
|
||||
stpncpy
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <string.h>
|
||||
char *stpncpy(char *restrict <[dst]>, const char *restrict <[src]>,
|
||||
size_t <[length]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <string.h>
|
||||
char *stpncpy(<[dst]>, <[src]>, <[length]>)
|
||||
char *<[dst]>;
|
||||
char *<[src]>;
|
||||
size_t <[length]>;
|
||||
|
||||
DESCRIPTION
|
||||
<<stpncpy>> copies not more than <[length]> characters from the
|
||||
the string pointed to by <[src]> (including the terminating
|
||||
|
|
|
|||
|
|
@ -5,16 +5,10 @@ FUNCTION
|
|||
INDEX
|
||||
strcasecmp
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <strings.h>
|
||||
int strcasecmp(const char *<[a]>, const char *<[b]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <strings.h>
|
||||
int strcasecmp(<[a]>, <[b]>)
|
||||
char *<[a]>;
|
||||
char *<[b]>;
|
||||
|
||||
DESCRIPTION
|
||||
<<strcasecmp>> compares the string at <[a]> to
|
||||
the string at <[b]> in a case-insensitive manner.
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ FUNCTION
|
|||
INDEX
|
||||
strcasecmp_l
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <strings.h>
|
||||
int strcasecmp_l(const char *<[a]>, const char *<[b]>,
|
||||
locale_t <[locale]>);
|
||||
|
|
|
|||
|
|
@ -5,16 +5,10 @@ FUNCTION
|
|||
INDEX
|
||||
strcasestr
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <string.h>
|
||||
char *strcasestr(const char *<[s]>, const char *<[find]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <string.h>
|
||||
int strcasecmp(<[s]>, <[find]>)
|
||||
char *<[s]>;
|
||||
char *<[find]>;
|
||||
|
||||
DESCRIPTION
|
||||
<<strcasestr>> searchs the string <[s]> for
|
||||
the first occurrence of the sequence <[find]>. <<strcasestr>>
|
||||
|
|
|
|||
|
|
@ -5,16 +5,10 @@ FUNCTION
|
|||
INDEX
|
||||
strcat
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <string.h>
|
||||
char *strcat(char *restrict <[dst]>, const char *restrict <[src]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <string.h>
|
||||
char *strcat(<[dst]>, <[src]>)
|
||||
char *<[dst]>;
|
||||
char *<[src]>;
|
||||
|
||||
DESCRIPTION
|
||||
<<strcat>> appends a copy of the string pointed to by <[src]>
|
||||
(including the terminating null character) to the end of the
|
||||
|
|
|
|||
|
|
@ -5,16 +5,10 @@ FUNCTION
|
|||
INDEX
|
||||
strchr
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <string.h>
|
||||
char * strchr(const char *<[string]>, int <[c]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <string.h>
|
||||
char * strchr(<[string]>, <[c]>);
|
||||
const char *<[string]>;
|
||||
int <[c]>;
|
||||
|
||||
DESCRIPTION
|
||||
This function finds the first occurence of <[c]> (converted to
|
||||
a char) in the string pointed to by <[string]> (including the
|
||||
|
|
|
|||
|
|
@ -5,16 +5,10 @@ FUNCTION
|
|||
INDEX
|
||||
strchrnul
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <string.h>
|
||||
char * strchrnul(const char *<[string]>, int <[c]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <string.h>
|
||||
char * strchrnul(<[string]>, <[c]>);
|
||||
const char *<[string]>;
|
||||
int <[c]>;
|
||||
|
||||
DESCRIPTION
|
||||
This function finds the first occurence of <[c]> (converted to
|
||||
a char) in the string pointed to by <[string]> (including the
|
||||
|
|
|
|||
|
|
@ -5,16 +5,10 @@ FUNCTION
|
|||
INDEX
|
||||
strcmp
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <string.h>
|
||||
int strcmp(const char *<[a]>, const char *<[b]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <string.h>
|
||||
int strcmp(<[a]>, <[b]>)
|
||||
char *<[a]>;
|
||||
char *<[b]>;
|
||||
|
||||
DESCRIPTION
|
||||
<<strcmp>> compares the string at <[a]> to
|
||||
the string at <[b]>.
|
||||
|
|
|
|||
|
|
@ -5,16 +5,10 @@ FUNCTION
|
|||
INDEX
|
||||
strcoll
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <string.h>
|
||||
int strcoll(const char *<[stra]>, const char * <[strb]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <string.h>
|
||||
int strcoll(<[stra]>, <[strb]>)
|
||||
char *<[stra]>;
|
||||
char *<[strb]>;
|
||||
|
||||
DESCRIPTION
|
||||
<<strcoll>> compares the string pointed to by <[stra]> to
|
||||
the string pointed to by <[strb]>, using an interpretation
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ FUNCTION
|
|||
INDEX
|
||||
strcoll_l
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <string.h>
|
||||
int strcoll_l(const char *<[stra]>, const char * <[strb]>,
|
||||
locale_t <[locale]>);
|
||||
|
|
|
|||
|
|
@ -5,16 +5,10 @@ FUNCTION
|
|||
INDEX
|
||||
strcpy
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <string.h>
|
||||
char *strcpy(char *<[dst]>, const char *<[src]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <string.h>
|
||||
char *strcpy(<[dst]>, <[src]>)
|
||||
char *<[dst]>;
|
||||
char *<[src]>;
|
||||
|
||||
DESCRIPTION
|
||||
<<strcpy>> copies the string pointed to by <[src]>
|
||||
(including the terminating null character) to the array
|
||||
|
|
|
|||
|
|
@ -5,14 +5,9 @@ FUNCTION
|
|||
INDEX
|
||||
strcspn
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
size_t strcspn(const char *<[s1]>, const char *<[s2]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
size_t strcspn(<[s1]>, <[s2]>)
|
||||
char *<[s1]>;
|
||||
char *<[s2]>;
|
||||
|
||||
DESCRIPTION
|
||||
This function computes the length of the initial part of
|
||||
the string pointed to by <[s1]> which consists entirely of
|
||||
|
|
|
|||
|
|
@ -15,18 +15,13 @@ INDEX
|
|||
INDEX
|
||||
strerror_l
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <string.h>
|
||||
char *strerror(int <[errnum]>);
|
||||
char *strerror_l(int <[errnum]>, locale_t <[locale]>);
|
||||
char *_strerror_r(struct _reent <[ptr]>, int <[errnum]>,
|
||||
int <[internal]>, int *<[error]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <string.h>
|
||||
char *strerror(<[errnum]>)
|
||||
int <[errnum]>;
|
||||
|
||||
DESCRIPTION
|
||||
<<strerror>> converts the error number <[errnum]> into a
|
||||
string. The value of <[errnum]> is usually a copy of <<errno>>.
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@ FUNCTION
|
|||
INDEX
|
||||
strerror_r
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <string.h>
|
||||
#ifdef _GNU_SOURCE
|
||||
char *strerror_r(int <[errnum]>, char *<[buffer]>, size_t <[n]>);
|
||||
|
|
@ -14,13 +14,6 @@ ANSI_SYNOPSIS
|
|||
int strerror_r(int <[errnum]>, char *<[buffer]>, size_t <[n]>);
|
||||
#endif
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <string.h>
|
||||
char *strerror_r(<[errnum]>, <[buffer]>, <[n]>)
|
||||
int <[errnum]>;
|
||||
char *<[buffer]>;
|
||||
size_t <[n]>;
|
||||
|
||||
DESCRIPTION
|
||||
<<strerror_r>> converts the error number <[errnum]> into a
|
||||
string and copies the result into the supplied <[buffer]> for
|
||||
|
|
|
|||
|
|
@ -5,15 +5,10 @@ FUNCTION
|
|||
INDEX
|
||||
strlen
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <string.h>
|
||||
size_t strlen(const char *<[str]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <string.h>
|
||||
size_t strlen(<[str]>)
|
||||
char *<[src]>;
|
||||
|
||||
DESCRIPTION
|
||||
The <<strlen>> function works out the length of the string
|
||||
starting at <<*<[str]>>> by counting chararacters until it
|
||||
|
|
|
|||
|
|
@ -5,15 +5,10 @@ FUNCTION
|
|||
INDEX
|
||||
strlwr
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <string.h>
|
||||
char *strlwr(char *<[a]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <string.h>
|
||||
char *strlwr(<[a]>)
|
||||
char *<[a]>;
|
||||
|
||||
DESCRIPTION
|
||||
<<strlwr>> converts each character in the string at <[a]> to
|
||||
lowercase.
|
||||
|
|
|
|||
|
|
@ -5,17 +5,10 @@ FUNCTION
|
|||
INDEX
|
||||
strncasecmp
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <strings.h>
|
||||
int strncasecmp(const char *<[a]>, const char * <[b]>, size_t <[length]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <strings.h>
|
||||
int strncasecmp(<[a]>, <[b]>, <[length]>)
|
||||
char *<[a]>;
|
||||
char *<[b]>;
|
||||
size_t <[length]>
|
||||
|
||||
DESCRIPTION
|
||||
<<strncasecmp>> compares up to <[length]> characters
|
||||
from the string at <[a]> to the string at <[b]> in a
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ FUNCTION
|
|||
INDEX
|
||||
strncasecmp_l
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <strings.h>
|
||||
int strncasecmp_l(const char *<[a]>, const char * <[b]>,
|
||||
size_t <[length]>, locale_t <[locale]>);
|
||||
|
|
|
|||
|
|
@ -5,18 +5,11 @@ FUNCTION
|
|||
INDEX
|
||||
strncat
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <string.h>
|
||||
char *strncat(char *restrict <[dst]>, const char *restrict <[src]>,
|
||||
size_t <[length]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <string.h>
|
||||
char *strncat(<[dst]>, <[src]>, <[length]>)
|
||||
char *<[dst]>;
|
||||
char *<[src]>;
|
||||
size_t <[length]>;
|
||||
|
||||
DESCRIPTION
|
||||
<<strncat>> appends not more than <[length]> characters from
|
||||
the string pointed to by <[src]> (including the terminating
|
||||
|
|
|
|||
|
|
@ -5,17 +5,10 @@ FUNCTION
|
|||
INDEX
|
||||
strncmp
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <string.h>
|
||||
int strncmp(const char *<[a]>, const char * <[b]>, size_t <[length]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <string.h>
|
||||
int strncmp(<[a]>, <[b]>, <[length]>)
|
||||
char *<[a]>;
|
||||
char *<[b]>;
|
||||
size_t <[length]>
|
||||
|
||||
DESCRIPTION
|
||||
<<strncmp>> compares up to <[length]> characters
|
||||
from the string at <[a]> to the string at <[b]>.
|
||||
|
|
|
|||
|
|
@ -5,18 +5,11 @@ FUNCTION
|
|||
INDEX
|
||||
strncpy
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <string.h>
|
||||
char *strncpy(char *restrict <[dst]>, const char *restrict <[src]>,
|
||||
size_t <[length]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <string.h>
|
||||
char *strncpy(<[dst]>, <[src]>, <[length]>)
|
||||
char *<[dst]>;
|
||||
char *<[src]>;
|
||||
size_t <[length]>;
|
||||
|
||||
DESCRIPTION
|
||||
<<strncpy>> copies not more than <[length]> characters from the
|
||||
the string pointed to by <[src]> (including the terminating
|
||||
|
|
|
|||
|
|
@ -5,16 +5,10 @@ FUNCTION
|
|||
INDEX
|
||||
strnlen
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <string.h>
|
||||
size_t strnlen(const char *<[str]>, size_t <[n]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <string.h>
|
||||
size_t strnlen(<[str]>, <[n]>)
|
||||
char *<[src]>;
|
||||
size_t <[n]>;
|
||||
|
||||
DESCRIPTION
|
||||
The <<strnlen>> function works out the length of the string
|
||||
starting at <<*<[str]>>> by counting chararacters until it
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ FUNCTION
|
|||
INDEX
|
||||
strnstr
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <string.h>
|
||||
size_t strnstr(const char *<[s1]>, const char *<[s2]>, size_t <[n]>);
|
||||
|
||||
|
|
|
|||
|
|
@ -5,16 +5,10 @@ FUNCTION
|
|||
INDEX
|
||||
strpbrk
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <string.h>
|
||||
char *strpbrk(const char *<[s1]>, const char *<[s2]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <string.h>
|
||||
char *strpbrk(<[s1]>, <[s2]>)
|
||||
char *<[s1]>;
|
||||
char *<[s2]>;
|
||||
|
||||
DESCRIPTION
|
||||
This function locates the first occurence in the string
|
||||
pointed to by <[s1]> of any character in string pointed to by
|
||||
|
|
|
|||
|
|
@ -5,16 +5,10 @@ FUNCTION
|
|||
INDEX
|
||||
strrchr
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <string.h>
|
||||
char * strrchr(const char *<[string]>, int <[c]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <string.h>
|
||||
char * strrchr(<[string]>, <[c]>);
|
||||
char *<[string]>;
|
||||
int *<[c]>;
|
||||
|
||||
DESCRIPTION
|
||||
This function finds the last occurence of <[c]> (converted to
|
||||
a char) in the string pointed to by <[string]> (including the
|
||||
|
|
|
|||
|
|
@ -5,15 +5,10 @@ FUNCTION
|
|||
INDEX
|
||||
strsignal
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <string.h>
|
||||
char *strsignal(int <[signal]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <string.h>
|
||||
char *strsignal(<[signal]>)
|
||||
int <[signal]>;
|
||||
|
||||
DESCRIPTION
|
||||
<<strsignal>> converts the signal number <[signal]> into a
|
||||
string. If <[signal]> is not a known signal number, the result
|
||||
|
|
|
|||
|
|
@ -5,16 +5,10 @@ FUNCTION
|
|||
INDEX
|
||||
strspn
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <string.h>
|
||||
size_t strspn(const char *<[s1]>, const char *<[s2]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <string.h>
|
||||
size_t strspn(<[s1]>, <[s2]>)
|
||||
char *<[s1]>;
|
||||
char *<[s2]>;
|
||||
|
||||
DESCRIPTION
|
||||
This function computes the length of the initial segment of
|
||||
the string pointed to by <[s1]> which consists entirely of
|
||||
|
|
|
|||
|
|
@ -5,16 +5,10 @@ FUNCTION
|
|||
INDEX
|
||||
strstr
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <string.h>
|
||||
char *strstr(const char *<[s1]>, const char *<[s2]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <string.h>
|
||||
char *strstr(<[s1]>, <[s2]>)
|
||||
char *<[s1]>;
|
||||
char *<[s2]>;
|
||||
|
||||
DESCRIPTION
|
||||
Locates the first occurrence in the string pointed to by <[s1]> of
|
||||
the sequence of characters in the string pointed to by <[s2]>
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ INDEX
|
|||
INDEX
|
||||
strsep
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <string.h>
|
||||
char *strtok(char *restrict <[source]>,
|
||||
const char *restrict <[delimiters]>);
|
||||
|
|
@ -20,21 +20,6 @@ ANSI_SYNOPSIS
|
|||
char **<[lasts]>);
|
||||
char *strsep(char **<[source_ptr]>, const char *<[delimiters]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <string.h>
|
||||
char *strtok(<[source]>, <[delimiters]>);
|
||||
char *<[source]>;
|
||||
char *<[delimiters]>;
|
||||
|
||||
char *strtok_r(<[source]>, <[delimiters]>, <[lasts]>);
|
||||
char *<[source]>;
|
||||
char *<[delimiters]>;
|
||||
char **<[lasts]>;
|
||||
|
||||
char *strsep(<[source_ptr]>, <[delimiters]>);
|
||||
char **<[source_ptr]>;
|
||||
char *<[delimiters]>;
|
||||
|
||||
DESCRIPTION
|
||||
The <<strtok>> function is used to isolate sequential tokens in a
|
||||
null-terminated string, <<*<[source]>>>. These tokens are delimited
|
||||
|
|
|
|||
|
|
@ -5,15 +5,10 @@ FUNCTION
|
|||
INDEX
|
||||
strupr
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <string.h>
|
||||
char *strupr(char *<[a]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <string.h>
|
||||
char *strupr(<[a]>)
|
||||
char *<[a]>;
|
||||
|
||||
DESCRIPTION
|
||||
<<strupr>> converts each character in the string at <[a]> to
|
||||
uppercase.
|
||||
|
|
|
|||
|
|
@ -5,18 +5,11 @@ FUNCTION
|
|||
INDEX
|
||||
strverscmp
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#define _GNU_SOURCE
|
||||
#include <string.h>
|
||||
int strverscmp(const char *<[a]>, const char *<[b]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#define _GNU_SOURCE
|
||||
#include <string.h>
|
||||
int strverscmp(<[a]>, <[b]>)
|
||||
char *<[a]>;
|
||||
char *<[b]>;
|
||||
|
||||
DESCRIPTION
|
||||
<<strverscmp>> compares the string at <[a]> to
|
||||
the string at <[b]> in a version-logical order.
|
||||
|
|
|
|||
|
|
@ -5,18 +5,11 @@ FUNCTION
|
|||
INDEX
|
||||
strxfrm
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <string.h>
|
||||
size_t strxfrm(char *restrict <[s1]>, const char *restrict <[s2]>,
|
||||
size_t <[n]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <string.h>
|
||||
size_t strxfrm(<[s1]>, <[s2]>, <[n]>);
|
||||
char *<[s1]>;
|
||||
char *<[s2]>;
|
||||
size_t <[n]>;
|
||||
|
||||
DESCRIPTION
|
||||
This function transforms the string pointed to by <[s2]> and
|
||||
places the resulting string into the array pointed to by
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ FUNCTION
|
|||
INDEX
|
||||
strxfrm_l
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <string.h>
|
||||
size_t strxfrm_l(char *restrict <[s1]>, const char *restrict <[s2]>,
|
||||
size_t <[n]>, locale_t <[locale]>);
|
||||
|
|
|
|||
|
|
@ -2,16 +2,10 @@
|
|||
FUNCTION
|
||||
<<swab>>---swap adjacent bytes
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <unistd.h>
|
||||
void swab(const void *<[in]>, void *<[out]>, ssize_t <[n]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
void swab(<[in]>, <[out]>, <[n]>
|
||||
void *<[in]>;
|
||||
void *<[out]>;
|
||||
ssize_t <[n]>;
|
||||
|
||||
DESCRIPTION
|
||||
This function copies <[n]> bytes from the memory region
|
||||
pointed to by <[in]> to the memory region pointed to by
|
||||
|
|
|
|||
|
|
@ -2,15 +2,10 @@
|
|||
FUNCTION
|
||||
<<wcpcpy>>---copy a wide-character string returning a pointer to its end
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <wchar.h>
|
||||
wchar_t *wcpcpy(wchar_t *<[s1]>, const wchar_t *<[s2]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
wchar_t *wcpcpy(<[s1]>, <[s2]>
|
||||
wchar_t *__restrict <[s1]>;
|
||||
const wchar_t *__restrict <[s2]>;
|
||||
|
||||
DESCRIPTION
|
||||
The <<wcpcpy>> function copies the wide-character string pointed to by
|
||||
<[s2]> (including the terminating null wide-character code) into the
|
||||
|
|
|
|||
|
|
@ -2,17 +2,11 @@
|
|||
FUNCTION
|
||||
<<wcpncpy>>---copy part of a wide-character string returning a pointer to its end
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <wchar.h>
|
||||
wchar_t *wcpncpy(wchar_t *__restrict <[s1]>,
|
||||
const wchar_t *__restrict <[s2]>, size_t <[n]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
wchar_t *wcpncpy(<[s1]>, <[s2]>, <[n]>
|
||||
wchar_t *__restrict <[s1]>;
|
||||
const wchar_t *__restrict <[s2]>;
|
||||
size_t <[n]>;
|
||||
|
||||
DESCRIPTION
|
||||
The <<wcpncpy>> function copies not more than n wide-character codes
|
||||
(wide-character codes that follow a null wide-character code are not
|
||||
|
|
|
|||
|
|
@ -5,16 +5,10 @@ FUNCTION
|
|||
INDEX
|
||||
wcscasecmp
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <wchar.h>
|
||||
int wcscasecmp(const wchar_t *<[a]>, const wchar_t *<[b]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <wchar.h>
|
||||
int wcscasecmp(<[a]>, <[b]>)
|
||||
wchar_t *<[a]>;
|
||||
wchar_t *<[b]>;
|
||||
|
||||
DESCRIPTION
|
||||
<<wcscasecmp>> compares the wide character string at <[a]> to
|
||||
the wide character string at <[b]> in a case-insensitive manner.
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ FUNCTION
|
|||
INDEX
|
||||
wcscasecmp_l
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <wchar.h>
|
||||
int wcscasecmp_l(const wchar_t *<[a]>, const wchar_t *<[b]>,
|
||||
locale_t <[locale]>);
|
||||
|
|
|
|||
|
|
@ -4,16 +4,11 @@ FUNCTION
|
|||
INDEX
|
||||
wcscat
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <wchar.h>
|
||||
wchar_t *wcscat(wchar_t *__restrict <[s1]>,
|
||||
const wchar_t *__restrict <[s2]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
wchar_t *wcscat(<[s1]>, <[s2]>
|
||||
wchar_t *__restrict <[s1]>;
|
||||
const wchar_t *__restrict <[s2]>;
|
||||
|
||||
DESCRIPTION
|
||||
The <<wcscat>> function appends a copy of the wide-character string
|
||||
pointed to by <[s2]> (including the terminating null wide-character
|
||||
|
|
|
|||
|
|
@ -2,15 +2,10 @@
|
|||
FUNCTION
|
||||
<<wcschr>>---wide-character string scanning operation
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <wchar.h>
|
||||
wchar_t *wcschr(const wchar_t *<[s]>, wchar_t <[c]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
wchar_t *wcschr(<[s]>, <[c]>
|
||||
const wchar_t *<[s]>;
|
||||
wchar_t <[c]>;
|
||||
|
||||
DESCRIPTION
|
||||
The <<wcschr>> function locates the first occurrence of <[c]> in the
|
||||
wide-character string pointed to by <[s]>. The value of <[c]> must be a
|
||||
|
|
|
|||
|
|
@ -2,14 +2,10 @@
|
|||
FUNCTION
|
||||
<<wcscmp>>---compare two wide-character strings
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <wchar.h>
|
||||
int wcscmp(const wchar_t *<[s1]>, *<[s2]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
int wcscmp(<[s1]>, <[s2]>
|
||||
const wchar_t *<[s1]>, <[s2]>;
|
||||
|
||||
DESCRIPTION
|
||||
The <<wcscmp>> function compares the wide-character string pointed to
|
||||
by <[s1]> to the wide-character string pointed to by <[s2]>.
|
||||
|
|
|
|||
|
|
@ -5,16 +5,10 @@ FUNCTION
|
|||
INDEX
|
||||
wcscoll
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <wchar.h>
|
||||
int wcscoll(const wchar_t *<[stra]>, const wchar_t * <[strb]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <wchar.h>
|
||||
int wcscoll(<[stra]>, <[strb]>)
|
||||
wchar_t *<[stra]>;
|
||||
wchar_t *<[strb]>;
|
||||
|
||||
DESCRIPTION
|
||||
<<wcscoll>> compares the wide-character string pointed to by
|
||||
<[stra]> to the wide-character string pointed to by <[strb]>,
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ FUNCTION
|
|||
INDEX
|
||||
wcscoll_l
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <wchar.h>
|
||||
int wcscoll_l(const wchar_t *<[stra]>, const wchar_t * <[strb]>,
|
||||
locale_t <[locale]>);
|
||||
|
|
|
|||
|
|
@ -2,16 +2,11 @@
|
|||
FUNCTION
|
||||
<<wcscpy>>---copy a wide-character string
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <wchar.h>
|
||||
wchar_t *wcscpy(wchar_t *__restrict <[s1]>,
|
||||
const wchar_t *__restrict <[s2]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
wchar_t *wcscpy(<[s1]>, <[s2]>
|
||||
wchar_t *__restrict <[s1]>;
|
||||
const wchar_t *__restrict <[s2]>;
|
||||
|
||||
DESCRIPTION
|
||||
The <<wcscpy>> function copies the wide-character string pointed to by
|
||||
<[s2]> (including the terminating null wide-character code) into the
|
||||
|
|
|
|||
|
|
@ -2,15 +2,10 @@
|
|||
FUNCTION
|
||||
<<wcscspn>>---get length of a complementary wide substring
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <wchar.h>
|
||||
size_t wcscspn(const wchar_t *<[s]>, wchar_t *<[set]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
size_t wcscspn(<[s]>, <[set]>
|
||||
const wchar_t *<[s]>;
|
||||
const wchar_t *<[set]>;
|
||||
|
||||
DESCRIPTION
|
||||
The <<wcscspn>> function computes the length of the maximum initial
|
||||
segment of the wide-character string pointed to by <[s]> which consists
|
||||
|
|
|
|||
|
|
@ -7,19 +7,13 @@ INDEX
|
|||
INDEX
|
||||
_wcsdup_r
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <wchar.h>
|
||||
wchar_t *wcsdup(const wchar_t *<[str]>);
|
||||
|
||||
#include <wchar.h>
|
||||
wchar_t *_wcsdup_r(struct _reent *<[ptr]>, const wchar_t *<[str]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <wchar.h>
|
||||
wchar_t *wcsdup(<[ptr]>, <[str]>)
|
||||
struct _reent *<[ptr]>;
|
||||
wchar_t *<[str]>;
|
||||
|
||||
DESCRIPTION
|
||||
<<wcsdup>> allocates a new wide character string using <<malloc>>,
|
||||
and copies the content of the argument <[str]> into the newly
|
||||
|
|
|
|||
|
|
@ -2,17 +2,10 @@
|
|||
FUNCTION
|
||||
<<wcslcat>>---concatenate wide-character strings to specified length
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <wchar.h>
|
||||
size_t wcslcat(wchar_t *<[dst]>, const wchar_t *<[src]>, size_t <[siz]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <wchar.h>
|
||||
size_t wcslcat(<[dst]>, <[src]>, <[siz]>
|
||||
wchar_t *<[dst]>;
|
||||
const wchar_t *<[src]>;
|
||||
size_t <[siz]>;
|
||||
|
||||
DESCRIPTION
|
||||
The <<wcslcat>> function appends wide characters from <[src]> to
|
||||
end of the <[dst]> wide-character string so that the resultant
|
||||
|
|
|
|||
|
|
@ -2,17 +2,10 @@
|
|||
FUNCTION
|
||||
<<wcslcpy>>---copy a wide-character string to specified length
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <wchar.h>
|
||||
size_t wcslcpy(wchar_t *<[dst]>, const wchar_t *<[src]>, size_t <[siz]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <wchar.h>
|
||||
size_t wcslcpy(<[dst]>, <[src]>, <[siz]>)
|
||||
wchar_t *<[dst]>;
|
||||
const wchar_t *<[src]>;
|
||||
size_t <[siz]>;
|
||||
|
||||
DESCRIPTION
|
||||
<<wcslcpy>> copies wide characters from <[src]> to <[dst]>
|
||||
such that up to <[siz]> - 1 characters are copied. A
|
||||
|
|
|
|||
|
|
@ -2,14 +2,10 @@
|
|||
FUNCTION
|
||||
<<wcslen>>---get wide-character string length
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <wchar.h>
|
||||
size_t wcslen(const wchar_t *<[s]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
size_t wcslen(<[s]>
|
||||
const wchar_t *<[s]>;
|
||||
|
||||
DESCRIPTION
|
||||
The <<wcslen>> function computes the number of wide-character codes
|
||||
in the wide-character string to which <[s]> points, not including the
|
||||
|
|
|
|||
|
|
@ -5,17 +5,10 @@ FUNCTION
|
|||
INDEX
|
||||
wcsncasecmp
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <wchar.h>
|
||||
int wcsncasecmp(const wchar_t *<[a]>, const wchar_t * <[b]>, size_t <[length]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <wchar.h>
|
||||
int wcsncasecmp(<[a]>, <[b]>, <[length]>)
|
||||
wchar_t *<[a]>;
|
||||
wchar_t *<[b]>;
|
||||
size_t <[length]>
|
||||
|
||||
DESCRIPTION
|
||||
<<wcsncasecmp>> compares up to <[length]> wide characters
|
||||
from the string at <[a]> to the string at <[b]> in a
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ FUNCTION
|
|||
INDEX
|
||||
wcsncasecmp_l
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <wchar.h>
|
||||
int wcsncasecmp_l(const wchar_t *<[a]>, const wchar_t * <[b]>,
|
||||
size_t <[length]>, locale_t <[locale]>);
|
||||
|
|
|
|||
|
|
@ -2,17 +2,11 @@
|
|||
FUNCTION
|
||||
<<wcsncat>>---concatenate part of two wide-character strings
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <wchar.h>
|
||||
wchar_t *wcsncat(wchar_t *__restrict <[s1]>,
|
||||
const wchar_t *__restrict <[s2]>, size_t <[n]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
wchar_t *wcsncat(<[s1]>, <[s2]>, <[n]>
|
||||
wchar_t *__restrict <[s1]>;
|
||||
const wchar_t *__restrict <[s2]>;
|
||||
size_t <[n]>;
|
||||
|
||||
DESCRIPTION
|
||||
The <<wcsncat>> function appends not more than <[n]> wide-character
|
||||
codes (a null wide-character code and wide-character codes that follow
|
||||
|
|
|
|||
|
|
@ -2,16 +2,10 @@
|
|||
FUNCTION
|
||||
<<wcsncmp>>---compare part of two wide-character strings
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <wchar.h>
|
||||
int wcsncmp(const wchar_t *<[s1]>, const wchar_t *<[s2]>, size_t <[n]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
int wcsncmp(<[s1]>, <[s2]>, <[n]>
|
||||
const wchar_t *<[s1]>;
|
||||
const wchar_t *<[s2]>;
|
||||
size_t <[n]>;
|
||||
|
||||
DESCRIPTION
|
||||
The <<wcsncmp>> function compares not more than <[n]> wide-character
|
||||
codes (wide-character codes that follow a null wide-character code are
|
||||
|
|
|
|||
|
|
@ -2,17 +2,11 @@
|
|||
FUNCTION
|
||||
<<wcsncpy>>---copy part of a wide-character string
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <wchar.h>
|
||||
wchar_t *wcsncpy(wchar_t *__restrict <[s1]>,
|
||||
const wchar_t *__restrict <[s2]>, size_t <[n]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
wchar_t *wcsncpy(<[s1]>, <[s2]>, <[n]>
|
||||
wchar_t *__restrict <[s1]>;
|
||||
const wchar_t *__restrict <[s2]>;
|
||||
size_t <[n]>;
|
||||
|
||||
DESCRIPTION
|
||||
The <<wcsncpy>> function copies not more than <[n]> wide-character codes
|
||||
(wide-character codes that follow a null wide-character code are not
|
||||
|
|
|
|||
|
|
@ -5,16 +5,10 @@ FUNCTION
|
|||
INDEX
|
||||
wcsnlen
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <wchar.h>
|
||||
size_t wcsnlen(const wchar_t *<[s]>, size_t <[maxlen]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <wchar.h>
|
||||
size_t wcsnlen(<[s]>, <[maxlen]>)
|
||||
wchar_t *<[s]>;
|
||||
size_t <[maxlen]>;
|
||||
|
||||
DESCRIPTION
|
||||
The <<wcsnlen>> function computes the number of wide-character codes
|
||||
in the wide-character string pointed to by <[s]> not including the
|
||||
|
|
|
|||
|
|
@ -2,15 +2,10 @@
|
|||
FUNCTION
|
||||
<<wcspbrk>>----scan wide-character string for a wide-character code
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <wchar.h>
|
||||
wchar_t *wcspbrk(const wchar_t *<[s]>, const wchar_t *<[set]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
wchar_t *wcspbrk(<[s]>, <[set]>
|
||||
const wchar_t *<[s]>;
|
||||
const wchar_t *<[set]>;
|
||||
|
||||
DESCRIPTION
|
||||
The <<wcspbrk>> function locates the first occurrence in the
|
||||
wide-character string pointed to by <[s]> of any wide-character code
|
||||
|
|
|
|||
|
|
@ -2,16 +2,10 @@
|
|||
FUNCTION
|
||||
<<wcsrchr>>---wide-character string scanning operation
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <wchar.h>
|
||||
wchar_t *wcsrchr(const wchar_t *<[s]>, wchar_t <[c]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <wchar.h>
|
||||
wchar_t *wcsrchr(<[s]>, <[c]>
|
||||
const wchar_t *<[s]>;
|
||||
wchar_t <[c]>;
|
||||
|
||||
DESCRIPTION
|
||||
The <<wcsrchr>> function locates the last occurrence of <[c]> in the
|
||||
wide-character string pointed to by <[s]>. The value of <[c]> must be a
|
||||
|
|
|
|||
|
|
@ -2,15 +2,10 @@
|
|||
FUNCTION
|
||||
<<wcsspn>>---get length of a wide substring
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <wchar.h>
|
||||
size_t wcsspn(const wchar_t *<[s]>, const wchar_t *<[set]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
size_t wcsspn(<[s]>, <[set]>
|
||||
const wchar_t *<[s]>;
|
||||
const wchar_t *<[set]>;
|
||||
|
||||
DESCRIPTION
|
||||
The <<wcsspn>> function computes the length of the maximum initial
|
||||
segment of the wide-character string pointed to by <[s]> which consists
|
||||
|
|
|
|||
|
|
@ -2,16 +2,11 @@
|
|||
FUNCTION
|
||||
<<wcsstr>>---find a wide-character substring
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <wchar.h>
|
||||
wchar_t *wcsstr(const wchar_t *__restrict <[big]>,
|
||||
const wchar_t *__restrict <[little]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
wchar_t *wcsstr(<[big]>, <[little]>
|
||||
const wchar_t *__restrict <[big]>;
|
||||
const wchar_t *__restrict <[little]>;
|
||||
|
||||
DESCRIPTION
|
||||
The <<wcsstr>> function locates the first occurrence in the
|
||||
wide-character string pointed to by <[big]> of the sequence of
|
||||
|
|
|
|||
|
|
@ -6,19 +6,12 @@ INDEX
|
|||
wcstok
|
||||
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <wchar.h>
|
||||
wchar_t *wcstok(wchar_t *__restrict <[source]>,
|
||||
const wchar_t *__restrict <[delimiters]>,
|
||||
wchar_t **__restrict <[lasts]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <wchar.h>
|
||||
wchar_t *wcstok(<[source]>, <[delimiters]>, <[lasts]>);
|
||||
wchar_t *__restrict <[source]>;
|
||||
wchar_t *__restrict <[delimiters]>;
|
||||
wchar_t **__restrict <[lasts]>;
|
||||
|
||||
DESCRIPTION
|
||||
The <<wcstok>> function is the wide-character equivalent of the
|
||||
<<strtok_r>> function (which in turn is the same as the <<strtok>>
|
||||
|
|
|
|||
|
|
@ -5,16 +5,10 @@ FUNCTION
|
|||
INDEX
|
||||
wcswidth
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <wchar.h>
|
||||
int wcswidth(const wchar_t *<[pwcs]>, size_t <[n]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <wchar.h>
|
||||
int wcswidth(<[pwcs]>, <[n]>)
|
||||
wchar_t *<[wc]>;
|
||||
size_t <[n]>;
|
||||
|
||||
DESCRIPTION
|
||||
The <<wcswidth>> function shall determine the number of column
|
||||
positions required for <[n]> wide-character codes (or fewer than <[n]>
|
||||
|
|
|
|||
|
|
@ -5,18 +5,11 @@ FUNCTION
|
|||
INDEX
|
||||
wcsxfrm
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <wchar.h>
|
||||
int wcsxfrm(wchar_t *__restrict <[stra]>,
|
||||
const wchar_t *__restrict <[strb]>, size_t <[n]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <wchar.h>
|
||||
size_t wcsxfrm(<[stra]>, <[strb]>, <[n]>)
|
||||
wchar_t *__restrict <[stra]>;
|
||||
wchar_t *__restrict <[strb]>;
|
||||
size_t <[n]>
|
||||
|
||||
DESCRIPTION
|
||||
<<wcsxfrm>> transforms the wide-character string pointed to by
|
||||
<[strb]> to the wide-character string pointed to by <[stra]>,
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ FUNCTION
|
|||
INDEX
|
||||
wcsxfrm_l
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <wchar.h>
|
||||
int wcsxfrm_l(wchar_t *__restrict <[stra]>,
|
||||
const wchar_t *__restrict <[strb]>, size_t <[n]>,
|
||||
|
|
|
|||
|
|
@ -5,15 +5,10 @@ FUNCTION
|
|||
INDEX
|
||||
wcwidth
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <wchar.h>
|
||||
int wcwidth(const wchar_t <[wc]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
#include <wchar.h>
|
||||
int wcwidth(<[wc]>)
|
||||
wchar_t *<[wc]>;
|
||||
|
||||
DESCRIPTION
|
||||
The <<wcwidth>> function shall determine the number of column
|
||||
positions required for the wide character <[wc]>. The application
|
||||
|
|
|
|||
|
|
@ -3,16 +3,10 @@ FUNCTION
|
|||
<<wmemchr>>---find a wide character in memory
|
||||
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <wchar.h>
|
||||
wchar_t *wmemchr(const wchar_t *<[s]>, wchar_t <[c]>, size_t <[n]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
wchar_t *wmemchr(<[s]>, <[c]>, <[n]>
|
||||
const wchar_t *<[s]>;
|
||||
wchar_t <[c]>;
|
||||
size_t <[n]>;
|
||||
|
||||
DESCRIPTION
|
||||
The <<wmemchr>> function locates the first occurrence of <[c]> in the
|
||||
initial <[n]> wide characters of the object pointed to be <[s]>. This
|
||||
|
|
|
|||
|
|
@ -2,16 +2,10 @@
|
|||
FUNCTION
|
||||
<<wmemcmp>>---compare wide characters in memory
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <wchar.h>
|
||||
int wmemcmp(const wchar_t *<[s1]>, const wchar_t *<[s2]>, size_t <[n]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
int wmemcmp(<[s1]>, <[s2]>, <[n]>
|
||||
const wchar_t *<[s1]>;
|
||||
const wchar_t *<[s2]>;
|
||||
size_t <[n]>;
|
||||
|
||||
DESCRIPTION
|
||||
The <<wmemcmp>> function compares the first <[n]> wide characters of the
|
||||
object pointed to by <[s1]> to the first <[n]> wide characters of the
|
||||
|
|
|
|||
|
|
@ -2,17 +2,11 @@
|
|||
FUNCTION
|
||||
<<wmemcpy>>---copy wide characters in memory
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <wchar.h>
|
||||
wchar_t *wmemcpy(wchar_t *__restrict <[d]>,
|
||||
const wchar_t *__restrict <[s]>, size_t <[n]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
wchar_t *wmemcpy(<[d]>, <[s]>, <[n]>
|
||||
wchar_t *__restrict <[d]>;
|
||||
const wchar_t *__restrict <[s]>;
|
||||
size_t <[n]>;
|
||||
|
||||
DESCRIPTION
|
||||
The <<wmemcpy>> function copies <[n]> wide characters from the object
|
||||
pointed to by <[s]> to the object pointed to be <[d]>. This function
|
||||
|
|
|
|||
|
|
@ -2,16 +2,10 @@
|
|||
FUNCTION
|
||||
<<wmemmove>>---copy wide characters in memory with overlapping areas
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <wchar.h>
|
||||
wchar_t *wmemmove(wchar_t *<[d]>, const wchar_t *<[s]>, size_t <[n]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
wchar_t *wmemmove(<[d]>, <[s]>, <[n]>
|
||||
wchar_t *<[d]>;
|
||||
const wchar_t *<[s]>;
|
||||
size_t <[n]>;
|
||||
|
||||
DESCRIPTION
|
||||
The <<wmemmove>> function copies <[n]> wide characters from the object
|
||||
pointed to by <[s]> to the object pointed to by <[d]>. Copying takes
|
||||
|
|
|
|||
|
|
@ -2,16 +2,10 @@
|
|||
FUNCTION
|
||||
<<wmemset>>---set wide characters in memory
|
||||
|
||||
ANSI_SYNOPSIS
|
||||
SYNOPSIS
|
||||
#include <wchar.h>
|
||||
wchar_t *wmemset(wchar_t *<[s]>, wchar_t <[c]>, size_t <[n]>);
|
||||
|
||||
TRAD_SYNOPSIS
|
||||
wchar_t *wmemset(<[s]>, <[c]>, <[n]>
|
||||
wchar_t *<[s]>;
|
||||
wchar_t <[c]>;
|
||||
size_t <[n]>;
|
||||
|
||||
DESCRIPTION
|
||||
The <<wmemset>> function copies the value of <[c]> into each of the
|
||||
first <[n]> wide characters of the object pointed to by <[s]>. This
|
||||
|
|
|
|||
Loading…
Reference in New Issue