[thirdparty/glibc.git] / ctype / ctype.h

/* Copyright (C) 1991-2019 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, see
   <https://www.gnu.org/licenses/>.  */

/*
 *	ISO C99 Standard 7.4: Character handling	<ctype.h>
 */

#ifndef	_CTYPE_H
#define	_CTYPE_H	1

#include <features.h>
#include <bits/types.h>

__BEGIN_DECLS

#ifndef _ISbit
/* These are all the characteristics of characters.
   If there get to be more than 16 distinct characteristics,
   many things must be changed that use `unsigned short int's.

   The characteristics are stored always in network byte order (big
   endian).  We define the bit value interpretations here dependent on the
   machine's byte order.  */

# include <bits/endian.h>
# if __BYTE_ORDER == __BIG_ENDIAN
#  define _ISbit(bit)	(1 << (bit))
# else /* __BYTE_ORDER == __LITTLE_ENDIAN */
#  define _ISbit(bit)	((bit) < 8 ? ((1 << (bit)) << 8) : ((1 << (bit)) >> 8))
# endif

enum
{
  _ISupper = _ISbit (0),	/* UPPERCASE.  */
  _ISlower = _ISbit (1),	/* lowercase.  */
  _ISalpha = _ISbit (2),	/* Alphabetic.  */
  _ISdigit = _ISbit (3),	/* Numeric.  */
  _ISxdigit = _ISbit (4),	/* Hexadecimal numeric.  */
  _ISspace = _ISbit (5),	/* Whitespace.  */
  _ISprint = _ISbit (6),	/* Printing.  */
  _ISgraph = _ISbit (7),	/* Graphical.  */
  _ISblank = _ISbit (8),	/* Blank (usually SPC and TAB).  */
  _IScntrl = _ISbit (9),	/* Control character.  */
  _ISpunct = _ISbit (10),	/* Punctuation.  */
  _ISalnum = _ISbit (11)	/* Alphanumeric.  */
};
#endif /* ! _ISbit  */

/* These are defined in ctype-info.c.
   The declarations here must match those in localeinfo.h.

   In the thread-specific locale model (see `uselocale' in <locale.h>)
   we cannot use global variables for these as was done in the past.
   Instead, the following accessor functions return the address of
   each variable, which is local to the current thread if multithreaded.

   These point into arrays of 384, so they can be indexed by any `unsigned
   char' value [0,255]; by EOF (-1); or by any `signed char' value
   [-128,-1).  ISO C requires that the ctype functions work for `unsigned
   char' values and for EOF; we also support negative `signed char' values
   for broken old programs.  The case conversion arrays are of `int's
   rather than `unsigned char's because tolower (EOF) must be EOF, which
   doesn't fit into an `unsigned char'.  But today more important is that
   the arrays are also used for multi-byte character sets.  */
extern const unsigned short int **__ctype_b_loc (void)
     __THROW __attribute__ ((__const__));
extern const __int32_t **__ctype_tolower_loc (void)
     __THROW __attribute__ ((__const__));
extern const __int32_t **__ctype_toupper_loc (void)
     __THROW __attribute__ ((__const__));


#ifndef __cplusplus
# define __isctype(c, type) \
  ((*__ctype_b_loc ())[(int) (c)] & (unsigned short int) type)
#elif defined __USE_EXTERN_INLINES
# define __isctype_f(type) \
  __extern_inline int							      \
  is##type (int __c) __THROW						      \
  {									      \
    return (*__ctype_b_loc ())[(int) (__c)] & (unsigned short int) _IS##type; \
  }
#endif

#define	__isascii(c)	(((c) & ~0x7f) == 0)	/* If C is a 7 bit value.  */
#define	__toascii(c)	((c) & 0x7f)		/* Mask off high bits.  */

#define	__exctype(name)	extern int name (int) __THROW

/* The following names are all functions:
     int isCHARACTERISTIC(int c);
   which return nonzero iff C has CHARACTERISTIC.
   For the meaning of the characteristic names, see the `enum' above.  */
__exctype (isalnum);
__exctype (isalpha);
__exctype (iscntrl);
__exctype (isdigit);
__exctype (islower);
__exctype (isgraph);
__exctype (isprint);
__exctype (ispunct);
__exctype (isspace);
__exctype (isupper);
__exctype (isxdigit);


/* Return the lowercase version of C.  */
extern int tolower (int __c) __THROW;

