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

Fold documentation of is*_l funcs into documentation of non-l is* funcs

Browse Source 
Signed-off-by: Corinna Vinschen <corinna@vinschen.de>
This commit is contained in:
Corinna Vinschen 2016-08-15 14:21:52 +02:00
parent 5bdf8cfa49
commit baf0c9fcb5
68 changed files with 514 additions and 1209 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

35
newlib/libc/ctype/Makefile.am
View File

@ -98,71 +98,38 @@ include $(srcdir)/../../Makefile.shared
CHEWOUT_FILES= \ CHEWOUT_FILES= \
isalnum.def \ isalnum.def \
isalnum_l.def \
isalpha.def \ isalpha.def \
isalpha_l.def \
isascii.def \ isascii.def \
isascii_l.def \
isblank.def \ isblank.def \
isblank_l.def \
iscntrl.def \ iscntrl.def \
iscntrl_l.def \
isdigit.def \ isdigit.def \
isdigit_l.def \
islower.def \ islower.def \
islower_l.def \
isprint.def \ isprint.def \
isprint_l.def \
ispunct.def \ ispunct.def \
ispunct_l.def \
isspace.def \ isspace.def \
isspace_l.def \
isupper.def \ isupper.def \
isupper_l.def \
iswalnum.def \ iswalnum.def \
iswalnum_l.def \
iswalpha.def \ iswalpha.def \
iswalpha_l.def \
iswblank.def \ iswblank.def \
iswblank_l.def \
iswcntrl.def \ iswcntrl.def \
iswcntrl_l.def \
iswctype.def \ iswctype.def \
iswctype_l.def \
iswdigit.def \ iswdigit.def \
iswdigit_l.def \
iswgraph.def \ iswgraph.def \
iswgraph_l.def \
iswlower.def \ iswlower.def \
iswlower_l.def \
iswprint.def \ iswprint.def \
iswprint_l.def \
iswpunct.def \ iswpunct.def \
iswpunct_l.def \
iswspace.def \ iswspace.def \
iswspace_l.def \
iswupper.def \ iswupper.def \
iswupper_l.def \
iswxdigit.def \ iswxdigit.def \
iswxdigit_l.def \
isxdigit.def \ isxdigit.def \
isxdigit_l.def \
toascii.def \ toascii.def \
toascii_l.def \
tolower.def \ tolower.def \
tolower_l.def \
toupper.def \ toupper.def \
toupper_l.def \
towctrans.def \ towctrans.def \
towctrans_l.def \
towlower.def \ towlower.def \
towlower_l.def \
towupper.def \ towupper.def \
towupper_l.def \
wctrans.def \ wctrans.def \
wctrans_l.def \ wctype.def
wctype.def \
wctype_l.def
CHAPTERS = ctype.tex CHAPTERS = ctype.tex

35
newlib/libc/ctype/Makefile.in
View File

@ -426,71 +426,38 @@ DOCBOOK_CHAPTERS = $(CHAPTERS:.tex=.xml)
CLEANFILES = $(CHEWOUT_FILES) $(CHEWOUT_FILES:.def=.ref) $(DOCBOOK_OUT_FILES) CLEANFILES = $(CHEWOUT_FILES) $(CHEWOUT_FILES:.def=.ref) $(DOCBOOK_OUT_FILES)
CHEWOUT_FILES = \ CHEWOUT_FILES = \
isalnum.def \ isalnum.def \
isalnum_l.def \
isalpha.def \ isalpha.def \
isalpha_l.def \
isascii.def \ isascii.def \
isascii_l.def \
isblank.def \ isblank.def \
isblank_l.def \
iscntrl.def \ iscntrl.def \
iscntrl_l.def \
isdigit.def \ isdigit.def \
isdigit_l.def \
islower.def \ islower.def \
islower_l.def \
isprint.def \ isprint.def \
isprint_l.def \
ispunct.def \ ispunct.def \
ispunct_l.def \
isspace.def \ isspace.def \
isspace_l.def \
isupper.def \ isupper.def \
isupper_l.def \
iswalnum.def \ iswalnum.def \
iswalnum_l.def \
iswalpha.def \ iswalpha.def \
iswalpha_l.def \
iswblank.def \ iswblank.def \
iswblank_l.def \
iswcntrl.def \ iswcntrl.def \
iswcntrl_l.def \
iswctype.def \ iswctype.def \
iswctype_l.def \
iswdigit.def \ iswdigit.def \
iswdigit_l.def \
iswgraph.def \ iswgraph.def \
iswgraph_l.def \
iswlower.def \ iswlower.def \
iswlower_l.def \
iswprint.def \ iswprint.def \
iswprint_l.def \
iswpunct.def \ iswpunct.def \
iswpunct_l.def \
iswspace.def \ iswspace.def \
iswspace_l.def \
iswupper.def \ iswupper.def \
iswupper_l.def \
iswxdigit.def \ iswxdigit.def \
iswxdigit_l.def \
isxdigit.def \ isxdigit.def \
isxdigit_l.def \
toascii.def \ toascii.def \
toascii_l.def \
tolower.def \ tolower.def \
tolower_l.def \
toupper.def \ toupper.def \
toupper_l.def \
towctrans.def \ towctrans.def \
towctrans_l.def \
towlower.def \ towlower.def \
towlower_l.def \
towupper.def \ towupper.def \
towupper_l.def \
wctrans.def \ wctrans.def \
wctrans_l.def \ wctype.def
wctype.def \
wctype_l.def
CHAPTERS = ctype.tex CHAPTERS = ctype.tex
all: all-am all: all-am

20
newlib/libc/ctype/isalnum.c
View File

@ -1,34 +1,43 @@
/* /*
FUNCTION FUNCTION
<<isalnum>>---alphanumeric character predicate <<isalnum>>, <<isalnum_l>>---alphanumeric character predicate
INDEX INDEX
isalnum isalnum
INDEX
isalnum_l
ANSI_SYNOPSIS ANSI_SYNOPSIS
#include <ctype.h> #include <ctype.h>
int isalnum(int <[c]>); int isalnum(int <[c]>);
#include <ctype.h>
int isalnum_l(int <[c]>, locale_t <[locale]>);
TRAD_SYNOPSIS TRAD_SYNOPSIS
#include <ctype.h> #include <ctype.h>
int isalnum(<[c]>); int isalnum(<[c]>);
DESCRIPTION DESCRIPTION
<<isalnum>> is a macro which classifies ASCII integer values by table <<isalnum>> is a macro which classifies singlebyte charset values by table
lookup. It is a predicate returning non-zero for alphabetic or lookup. It is a predicate returning non-zero for alphabetic or
numeric ASCII characters, and <<0>> for other arguments. It is defined numeric ASCII characters, and <<0>> for other arguments. It is defined
only if <[c]> is representable as an unsigned char or if <[c]> is EOF. only if <[c]> is representable as an unsigned char or if <[c]> is EOF.
<<isalnum_l>> is like <<isalnum>> but performs the check based on the
locale specified by the locale object locale. If <[locale]> is
LC_GLOBAL_LOCALE or not a valid locale object, the behaviour is undefined.
You can use a compiled subroutine instead of the macro definition by You can use a compiled subroutine instead of the macro definition by
undefining the macro using `<<#undef isalnum>>'. undefining the macro using `<<#undef isalnum>>' or `<<#undef isalnum_l>>'.
RETURNS RETURNS
<<isalnum>> returns non-zero if <[c]> is a letter (<<a>>--<<z>> or <<isalnum>>,<<isalnum_l>> return non-zero if <[c]> is a letter or a digit.
<<A>>--<<Z>>) or a digit (<<0>>--<<9>>).
PORTABILITY PORTABILITY
<<isalnum>> is ANSI C. <<isalnum>> is ANSI C.
<<isalnum_l>> is POSIX-1.2008.
No OS subroutines are required. No OS subroutines are required.
*/ */
@ -43,4 +52,3 @@ _DEFUN(isalnum,(c),int c)
{ {
return(__CTYPE_PTR[c+1] & (_U|_L|_N)); return(__CTYPE_PTR[c+1] & (_U|_L|_N));
} }

34
newlib/libc/ctype/isalnum_l.c
View File

@ -1,37 +1,3 @@
/*
FUNCTION
<<isalnum_l>>---alphanumeric character predicate
INDEX
isalnum_l
ANSI_SYNOPSIS
#include <ctype.h>
int isalnum_l(int <[c]>, locale_t <[locale]>);
DESCRIPTION
<<isalnum_l>> is a macro which classifies ASCII integer values by table
lookup in locale <[locale]>. It is a predicate returning non-zero for
alphabetic or numeric ASCII characters, and <<0>> for other arguments.
It is defined only if <[c]> is representable as an unsigned char or if
<[c]> is EOF.
if <[locale]> is LC_GLOBAL_LOCALE or not a valid locale object, the behaviour
is undefined.
You can use a compiled subroutine instead of the macro definition by
undefining the macro using `<<#undef isalnum_l>>'.
RETURNS
<<isalnum_l>> returns non-zero if <[c]> is a letter (<<a>>--<<z>> or
<<A>>--<<Z>>) or a digit (<<0>>--<<9>>).
PORTABILITY
<<isalnum_l>> is POSIX-1.2008.
No OS subroutines are required.
*/
#include <_ansi.h> #include <_ansi.h>
#include <ctype.h> #include <ctype.h>

21
newlib/libc/ctype/isalpha.c
View File

@ -1,33 +1,43 @@
/* /*
FUNCTION FUNCTION
<<isalpha>>---alphabetic character predicate <<isalpha>>, <isalpha_l>>---alphabetic character predicate
INDEX INDEX
isalpha isalpha
INDEX
isalpha_l
ANSI_SYNOPSIS ANSI_SYNOPSIS
#include <ctype.h> #include <ctype.h>
int isalpha(int <[c]>); int isalpha(int <[c]>);
#include <ctype.h>
int isalpha_l(int <[c]>, locale_t <[locale]>);
TRAD_SYNOPSIS TRAD_SYNOPSIS
#include <ctype.h> #include <ctype.h>
int isalpha(<[c]>); int isalpha(<[c]>);
DESCRIPTION DESCRIPTION
<<isalpha>> is a macro which classifies ASCII integer values by table <<isalpha>> is a macro which classifies singlebyte charset values by table
lookup. It is a predicate returning non-zero when <[c]> represents an lookup. It is a predicate returning non-zero when <[c]> represents an
alphabetic ASCII character, and 0 otherwise. It is defined only if alphabetic ASCII character, and 0 otherwise. It is defined only if
<[c]> is representable as an unsigned char or if <[c]> is EOF. <[c]> is representable as an unsigned char or if <[c]> is EOF.
<<isalpha_l>> is like <<isalpha>> but performs the check based on the
locale specified by the locale object locale. If <[locale]> is
LC_GLOBAL_LOCALE or not a valid locale object, the behaviour is undefined.
You can use a compiled subroutine instead of the macro definition by You can use a compiled subroutine instead of the macro definition by
undefining the macro using `<<#undef isalpha>>'. undefining the macro using `<<#undef isalpha>>' or `<<#undef isalpha_l>>'.
RETURNS RETURNS
<<isalpha>> returns non-zero if <[c]> is a letter (<<A>>--<<Z>> or <<isalpha>>, <<isalpha_l>> return non-zero if <[c]> is a letter.
<<a>>--<<z>>).
PORTABILITY PORTABILITY
<<isalpha>> is ANSI C. <<isalpha>> is ANSI C.
<<isalpha_l>> is POSIX-1.2008.
No supporting OS subroutines are required. No supporting OS subroutines are required.
*/ */
@ -41,4 +51,3 @@ _DEFUN(isalpha,(c),int c)
{ {
return(__CTYPE_PTR[c+1] & (_U|_L)); return(__CTYPE_PTR[c+1] & (_U|_L));
} }

33
newlib/libc/ctype/isalpha_l.c
View File

@ -1,36 +1,3 @@
/*
FUNCTION
<<isalpha_l>>---alphabetic character predicate
INDEX
isalpha_l
ANSI_SYNOPSIS
#include <ctype.h>
int isalpha_l(int <[c]>, locale_t <[locale]>);
DESCRIPTION
<<isalpha_l>> is a macro which classifies ASCII integer values by table
lookup in locale <[locale]>. It is a predicate returning non-zero when
<[c]> represents an alphabetic ASCII character, and 0 otherwise. It is
defined only if <[c]> is representable as an unsigned char or if <[c]> is EOF.
if <[locale]> is LC_GLOBAL_LOCALE or not a valid locale object, the behaviour
is undefined.
You can use a compiled subroutine instead of the macro definition by
undefining the macro using `<<#undef isalpha_l>>'.
RETURNS
<<isalpha_l>> returns non-zero if <[c]> is a letter (<<A>>--<<Z>> or
<<a>>--<<z>>).
PORTABILITY
<<isalpha_l>> is POSIX-1.2008.
No supporting OS subroutines are required.
*/
#include <_ansi.h> #include <_ansi.h>
#include <ctype.h> #include <ctype.h>

19
newlib/libc/ctype/isascii.c
View File

