[glibc.git] / ctype / ctype.h

/* Copyright (C) 1991, 92, 93, 95, 96, 97 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 Library General Public License as
   published by the Free Software Foundation; either version 2 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
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public
   License along with the GNU C Library; see the file COPYING.LIB.  If not,
   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */

/*
 *	ISO C Standard 4.3: CHARACTER HANDLING	<ctype.h>
 */

#ifndef	_CTYPE_H
#define	_CTYPE_H	1

#include <features.h>
#include <gnu/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	__tolower(c)	((int) __ctype_tolower[(int) (c)])
#define	__toupper(c)	((int) __ctype_toupper[(int) (c)])

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

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

#ifdef	__USE_GNU
__exctype (isblank);
#endif


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

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


#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 __P ((int __c));

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

#endif /* Use SVID or use misc.  */

#if defined(__USE_SVID) || defined(__USE_MISC) || defined(__USE_XOPEN)
/* These are the same as `toupper' and `tolower'.  */
__exctype (_toupper);
__exctype (_tolower);
#endif

#ifndef	__NO_CTYPE
#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_GNU
#define	isblank(c)	__isctype((c), _ISblank)
#endif

#define	tolower(c)	__tolower(c)
#define	toupper(c)	__toupper(c)

#if defined(__USE_SVID) || defined(__USE_MISC) || defined(__USE_XOPEN)
#define	isascii(c)	__isascii(c)
#define	toascii(c)	__toascii(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	__tolower_l(c, locale)	((int) (locale)->__ctype_tolower[(int) (c)])
#define	__toupper_l(c, locale)	((int) (locale)->__ctype_toupper[(int) (c)])

#define	__exctype_l(name)	extern int name __P ((int, __locale_t))

/* 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 __P ((int __c, __locale_t __l));

/* Return the uppercase version of C.  */
extern int __toupper_l __P ((int __c, __locale_t __l));


#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)	__isascii(c)
#define	__toascii_l(c,l)	__toascii(c)
#endif

#endif /* Not __NO_CTYPE.  */

#endif /* Use GNU.  */

__END_DECLS

#endif /* ctype.h  */
Commit	Line	Data
c84142e8	1	/* Copyright (C) 1991, 92, 93, 95, 96, 97 Free Software Foundation, Inc.
ba1ffaa1	2	This file is part of the GNU C Library.
28f540f4	3
ba1ffaa1 UD	4	The GNU C Library is free software; you can redistribute it and/or
	5	modify it under the terms of the GNU Library General Public License as
	6	published by the Free Software Foundation; either version 2 of the
	7	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
	12	Library General Public License for more details.
28f540f4	13
ba1ffaa1 UD	14	You should have received a copy of the GNU Library General Public
	15	License along with the GNU C Library; see the file COPYING.LIB. If not,
	16	write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
	17	Boston, MA 02111-1307, USA. */
28f540f4 RM	18
28f540f4 RM	19	/*
ba1ffaa1	20	* ISO C Standard 4.3: CHARACTER HANDLING <ctype.h>
28f540f4 RM	21	*/
	22
	23	#ifndef _CTYPE_H
28f540f4	24	#define _CTYPE_H 1
5107cf1d	25
28f540f4	26	#include <features.h>
5107cf1d	27	#include <gnu/types.h>
28f540f4 RM	28
	29	__BEGIN_DECLS
	30
19bc17a9	31	#ifndef _ISbit
28635115 RM	32	/* These are all the characteristics of characters.
	33	If there get to be more than 16 distinct characteristics,
	34	many things must be changed that use `unsigned short int's.
	35
	36	The characteristics are stored always in network byte order (big
	37	endian). We define the bit value interpretations here dependent on the
	38	machine's byte order. */
	39
	40	#include <endian.h>
	41	#if __BYTE_ORDER == __BIG_ENDIAN
	42	#define _ISbit(bit) (1 << bit)
	43	#else /* __BYTE_ORDER == __LITTLE_ENDIAN */