/* Return the uppercase version of C.  */
extern int toupper (int __c) __THROW;


/* ISO C99 introduced one new function.  */
#ifdef	__USE_ISOC99
__exctype (isblank);
#endif

#ifdef __USE_GNU
/* Test C for a set of character classes according to MASK.  */
extern int isctype (int __c, int __mask) __THROW;
#endif

#if defined __USE_MISC || defined __USE_XOPEN

/* Return nonzero iff C is in the ASCII set
   (i.e., is no more than 7 bits wide).  */
extern int isascii (int __c) __THROW;

/* Return the part of C that is in the ASCII set
   (i.e., the low-order 7 bits of C).  */
extern int toascii (int __c) __THROW;

/* These are the same as `toupper' and `tolower' except that they do not
   check the argument for being in the range of a `char'.  */
__exctype (_toupper);
__exctype (_tolower);
#endif /* Use X/Open or use misc.  */

/* This code is needed for the optimized mapping functions.  */
#define __tobody(c, f, a, args) \
  (__extension__							      \
   ({ int __res;							      \
      if (sizeof (c) > 1)						      \
	{								      \
	  if (__builtin_constant_p (c))					      \
	    {								      \
	      int __c = (c);						      \
	      __res = __c < -128 || __c > 255 ? __c : (a)[__c];		      \
	    }								      \
	  else								      \
	    __res = f args;						      \
	}								      \
      else								      \
	__res = (a)[(int) (c)];						      \
      __res; }))

#if !defined __NO_CTYPE
# ifdef __isctype_f
__isctype_f (alnum)
__isctype_f (alpha)
__isctype_f (cntrl)
__isctype_f (digit)
__isctype_f (lower)
__isctype_f (graph)
__isctype_f (print)
__isctype_f (punct)
__isctype_f (space)
__isctype_f (upper)
__isctype_f (xdigit)
#  ifdef __USE_ISOC99
__isctype_f (blank)
#  endif
# elif defined __isctype
# define isalnum(c)	__isctype((c), _ISalnum)
# define isalpha(c)	__isctype((c), _ISalpha)
# define iscntrl(c)	__isctype((c), _IScntrl)
# define isdigit(c)	__isctype((c), _ISdigit)
# define islower(c)	__isctype((c), _ISlower)
# define isgraph(c)	__isctype((c), _ISgraph)
# define isprint(c)	__isctype((c), _ISprint)
# define ispunct(c)	__isctype((c), _ISpunct)
# define isspace(c)	__isctype((c), _ISspace)
# define isupper(c)	__isctype((c), _ISupper)
# define isxdigit(c)	__isctype((c), _ISxdigit)
#  ifdef __USE_ISOC99
#   define isblank(c)	__isctype((c), _ISblank)
#  endif
# endif

# ifdef __USE_EXTERN_INLINES
__extern_inline int
__NTH (tolower (int __c))
{
  return __c >= -128 && __c < 256 ? (*__ctype_tolower_loc ())[__c] : __c;
}

__extern_inline int
__NTH (toupper (int __c))
{
  return __c >= -128 && __c < 256 ? (*__ctype_toupper_loc ())[__c] : __c;
}
# endif

# if __GNUC__ >= 2 && defined __OPTIMIZE__ && !defined __cplusplus
#  define tolower(c)	__tobody (c, tolower, *__ctype_tolower_loc (), (c))
#  define toupper(c)	__tobody (c, toupper, *__ctype_toupper_loc (), (c))
# endif /* Optimizing gcc */

# if defined __USE_MISC || defined __USE_XOPEN
#  define isascii(c)	__isascii (c)
#  define toascii(c)	__toascii (c)

#  define _tolower(c)	((int) (*__ctype_tolower_loc ())[(int) (c)])
#  define _toupper(c)	((int) (*__ctype_toupper_loc ())[(int) (c)])
# endif

#endif /* Not __NO_CTYPE.  */


#ifdef __USE_XOPEN2K8
/* POSIX.1-2008 extended locale interface (see locale.h).  */
# include <bits/types/locale_t.h>

/* These definitions are similar to the ones above but all functions
   take as an argument a handle for the locale which shall be used.  */
#  define __isctype_l(c, type, locale) \
  ((locale)->__ctype_b[(int) (c)] & (unsigned short int) type)