@ -1,14 +1,20 @@
/* /*
FUNCTION FUNCTION
<<isascii>>---ASCII character predicate <<isascii>>, <<isascii_l>>---ASCII character predicate
INDEX INDEX
isascii isascii
INDEX
isascii_l
ANSI_SYNOPSIS ANSI_SYNOPSIS
#include <ctype.h> #include <ctype.h>
int isascii(int <[c]>); int isascii(int <[c]>);
#include <ctype.h>
int isascii_l(int <[c]>, locale_t <[locale]>);
TRAD_SYNOPSIS TRAD_SYNOPSIS
#include <ctype.h> #include <ctype.h>
int isascii(<[c]>); int isascii(<[c]>);
@ -17,15 +23,20 @@ DESCRIPTION
<<isascii>> is a macro which returns non-zero when <[c]> is an ASCII <<isascii>> is a macro which returns non-zero when <[c]> is an ASCII
character, and 0 otherwise. It is defined for all integer values. character, and 0 otherwise. It is defined for all integer values.
<<isascii_l>> is like <<isascii>> but performs the check based on the
locale specified by the locale object locale. If <[locale]> is
LC_GLOBAL_LOCALE or not a valid locale object, the behaviour is undefined.
You can use a compiled subroutine instead of the macro definition by You can use a compiled subroutine instead of the macro definition by
undefining the macro using `<<#undef isascii>>'. undefining the macro using `<<#undef isascii>>' or `<<#undef isascii_l>>'.
RETURNS RETURNS
<<isascii>> returns non-zero if the low order byte of <[c]> is in the range <<isascii>>, <<isascii_l>> return non-zero if the low order byte of <[c]>
0 to 127 (<<0x00>>--<<0x7F>>). is in the range 0 to 127 (<<0x00>>--<<0x7F>>).
PORTABILITY PORTABILITY
<<isascii>> is ANSI C. <<isascii>> is ANSI C.
<<isascii_l>> is a GNU extension.
No supporting OS subroutines are required. No supporting OS subroutines are required.
*/ */

30
newlib/libc/ctype/isascii_l.c
View File

@ -1,33 +1,3 @@
/*
FUNCTION
<<isascii_l>>---ASCII character predicate
INDEX
isascii_l
ANSI_SYNOPSIS
#include <ctype.h>
int isascii_l(int <[c]>, locale_t <[locale]>);
DESCRIPTION
<<isascii_l>> is a macro which returns non-zero when <[c]> is an ASCII
character, and 0 otherwise. It is defined for all integer values.
if <[locale]> is LC_GLOBAL_LOCALE or not a valid locale object, the behaviour
is undefined.
You can use a compiled subroutine instead of the macro definition by
undefining the macro using `<<#undef isascii_l>>'.
RETURNS
<<isascii_l>> returns non-zero if the low order byte of <[c]> is in the range
0 to 127 (<<0x00>>--<<0x7F>>).
PORTABILITY
<<isascii_l>> is a GNU extension.
No supporting OS subroutines are required.
*/
#include <_ansi.h> #include <_ansi.h>
#include <ctype.h> #include <ctype.h>

18
newlib/libc/ctype/isblank.c
View File

@ -1,30 +1,40 @@
/* /*
FUNCTION FUNCTION
<<isblank>>---blank character predicate <<isblank>>, <<isblank_l>>---blank character predicate
INDEX INDEX
isblank isblank
INDEX
isblank_l
ANSI_SYNOPSIS ANSI_SYNOPSIS
#include <ctype.h> #include <ctype.h>
int isblank(int <[c]>); int isblank(int <[c]>);
#include <ctype.h>
int isblank_l(int <[c]>, locale_t <[locale]>);
TRAD_SYNOPSIS TRAD_SYNOPSIS
#include <ctype.h> #include <ctype.h>
int isblank(<[c]>); int isblank(<[c]>);
DESCRIPTION DESCRIPTION
<<isblank>> is a function which classifies ASCII integer values by table <<isblank>> is a function which classifies singlebyte charset values by table
lookup. It is a predicate returning non-zero for blank characters, and 0 lookup. It is a predicate returning non-zero for blank characters, and 0
for other characters. It is defined only if <[c]> is representable as an for other characters. It is defined only if <[c]> is representable as an
unsigned char or if <[c]> is EOF. unsigned char or if <[c]> is EOF.
<<isblank_l>> is like <<isblank>> but performs the check based on the
locale specified by the locale object locale. If <[locale]> is
LC_GLOBAL_LOCALE or not a valid locale object, the behaviour is undefined.
RETURNS RETURNS
<<isblank>> returns non-zero if <[c]> is a blank character. <<isblank>>, <<isblank_l>> return non-zero if <[c]> is a blank character.
PORTABILITY PORTABILITY
<<isblank>> is C99. <<isblank>> is C99.
<<isblank_l>> is POSIX-1.2008.
No supporting OS subroutines are required. No supporting OS subroutines are required.
*/ */

29
newlib/libc/ctype/isblank_l.c
View File

@ -1,32 +1,3 @@
/*
FUNCTION
<<isblank_l>>---blank character predicate
INDEX
isblank_l
ANSI_SYNOPSIS
#include <ctype.h>
int isblank_l(int <[c]>, locale_t <[locale]>);
DESCRIPTION
<<isblank_l>> is a function which classifies ASCII integer values by table
lookup in locale <[locale]>. It is a predicate returning non-zero for blank
characters, and 0 for other characters. It is defined only if <[c]> is
representable as an unsigned char or if <[c]> is EOF.
if <[locale]> is LC_GLOBAL_LOCALE or not a valid locale object, the behaviour
is undefined.
RETURNS
<<isblank_l>> returns non-zero if <[c]> is a blank character.
PORTABILITY
<<isblank_l>> is POSIX-1.2008.
No supporting OS subroutines are required.
*/
#include <_ansi.h> #include <_ansi.h>
#include <ctype.h> #include <ctype.h>

24
newlib/libc/ctype/iscntrl.c
View File

@ -1,34 +1,44 @@
/* /*
FUNCTION FUNCTION
<<iscntrl>>---control character predicate <<iscntrl>>, <<iscntrl_l>>---control character predicate
INDEX INDEX
iscntrl iscntrl
INDEX
iscntrl_l
ANSI_SYNOPSIS ANSI_SYNOPSIS
#include <ctype.h> #include <ctype.h>
int iscntrl(int <[c]>); int iscntrl(int <[c]>);
#include <ctype.h>
int iscntrl_l(int <[c]>, locale_t <[locale]>);
TRAD_SYNOPSIS TRAD_SYNOPSIS
#include <ctype.h> #include <ctype.h>
int iscntrl(<[c]>); int iscntrl(<[c]>);
DESCRIPTION DESCRIPTION
<<iscntrl>> is a macro which classifies ASCII integer values by table <<iscntrl>> is a macro which classifies singlebyte charset values by table
lookup. It is a predicate returning non-zero for control characters, and 0 lookup. It is a predicate returning non-zero for control characters, and 0
for other characters. It is defined only if <[c]> is representable as an for other characters. It is defined only if <[c]> is representable as an
unsigned char or if <[c]> is EOF. unsigned char or if <[c]> is EOF.
<<iscntrl_l>> is like <<iscntrl>> but performs the check based on the
locale specified by the locale object locale. If <[locale]> is
LC_GLOBAL_LOCALE or not a valid locale object, the behaviour is undefined.
You can use a compiled subroutine instead of the macro definition by You can use a compiled subroutine instead of the macro definition by
undefining the macro using `<<#undef iscntrl>>'. undefining the macro using `<<#undef iscntrl>>' or `<<#undef iscntrl_l>>'.
RETURNS RETURNS
<<iscntrl>> returns non-zero if <[c]> is a delete character or ordinary <<iscntrl>>, <<iscntrl_l>> return non-zero if <[c]> is a delete character
control character (<<0x7F>> or <<0x00>>--<<0x1F>>). or ordinary control character.
PORTABILITY PORTABILITY
<<iscntrl>> is ANSI C. <<iscntrl>> is ANSI C.
<<iscntrl_l>> is POSIX-1.2008.
No supporting OS subroutines are required. No supporting OS subroutines are required.
*/ */
@ -44,5 +54,3 @@ _DEFUN(iscntrl,(c),int c)
{ {
return(__CTYPE_PTR[c+1] & _C); return(__CTYPE_PTR[c+1] & _C);
} }

34
newlib/libc/ctype/iscntrl_l.c
View File

@ -1,37 +1,3 @@
/*
FUNCTION
<<iscntrl_l>>---control character predicate
INDEX
iscntrl_l
ANSI_SYNOPSIS
#include <ctype.h>
int iscntrl_l(int <[c]>, locale_t <[locale]>);
DESCRIPTION
<<iscntrl_l>> is a macro which classifies ASCII integer values by table
lookup in locale <[locale]>. It is a predicate returning non-zero for
control characters, and 0 for other characters. It is defined only if
<[c]> is representable as an unsigned char or if <[c]> is EOF.
if <[locale]> is LC_GLOBAL_LOCALE or not a valid locale object, the behaviour
is undefined.
You can use a compiled subroutine instead of the macro definition by
undefining the macro using `<<#undef iscntrl_l>>'.
RETURNS
<<iscntrl_l>> returns non-zero if <[c]> is a delete character or ordinary
control character (<<0x7F>> or <<0x00>>--<<0x1F>>).
PORTABILITY
<<iscntrl_l>> is POSIX-1.2008.
No supporting OS subroutines are required.
*/
#include <_ansi.h> #include <_ansi.h>
#include <ctype.h> #include <ctype.h>

30
newlib/libc/ctype/isdigit.c
View File

@ -1,32 +1,44 @@
/* /*
FUNCTION FUNCTION
<<isdigit>>---decimal digit predicate <<isdigit>>, <<isdigit_l>>---decimal digit predicate
INDEX INDEX
isdigit isdigit
INDEX
isdigit_l
ANSI_SYNOPSIS ANSI_SYNOPSIS
#include <ctype.h> #include <ctype.h>
int isdigit(int <[c]>); int isdigit(int <[c]>);
#include <ctype.h>
int isdigit_l(int <[c]>, locale_t <[locale]>);
TRAD_SYNOPSIS TRAD_SYNOPSIS
#include <ctype.h> #include <ctype.h>
int isdigit(<[c]>); int isdigit(<[c]>);
DESCRIPTION DESCRIPTION
<<isdigit>> is a macro which classifies ASCII integer values by table <<isdigit>> is a macro which classifies singlebyte charset values by table
lookup. It is a predicate returning non-zero for decimal digits, and 0 for lookup. It is a predicate returning non-zero for decimal digits, and 0 for
other characters. It is defined only if <[c]> is representable as an other characters. It is defined only if <[c]> is representable as an
unsigned char or if <[c]> is EOF. unsigned char or if <[c]> is EOF.
<<isdigit_l>> is like <<isdigit>> but performs the check based on the
locale specified by the locale object locale. If <[locale]> is
LC_GLOBAL_LOCALE or not a valid locale object, the behaviour is undefined.
You can use a compiled subroutine instead of the macro definition by You can use a compiled subroutine instead of the macro definition by
undefining the macro using `<<#undef isdigit>>'. undefining the macro using `<<#undef isdigit>>' or `<<#undef isdigit_l>>'.
RETURNS RETURNS
<<isdigit>> returns non-zero if <[c]> is a decimal digit (<<0>>--<<9>>). <<isdigit>>, <<isdigit_l>> return non-zero if <[c]> is a decimal digit
(<<0>>--<<9>>).
PORTABILITY PORTABILITY
<<isdigit>> is ANSI C. <<isdigit>> is ANSI C.
<<isdigit_l>> is POSIX-1.2008.
No supporting OS subroutines are required. No supporting OS subroutines are required.
*/ */

32
newlib/libc/ctype/isdigit_l.c
View File

@ -1,35 +1,3 @@
/*
FUNCTION
<<isdigit_l>>---decimal digit predicate
INDEX
isdigit_l
ANSI_SYNOPSIS
#include <ctype.h>
int isdigit_l(int <[c]>, locale_t <[locale]>);
DESCRIPTION
<<isdigit_l>> is a macro which classifies ASCII integer values by table
lookup in locale <[locale]>. It is a predicate returning non-zero for
decimal digits, and 0 for other characters. It is defined only if <[c]>
is representable as an unsigned char or if <[c]> is EOF.
if <[locale]> is LC_GLOBAL_LOCALE or not a valid locale object, the behaviour
is undefined.
You can use a compiled subroutine instead of the macro definition by
undefining the macro using `<<#undef isdigit_l>>'.
RETURNS
<<isdigit_l>> returns non-zero if <[c]> is a decimal digit (<<0>>--<<9>>).
PORTABILITY
<<isdigit_l>> is POSIX-1.2008.
No supporting OS subroutines are required.
*/
#include <_ansi.h> #include <_ansi.h>
#include <ctype.h> #include <ctype.h>

31
newlib/libc/ctype/islower.c
View File

@ -1,34 +1,44 @@
/* /*
FUNCTION FUNCTION
<<islower>>---lowercase character predicate <<islower>>, <<islower_l>>---lowercase character predicate
INDEX INDEX
islower islower
INDEX
islower_l
ANSI_SYNOPSIS ANSI_SYNOPSIS
#include <ctype.h> #include <ctype.h>
int islower(int <[c]>); int islower(int <[c]>);
#include <ctype.h>
int islower_l(int <[c]>, locale_t <[locale]>);
TRAD_SYNOPSIS TRAD_SYNOPSIS
#include <ctype.h> #include <ctype.h>
int islower(<[c]>); int islower(<[c]>);
DESCRIPTION DESCRIPTION
<<islower>> is a macro which classifies ASCII integer values by table <<islower>> is a macro which classifies singlebyte charset values by table
lookup. It is a predicate returning non-zero for minuscules lookup. It is a predicate returning non-zero for minuscules
(lowercase alphabetic characters), and 0 for other characters. (lowercase alphabetic characters), and 0 for other characters.
It is defined only if <[c]> is representable as an unsigned char or if It is defined only if <[c]> is representable as an unsigned char or if
<[c]> is EOF. <[c]> is EOF.
<<islower_l>> is like <<islower>> but performs the check based on the
locale specified by the locale object locale. If <[locale]> is
LC_GLOBAL_LOCALE or not a valid locale object, the behaviour is undefined.
You can use a compiled subroutine instead of the macro definition by You can use a compiled subroutine instead of the macro definition by
undefining the macro using `<<#undef islower>>'. undefining the macro using `<<#undef islower>>' or `<<#undef islower_l>>'.
RETURNS RETURNS
<<islower>> returns non-zero if <[c]> is a lowercase letter (<<a>>--<<z>>). <<islower>>, <<islower_l>> return non-zero if <[c]> is a lowercase letter.
PORTABILITY PORTABILITY
<<islower>> is ANSI C. <<islower>> is ANSI C.
<<islower_l>> is POSIX-1.2008.
No supporting OS subroutines are required. No supporting OS subroutines are required.
*/ */
@ -41,4 +51,3 @@ _DEFUN(islower,(c),int c)
{ {
return ((__CTYPE_PTR[c+1] & (_U|_L)) == _L); return ((__CTYPE_PTR[c+1] & (_U|_L)) == _L);
} }