40deae08	44	#define _ISbit(bit) (bit < 8 ? ((1 << bit) << 8) : ((1 << bit) >> 8))
28635115 RM	45	#endif
28635115 RM	46
28f540f4 RM	47	enum
28f540f4 RM	48	{
28635115 RM	49	_ISupper = _ISbit (0), /* UPPERCASE. */
	50	_ISlower = _ISbit (1), /* lowercase. */
	51	_ISalpha = _ISbit (2), /* Alphabetic. */
	52	_ISdigit = _ISbit (3), /* Numeric. */
	53	_ISxdigit = _ISbit (4), /* Hexadecimal numeric. */
	54	_ISspace = _ISbit (5), /* Whitespace. */
	55	_ISprint = _ISbit (6), /* Printing. */
	56	_ISgraph = _ISbit (7), /* Graphical. */
	57	_ISblank = _ISbit (8), /* Blank (usually SPC and TAB). */
	58	_IScntrl = _ISbit (9), /* Control character. */
	59	_ISpunct = _ISbit (10), /* Punctuation. */
19bc17a9	60	_ISalnum = _ISbit (11) /* Alphanumeric. */
28f540f4	61	};
19bc17a9	62	#endif /* ! _ISbit */
28f540f4	63
28635115	64	/* These are defined in ctype-info.c.
28f540f4 RM	65	The declarations here must match those in localeinfo.h.
28f540f4 RM	66
28635115 RM	67	These point into arrays of 384, so they can be indexed by any `unsigned
28635115 RM	68	char' value [0,255]; by EOF (-1); or by any `signed char' value
ba1ffaa1	69	[-128,-1). ISO C requires that the ctype functions work for `unsigned
28635115	70	char' values and for EOF; we also support negative `signed char' values
6c2f0507	71	for broken old programs. The case conversion arrays are of `int's
28635115	72	rather than `unsigned char's because tolower (EOF) must be EOF, which
19bc17a9 RM	73	doesn't fit into an `unsigned char'. But today more important is that
19bc17a9 RM	74	the arrays are also used for multi-byte character sets. */
28f540f4	75	extern __const unsigned short int __ctype_b; / Characteristics. */
5107cf1d UD	76	extern __const __int32_t __ctype_tolower; / Case conversions. */
5107cf1d UD	77	extern __const __int32_t __ctype_toupper; / Case conversions. */
28f540f4 RM	78
	79	#define __isctype(c, type) \
	80	(__ctype_b[(int) (c)] & (unsigned short int) type)
	81
2303f5fd UD	82	#define __isascii(c) (((c) & ~0x7f) == 0) /* If C is a 7 bit value. */
2303f5fd UD	83	#define __toascii(c) ((c) & 0x7f) /* Mask off high bits. */
28f540f4 RM	84
	85	#define __tolower(c) ((int) __ctype_tolower[(int) (c)])
	86	#define __toupper(c) ((int) __ctype_toupper[(int) (c)])
	87
	88	#define __exctype(name) extern int name __P ((int))
	89
	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
	106	#ifdef __USE_GNU
	107	__exctype (isblank);
	108	#endif
	109
	110
	111	/* Return the lowercase version of C. */
	112	extern int tolower __P ((int __c));
	113
	114	/* Return the uppercase version of C. */
	115	extern int toupper __P ((int __c));
	116
	117
2c6fe0bd	118	#if defined(__USE_SVID) \|\| defined(__USE_MISC) \|\| defined(__USE_XOPEN)
28f540f4 RM	119
	120	/* Return nonzero iff C is in the ASCII set
	121	(i.e., is no more than 7 bits wide). */
	122	extern int isascii __P ((int __c));
	123
	124	/* Return the part of C that is in the ASCII set
	125	(i.e., the low-order 7 bits of C). */
	126	extern int toascii __P ((int __c));
	127
	128	#endif /* Use SVID or use misc. */
	129
2303f5fd	130	#if defined(__USE_SVID) \|\| defined(__USE_MISC) \|\| defined(__USE_XOPEN)
933e73fa	131	/* These are the same as `toupper' and `tolower'. */
28f540f4 RM	132	__exctype (_toupper);
	133	__exctype (_tolower);
	134	#endif
	135
	136	#ifndef __NO_CTYPE
	137	#define isalnum(c) __isctype((c), _ISalnum)
	138	#define isalpha(c) __isctype((c), _ISalpha)
	139	#define iscntrl(c) __isctype((c), _IScntrl)
	140	#define isdigit(c) __isctype((c), _ISdigit)
	141	#define islower(c) __isctype((c), _ISlower)
	142	#define isgraph(c) __isctype((c), _ISgraph)
	143	#define isprint(c) __isctype((c), _ISprint)
	144	#define ispunct(c) __isctype((c), _ISpunct)
	145	#define isspace(c) __isctype((c), _ISspace)
	146	#define isupper(c) __isctype((c), _ISupper)
	147	#define isxdigit(c) __isctype((c), _ISxdigit)
	148
	149	#ifdef __USE_GNU
	150	#define isblank(c) __isctype((c), _ISblank)
	151	#endif
	152
	153	#define tolower(c) __tolower(c)
	154	#define toupper(c) __toupper(c)
	155