# define __exctype_l(name) 						      \
  extern int name (int, locale_t) __THROW

/* The following names are all functions:
     int isCHARACTERISTIC(int c, locale_t *locale);
   which return nonzero iff C has CHARACTERISTIC.
   For the meaning of the characteristic names, see the `enum' above.  */
__exctype_l (isalnum_l);
__exctype_l (isalpha_l);
__exctype_l (iscntrl_l);
__exctype_l (isdigit_l);
__exctype_l (islower_l);
__exctype_l (isgraph_l);
__exctype_l (isprint_l);
__exctype_l (ispunct_l);
__exctype_l (isspace_l);
__exctype_l (isupper_l);
__exctype_l (isxdigit_l);

__exctype_l (isblank_l);


/* Return the lowercase version of C in locale L.  */
extern int __tolower_l (int __c, locale_t __l) __THROW;
extern int tolower_l (int __c, locale_t __l) __THROW;

/* Return the uppercase version of C.  */
extern int __toupper_l (int __c, locale_t __l) __THROW;
extern int toupper_l (int __c, locale_t __l) __THROW;

# if __GNUC__ >= 2 && defined __OPTIMIZE__ && !defined __cplusplus
#  define __tolower_l(c, locale) \
  __tobody (c, __tolower_l, (locale)->__ctype_tolower, (c, locale))
#  define __toupper_l(c, locale) \
  __tobody (c, __toupper_l, (locale)->__ctype_toupper, (c, locale))
#  define tolower_l(c, locale)	__tolower_l ((c), (locale))
#  define toupper_l(c, locale)	__toupper_l ((c), (locale))
# endif	/* Optimizing gcc */


# ifndef __NO_CTYPE
#  define __isalnum_l(c,l)	__isctype_l((c), _ISalnum, (l))
#  define __isalpha_l(c,l)	__isctype_l((c), _ISalpha, (l))
#  define __iscntrl_l(c,l)	__isctype_l((c), _IScntrl, (l))
#  define __isdigit_l(c,l)	__isctype_l((c), _ISdigit, (l))
#  define __islower_l(c,l)	__isctype_l((c), _ISlower, (l))
#  define __isgraph_l(c,l)	__isctype_l((c), _ISgraph, (l))
#  define __isprint_l(c,l)	__isctype_l((c), _ISprint, (l))
#  define __ispunct_l(c,l)	__isctype_l((c), _ISpunct, (l))
#  define __isspace_l(c,l)	__isctype_l((c), _ISspace, (l))
#  define __isupper_l(c,l)	__isctype_l((c), _ISupper, (l))
#  define __isxdigit_l(c,l)	__isctype_l((c), _ISxdigit, (l))

#  define __isblank_l(c,l)	__isctype_l((c), _ISblank, (l))

#  ifdef __USE_MISC
#   define __isascii_l(c,l)	((l), __isascii (c))
#   define __toascii_l(c,l)	((l), __toascii (c))
#  endif

#  define isalnum_l(c,l)	__isalnum_l ((c), (l))
#  define isalpha_l(c,l)	__isalpha_l ((c), (l))
#  define iscntrl_l(c,l)	__iscntrl_l ((c), (l))
#  define isdigit_l(c,l)	__isdigit_l ((c), (l))
#  define islower_l(c,l)	__islower_l ((c), (l))
#  define isgraph_l(c,l)	__isgraph_l ((c), (l))
#  define isprint_l(c,l)	__isprint_l ((c), (l))
#  define ispunct_l(c,l)	__ispunct_l ((c), (l))
#  define isspace_l(c,l)	__isspace_l ((c), (l))
#  define isupper_l(c,l)	__isupper_l ((c), (l))
#  define isxdigit_l(c,l)	__isxdigit_l ((c), (l))

#  define isblank_l(c,l)	__isblank_l ((c), (l))

#  ifdef __USE_MISC
#   define isascii_l(c,l)	__isascii_l ((c), (l))
#   define toascii_l(c,l)	__toascii_l ((c), (l))
#  endif

# endif /* Not __NO_CTYPE.  */

#endif /* Use POSIX 2008.  */

__END_DECLS