33
newlib/libc/ctype/islower_l.c
View File

@ -1,36 +1,3 @@
/*
FUNCTION
<<islower_l>>---lowercase character predicate
INDEX
islower_l
ANSI_SYNOPSIS
#include <ctype.h>
int islower_l(int <[c]>, locale_t <[locale]>);
DESCRIPTION
<<islower_l>> is a macro which classifies ASCII integer values by table
lookup in locale <[locale]>. It is a predicate returning non-zero for
minuscules (lowercase alphabetic characters), and 0 for other characters.
It is defined only if <[c]> is representable as an unsigned char or if
<[c]> is EOF.
if <[locale]> is LC_GLOBAL_LOCALE or not a valid locale object, the behaviour
is undefined.
You can use a compiled subroutine instead of the macro definition by
undefining the macro using `<<#undef islower_l>>'.
RETURNS
<<islower_l>> returns non-zero if <[c]> is a lowercase letter (<<a>>--<<z>>).
PORTABILITY
<<islower_l>> is POSIX-1.2008.
No supporting OS subroutines are required.
*/
#include <_ansi.h> #include <_ansi.h>
#include <ctype.h> #include <ctype.h>

43
newlib/libc/ctype/isprint.c
View File

@ -1,39 +1,55 @@
/* /*
FUNCTION FUNCTION
<<isprint>>, <<isgraph>>---printable character predicates <<isprint>>, <<isgraph>>, <<isprint_l>>, <<isgraph_l>>---printable character predicates
INDEX INDEX
isprint isprint
INDEX INDEX
isgraph isgraph
INDEX
isprint_l
INDEX
isgraph_l
ANSI_SYNOPSIS ANSI_SYNOPSIS
#include <ctype.h> #include <ctype.h>
int isprint(int <[c]>); int isprint(int <[c]>);
int isgraph(int <[c]>); int isgraph(int <[c]>);
#include <ctype.h>
int isprint_l(int <[c]>, locale_t <[locale]>);
int isgraph_l(int <[c]>, locale_t <[locale]>);
TRAD_SYNOPSIS TRAD_SYNOPSIS
#include <ctype.h> #include <ctype.h>
int isprint(<[c]>); int isprint(<[c]>);
int isgraph(<[c]>); int isgraph(<[c]>);
DESCRIPTION DESCRIPTION
<<isprint>> is a macro which classifies ASCII integer values by table <<isprint>> is a macro which classifies singlebyte charset values by table
lookup. It is a predicate returning non-zero for printable lookup. It is a predicate returning non-zero for printable characters,
characters, and 0 for other character arguments. and 0 for other character arguments. It is defined only if <[c]> is
It is defined only if <[c]> is representable as an unsigned char or if representable as an unsigned char or if <[c]> is EOF.
<[c]> is EOF.
<<isgraph>> behaves identically to <<isprint>>, except that space characters
are excluded.
<<isprint_l>>, <<isgraph_l>> are like <<isprint>>, <<isgraph>> but perform
the check based on the locale specified by the locale object locale. If
<[locale]> is LC_GLOBAL_LOCALE or not a valid locale object, the behaviour
is undefined.
You can use a compiled subroutine instead of the macro definition by You can use a compiled subroutine instead of the macro definition by
undefining either macro using `<<#undef isprint>>' or `<<#undef isgraph>>'. undefining either macro using `<<#undef isprint>>' or `<<#undef isgraph>>',
or `<<#undef isprint_l>>' or `<<#undef isgraph_l>>'.
RETURNS RETURNS
<<isprint>> returns non-zero if <[c]> is a printing character, <<isprint>>,<isprint_l> return non-zero if <[c]> is a printing character.
(<<0x20>>--<<0x7E>>). <<isgraph>>, <<isgraph_l> return non-zero if <[c]> is a printing character
<<isgraph>> behaves identically to <<isprint>>, except that the space except spaces.
character (<<0x20>>) is excluded.
PORTABILITY PORTABILITY
<<isprint>> and <<isgraph>> are ANSI C. <<isprint>> and <<isgraph>> are ANSI C.
@ -58,4 +74,3 @@ _DEFUN(isprint,(c),int c)
{ {
return(__CTYPE_PTR[c+1] & (_P|_U|_L|_N|_B)); return(__CTYPE_PTR[c+1] & (_P|_U|_L|_N|_B));
} }

39
newlib/libc/ctype/isprint_l.c
View File

@ -1,42 +1,3 @@
/*
FUNCTION
<<isprint_l>>, <<isgraph_l>>---printable character predicates
INDEX
isprint_l
INDEX
isgraph_l
ANSI_SYNOPSIS
#include <ctype.h>
int isprint_l(int <[c]>, locale_t <[locale]>);
int isgraph_l(int <[c]>, locale_t <[locale]>);
DESCRIPTION
<<isprint_l>> is a macro which classifies ASCII integer values by table
lookup in locale <[locale]>. It is a predicate returning non-zero for
printable characters, and 0 for other character arguments. It is defined
only if <[c]> is representable as an unsigned char or if <[c]> is EOF.
if <[locale]> is LC_GLOBAL_LOCALE or not a valid locale object, the behaviour
is undefined.
You can use a compiled subroutine instead of the macro definition by
undefining either macro using `<<#undef isprint_l>>' or `<<#undef isgraph_l>>'.
RETURNS
<<isprint_l>> returns non-zero if <[c]> is a printing character,
(<<0x20>>--<<0x7E>>).
<<isgraph_l>> behaves identically to <<isprint_l>>, except that the space
character (<<0x20>>) is excluded.
PORTABILITY
<<isprint_l>> and <<isgraph_l>> are POSIX-1.2008.
No supporting OS subroutines are required.
*/
#include <_ansi.h> #include <_ansi.h>
#include <ctype.h> #include <ctype.h>

33
newlib/libc/ctype/ispunct.c
View File

@ -1,34 +1,44 @@
/* /*
FUNCTION FUNCTION
<<ispunct>>---punctuation character predicate <<ispunct>>, <<ispunct_l>>---punctuation character predicate
INDEX INDEX
ispunct ispunct
INDEX
ispunct_l
ANSI_SYNOPSIS ANSI_SYNOPSIS
#include <ctype.h> #include <ctype.h>
int ispunct(int <[c]>); int ispunct(int <[c]>);
#include <ctype.h>
int ispunct_l(int <[c]>, locale_t <[locale]>);
TRAD_SYNOPSIS TRAD_SYNOPSIS
#include <ctype.h> #include <ctype.h>
int ispunct(<[c]>); int ispunct(<[c]>);
DESCRIPTION DESCRIPTION
<<ispunct>> is a macro which classifies ASCII integer values by table <<ispunct>> is a macro which classifies singlebyte charset values by table
lookup. It is a predicate returning non-zero for printable lookup. It is a predicate returning non-zero for printable
punctuation characters, and 0 for other characters. It is defined only punctuation characters, and 0 for other characters. It is defined only
if <[c]> is representable as an unsigned char or if <[c]> is EOF. if <[c]> is representable as an unsigned char or if <[c]> is EOF.
<<ispunct_l>> is like <<ispunct>> but performs the check based on the
locale specified by the locale object locale. If <[locale]> is
LC_GLOBAL_LOCALE or not a valid locale object, the behaviour is undefined.
You can use a compiled subroutine instead of the macro definition by You can use a compiled subroutine instead of the macro definition by
undefining the macro using `<<#undef ispunct>>'. undefining the macro using `<<#undef ispunct>>' or `<<#undef ispunct_l>>'.
RETURNS RETURNS
<<ispunct>> returns non-zero if <[c]> is a printable punctuation character <<ispunct>>, <<ispunct_l>> return non-zero if <[c]> is a printable
(<<isgraph(<[c]>) && !isalnum(<[c]>)>>). punctuation character.
PORTABILITY PORTABILITY
<<ispunct>> is ANSI C. <<ispunct>> is ANSI C.
<<ispunct_l>> is POSIX-1.2008.
No supporting OS subroutines are required. No supporting OS subroutines are required.
*/ */
@ -43,4 +53,3 @@ _DEFUN(ispunct,(c),int c)
{ {
return(__CTYPE_PTR[c+1] & _P); return(__CTYPE_PTR[c+1] & _P);
} }

34
newlib/libc/ctype/ispunct_l.c
View File

@ -1,37 +1,3 @@
/*
FUNCTION
<<ispunct_l>>---punctuation character predicate
INDEX
ispunct_l
ANSI_SYNOPSIS
#include <ctype.h>
int ispunct_l(int <[c]>, locale_t <[locale]>);
DESCRIPTION
<<ispunct_l>> is a macro which classifies ASCII integer values by table
lookup in locale <[locale]>. It is a predicate returning non-zero for
printable punctuation characters, and 0 for other characters. It is
defined only if <[c]> is representable as an unsigned char or if <[c]> is EOF.
if <[locale]> is LC_GLOBAL_LOCALE or not a valid locale object, the behaviour
is undefined.
You can use a compiled subroutine instead of the macro definition by
undefining the macro using `<<#undef ispunct_l>>'.
RETURNS
<<ispunct_l>> returns non-zero if <[c]> is a printable punctuation character
(<<isgraph(<[c]>) && !isalnum(<[c]>)>>).
PORTABILITY
<<ispunct_l>> is POSIX-1.2008
No supporting OS subroutines are required.
*/
#include <_ansi.h> #include <_ansi.h>
#include <ctype.h> #include <ctype.h>

24
newlib/libc/ctype/isspace.c
View File

@ -1,33 +1,44 @@
/* /*
FUNCTION FUNCTION
<<isspace>>---whitespace character predicate <<isspace>>, <<isspace_l>>---whitespace character predicate
INDEX INDEX
isspace isspace
INDEX
isspace_l
ANSI_SYNOPSIS ANSI_SYNOPSIS
#include <ctype.h> #include <ctype.h>
int isspace(int <[c]>); int isspace(int <[c]>);
#include <ctype.h>
int isspace_l(int <[c]>, locale_t <[locale]>);
TRAD_SYNOPSIS TRAD_SYNOPSIS
#include <ctype.h> #include <ctype.h>
int isspace(<[c]>); int isspace(<[c]>);
DESCRIPTION DESCRIPTION
<<isspace>> is a macro which classifies ASCII integer values by table <<isspace>> is a macro which classifies singlebyte charset values by table
lookup. It is a predicate returning non-zero for whitespace lookup. It is a predicate returning non-zero for whitespace
characters, and 0 for other characters. It is defined only when <<isascii>>(<[c]>) is true or <[c]> is EOF. characters, and 0 for other characters. It is defined only when <<isascii>>(<[c]>) is true or <[c]> is EOF.
<<isspace_l>> is like <<isspace>> but performs the check based on the
locale specified by the locale object locale. If <[locale]> is
LC_GLOBAL_LOCALE or not a valid locale object, the behaviour is undefined.
You can use a compiled subroutine instead of the macro definition by You can use a compiled subroutine instead of the macro definition by
undefining the macro using `<<#undef isspace>>'. undefining the macro using `<<#undef isspace>>' or `<<#undef isspace_l>>'.
RETURNS RETURNS
<<isspace>> returns non-zero if <[c]> is a space, tab, carriage return, new <<isspace>>, <<isspace_l>> return non-zero if <[c]> is a space, tab,
line, vertical tab, or formfeed (<<0x09>>--<<0x0D>>, <<0x20>>). carriage return, new line, vertical tab, or formfeed (<<0x09>>--<<0x0D>>,
<<0x20>>), or one of the other space characters in non-ASCII charsets.
PORTABILITY PORTABILITY
<<isspace>> is ANSI C. <<isspace>> is ANSI C.
<<isspace_l>> is POSIX-1.2008.
No supporting OS subroutines are required. No supporting OS subroutines are required.
*/ */
@ -41,4 +52,3 @@ _DEFUN(isspace,(c),int c)
{ {
return(__CTYPE_PTR[c+1] & _S); return(__CTYPE_PTR[c+1] & _S);
} }

32
newlib/libc/ctype/isspace_l.c
View File

@ -1,35 +1,3 @@
/*
FUNCTION
<<isspace_l>>---whitespace character predicate
INDEX
isspace_l
ANSI_SYNOPSIS
#include <ctype.h>
int isspace_l(int <[c]>, locale_t *<[locale]>);
DESCRIPTION
<<isspace_l>> is a macro which classifies ASCII integer values by table
lookup in locale <[locale]>. It is a predicate returning non-zero for
whitespace characters, and 0 for other characters. It is defined only
when <<isascii>>(<[c]>) is true or <[c]> is EOF.
if <[locale]> is LC_GLOBAL_LOCALE or not a valid locale object, the behaviour
is undefined.
You can use a compiled subroutine instead of the macro definition by
undefining the macro using `<<#undef isspace_l>>'.
RETURNS
<<isspace_l>> returns non-zero if <[c]> is a space, tab, carriage return, new
line, vertical tab, or formfeed (<<0x09>>--<<0x0D>>, <<0x20>>).
PORTABILITY
<<isspace_l>> is POSIX-1.2008.
No supporting OS subroutines are required.
*/
#include <_ansi.h> #include <_ansi.h>
#include <ctype.h> #include <ctype.h>

34
newlib/libc/ctype/isupper.c
View File

