[glibc.git] / ctype / ctype.h

/* Copyright (C) 1991,92,93,95,96,97,98,99,2001,02
   	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, write to the Free
   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   02111-1307 USA.  */

/*
 *	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 <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.

   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;	/* Characteristics.  */
extern __const __int32_t *__ctype_tolower;	/* Case conversions.  */
extern __const __int32_t *__ctype_toupper;	/* Case conversions.  */

#define __isctype(c, type) \
  (__ctype_b[(int) (c)] & (unsigned short int) type)

#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

__BEGIN_NAMESPACE_STD

/* 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;

__END_NAMESPACE_STD


/* ISO C99 introduced one new function.  */
#ifdef	__USE_ISOC99
__BEGIN_NAMESPACE_C99

__exctype (isblank);

__END_NAMESPACE_C99
#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_SVID || 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 SVID 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 && !defined __cplusplus
# 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

# ifdef __USE_EXTERN_INLINES
extern __inline int
tolower (int __c) __THROW
{
  return __c >= -128 && __c < 256 ? __ctype_tolower[__c] : __c;
}

extern __inline int
toupper (int __c) __THROW
{
  return __c >= -128 && __c < 256 ? __ctype_toupper[__c] : __c;
}
# endif

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

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

#  define _tolower(c)	((int) __ctype_tolower[(int) (c)])
#  define _toupper(c)	((int) __ctype_toupper[(int) (c)])
# endif

#endif /* Not __NO_CTYPE.  */


#ifdef __USE_GNU
/* The concept of one static locale per category is not very well
   thought out.  Many applications will need to process its data using
   information from several different locales.  Another application is
   the implementation of the internationalization handling in the
   upcoming ISO C++ standard library.  To support this another set of
   the functions using locale data exist which have an additional
   argument.

   Attention: all these functions are *not* standardized in any form.
   This is a proof-of-concept implementation.  */

/* Structure for reentrant locale using functions.  This is an
   (almost) opaque type for the user level programs.  */
# include <xlocale.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))

#  if defined __USE_SVID || defined __USE_MISC || defined __USE_XOPEN
#   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))

#  if defined __USE_SVID || defined __USE_MISC || defined __USE_XOPEN
#   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 GNU.  */

__END_DECLS

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