2303f5fd	156	#if defined(__USE_SVID) \|\| defined(__USE_MISC) \|\| defined(__USE_XOPEN)
28f540f4 RM	157	#define isascii(c) __isascii(c)
	158	#define toascii(c) __toascii(c)
	159	#endif
	160
	161	#endif /* Not __NO_CTYPE. */
	162
c84142e8 UD	163
	164	#ifdef __USE_GNU
	165	/* The concept of one static locale per category is not very well
	166	thought out. Many applications will need to process its data using
	167	information from several different locales. Another application is
	168	the implementation of the internationalization handling in the
	169	upcoming ISO C++ standard library. To support this another set of
	170	the functions using locale data exist which have an additional
	171	argument.
	172
	173	Attention: all these functions are not standardized in any form.
	174	This is a proof-of-concept implementation. */
	175
	176	/* Structure for reentrant locale using functions. This is an
	177	(almost) opaque type for the user level programs. */
	178	# include <xlocale.h>
	179
	180	/* These definitions are similar to the ones above but all functions
	181	take as an argument a handle for the locale which shall be used. */
	182	#define __isctype_l(c, type, locale) \
	183	((locale)->__ctype_b[(int) (c)] & (unsigned short int) type)
	184
	185	#define __tolower_l(c, locale) ((int) (locale)->__ctype_tolower[(int) (c)])
	186	#define __toupper_l(c, locale) ((int) (locale)->__ctype_toupper[(int) (c)])
	187
	188	#define __exctype_l(name) extern int name __P ((int, __locale_t))
	189
	190	/* The following names are all functions:
	191	int isCHARACTERISTIC(int c, locale_t *locale);
	192	which return nonzero iff C has CHARACTERISTIC.
	193	For the meaning of the characteristic names, see the `enum' above. */
	194	__exctype_l (__isalnum_l);
	195	__exctype_l (__isalpha_l);
	196	__exctype_l (__iscntrl_l);
	197	__exctype_l (__isdigit_l);
	198	__exctype_l (__islower_l);
	199	__exctype_l (__isgraph_l);
	200	__exctype_l (__isprint_l);
	201	__exctype_l (__ispunct_l);
	202	__exctype_l (__isspace_l);
	203	__exctype_l (__isupper_l);
	204	__exctype_l (__isxdigit_l);
	205
	206	__exctype_l (__isblank_l);
	207
	208
	209	/* Return the lowercase version of C in locale L. */
	210	extern int __tolower_l __P ((int __c, __locale_t __l));
	211
	212	/* Return the uppercase version of C. */
	213	extern int __toupper_l __P ((int __c, __locale_t __l));
	214
	215
	216	#ifndef __NO_CTYPE
	217	#define __isalnum_l(c,l) __isctype_l((c), _ISalnum, (l))
	218	#define __isalpha_l(c,l) __isctype_l((c), _ISalpha, (l))
	219	#define __iscntrl_l(c,l) __isctype_l((c), _IScntrl, (l))
	220	#define __isdigit_l(c,l) __isctype_l((c), _ISdigit, (l))
	221	#define __islower_l(c,l) __isctype_l((c), _ISlower, (l))
	222	#define __isgraph_l(c,l) __isctype_l((c), _ISgraph, (l))
	223	#define __isprint_l(c,l) __isctype_l((c), _ISprint, (l))
	224	#define __ispunct_l(c,l) __isctype_l((c), _ISpunct, (l))
	225	#define __isspace_l(c,l) __isctype_l((c), _ISspace, (l))
	226	#define __isupper_l(c,l) __isctype_l((c), _ISupper, (l))
227	#define __isxdigit_l(c,l) __isctype_l((c), _ISxdigit, (l))
228
229	#define __isblank_l(c,l) __isctype_l((c), _ISblank, (l))
230
231	#if defined(__USE_SVID) \|\| defined(__USE_MISC) \|\| defined(__USE_XOPEN)
232	#define __isascii_l(c,l) __isascii(c)
233	#define __toascii_l(c,l) __toascii(c)
234	#endif
235
236	#endif /* Not __NO_CTYPE. */
237
238	#endif /* Use GNU. */
239
28f540f4 RM	240	__END_DECLS
	241
	242	#endif /* ctype.h */