@ -1,33 +1,42 @@
/* /*
FUNCTION FUNCTION
<<isupper>>---uppercase character predicate <<isupper>>, <<isupper_l>>---uppercase character predicate
INDEX INDEX
isupper isupper
INDEX
isupper_l
ANSI_SYNOPSIS ANSI_SYNOPSIS
#include <ctype.h> #include <ctype.h>
int isupper(int <[c]>); int isupper(int <[c]>);
#include <ctype.h>
int isupper_l(int <[c]>, locale_t <[locale]>);
TRAD_SYNOPSIS TRAD_SYNOPSIS
#include <ctype.h> #include <ctype.h>
int isupper(<[c]>); int isupper(<[c]>);
DESCRIPTION DESCRIPTION
<<isupper>> is a macro which classifies ASCII integer values by table <<isupper>> is a macro which classifies singlebyte charset values by table
lookup. It is a predicate returning non-zero for uppercase letters lookup. It is a predicate returning non-zero for uppercase letters
(<<A>>--<<Z>>), and 0 for other characters. It is defined only when (<<A>>--<<Z>>), and 0 for other characters.
<<isascii>>(<[c]>) is true or <[c]> is EOF.
<<isupper_l>> is like <<isupper>> but performs the check based on the
locale specified by the locale object locale. If <[locale]> is
LC_GLOBAL_LOCALE or not a valid locale object, the behaviour is undefined.
You can use a compiled subroutine instead of the macro definition by You can use a compiled subroutine instead of the macro definition by
undefining the macro using `<<#undef isupper>>'. undefining the macro using `<<#undef isupper>>' or `<<#undef isupper_l>>'.
RETURNS RETURNS
<<isupper>> returns non-zero if <[c]> is a uppercase letter (A-Z). <<isupper>>, <<isupper_l>> return non-zero if <[c]> is an uppercase letter.
PORTABILITY PORTABILITY
<<isupper>> is ANSI C. <<isupper>> is ANSI C.
<<isupper_l>> is POSIX-1.2008.
No supporting OS subroutines are required. No supporting OS subroutines are required.
*/ */
@ -40,4 +49,3 @@ _DEFUN(isupper,(c),int c)
{ {
return ((__CTYPE_PTR[c+1] & (_U|_L)) == _U); return ((__CTYPE_PTR[c+1] & (_U|_L)) == _U);
} }

31
newlib/libc/ctype/isupper_l.c
View File

@ -1,34 +1,3 @@
/*
FUNCTION
<<isupper_l>>---uppercase character predicate
INDEX
isupper_l
ANSI_SYNOPSIS
#include <ctype.h>
int isupper_l(int <[c]>, locale_t <[locale]>);
DESCRIPTION
<<isupper_l>> is a macro which classifies ASCII integer values by table
lookup in locale <[locale]>. It is a predicate returning non-zero for
uppercase letters (<<A>>--<<Z>>), and 0 for other characters. It is
defined only when <<isascii>>(<[c]>) is true or <[c]> is EOF.
if <[locale]> is LC_GLOBAL_LOCALE or not a valid locale object, the behaviour
is undefined.
You can use a compiled subroutine instead of the macro definition by
undefining the macro using `<<#undef isupper_l>>'.
RETURNS
<<isupper_l>> returns non-zero if <[c]> is a uppercase letter (A-Z).
PORTABILITY
<<isupper_l>> is POSIX-1.2008.
No supporting OS subroutines are required.
*/
#include <_ansi.h> #include <_ansi.h>
#include <ctype.h> #include <ctype.h>

17
newlib/libc/ctype/iswalnum.c
View File

@ -1,14 +1,20 @@
/* /*
FUNCTION FUNCTION
<<iswalnum>>---alphanumeric wide character test <<iswalnum>>, <<iswalnum_l>>---alphanumeric wide character test
INDEX INDEX
iswalnum iswalnum
INDEX
iswalnum_l
ANSI_SYNOPSIS ANSI_SYNOPSIS
#include <wctype.h> #include <wctype.h>
int iswalnum(wint_t <[c]>); int iswalnum(wint_t <[c]>);
#include <wctype.h>
int iswalnum_l(wint_t <[c]>, locale_t <[locale]>);
TRAD_SYNOPSIS TRAD_SYNOPSIS
#include <wctype.h> #include <wctype.h>
int iswalnum(<[c]>) int iswalnum(<[c]>)
@ -18,11 +24,17 @@ DESCRIPTION
<<iswalnum>> is a function which classifies wide-character values that <<iswalnum>> is a function which classifies wide-character values that
are alphanumeric. are alphanumeric.
<<iswalnum_l>> is like <<iswalnum>> but performs the check based on the
locale specified by the locale object locale. If <[locale]> is
LC_GLOBAL_LOCALE or not a valid locale object, the behaviour is undefined.
RETURNS RETURNS
<<iswalnum>> returns non-zero if <[c]> is a alphanumeric wide character. <<iswalnum>>, <<iswalnum_l>> return non-zero if <[c]> is a alphanumeric
wide character.
PORTABILITY PORTABILITY
<<iswalnum>> is C99. <<iswalnum>> is C99.
<<iswalnum_l>> is POSIX-1.2008.
No supporting OS subroutines are required. No supporting OS subroutines are required.
*/ */
@ -34,4 +46,3 @@ _DEFUN(iswalnum,(c),wint_t c)
{ {
return (iswalpha (c) || iswdigit (c)); return (iswalpha (c) || iswdigit (c));
} }

26
newlib/libc/ctype/iswalnum_l.c
View File

@ -1,29 +1,3 @@
/*
FUNCTION
<<iswalnum_l>>---alphanumeric wide character test
INDEX
iswalnum_l
ANSI_SYNOPSIS
#include <wctype.h>
int iswalnum_l(wint_t <[c]>, locale_t <[locale]>);
DESCRIPTION
<<iswalnum_l>> is a function which classifies wide-character values that
are alphanumeric in locale <[locale]>.
if <[locale]> is LC_GLOBAL_LOCALE or not a valid locale object, the behaviour
is undefined.
RETURNS
<<iswalnum_l>> returns non-zero if <[c]> is a alphanumeric wide character.
PORTABILITY
<<iswalnum_l>> is POSIX-1.2008.
No supporting OS subroutines are required.
*/
#include <_ansi.h> #include <_ansi.h>
#include <wctype.h> #include <wctype.h>

17
newlib/libc/ctype/iswalpha.c
View File

@ -29,15 +29,21 @@
/* /*
FUNCTION FUNCTION
<<iswalpha>>---alphabetic wide character test <<iswalpha>>, <<iswalpha_l>>---alphabetic wide character test
INDEX INDEX
iswalpha iswalpha
INDEX
iswalpha_l
ANSI_SYNOPSIS ANSI_SYNOPSIS
#include <wctype.h> #include <wctype.h>
int iswalpha(wint_t <[c]>); int iswalpha(wint_t <[c]>);
#include <wctype.h>
int iswalpha_l(wint_t <[c]>, locale_t <[locale]>);
TRAD_SYNOPSIS TRAD_SYNOPSIS
#include <wctype.h> #include <wctype.h>
int iswalpha(<[c]>) int iswalpha(<[c]>)
@ -47,11 +53,17 @@ DESCRIPTION
<<iswalpha>> is a function which classifies wide-character values that <<iswalpha>> is a function which classifies wide-character values that
are alphabetic. are alphabetic.
<<iswalpha_l>> is like <<iswalpha>> but performs the check based on the
locale specified by the locale object locale. If <[locale]> is
LC_GLOBAL_LOCALE or not a valid locale object, the behaviour is undefined.
RETURNS RETURNS
<<iswalpha>> returns non-zero if <[c]> is an alphabetic wide character. <<iswalpha>>, <<iswalpha_l>> return non-zero if <[c]> is an alphabetic
wide character.
PORTABILITY PORTABILITY
<<iswalpha>> is C99. <<iswalpha>> is C99.
<<iswalpha_l>> is POSIX-1.2008.
No supporting OS subroutines are required. No supporting OS subroutines are required.
*/ */
@ -430,4 +442,3 @@ _DEFUN(iswalpha,(c), wint_t c)
return (c < (wint_t)0x100 ? isalpha (c) : 0); return (c < (wint_t)0x100 ? isalpha (c) : 0);
#endif /* _MB_CAPABLE */ #endif /* _MB_CAPABLE */
} }

26
newlib/libc/ctype/iswalpha_l.c
View File

@ -1,29 +1,3 @@
/*
FUNCTION
<<iswalpha_l>>---alphabetic wide character test
INDEX
iswalpha_l
ANSI_SYNOPSIS
#include <wctype.h>
int iswalpha_l(wint_t <[c]>, locale_t <[locale]>);
DESCRIPTION
<<iswalpha_l>> is a function which classifies wide-character values that
are alphabetic.
if <[locale]> is LC_GLOBAL_LOCALE or not a valid locale object, the behaviour
is undefined.
RETURNS
<<iswalpha_l>> returns non-zero if <[c]> is an alphabetic wide character.
PORTABILITY
<<iswalpha_l>> is POSIX-1.2008.
No supporting OS subroutines are required.
*/
#include <_ansi.h> #include <_ansi.h>
#include <wctype.h> #include <wctype.h>

16
newlib/libc/ctype/iswblank.c
View File

@ -29,15 +29,21 @@
/* /*
FUNCTION FUNCTION
<<iswblank>>---blank wide character test <<iswblank>>, <<iswblank_l>>---blank wide character test
INDEX INDEX
iswblank iswblank
INDEX
iswblank_l
ANSI_SYNOPSIS ANSI_SYNOPSIS
#include <wctype.h> #include <wctype.h>
int iswblank(wint_t <[c]>); int iswblank(wint_t <[c]>);
#include <wctype.h>
int iswblank_l(wint_t <[c]>, locale_t <[locale]>);
TRAD_SYNOPSIS TRAD_SYNOPSIS
#include <wctype.h> #include <wctype.h>
int iswblank(<[c]>) int iswblank(<[c]>)
@ -47,11 +53,16 @@ DESCRIPTION
<<iswblank>> is a function which classifies wide-character values that <<iswblank>> is a function which classifies wide-character values that
are categorized as blank. are categorized as blank.
<<iswblank_l>> is like <<iswblank>> but performs the check based on the
locale specified by the locale object locale. If <[locale]> is
LC_GLOBAL_LOCALE or not a valid locale object, the behaviour is undefined.
RETURNS RETURNS
<<iswblank>> returns non-zero if <[c]> is a blank wide character. <<iswblank>>, <<iswblank_l>> return non-zero if <[c]> is a blank wide character.
PORTABILITY PORTABILITY
<<iswblank>> is C99. <<iswblank>> is C99.
<<iswblank_l>> is POSIX-1.2008.
No supporting OS subroutines are required. No supporting OS subroutines are required.
*/ */
@ -79,4 +90,3 @@ _DEFUN(iswblank,(c), wint_t c)
return (c < 0x100 ? isblank (c) : 0); return (c < 0x100 ? isblank (c) : 0);
#endif /* _MB_CAPABLE */ #endif /* _MB_CAPABLE */
} }

26
newlib/libc/ctype/iswblank_l.c
View File

@ -1,29 +1,3 @@
/*
FUNCTION
<<iswblank_l>>---blank wide character test
INDEX
iswblank_l
ANSI_SYNOPSIS
#include <wctype.h>
int iswblank_l(wint_t <[c]>, locale_t <[locale]>);
DESCRIPTION
<<iswblank_l>> is a function which classifies wide-character values that
are categorized as blank.
if <[locale]> is LC_GLOBAL_LOCALE or not a valid locale object, the behaviour
is undefined.
RETURNS
<<iswblank_l>> returns non-zero if <[c]> is a blank wide character.
PORTABILITY
<<iswblank_l>> is POSIX-1.2008.
No supporting OS subroutines are required.
*/
#include <_ansi.h> #include <_ansi.h>
#include <wctype.h> #include <wctype.h>

16
newlib/libc/ctype/iswcntrl.c
View File

@ -29,15 +29,21 @@
/* /*
FUNCTION FUNCTION
<<iswcntrl>>---control wide character test <<iswcntrl>>, <<iswcntrl_l>>---control wide character test
INDEX INDEX
iswcntrl iswcntrl
INDEX
iswcntrl_l
ANSI_SYNOPSIS ANSI_SYNOPSIS
#include <wctype.h> #include <wctype.h>
int iswcntrl(wint_t <[c]>); int iswcntrl(wint_t <[c]>);
#include <wctype.h>
int iswcntrl_l(wint_t <[c]>, locale_t <[locale]>);
TRAD_SYNOPSIS TRAD_SYNOPSIS
#include <wctype.h> #include <wctype.h>
int iswcntrl(<[c]>) int iswcntrl(<[c]>)
@ -47,11 +53,16 @@ DESCRIPTION
<<iswcntrl>> is a function which classifies wide-character values that <<iswcntrl>> is a function which classifies wide-character values that
are categorized as control characters. are categorized as control characters.
<<iswcntrl_l>> is like <<iswcntrl>> but performs the check based on the
locale specified by the locale object locale. If <[locale]> is
LC_GLOBAL_LOCALE or not a valid locale object, the behaviour is undefined.
RETURNS RETURNS
<<iswcntrl>> returns non-zero if <[c]> is a control wide character. <<iswcntrl>>, <<iswcntrl_l>> return non-zero if <[c]> is a control wide character.
PORTABILITY PORTABILITY
<<iswcntrl>> is C99. <<iswcntrl>> is C99.
<<iswcntrl_l>> is POSIX-1.2008.
No supporting OS subroutines are required. No supporting OS subroutines are required.
*/ */
@ -77,4 +88,3 @@ _DEFUN(iswcntrl,(c), wint_t c)
return (c < 0x100 ? iscntrl (c) : 0); return (c < 0x100 ? iscntrl (c) : 0);
#endif /* _MB_CAPABLE */ #endif /* _MB_CAPABLE */
} }

26
newlib/libc/ctype/iswcntrl_l.c
View File