#endif /* ctype.h  */
Commit	Line	Data
04277e02	1	/* Copyright (C) 1991-2019 Free Software Foundation, Inc.
ba1ffaa1	2	This file is part of the GNU C Library.
28f540f4	3
ba1ffaa1	4	The GNU C Library is free software; you can redistribute it and/or
41bdb6e2 AJ	5	modify it under the terms of the GNU Lesser General Public
	6	License as published by the Free Software Foundation; either
	7	version 2.1 of the License, or (at your option) any later version.
28f540f4	8
ba1ffaa1 UD	9	The GNU C Library is distributed in the hope that it will be useful,
	10	but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
41bdb6e2	12	Lesser General Public License for more details.
28f540f4	13
41bdb6e2	14	You should have received a copy of the GNU Lesser General Public
59ba27a6	15	License along with the GNU C Library; if not, see
5a82c748	16	<https://www.gnu.org/licenses/>. */
28f540f4 RM	17
28f540f4 RM	18	/*
d1646309	19	* ISO C99 Standard 7.4: Character handling <ctype.h>
28f540f4 RM	20	*/
	21
	22	#ifndef _CTYPE_H
28f540f4	23	#define _CTYPE_H 1
5107cf1d	24
28f540f4	25	#include <features.h>
36775c3b	26	#include <bits/types.h>
28f540f4 RM	27
	28	__BEGIN_DECLS
	29
19bc17a9	30	#ifndef _ISbit
28635115 RM	31	/* These are all the characteristics of characters.
	32	If there get to be more than 16 distinct characteristics,
	33	many things must be changed that use `unsigned short int's.
	34
	35	The characteristics are stored always in network byte order (big
	36	endian). We define the bit value interpretations here dependent on the
	37	machine's byte order. */
	38
aa706e13	39	# include <bits/endian.h>
dfd2257a	40	# if __BYTE_ORDER == __BIG_ENDIAN
6685edd3	41	# define _ISbit(bit) (1 << (bit))
dfd2257a	42	# else /* __BYTE_ORDER == __LITTLE_ENDIAN */
6685edd3	43	# define _ISbit(bit) ((bit) < 8 ? ((1 << (bit)) << 8) : ((1 << (bit)) >> 8))
dfd2257a	44	# endif
28635115	45
28f540f4 RM	46	enum
28f540f4 RM	47	{
28635115 RM	48	_ISupper = _ISbit (0), /* UPPERCASE. */
	49	_ISlower = _ISbit (1), /* lowercase. */
	50	_ISalpha = _ISbit (2), /* Alphabetic. */
	51	_ISdigit = _ISbit (3), /* Numeric. */
	52	_ISxdigit = _ISbit (4), /* Hexadecimal numeric. */
	53	_ISspace = _ISbit (5), /* Whitespace. */
	54	_ISprint = _ISbit (6), /* Printing. */
	55	_ISgraph = _ISbit (7), /* Graphical. */
	56	_ISblank = _ISbit (8), /* Blank (usually SPC and TAB). */
	57	_IScntrl = _ISbit (9), /* Control character. */
	58	_ISpunct = _ISbit (10), /* Punctuation. */
19bc17a9	59	_ISalnum = _ISbit (11) /* Alphanumeric. */
28f540f4	60	};
19bc17a9	61	#endif /* ! _ISbit */
28f540f4	62
d20fec5d UD	63	/* These are defined in ctype-info.c.
	64	The declarations here must match those in localeinfo.h.
	65
cf684340 RM	66	In the thread-specific locale model (see `uselocale' in <locale.h>)
	67	we cannot use global variables for these as was done in the past.
	68	Instead, the following accessor functions return the address of
	69	each variable, which is local to the current thread if multithreaded.
	70
d20fec5d UD	71	These point into arrays of 384, so they can be indexed by any `unsigned
	72	char' value [0,255]; by EOF (-1); or by any `signed char' value
	73	[-128,-1). ISO C requires that the ctype functions work for `unsigned
	74	char' values and for EOF; we also support negative `signed char' values
	75	for broken old programs. The case conversion arrays are of `int's
	76	rather than `unsigned char's because tolower (EOF) must be EOF, which
	77	doesn't fit into an `unsigned char'. But today more important is that
	78	the arrays are also used for multi-byte character sets. */
a784e502 UD	79	extern const unsigned short int **__ctype_b_loc (void)
	80	__THROW __attribute__ ((__const__));
	81	extern const __int32_t **__ctype_tolower_loc (void)
	82	__THROW __attribute__ ((__const__));
	83	extern const __int32_t **__ctype_toupper_loc (void)
	84	__THROW __attribute__ ((__const__));