@ -1,29 +1,3 @@
/*
FUNCTION
<<iswcntrl_l>>---control wide character test
INDEX
iswcntrl_l
ANSI_SYNOPSIS
#include <wctype.h>
int iswcntrl_l(wint_t <[c]>, locale_t <[locale]>);
DESCRIPTION
<<iswcntrl_l>> is a function which classifies wide-character values that
are categorized as control characters.
if <[locale]> is LC_GLOBAL_LOCALE or not a valid locale object, the behaviour
is undefined.
RETURNS
<<iswcntrl_l>> returns non-zero if <[c]> is a control wide character.
PORTABILITY
<<iswcntrl_l>> is POSIX-1.2008.
No supporting OS subroutines are required.
*/
#include <_ansi.h> #include <_ansi.h>
#include <wctype.h> #include <wctype.h>

18
newlib/libc/ctype/iswctype.c
View File

@ -1,14 +1,20 @@
/* /*
FUNCTION FUNCTION
<<iswctype>>---extensible wide-character test <<iswctype>>, <<iswctype_l>>---extensible wide-character test
INDEX INDEX
iswctype iswctype
INDEX
iswctype_l
ANSI_SYNOPSIS ANSI_SYNOPSIS
#include <wctype.h> #include <wctype.h>
int iswctype(wint_t <[c]>, wctype_t <[desc]>); int iswctype(wint_t <[c]>, wctype_t <[desc]>);
#include <wctype.h>
int iswctype_l(wint_t <[c]>, wctype_t <[desc]>, locale_t <[locale]>);
TRAD_SYNOPSIS TRAD_SYNOPSIS
#include <wctype.h> #include <wctype.h>
int iswctype(<[c]>, <[desc]>) int iswctype(<[c]>, <[desc]>)
@ -19,12 +25,17 @@ DESCRIPTION
<<iswctype>> is a function which classifies wide-character values using the <<iswctype>> is a function which classifies wide-character values using the
wide-character test specified by <[desc]>. wide-character test specified by <[desc]>.
<<iswctype_l>> is like <<iswctype>> but performs the check based on the
locale specified by the locale object locale. If <[locale]> is
LC_GLOBAL_LOCALE or not a valid locale object, the behaviour is undefined.
RETURNS RETURNS
<<iswctype>> returns non-zero if and only if <[c]> matches the test specified by <[desc]>. <<iswctype>>, <<iswctype_l>> return non-zero if and only if <[c]> matches
If <[desc]> is unknown, zero is returned. the test specified by <[desc]>. If <[desc]> is unknown, zero is returned.
PORTABILITY PORTABILITY
<<iswctype>> is C99. <<iswctype>> is C99.
<<iswctype_l>> is POSIX-1.2008.
No supporting OS subroutines are required. No supporting OS subroutines are required.
*/ */
@ -68,4 +79,3 @@ _DEFUN(iswctype,(c, desc), wint_t c _AND wctype_t desc)
/* otherwise unknown */ /* otherwise unknown */
return 0; return 0;
} }

27
newlib/libc/ctype/iswctype_l.c
View File

@ -1,30 +1,3 @@
/*
FUNCTION
<<iswctype_l>>---extensible wide-character test
INDEX
iswctype_l
ANSI_SYNOPSIS
#include <wctype.h>
int iswctype_l(wint_t <[c]>, wctype_t <[desc]>, locale_t <[locale]>);
DESCRIPTION
<<iswctype_l>> is a function which classifies wide-character values using the
wide-character test specified by <[desc]>.
if <[locale]> is LC_GLOBAL_LOCALE or not a valid locale object, the behaviour
is undefined.
RETURNS
<<iswctype_l>> returns non-zero if and only if <[c]> matches the test specified by <[desc]>.
If <[desc]> is unknown, zero is returned.
PORTABILITY
<<iswctype_l>> is POSIX-1.2008.
No supporting OS subroutines are required.
*/
#include <_ansi.h> #include <_ansi.h>
#include <wctype.h> #include <wctype.h>

16
newlib/libc/ctype/iswdigit.c
View File

@ -1,14 +1,20 @@
/* /*
FUNCTION FUNCTION
<<iswdigit>>---decimal digit wide character test <<iswdigit>>, <<iswdigit_l>>---decimal digit wide character test
INDEX INDEX
iswdigit iswdigit
INDEX
iswdigit_l
ANSI_SYNOPSIS ANSI_SYNOPSIS
#include <wctype.h> #include <wctype.h>
int iswdigit(wint_t <[c]>); int iswdigit(wint_t <[c]>);
#include <wctype.h>
int iswdigit_l(wint_t <[c]>, locale_t <[locale]>);
TRAD_SYNOPSIS TRAD_SYNOPSIS
#include <wctype.h> #include <wctype.h>
int iswdigit(<[c]>) int iswdigit(<[c]>)
@ -18,11 +24,16 @@ DESCRIPTION
<<iswdigit>> is a function which classifies wide-character values that <<iswdigit>> is a function which classifies wide-character values that
are decimal digits. are decimal digits.
<<iswdigit_l>> is like <<iswdigit>> but performs the check based on the
locale specified by the locale object locale. If <[locale]> is
LC_GLOBAL_LOCALE or not a valid locale object, the behaviour is undefined.
RETURNS RETURNS
<<iswdigit>> returns non-zero if <[c]> is a decimal digit wide character. <<iswdigit>>, <<iswdigit_l>> return non-zero if <[c]> is a decimal digit wide character.
PORTABILITY PORTABILITY
<<iswdigit>> is C99. <<iswdigit>> is C99.
<<iswdigit_l>> is POSIX-1.2008.
No supporting OS subroutines are required. No supporting OS subroutines are required.
*/ */
@ -34,4 +45,3 @@ _DEFUN(iswdigit,(c), wint_t c)
{ {
return (c >= (wint_t)'0' && c <= (wint_t)'9'); return (c >= (wint_t)'0' && c <= (wint_t)'9');
} }

26
newlib/libc/ctype/iswdigit_l.c
View File

@ -1,29 +1,3 @@
/*
FUNCTION
<<iswdigit_l>>---decimal digit wide character test
INDEX
iswdigit_l
ANSI_SYNOPSIS
#include <wctype.h>
int iswdigit_l(wint_t <[c]>, locale_t <[locale]>);
DESCRIPTION
<<iswdigit_l>> is a function which classifies wide-character values that
are decimal digits.
if <[locale]> is LC_GLOBAL_LOCALE or not a valid locale object, the behaviour
is undefined.
RETURNS
<<iswdigit_l>> returns non-zero if <[c]> is a decimal digit wide character.
PORTABILITY
<<iswdigit_l>> is POSIX-1.2008.
No supporting OS subroutines are required.
*/
#include <_ansi.h> #include <_ansi.h>
#include <wctype.h> #include <wctype.h>

16
newlib/libc/ctype/iswgraph.c
View File

@ -29,15 +29,21 @@
/* /*
FUNCTION FUNCTION
<<iswgraph>>---graphic wide character test <<iswgraph>>, <<iswgraph_l>>---graphic wide character test
INDEX INDEX
iswgraph iswgraph
INDEX
iswgraph_l
ANSI_SYNOPSIS ANSI_SYNOPSIS
#include <wctype.h> #include <wctype.h>
int iswgraph(wint_t <[c]>); int iswgraph(wint_t <[c]>);
#include <wctype.h>
int iswgraph_l(wint_t <[c]>, locale_t <[locale]>);
TRAD_SYNOPSIS TRAD_SYNOPSIS
#include <wctype.h> #include <wctype.h>
int iswgraph(<[c]>) int iswgraph(<[c]>)
@ -47,11 +53,16 @@ DESCRIPTION
<<iswgraph>> is a function which classifies wide-character values that <<iswgraph>> is a function which classifies wide-character values that
are graphic. are graphic.
<<iswgraph_l>> is like <<iswgraph>> but performs the check based on the
locale specified by the locale object locale. If <[locale]> is
LC_GLOBAL_LOCALE or not a valid locale object, the behaviour is undefined.
RETURNS RETURNS
<<iswgraph>> returns non-zero if <[c]> is a graphic wide character. <<iswgraph>>, <<iswgraph_l>> return non-zero if <[c]> is a graphic wide character.
PORTABILITY PORTABILITY
<<iswgraph>> is C99. <<iswgraph>> is C99.
<<iswgraph_l>> is POSIX-1.2008.
No supporting OS subroutines are required. No supporting OS subroutines are required.
*/ */
@ -63,4 +74,3 @@ _DEFUN(iswgraph,(c),wint_t c)
{ {
return (iswprint (c) && !iswspace (c)); return (iswprint (c) && !iswspace (c));
} }

26
newlib/libc/ctype/iswgraph_l.c
View File

@ -1,29 +1,3 @@
/*
FUNCTION
<<iswgraph_l>>---graphic wide character test
INDEX
iswgraph_l
ANSI_SYNOPSIS
#include <wctype.h>
int iswgraph_l(wint_t <[c]>, locale_t <[locale]>);
DESCRIPTION
<<iswgraph_l>> is a function which classifies wide-character values that
are graphic.
if <[locale]> is LC_GLOBAL_LOCALE or not a valid locale object, the behaviour
is undefined.
RETURNS
<<iswgraph_l>> returns non-zero if <[c]> is a graphic wide character.
PORTABILITY
<<iswgraph_l>> is POSIX-1.2008.
No supporting OS subroutines are required.
*/
#include <_ansi.h> #include <_ansi.h>
#include <wctype.h> #include <wctype.h>

17
newlib/libc/ctype/iswlower.c
View File

@ -1,15 +1,20 @@
/* /*
FUNCTION FUNCTION
<<iswlower>>---lowercase wide character test <<iswlower>>, <<iswlower_l>>---lowercase wide character test
INDEX INDEX
iswlower iswlower
INDEX
iswlower_l
ANSI_SYNOPSIS ANSI_SYNOPSIS
#include <wctype.h> #include <wctype.h>
int iswlower(wint_t <[c]>); int iswlower(wint_t <[c]>);
#include <wctype.h>
int iswlower_l(wint_t <[c]>, locale_t <[locale]>);
TRAD_SYNOPSIS TRAD_SYNOPSIS
#include <wctype.h> #include <wctype.h>
int iswlower(<[c]>) int iswlower(<[c]>)
@ -19,11 +24,16 @@ DESCRIPTION
<<iswlower>> is a function which classifies wide-character values that <<iswlower>> is a function which classifies wide-character values that
have uppercase translations. have uppercase translations.
<<iswlower_l>> is like <<iswlower>> but performs the check based on the
locale specified by the locale object locale. If <[locale]> is
LC_GLOBAL_LOCALE or not a valid locale object, the behaviour is undefined.
RETURNS RETURNS
<<iswlower>> returns non-zero if <[c]> is a lowercase wide character. <<iswlower>>, <<iswlower_l>> return non-zero if <[c]> is a lowercase wide character.
PORTABILITY PORTABILITY
<<iswlower>> is C99. <<iswlower>> is C99.
<<iswlower_l>> is POSIX-1.2008.
No supporting OS subroutines are required. No supporting OS subroutines are required.
*/ */
@ -35,4 +45,3 @@ _DEFUN(iswlower,(c),wint_t c)
{ {
return (towupper (c) != c); return (towupper (c) != c);
} }

27
newlib/libc/ctype/iswlower_l.c
View File

@ -1,30 +1,3 @@
/*
FUNCTION
<<iswlower_l>>---lowercase wide character test
INDEX
iswlower_l
ANSI_SYNOPSIS
#include <wctype.h>
int iswlower_l(wint_t <[c]>, locale_t <[locale]>);
DESCRIPTION
<<iswlower_l>> is a function which classifies wide-character values that
have uppercase translations.
if <[locale]> is LC_GLOBAL_LOCALE or not a valid locale object, the behaviour
is undefined.
RETURNS
<<iswlower_l>> returns non-zero if <[c]> is a lowercase wide character.
PORTABILITY
<<iswlower_l>> is POSIX-1.2008.
No supporting OS subroutines are required.
*/
#include <_ansi.h> #include <_ansi.h>
#include <wctype.h> #include <wctype.h>

16
newlib/libc/ctype/iswprint.c
View File

@ -29,15 +29,21 @@
/* /*
FUNCTION FUNCTION
<<iswprint>>---printable wide character test <<iswprint>>, <<iswprint_l>>---printable wide character test
INDEX INDEX
iswprint iswprint
INDEX
iswprint_l
ANSI_SYNOPSIS ANSI_SYNOPSIS
#include <wctype.h> #include <wctype.h>
int iswprint(wint_t <[c]>); int iswprint(wint_t <[c]>);
#include <wctype.h>
int iswprint_l(wint_t <[c]>, locale_t <[locale]>);
TRAD_SYNOPSIS TRAD_SYNOPSIS
#include <wctype.h> #include <wctype.h>
int iswprint(<[c]>) int iswprint(<[c]>)
@ -47,11 +53,16 @@ DESCRIPTION
<<iswprint>> is a function which classifies wide-character values that <<iswprint>> is a function which classifies wide-character values that
are printable. are printable.
<<iswprint_l>> is like <<iswprint>> but performs the check based on the
locale specified by the locale object locale. If <[locale]> is
LC_GLOBAL_LOCALE or not a valid locale object, the behaviour is undefined.
RETURNS RETURNS
<<iswprint>> returns non-zero if <[c]> is a printable wide character. <<iswprint>>, <<iswprint_l>> return non-zero if <[c]> is a printable wide character.
PORTABILITY PORTABILITY
<<iswprint>> is C99. <<iswprint>> is C99.
<<iswprint_l>> is POSIX-1.2008.
No supporting OS subroutines are required. No supporting OS subroutines are required.
*/ */
@ -493,4 +504,3 @@ _DEFUN(iswprint,(c), wint_t c)
return (c < (wint_t)0x100 ? isprint (c) : 0); return (c < (wint_t)0x100 ? isprint (c) : 0);
#endif /* _MB_CAPABLE */ #endif /* _MB_CAPABLE */
} }

26
newlib/libc/ctype/iswprint_l.c
View File

@ -1,29 +1,3 @@
/*
FUNCTION
<<iswprint_l>>---printable wide character test
INDEX
iswprint_l
ANSI_SYNOPSIS
#include <wctype.h>
int iswprint_l(wint_t <[c]>, locale_t <[locale]>);
DESCRIPTION
<<iswprint_l>> is a function which classifies wide-character values that
are printable.
if <[locale]> is LC_GLOBAL_LOCALE or not a valid locale object, the behaviour
is undefined.
RETURNS
<<iswprint_l>> returns non-zero if <[c]> is a printable wide character.
PORTABILITY
<<iswprint_l>> is POSIX-1.2008.
No supporting OS subroutines are required.
*/
#include <_ansi.h> #include <_ansi.h>
#include <wctype.h> #include <wctype.h>

16
newlib/libc/ctype/iswpunct.c
View File

@ -29,15 +29,21 @@
/* /*
FUNCTION FUNCTION
<<iswpunct>>---punctuation wide character test <<iswpunct>>, <<iswpunct_l>>---punctuation wide character test
INDEX INDEX
iswpunct iswpunct
INDEX
iswpunct_l
ANSI_SYNOPSIS ANSI_SYNOPSIS
#include <wctype.h> #include <wctype.h>
int iswpunct(wint_t <[c]>); int iswpunct(wint_t <[c]>);
#include <wctype.h>
int iswpunct_l(wint_t <[c]>, locale_t <[locale]>);
TRAD_SYNOPSIS TRAD_SYNOPSIS
#include <wctype.h> #include <wctype.h>
int iswpunct(<[c]>) int iswpunct(<[c]>)
@ -47,11 +53,16 @@ DESCRIPTION
<<iswpunct>> is a function which classifies wide-character values that <<iswpunct>> is a function which classifies wide-character values that
are punctuation. are punctuation.
<<iswpunct_l>> is like <<iswpunct>> but performs the check based on the
locale specified by the locale object locale. If <[locale]> is
LC_GLOBAL_LOCALE or not a valid locale object, the behaviour is undefined.
RETURNS RETURNS
<<iswpunct>> returns non-zero if <[c]> is a punctuation wide character. <<iswpunct>>, <<iswpunct_l>> return non-zero if <[c]> is a punctuation wide character.
PORTABILITY PORTABILITY
<<iswpunct>> is C99. <<iswpunct>> is C99.
<<iswpunct_l>> is POSIX-1.2008.
No supporting OS subroutines are required. No supporting OS subroutines are required.
*/ */
@ -67,4 +78,3 @@ _DEFUN(iswpunct,(c), wint_t c)
{ {
return (!iswalnum (c) && iswgraph (c)); return (!iswalnum (c) && iswgraph (c));
} }

26
newlib/libc/ctype/iswpunct_l.c
View File

@ -1,29 +1,3 @@
/*
FUNCTION
<<iswpunct_l>>---punctuation wide character test
INDEX
iswpunct_l
ANSI_SYNOPSIS
#include <wctype.h>
int iswpunct_l(wint_t <[c]>, locale_t <[locale]>);
DESCRIPTION
<<iswpunct_l>> is a function which classifies wide-character values that
are punctuation.
if <[locale]> is LC_GLOBAL_LOCALE or not a valid locale object, the behaviour
is undefined.
RETURNS
<<iswpunct_l>> returns non-zero if <[c]> is a punctuation wide character.
PORTABILITY
<<iswpunct_l>> is POSIX-1.2008.
No supporting OS subroutines are required.
*/
#include <_ansi.h> #include <_ansi.h>
#include <wctype.h> #include <wctype.h>

16
newlib/libc/ctype/iswspace.c
View File

@ -29,15 +29,21 @@
/* /*
FUNCTION FUNCTION
<<iswspace>>---whitespace wide character test <<iswspace>>, <<iswspace_l>>---whitespace wide character test
INDEX INDEX
iswspace iswspace
INDEX
iswspace_l
ANSI_SYNOPSIS ANSI_SYNOPSIS
#include <wctype.h> #include <wctype.h>
int iswspace(wint_t <[c]>); int iswspace(wint_t <[c]>);
#include <wctype.h>
int iswspace_l(wint_t <[c]>, locale_t <[locale]>);
TRAD_SYNOPSIS TRAD_SYNOPSIS
#include <wctype.h> #include <wctype.h>
int iswspace(<[c]>) int iswspace(<[c]>)
@ -47,11 +53,16 @@ DESCRIPTION
<<iswspace>> is a function which classifies wide-character values that <<iswspace>> is a function which classifies wide-character values that
are categorized as whitespace. are categorized as whitespace.
<<iswspace_l>> is like <<iswspace>> but performs the check based on the
locale specified by the locale object locale. If <[locale]> is
LC_GLOBAL_LOCALE or not a valid locale object, the behaviour is undefined.
RETURNS RETURNS
<<iswspace>> returns non-zero if <[c]> is a whitespace wide character. <<iswspace>>, <<iswspace_l>> return non-zero if <[c]> is a whitespace wide character.
PORTABILITY PORTABILITY
<<iswspace>> is C99. <<iswspace>> is C99.
<<iswspace_l>> is POSIX-1.2008.
No supporting OS subroutines are required. No supporting OS subroutines are required.
*/ */
@ -80,4 +91,3 @@ _DEFUN(iswspace,(c), wint_t c)
return (c < 0x100 ? isspace (c) : 0); return (c < 0x100 ? isspace (c) : 0);
#endif /* _MB_CAPABLE */ #endif /* _MB_CAPABLE */
} }

26
newlib/libc/ctype/iswspace_l.c
View File

@ -1,29 +1,3 @@
/*
FUNCTION
<<iswspace_l>>---whitespace wide character test
INDEX
iswspace_l
ANSI_SYNOPSIS
#include <wctype.h>
int iswspace_l(wint_t <[c]>, locale_t <[locale]>);
DESCRIPTION
<<iswspace_l>> is a function which classifies wide-character values that
are categorized as whitespace.
if <[locale]> is LC_GLOBAL_LOCALE or not a valid locale object, the behaviour
is undefined.
RETURNS
<<iswspace_l>> returns non-zero if <[c]> is a whitespace wide character.
PORTABILITY
<<iswspace_l>> is POSIX-1.2008.
No supporting OS subroutines are required.
*/
#include <_ansi.h> #include <_ansi.h>
#include <wctype.h> #include <wctype.h>

17
newlib/libc/ctype/iswupper.c
View File

@ -1,15 +1,20 @@
/* /*
FUNCTION FUNCTION
<<iswupper>>---uppercase wide character test <<iswupper>>, <<iswupper_l>>---uppercase wide character test
INDEX INDEX
iswupper iswupper
INDEX
iswupper_l
ANSI_SYNOPSIS ANSI_SYNOPSIS
#include <wctype.h> #include <wctype.h>
int iswupper(wint_t <[c]>); int iswupper(wint_t <[c]>);
#include <wctype.h>
int iswupper_l(wint_t <[c]>, locale_t <[locale]>);
TRAD_SYNOPSIS TRAD_SYNOPSIS
#include <wctype.h> #include <wctype.h>
int iswupper(<[c]>) int iswupper(<[c]>)
@ -19,11 +24,16 @@ DESCRIPTION
<<iswupper>> is a function which classifies wide-character values that <<iswupper>> is a function which classifies wide-character values that
have uppercase translations. have uppercase translations.
<<iswupper_l>> is like <<iswupper>> but performs the check based on the
locale specified by the locale object locale. If <[locale]> is
LC_GLOBAL_LOCALE or not a valid locale object, the behaviour is undefined.
RETURNS RETURNS
<<iswupper>> returns non-zero if <[c]> is a uppercase wide character. <<iswupper>>, <<iswupper_l>> return non-zero if <[c]> is a uppercase wide character.
PORTABILITY PORTABILITY
<<iswupper>> is C99. <<iswupper>> is C99.
<<iswupper_l>> is POSIX-1.2008.
No supporting OS subroutines are required. No supporting OS subroutines are required.
*/ */
@ -35,4 +45,3 @@ _DEFUN(iswupper,(c),wint_t c)
{ {
return (towlower (c) != c); return (towlower (c) != c);
} }

26
newlib/libc/ctype/iswupper_l.c
View File

@ -1,29 +1,3 @@
/*
FUNCTION
<<iswupper_l>>---uppercase wide character test
INDEX
iswupper_l
ANSI_SYNOPSIS
#include <wctype.h>
int iswupper_l(wint_t <[c]>, locale_t <[locale]>);
DESCRIPTION
<<iswupper_l>> is a function which classifies wide-character values that
have uppercase translations.
if <[locale]> is LC_GLOBAL_LOCALE or not a valid locale object, the behaviour
is undefined.
RETURNS
<<iswupper_l>> returns non-zero if <[c]> is a uppercase wide character.
PORTABILITY
<<iswupper_l>> is POSIX-1.2008.
No supporting OS subroutines are required.
*/
#include <_ansi.h> #include <_ansi.h>
#include <wctype.h> #include <wctype.h>

16
newlib/libc/ctype/iswxdigit.c
View File

@ -1,14 +1,20 @@
/* /*
FUNCTION FUNCTION
<<iswxdigit>>---hexadecimal digit wide character test <<iswxdigit>>, <<iswxdigit_l>>---hexadecimal digit wide character test
INDEX INDEX
iswxdigit iswxdigit
INDEX
iswxdigit_l
ANSI_SYNOPSIS ANSI_SYNOPSIS
#include <wctype.h> #include <wctype.h>
int iswxdigit(wint_t <[c]>); int iswxdigit(wint_t <[c]>);
#include <wctype.h>
int iswxdigit_l(wint_t <[c]>, locale_t <[locale]>);
TRAD_SYNOPSIS TRAD_SYNOPSIS
#include <wctype.h> #include <wctype.h>
int iswxdigit(<[c]>) int iswxdigit(<[c]>)
@ -18,11 +24,16 @@ DESCRIPTION
<<iswxdigit>> is a function which classifies wide character values that <<iswxdigit>> is a function which classifies wide character values that
are hexadecimal digits. are hexadecimal digits.
<<iswxdigit_l>> is like <<iswxdigit>> but performs the check based on the
locale specified by the locale object locale. If <[locale]> is
LC_GLOBAL_LOCALE or not a valid locale object, the behaviour is undefined.
RETURNS RETURNS
<<iswxdigit>> returns non-zero if <[c]> is a hexadecimal digit wide character. <<iswxdigit>>, <<iswxdigit_l>> return non-zero if <[c]> is a hexadecimal digit wide character.
PORTABILITY PORTABILITY
<<iswxdigit>> is C99. <<iswxdigit>> is C99.
<<iswxdigit_l>> is POSIX-1.2008.
No supporting OS subroutines are required. No supporting OS subroutines are required.
*/ */
@ -36,4 +47,3 @@ _DEFUN(iswxdigit,(c), wint_t c)
(c >= (wint_t)'a' && c <= (wint_t)'f') || (c >= (wint_t)'a' && c <= (wint_t)'f') ||
(c >= (wint_t)'A' && c <= (wint_t)'F')); (c >= (wint_t)'A' && c <= (wint_t)'F'));
} }

26
newlib/libc/ctype/iswxdigit_l.c
View File

@ -1,29 +1,3 @@
/*
FUNCTION
<<iswxdigit_l>>---hexadecimal digit wide character test
INDEX
iswxdigit_l
ANSI_SYNOPSIS
#include <wctype.h>
int iswxdigit_l(wint_t <[c]>, locale_t <[locale]>);
DESCRIPTION
<<iswxdigit_l>> is a function which classifies wide character values that
are hexadecimal digits.
if <[locale]> is LC_GLOBAL_LOCALE or not a valid locale object, the behaviour
is undefined.
RETURNS
<<iswxdigit_l>> returns non-zero if <[c]> is a hexadecimal digit wide character.
PORTABILITY
<<iswxdigit_l>> is POSIX-1.2008.
No supporting OS subroutines are required.
*/
#include <_ansi.h> #include <_ansi.h>
#include <wctype.h> #include <wctype.h>

31
newlib/libc/ctype/isxdigit.c
View File

@ -1,34 +1,44 @@
/* /*
FUNCTION FUNCTION
<<isxdigit>>---hexadecimal digit predicate <<isxdigit>>, <<isxdigit_l>>---hexadecimal digit predicate
INDEX INDEX
isxdigit isxdigit
INDEX
isxdigit_l
ANSI_SYNOPSIS ANSI_SYNOPSIS
#include <ctype.h> #include <ctype.h>
int isxdigit(int <[c]>); int isxdigit(int <[c]>);
#include <ctype.h>
int isxdigit_l(int <[c]>, locale_t <[locale]>);
TRAD_SYNOPSIS TRAD_SYNOPSIS
#include <ctype.h> #include <ctype.h>
int isxdigit(int <[c]>); int isxdigit(int <[c]>);
DESCRIPTION DESCRIPTION
<<isxdigit>> is a macro which classifies ASCII integer values by table <<isxdigit>> is a macro which classifies singlebyte charset values by table
lookup. It is a predicate returning non-zero for hexadecimal digits, lookup. It is a predicate returning non-zero for hexadecimal digits,
and <<0>> for other characters. It is defined only if <[c]> is and <<0>> for other characters. It is defined only if <[c]> is
representable as an unsigned char or if <[c]> is EOF. representable as an unsigned char or if <[c]> is EOF.
<<isxdigit_l>> is like <<isxdigit>> but performs the check based on the
locale specified by the locale object locale. If <[locale]> is
LC_GLOBAL_LOCALE or not a valid locale object, the behaviour is undefined.
You can use a compiled subroutine instead of the macro definition by You can use a compiled subroutine instead of the macro definition by
undefining the macro using `<<#undef isxdigit>>'. undefining the macro using `<<#undef isxdigit>>' or `<<#undef isxdigit_l>>'.
RETURNS RETURNS
<<isxdigit>> returns non-zero if <[c]> is a hexadecimal digit <<isxdigit>>, <<isxdigit_l>> return non-zero if <[c]> is a hexadecimal digit
(<<0>>--<<9>>, <<a>>--<<f>>, or <<A>>--<<F>>). (<<0>>--<<9>>, <<a>>--<<f>>, or <<A>>--<<F>>).
PORTABILITY PORTABILITY
<<isxdigit>> is ANSI C. <<isxdigit>> is ANSI C.
<<isxdigit_l>> is POSIX-1.2008.
No supporting OS subroutines are required. No supporting OS subroutines are required.
*/ */
@ -42,4 +52,3 @@ _DEFUN(isxdigit,(c),int c)
{ {
return(__CTYPE_PTR[c+1] & ((_X)|(_N))); return(__CTYPE_PTR[c+1] & ((_X)|(_N)));
} }