d20fec5d	85
396a21b1 UD	86
	87	#ifndef __cplusplus
	88	# define __isctype(c, type) \
cf684340	89	((*__ctype_b_loc ())[(int) (c)] & (unsigned short int) type)
396a21b1 UD	90	#elif defined __USE_EXTERN_INLINES
	91	# define __isctype_f(type) \
	92	__extern_inline int \
538faaa7	93	is##type (int __c) __THROW \
396a21b1 UD	94	{ \
	95	return (*__ctype_b_loc ())[(int) (__c)] & (unsigned short int) _IS##type; \
	96	}
	97	#endif
d20fec5d	98
2303f5fd UD	99	#define __isascii(c) (((c) & ~0x7f) == 0) /* If C is a 7 bit value. */
2303f5fd UD	100	#define __toascii(c) ((c) & 0x7f) /* Mask off high bits. */
28f540f4	101
c1422e5b	102	#define __exctype(name) extern int name (int) __THROW
28f540f4 RM	103
	104	/* The following names are all functions:
	105	int isCHARACTERISTIC(int c);
	106	which return nonzero iff C has CHARACTERISTIC.
	107	For the meaning of the characteristic names, see the `enum' above. */
	108	__exctype (isalnum);
	109	__exctype (isalpha);
	110	__exctype (iscntrl);
	111	__exctype (isdigit);
	112	__exctype (islower);
	113	__exctype (isgraph);
	114	__exctype (isprint);
	115	__exctype (ispunct);
	116	__exctype (isspace);
	117	__exctype (isupper);
	118	__exctype (isxdigit);
	119
28f540f4 RM	120
28f540f4 RM	121	/* Return the lowercase version of C. */
c1422e5b	122	extern int tolower (int __c) __THROW;
28f540f4 RM	123
28f540f4 RM	124	/* Return the uppercase version of C. */
c1422e5b	125	extern int toupper (int __c) __THROW;
28f540f4	126
7a5affeb UD	127
	128	/* ISO C99 introduced one new function. */
	129	#ifdef __USE_ISOC99
7a5affeb	130	__exctype (isblank);
7a5affeb	131	#endif
28f540f4	132
fa1861d9 UD	133	#ifdef __USE_GNU
	134	/* Test C for a set of character classes according to MASK. */
	135	extern int isctype (int __c, int __mask) __THROW;
	136	#endif
	137
ed9a38e2	138	#if defined __USE_MISC \|\| defined __USE_XOPEN
28f540f4 RM	139
	140	/* Return nonzero iff C is in the ASCII set
	141	(i.e., is no more than 7 bits wide). */
c1422e5b	142	extern int isascii (int __c) __THROW;
28f540f4 RM	143
	144	/* Return the part of C that is in the ASCII set
	145	(i.e., the low-order 7 bits of C). */
c1422e5b	146	extern int toascii (int __c) __THROW;
28f540f4	147
8d8c6efa UD	148	/* These are the same as `toupper' and `tolower' except that they do not
8d8c6efa UD	149	check the argument for being in the range of a `char'. */
28f540f4 RM	150	__exctype (_toupper);
28f540f4 RM	151	__exctype (_tolower);
acd7f096	152	#endif /* Use X/Open or use misc. */
28f540f4	153
c1422e5b UD	154	/* This code is needed for the optimized mapping functions. */
	155	#define __tobody(c, f, a, args) \
	156	(__extension__ \
	157	({ int __res; \
	158	if (sizeof (c) > 1) \
	159	{ \
	160	if (__builtin_constant_p (c)) \
	161	{ \
	162	int __c = (c); \
0f283ffc	163	__res = __c < -128 \|\| __c > 255 ? __c : (a)[__c]; \
c1422e5b UD	164	} \
	165	else \
	166	__res = f args; \
	167	} \
	168	else \
0f283ffc	169	__res = (a)[(int) (c)]; \
c1422e5b UD	170	__res; }))
c1422e5b UD	171
396a21b1 UD	172	#if !defined __NO_CTYPE
	173	# ifdef __isctype_f
	174	__isctype_f (alnum)
	175	__isctype_f (alpha)
	176	__isctype_f (cntrl)
	177	__isctype_f (digit)
	178	__isctype_f (lower)
	179	__isctype_f (graph)
	180	__isctype_f (print)
	181	__isctype_f (punct)
	182	__isctype_f (space)
	183	__isctype_f (upper)
	184	__isctype_f (xdigit)
	185	# ifdef __USE_ISOC99
	186	__isctype_f (blank)
	187	# endif
	188	# elif defined __isctype