32
newlib/libc/ctype/isxdigit_l.c
View File

@ -1,35 +1,3 @@
/*
FUNCTION
<<isxdigit_l>>---hexadecimal digit predicate
INDEX
isxdigit_l
ANSI_SYNOPSIS
#include <ctype.h>
int isxdigit_l(int <[c]>, locale_t <[locale]>);
DESCRIPTION
<<isxdigit_l>> is a macro which classifies ASCII integer values by table
lookup in locale <[locale]>. It is a predicate returning non-zero for
hexadecimal digits, and <<0>> for other characters. It is defined only
if <[c]> is representable as an unsigned char or if <[c]> is EOF.
if <[locale]> is LC_GLOBAL_LOCALE or not a valid locale object, the behaviour
is undefined.
You can use a compiled subroutine instead of the macro definition by
undefining the macro using `<<#undef isxdigit_l>>'.
RETURNS
<<isxdigit_l>> returns non-zero if <[c]> is a hexadecimal digit
(<<0>>--<<9>>, <<a>>--<<f>>, or <<A>>--<<F>>).
PORTABILITY
<<isxdigit_l>> is POSIX-1.2008.
No supporting OS subroutines are required.
*/
#include <_ansi.h> #include <_ansi.h>
#include <ctype.h> #include <ctype.h>

20
newlib/libc/ctype/toascii.c
View File

@ -1,14 +1,20 @@
/* /*
FUNCTION FUNCTION
<<toascii>>---force integers to ASCII range <<toascii>>, <<toascii_l>>---force integers to ASCII range
INDEX INDEX
toascii toascii
INDEX
toascii_l
ANSI_SYNOPSIS ANSI_SYNOPSIS
#include <ctype.h> #include <ctype.h>
int toascii(int <[c]>); int toascii(int <[c]>);
#include <ctype.h>
int toascii_l(int <[c]>, locale_t <[locale]>);
TRAD_SYNOPSIS TRAD_SYNOPSIS
#include <ctype.h> #include <ctype.h>
int toascii(<[c]>); int toascii(<[c]>);
@ -17,14 +23,20 @@ TRAD_SYNOPSIS
DESCRIPTION DESCRIPTION
<<toascii>> is a macro which coerces integers to the ASCII range (0--127) by zeroing any higher-order bits. <<toascii>> is a macro which coerces integers to the ASCII range (0--127) by zeroing any higher-order bits.
<<toascii_l>> is like <<toascii>> but performs the function based on the
locale specified by the locale object locale. If <[locale]> is
LC_GLOBAL_LOCALE or not a valid locale object, the behaviour is undefined.
You can use a compiled subroutine instead of the macro definition by You can use a compiled subroutine instead of the macro definition by
undefining this macro using `<<#undef toascii>>'. undefining this macro using `<<#undef toascii>>' or `<<#undef toascii_l>>'.
RETURNS RETURNS
<<toascii>> returns integers between 0 and 127. <<toascii>>, <<toascii_l>> return integers between 0 and 127.
PORTABILITY PORTABILITY
<<toascii>> is not ANSI C. <<toascii>> is X/Open, BSD and POSIX-1.2001, but marked obsolete in
POSIX-1.2008.
<<toascii_l>> is a GNU extension.
No supporting OS subroutines are required. No supporting OS subroutines are required.
*/ */

29
newlib/libc/ctype/toascii_l.c
View File

@ -1,32 +1,3 @@
/*
FUNCTION
<<toascii_l>>---force integers to ASCII range
INDEX
toascii_l
ANSI_SYNOPSIS
#include <ctype.h>
int toascii_l(int <[c]>, locale_t <[locale]>);
DESCRIPTION
<<toascii_l>> is a macro which coerces integers to the ASCII range (0--127) by zeroing any higher-order bits.
if <[locale]> is LC_GLOBAL_LOCALE or not a valid locale object, the behaviour
is undefined.
You can use a compiled subroutine instead of the macro definition by
undefining this macro using `<<#undef toascii_l>>'.
RETURNS
<<toascii_l>> returns integers between 0 and 127.
PORTABILITY
<<toascii_l>> is a GNU extension.
No supporting OS subroutines are required.
*/
#include <_ansi.h> #include <_ansi.h>
#include <ctype.h> #include <ctype.h>

23
newlib/libc/ctype/tolower.c
View File

@ -1,9 +1,13 @@
/* /*
FUNCTION FUNCTION
<<tolower>>---translate characters to lowercase <<tolower>>, <<tolower_l>>---translate characters to lowercase
INDEX INDEX
tolower tolower
INDEX
tolower_l
INDEX INDEX
_tolower _tolower
@ -12,6 +16,9 @@ ANSI_SYNOPSIS
int tolower(int <[c]>); int tolower(int <[c]>);
int _tolower(int <[c]>); int _tolower(int <[c]>);
#include <ctype.h>
int tolower_l(int <[c]>, locale_t <[locale]>);
TRAD_SYNOPSIS TRAD_SYNOPSIS
#include <ctype.h> #include <ctype.h>
int tolower(<[c]>); int tolower(<[c]>);
@ -23,23 +30,27 @@ DESCRIPTION
leaving all other characters unchanged. It is only defined when leaving all other characters unchanged. It is only defined when
<[c]> is an integer in the range <<EOF>> to <<255>>. <[c]> is an integer in the range <<EOF>> to <<255>>.
<<tolower_l>> is like <<tolower>> but performs the function based on the
locale specified by the locale object locale. If <[locale]> is
LC_GLOBAL_LOCALE or not a valid locale object, the behaviour is undefined.
You can use a compiled subroutine instead of the macro definition by You can use a compiled subroutine instead of the macro definition by
undefining this macro using `<<#undef tolower>>'. undefining this macro using `<<#undef tolower>>' or `<<#undef tolower_l>>'.
<<_tolower>> performs the same conversion as <<tolower>>, but should <<_tolower>> performs the same conversion as <<tolower>>, but should
only be used when <[c]> is known to be an uppercase character (<<A>>--<<Z>>). only be used when <[c]> is known to be an uppercase character (<<A>>--<<Z>>).
RETURNS RETURNS
<<tolower>> returns the lowercase equivalent of <[c]> when it is a <<tolower>>, <<tolower_l>> return the lowercase equivalent of <[c]> when
character between <<A>> and <<Z>>, and <[c]> otherwise. <[c]> is an uppercase character, and <[c]> otherwise.
<<_tolower>> returns the lowercase equivalent of <[c]> when it is a <<_tolower>> returns the lowercase equivalent of <[c]> when it is a
character between <<A>> and <<Z>>. If <[c]> is not one of these character between <<A>> and <<Z>>. If <[c]> is not one of these
characters, the behaviour of <<_tolower>> is undefined. characters, the behaviour of <<_tolower>> is undefined.
PORTABILITY PORTABILITY
<<tolower>> is ANSI C. <<_tolower>> is not recommended for portable <<tolower>> is ANSI C. <<_tolower>> is not recommended for portable programs.
programs. <<tolower_l>> is POSIX-1.2008.
No supporting OS subroutines are required. No supporting OS subroutines are required.
*/ */

30
newlib/libc/ctype/tolower_l.c
View File

@ -1,33 +1,3 @@
/*
FUNCTION
<<tolower_l>>---translate characters to lowercase
INDEX
tolower_l
ANSI_SYNOPSIS
#include <ctype.h>
int tolower_l(int <[c]>, locale_t <[locale]>);
DESCRIPTION
<<tolower_l>> is a macro which converts uppercase characters to lowercase,
leaving all other characters unchanged. It is only defined when
<[c]> is an integer in the range <<EOF>> to <<255>>.
if <[locale]> is LC_GLOBAL_LOCALE or not a valid locale object, the behaviour
is undefined.
RETURNS
<<tolower_l>> returns the lowercase equivalent of <[c]> when it is a
character between <<A>> and <<Z>>, and <[c]> otherwise.
PORTABILITY
<<tolower_l>> is POSIX-1.2008.
programs.
No supporting OS subroutines are required.
*/
#include <_ansi.h> #include <_ansi.h>
#include <ctype.h> #include <ctype.h>
#if defined (_MB_EXTENDED_CHARSETS_ISO) || defined (_MB_EXTENDED_CHARSETS_WINDOWS) #if defined (_MB_EXTENDED_CHARSETS_ISO) || defined (_MB_EXTENDED_CHARSETS_WINDOWS)

20
newlib/libc/ctype/toupper.c
View File

@ -1,9 +1,13 @@
/* /*
FUNCTION FUNCTION
<<toupper>>---translate characters to uppercase <<toupper>>, <<toupper_l>>---translate characters to uppercase
INDEX INDEX
toupper toupper
INDEX
toupper_l
INDEX INDEX
_toupper _toupper
@ -12,6 +16,9 @@ ANSI_SYNOPSIS
int toupper(int <[c]>); int toupper(int <[c]>);
int _toupper(int <[c]>); int _toupper(int <[c]>);
#include <ctype.h>
int toupper_l(int <[c]>, locale_t <[locale]>);
TRAD_SYNOPSIS TRAD_SYNOPSIS
#include <ctype.h> #include <ctype.h>
int toupper(<[c]>); int toupper(<[c]>);
@ -23,15 +30,19 @@ DESCRIPTION
leaving all other characters unchanged. It is only defined when leaving all other characters unchanged. It is only defined when
<[c]> is an integer in the range <<EOF>> to <<255>>. <[c]> is an integer in the range <<EOF>> to <<255>>.
<<toupper_l>> is like <<toupper>> but performs the function based on the
locale specified by the locale object locale. If <[locale]> is
LC_GLOBAL_LOCALE or not a valid locale object, the behaviour is undefined.
You can use a compiled subroutine instead of the macro definition by You can use a compiled subroutine instead of the macro definition by
undefining this macro using `<<#undef toupper>>'. undefining this macro using `<<#undef toupper>>' or `<<#undef toupper_l>>'.
<<_toupper>> performs the same conversion as <<toupper>>, but should <<_toupper>> performs the same conversion as <<toupper>>, but should
only be used when <[c]> is known to be a lowercase character (<<a>>--<<z>>). only be used when <[c]> is known to be a lowercase character (<<a>>--<<z>>).
RETURNS RETURNS
<<toupper>> returns the uppercase equivalent of <[c]> when it is a <<toupper>>, <<toupper_l>> return the uppercase equivalent of <[c]> when
character between <<a>> and <<z>>, and <[c]> otherwise. <[c]> is a lowercase character, and <[c]> otherwise.
<<_toupper>> returns the uppercase equivalent of <[c]> when it is a <<_toupper>> returns the uppercase equivalent of <[c]> when it is a
character between <<a>> and <<z>>. If <[c]> is not one of these character between <<a>> and <<z>>. If <[c]> is not one of these
@ -39,6 +50,7 @@ characters, the behaviour of <<_toupper>> is undefined.
PORTABILITY PORTABILITY
<<toupper>> is ANSI C. <<_toupper>> is not recommended for portable programs. <<toupper>> is ANSI C. <<_toupper>> is not recommended for portable programs.
<<toupper_l>> is POSIX-1.2008.
No supporting OS subroutines are required. No supporting OS subroutines are required.
*/ */

29
newlib/libc/ctype/toupper_l.c
View File

@ -1,32 +1,3 @@
/*
FUNCTION
<<toupper_l>>---translate characters to uppercase
INDEX
toupper_l
ANSI_SYNOPSIS
#include <ctype.h>
int toupper_l(int <[c]>, locale_t <[locale]>);
DESCRIPTION
<<toupper_l>> is a macro which converts lowercase characters to uppercase,
leaving all other characters unchanged. It is only defined when
<[c]> is an integer in the range <<EOF>> to <<255>>.
if <[locale]> is LC_GLOBAL_LOCALE or not a valid locale object, the behaviour
is undefined.
RETURNS
<<toupper_l>> returns the uppercase equivalent of <[c]> when it is a
character between <<a>> and <<z>>, and <[c]> otherwise.
PORTABILITY
<<toupper_l>> is POSIX-1.2008.
No supporting OS subroutines are required.
*/
#include <_ansi.h> #include <_ansi.h>
#include <ctype.h> #include <ctype.h>
#if defined (_MB_EXTENDED_CHARSETS_ISO) \ #if defined (_MB_EXTENDED_CHARSETS_ISO) \

20
newlib/libc/ctype/towctrans.c
View File