d20fec5d UD	189	# define isalnum(c) __isctype((c), _ISalnum)
	190	# define isalpha(c) __isctype((c), _ISalpha)
	191	# define iscntrl(c) __isctype((c), _IScntrl)
	192	# define isdigit(c) __isctype((c), _ISdigit)
	193	# define islower(c) __isctype((c), _ISlower)
	194	# define isgraph(c) __isctype((c), _ISgraph)
	195	# define isprint(c) __isctype((c), _ISprint)
	196	# define ispunct(c) __isctype((c), _ISpunct)
	197	# define isspace(c) __isctype((c), _ISspace)
	198	# define isupper(c) __isctype((c), _ISupper)
	199	# define isxdigit(c) __isctype((c), _ISxdigit)
396a21b1 UD	200	# ifdef __USE_ISOC99
	201	# define isblank(c) __isctype((c), _ISblank)
	202	# endif
d20fec5d UD	203	# endif
	204
	205	# ifdef __USE_EXTERN_INLINES
b037a293	206	__extern_inline int
f377d022	207	__NTH (tolower (int __c))
d20fec5d	208	{
cf684340	209	return __c >= -128 && __c < 256 ? (*__ctype_tolower_loc ())[__c] : __c;
d20fec5d UD	210	}
d20fec5d UD	211
b037a293	212	__extern_inline int
f377d022	213	__NTH (toupper (int __c))
d20fec5d	214	{
cf684340	215	return __c >= -128 && __c < 256 ? (*__ctype_toupper_loc ())[__c] : __c;
d20fec5d UD	216	}
	217	# endif
	218
	219	# if __GNUC__ >= 2 && defined __OPTIMIZE__ && !defined __cplusplus
cf684340 RM	220	# define tolower(c) __tobody (c, tolower, *__ctype_tolower_loc (), (c))
cf684340 RM	221	# define toupper(c) __tobody (c, toupper, *__ctype_toupper_loc (), (c))
d20fec5d UD	222	# endif /* Optimizing gcc */
d20fec5d UD	223
ed9a38e2	224	# if defined __USE_MISC \|\| defined __USE_XOPEN
c813f986 UD	225	# define isascii(c) __isascii (c)
c813f986 UD	226	# define toascii(c) __toascii (c)
d20fec5d	227
cf684340 RM	228	# define _tolower(c) ((int) (*__ctype_tolower_loc ())[(int) (c)])
cf684340 RM	229	# define _toupper(c) ((int) (*__ctype_toupper_loc ())[(int) (c)])
c813f986	230	# endif
d20fec5d	231
28f540f4 RM	232	#endif /* Not __NO_CTYPE. */
28f540f4 RM	233
c84142e8	234
77db439e	235	#ifdef __USE_XOPEN2K8
f0be25b6 ZW	236	/* POSIX.1-2008 extended locale interface (see locale.h). */
f0be25b6 ZW	237	# include <bits/types/locale_t.h>
c84142e8 UD	238
	239	/* These definitions are similar to the ones above but all functions
	240	take as an argument a handle for the locale which shall be used. */
c1422e5b	241	# define __isctype_l(c, type, locale) \
c84142e8 UD	242	((locale)->__ctype_b[(int) (c)] & (unsigned short int) type)
c84142e8 UD	243
1ab62b32	244	# define __exctype_l(name) \
af85385f	245	extern int name (int, locale_t) __THROW
c84142e8 UD	246
	247	/* The following names are all functions:
	248	int isCHARACTERISTIC(int c, locale_t *locale);
	249	which return nonzero iff C has CHARACTERISTIC.
	250	For the meaning of the characteristic names, see the `enum' above. */
1ab62b32 RM	251	__exctype_l (isalnum_l);
	252	__exctype_l (isalpha_l);
	253	__exctype_l (iscntrl_l);
	254	__exctype_l (isdigit_l);
	255	__exctype_l (islower_l);
	256	__exctype_l (isgraph_l);
	257	__exctype_l (isprint_l);
	258	__exctype_l (ispunct_l);
	259	__exctype_l (isspace_l);
	260	__exctype_l (isupper_l);
	261	__exctype_l (isxdigit_l);