@ -29,15 +29,21 @@
/* /*
FUNCTION FUNCTION
<<towctrans>>---extensible wide-character translation <<towctrans>>, <<towctrans_l>>---extensible wide-character translation
INDEX INDEX
towctrans towctrans
INDEX
towctrans_l
ANSI_SYNOPSIS ANSI_SYNOPSIS
#include <wctype.h> #include <wctype.h>
wint_t towctrans(wint_t <[c]>, wctrans_t <[w]>); wint_t towctrans(wint_t <[c]>, wctrans_t <[w]>);
#include <wctype.h>
wint_t towctrans_l(wint_t <[c]>, wctrans_t <[w]>, locale_t <[locale]>);
TRAD_SYNOPSIS TRAD_SYNOPSIS
#include <wctype.h> #include <wctype.h>
wint_t towctrans(<[c]>, <[w]>) wint_t towctrans(<[c]>, <[w]>)
@ -51,13 +57,19 @@ a specified translation type <[w]>. If the translation type is
invalid or cannot be applied to the current character, no change invalid or cannot be applied to the current character, no change
to the character is made. to the character is made.
<<towctrans_l>> is like <<towctrans>> but performs the function based on the
locale specified by the locale object locale. If <[locale]> is
LC_GLOBAL_LOCALE or not a valid locale object, the behaviour is undefined.
RETURNS RETURNS
<<towctrans>> returns the translated equivalent of <[c]> when it is a <<towctrans>>, <<towctrans_l>> return the translated equivalent of <[c]>
valid for the given translation, otherwise, it returns the input character. when it is a valid for the given translation, otherwise, it returns the
When the translation type is invalid, <<errno>> is set <<EINVAL>>. input character. When the translation type is invalid, <<errno>> is
set to <<EINVAL>>.
PORTABILITY PORTABILITY
<<towctrans>> is C99. <<towctrans>> is C99.
<<towctrans_l>> is POSIX-1.2008.
No supporting OS subroutines are required. No supporting OS subroutines are required.
*/ */

30
newlib/libc/ctype/towctrans_l.c
View File

@ -1,33 +1,3 @@
/*
FUNCTION
<<towctrans_l>>---extensible wide-character translation
INDEX
towctrans_l
ANSI_SYNOPSIS
#include <wctype.h>
wint_t towctrans_l(wint_t <[c]>, wctrans_t <[w]>, locale_t <[locale]>);
DESCRIPTION
<<towctrans_l>> is a function which converts wide characters based on
a specified translation type <[w]>. If the translation type is
invalid or cannot be applied to the current character, no change
to the character is made.
if <[locale]> is LC_GLOBAL_LOCALE or not a valid locale object, the behaviour
is undefined.
RETURNS
<<towctrans_l>> returns the translated equivalent of <[c]> when it is a
valid for the given translation, otherwise, it returns the input character.
When the translation type is invalid, <<errno>> is set <<EINVAL>>.
PORTABILITY
<<towctrans_l>> is POSIX-1.2008.
No supporting OS subroutines are required.
*/
#include <_ansi.h> #include <_ansi.h>
#include <wctype.h> #include <wctype.h>

15
newlib/libc/ctype/towlower.c
View File

@ -29,15 +29,21 @@
/* /*
FUNCTION FUNCTION
<<towlower>>---translate wide characters to lowercase <<towlower>>, <<towlower_l>>---translate wide characters to lowercase
INDEX INDEX
towlower towlower
INDEX
towlower_l
ANSI_SYNOPSIS ANSI_SYNOPSIS
#include <wctype.h> #include <wctype.h>
wint_t towlower(wint_t <[c]>); wint_t towlower(wint_t <[c]>);
#include <wctype.h>
wint_t towlower_l(wint_t <[c]>, locale_t <[locale]>);
TRAD_SYNOPSIS TRAD_SYNOPSIS
#include <wctype.h> #include <wctype.h>
wint_t towlower(<[c]>) wint_t towlower(<[c]>)
@ -48,12 +54,17 @@ DESCRIPTION
<<towlower>> is a function which converts uppercase wide characters to <<towlower>> is a function which converts uppercase wide characters to
lowercase, leaving all other characters unchanged. lowercase, leaving all other characters unchanged.
<<towlower_l>> is like <<towlower>> but performs the function based on the
locale specified by the locale object locale. If <[locale]> is
LC_GLOBAL_LOCALE or not a valid locale object, the behaviour is undefined.
RETURNS RETURNS
<<towlower>> returns the lowercase equivalent of <[c]> when it is a <<towlower>>, <<towlower_l>> return the lowercase equivalent of <[c]> when it is a
uppercase wide character; otherwise, it returns the input character. uppercase wide character; otherwise, it returns the input character.
PORTABILITY PORTABILITY
<<towlower>> is C99. <<towlower>> is C99.
<<towlower_l>> is POSIX-1.2008.
No supporting OS subroutines are required. No supporting OS subroutines are required.
*/ */

28
newlib/libc/ctype/towlower_l.c
View File

@ -1,31 +1,3 @@
/*
FUNCTION
<<towlower_l>>---translate wide characters to lowercase
INDEX
towlower_l
ANSI_SYNOPSIS
#include <wctype.h>
wint_t towlower_l(wint_t <[c]>, local_t <[locale]>);
DESCRIPTION
<<towlower_l>> is a function which converts uppercase wide characters to
lowercase, leaving all other characters unchanged.
if <[locale]> is LC_GLOBAL_LOCALE or not a valid locale object, the behaviour
is undefined.
RETURNS
<<towlower_l>> returns the lowercase equivalent of <[c]> when it is a
uppercase wide character; otherwise, it returns the input character.
PORTABILITY
<<towlower_l>> is POSIX-1.2008.
No supporting OS subroutines are required.
*/
#include <_ansi.h> #include <_ansi.h>
#include <newlib.h> #include <newlib.h>
#include <wctype.h> #include <wctype.h>

15
newlib/libc/ctype/towupper.c
View File

@ -29,15 +29,21 @@
/* /*
FUNCTION FUNCTION
<<towupper>>---translate wide characters to uppercase <<towupper>>, <<towupper_l>>---translate wide characters to uppercase
INDEX INDEX
towupper towupper
INDEX
towupper_l
ANSI_SYNOPSIS ANSI_SYNOPSIS
#include <wctype.h> #include <wctype.h>
wint_t towupper(wint_t <[c]>); wint_t towupper(wint_t <[c]>);
#include <wctype.h>
wint_t towupper_l(wint_t <[c]>, locale_t <[locale]>);
TRAD_SYNOPSIS TRAD_SYNOPSIS
#include <wctype.h> #include <wctype.h>
wint_t towupper(<[c]>) wint_t towupper(<[c]>)
@ -48,12 +54,17 @@ DESCRIPTION
<<towupper>> is a function which converts lowercase wide characters to <<towupper>> is a function which converts lowercase wide characters to
uppercase, leaving all other characters unchanged. uppercase, leaving all other characters unchanged.
<<towupper_l>> is like <<towupper>> but performs the function based on the
locale specified by the locale object locale. If <[locale]> is
LC_GLOBAL_LOCALE or not a valid locale object, the behaviour is undefined.
RETURNS RETURNS
<<towupper>> returns the uppercase equivalent of <[c]> when it is a <<towupper>>, <<towupper_l>> return the uppercase equivalent of <[c]> when it is a
lowercase wide character, otherwise, it returns the input character. lowercase wide character, otherwise, it returns the input character.
PORTABILITY PORTABILITY
<<towupper>> is C99. <<towupper>> is C99.
<<towupper_l>> is POSIX-1.2008.
No supporting OS subroutines are required. No supporting OS subroutines are required.
*/ */

28
newlib/libc/ctype/towupper_l.c
View File

@ -1,31 +1,3 @@
/*
FUNCTION
<<towupper_l>>---translate wide characters to uppercase
INDEX
towupper_l
ANSI_SYNOPSIS
#include <wctype.h>
wint_t towupper_l(wint_t <[c]>, locale_t <[locale]>);
DESCRIPTION
<<towupper_l>> is a function which converts lowercase wide characters to
uppercase, leaving all other characters unchanged.
if <[locale]> is LC_GLOBAL_LOCALE or not a valid locale object, the behaviour
is undefined.
RETURNS
<<towupper_l>> returns the uppercase equivalent of <[c]> when it is a
lowercase wide character, otherwise, it returns the input character.
PORTABILITY
<<towupper_l>> is POSIX-1.2008.
No supporting OS subroutines are required.
*/
#include <_ansi.h> #include <_ansi.h>
#include <wctype.h> #include <wctype.h>

15
newlib/libc/ctype/wctrans.c
View File

@ -29,15 +29,21 @@
/* /*
FUNCTION FUNCTION
<<wctrans>>---get wide-character translation type <<wctrans>>, <<wctrans_l>>---get wide-character translation type
INDEX INDEX
wctrans wctrans
INDEX
wctrans_l
ANSI_SYNOPSIS ANSI_SYNOPSIS
#include <wctype.h> #include <wctype.h>
wctrans_t wctrans(const char *<[c]>); wctrans_t wctrans(const char *<[c]>);
#include <wctype.h>
wctrans_t wctrans_l(const char *<[c]>, locale_t <[locale]>);
TRAD_SYNOPSIS TRAD_SYNOPSIS
#include <wctype.h> #include <wctype.h>
wctrans_t wctrans(<[c]>) wctrans_t wctrans(<[c]>)
@ -50,13 +56,18 @@ the appropriate wctrans_t type value associated with the string,
if one exists. The following values are guaranteed to be recognized: if one exists. The following values are guaranteed to be recognized:
"tolower" and "toupper". "tolower" and "toupper".
<<wctrans_l>> is like <<wctrans>> but performs the function based on the
locale specified by the locale object locale. If <[locale]> is
LC_GLOBAL_LOCALE or not a valid locale object, the behaviour is undefined.
RETURNS RETURNS
<<wctrans>> returns 0 and sets <<errno>> to <<EINVAL>> if the <<wctrans>>, <<wctrans_l>> return 0 and sets <<errno>> to <<EINVAL>> if the
given name is invalid. Otherwise, it returns a valid non-zero wctrans_t given name is invalid. Otherwise, it returns a valid non-zero wctrans_t
value. value.
PORTABILITY PORTABILITY
<<wctrans>> is C99. <<wctrans>> is C99.
<<wctrans_l>> is POSIX-1.2008.
No supporting OS subroutines are required. No supporting OS subroutines are required.
*/ */

30
newlib/libc/ctype/wctrans_l.c
View File

@ -1,33 +1,3 @@
/*
FUNCTION
<<wctrans_l>>---get wide-character translation type
INDEX
wctrans_l
ANSI_SYNOPSIS
#include <wctype.h>
wctrans_t wctrans_l(const char *<[c]>, locale_t <[locale]>);
DESCRIPTION
<<wctrans_l>> is a function which takes a string <[c]> and gives back
the appropriate wctrans_t type value associated with the string,
if one exists. The following values are guaranteed to be recognized:
"tolower" and "toupper".
if <[locale]> is LC_GLOBAL_LOCALE or not a valid locale object, the behaviour
is undefined.
RETURNS
<<wctrans_l>> returns 0 and sets <<errno>> to <<EINVAL>> if the
given name is invalid. Otherwise, it returns a valid non-zero wctrans_t
value.
PORTABILITY
<<wctrans_l>> is POSIX-1.2008.
No supporting OS subroutines are required.
*/
#include <_ansi.h> #include <_ansi.h>
#include <wctype.h> #include <wctype.h>

15
newlib/libc/ctype/wctype.c
View File

@ -29,15 +29,21 @@
/* /*
FUNCTION FUNCTION
<<wctype>>---get wide-character classification type <<wctype>>, <<wctype_l>>---get wide-character classification type
INDEX INDEX
wctype wctype
INDEX
wctype_l
ANSI_SYNOPSIS ANSI_SYNOPSIS
#include <wctype.h> #include <wctype.h>
wctype_t wctype(const char *<[c]>); wctype_t wctype(const char *<[c]>);
#include <wctype.h>
wctype_t wctype_l(const char *<[c]>, locale_t <[locale]>);
TRAD_SYNOPSIS TRAD_SYNOPSIS
#include <wctype.h> #include <wctype.h>
wctype_t wctype(<[c]>) wctype_t wctype(<[c]>)
@ -51,13 +57,18 @@ if one exists. The following values are guaranteed to be recognized:
"alnum", "alpha", "blank", "cntrl", "digit", "graph", "lower", "print", "alnum", "alpha", "blank", "cntrl", "digit", "graph", "lower", "print",
"punct", "space", "upper", and "xdigit". "punct", "space", "upper", and "xdigit".
<<wctype_l>> is like <<wctype>> but performs the function based on the
locale specified by the locale object locale. If <[locale]> is
LC_GLOBAL_LOCALE or not a valid locale object, the behaviour is undefined.
RETURNS RETURNS
<<wctype>> returns 0 and sets <<errno>> to <<EINVAL>> if the <<wctype>>, <<wctype_l>> return 0 and sets <<errno>> to <<EINVAL>> if the
given name is invalid. Otherwise, it returns a valid non-zero wctype_t given name is invalid. Otherwise, it returns a valid non-zero wctype_t
value. value.
PORTABILITY PORTABILITY
<<wctype>> is C99. <<wctype>> is C99.
<<wctype_l>> is POSIX-1.2008.
No supporting OS subroutines are required. No supporting OS subroutines are required.
*/ */

31
newlib/libc/ctype/wctype_l.c
View File

@ -1,34 +1,3 @@
/*
FUNCTION
<<wctype_l>>---get wide-character classification type
INDEX
wctype_l
ANSI_SYNOPSIS
#include <wctype_l.h>
wctype_t wctype_l(const char *<[c]>, locale_t <[locale]>);
DESCRIPTION
<<wctype_l>> is a function which takes a string <[c]> and gives back
the appropriate wctype_t type value associated with the string,
if one exists. The following values are guaranteed to be recognized:
"alnum", "alpha", "blank", "cntrl", "digit", "graph", "lower", "print",
"punct", "space", "upper", and "xdigit".
if <[locale]> is LC_GLOBAL_LOCALE or not a valid locale object, the behaviour
is undefined.
RETURNS
<<wctype_l>> returns 0 and sets <<errno>> to <<EINVAL>> if the
given name is invalid. Otherwise, it returns a valid non-zero wctype_t
value.
PORTABILITY
<<wctype_l>> is POSIX-1.2008.
No supporting OS subroutines are required.
*/
#include <_ansi.h> #include <_ansi.h>
#include <wctype.h> #include <wctype.h>