c84142e8	262
1ab62b32	263	__exctype_l (isblank_l);
c84142e8 UD	264
	265
	266	/* Return the lowercase version of C in locale L. */
af85385f ZW	267	extern int __tolower_l (int __c, locale_t __l) __THROW;
af85385f ZW	268	extern int tolower_l (int __c, locale_t __l) __THROW;
c84142e8 UD	269
c84142e8 UD	270	/* Return the uppercase version of C. */
af85385f ZW	271	extern int __toupper_l (int __c, locale_t __l) __THROW;
af85385f ZW	272	extern int toupper_l (int __c, locale_t __l) __THROW;
c1422e5b UD	273
	274	# if __GNUC__ >= 2 && defined __OPTIMIZE__ && !defined __cplusplus
	275	# define __tolower_l(c, locale) \
	276	__tobody (c, __tolower_l, (locale)->__ctype_tolower, (c, locale))
	277	# define __toupper_l(c, locale) \
	278	__tobody (c, __toupper_l, (locale)->__ctype_toupper, (c, locale))
1ab62b32 RM	279	# define tolower_l(c, locale) __tolower_l ((c), (locale))
1ab62b32 RM	280	# define toupper_l(c, locale) __toupper_l ((c), (locale))
c1422e5b	281	# endif /* Optimizing gcc */
c84142e8 UD	282
c84142e8 UD	283
dfd2257a UD	284	# ifndef __NO_CTYPE
	285	# define __isalnum_l(c,l) __isctype_l((c), _ISalnum, (l))
	286	# define __isalpha_l(c,l) __isctype_l((c), _ISalpha, (l))
	287	# define __iscntrl_l(c,l) __isctype_l((c), _IScntrl, (l))
	288	# define __isdigit_l(c,l) __isctype_l((c), _ISdigit, (l))
	289	# define __islower_l(c,l) __isctype_l((c), _ISlower, (l))
	290	# define __isgraph_l(c,l) __isctype_l((c), _ISgraph, (l))
	291	# define __isprint_l(c,l) __isctype_l((c), _ISprint, (l))
	292	# define __ispunct_l(c,l) __isctype_l((c), _ISpunct, (l))
	293	# define __isspace_l(c,l) __isctype_l((c), _ISspace, (l))
	294	# define __isupper_l(c,l) __isctype_l((c), _ISupper, (l))
	295	# define __isxdigit_l(c,l) __isctype_l((c), _ISxdigit, (l))
c84142e8	296
dfd2257a UD	297	# define __isblank_l(c,l) __isctype_l((c), _ISblank, (l))
dfd2257a UD	298
ed9a38e2	299	# ifdef __USE_MISC
1ab62b32 RM	300	# define __isascii_l(c,l) ((l), __isascii (c))
	301	# define __toascii_l(c,l) ((l), __toascii (c))
	302	# endif
	303
	304	# define isalnum_l(c,l) __isalnum_l ((c), (l))
	305	# define isalpha_l(c,l) __isalpha_l ((c), (l))
	306	# define iscntrl_l(c,l) __iscntrl_l ((c), (l))
	307	# define isdigit_l(c,l) __isdigit_l ((c), (l))
	308	# define islower_l(c,l) __islower_l ((c), (l))
	309	# define isgraph_l(c,l) __isgraph_l ((c), (l))
	310	# define isprint_l(c,l) __isprint_l ((c), (l))
	311	# define ispunct_l(c,l) __ispunct_l ((c), (l))
	312	# define isspace_l(c,l) __isspace_l ((c), (l))
	313	# define isupper_l(c,l) __isupper_l ((c), (l))
	314	# define isxdigit_l(c,l) __isxdigit_l ((c), (l))
	315
	316	# define isblank_l(c,l) __isblank_l ((c), (l))
	317
ed9a38e2	318	# ifdef __USE_MISC
da4cfe38 RM	319	# define isascii_l(c,l) __isascii_l ((c), (l))
da4cfe38 RM	320	# define toascii_l(c,l) __toascii_l ((c), (l))
dfd2257a UD	321	# endif
	322
	323	# endif /* Not __NO_CTYPE. */
c84142e8	324
77db439e	325	#endif /* Use POSIX 2008. */
c84142e8	326
28f540f4 RM	327	__END_DECLS
	328
	329	#endif /* ctype.h */