[thirdparty/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>

__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 int *__ctype_tolower; /* Case conversions.  */
extern __const int *__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
	24
	25	#define _CTYPE_H 1
	26	#include <features.h>
	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
	39	#include <endian.h>
	40	#if __BYTE_ORDER == __BIG_ENDIAN
	41	#define _ISbit(bit) (1 << bit)
	42	#else /* __BYTE_ORDER == __LITTLE_ENDIAN */
40deae08	43	#define _ISbit(bit) (bit < 8 ? ((1 << bit) << 8) : ((1 << bit) >> 8))
28635115 RM	44	#endif
28635115 RM	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
28635115	63	/* These are defined in ctype-info.c.
28f540f4 RM	64	The declarations here must match those in localeinfo.h.
28f540f4 RM	65
28635115 RM	66	These point into arrays of 384, so they can be indexed by any `unsigned
28635115 RM	67	char' value [0,255]; by EOF (-1); or by any `signed char' value
ba1ffaa1	68	[-128,-1). ISO C requires that the ctype functions work for `unsigned
28635115	69	char' values and for EOF; we also support negative `signed char' values
6c2f0507	70	for broken old programs. The case conversion arrays are of `int's
28635115	71	rather than `unsigned char's because tolower (EOF) must be EOF, which
19bc17a9 RM	72	doesn't fit into an `unsigned char'. But today more important is that
19bc17a9 RM	73	the arrays are also used for multi-byte character sets. */
28f540f4	74	extern __const unsigned short int __ctype_b; / Characteristics. */
6c2f0507 RM	75	extern __const int __ctype_tolower; / Case conversions. */
6c2f0507 RM	76	extern __const int __ctype_toupper; / Case conversions. */
28f540f4 RM	77
	78	#define __isctype(c, type) \
	79	(__ctype_b[(int) (c)] & (unsigned short int) type)
	80
2303f5fd UD	81	#define __isascii(c) (((c) & ~0x7f) == 0) /* If C is a 7 bit value. */
2303f5fd UD	82	#define __toascii(c) ((c) & 0x7f) /* Mask off high bits. */
28f540f4 RM	83
	84	#define __tolower(c) ((int) __ctype_tolower[(int) (c)])
	85	#define __toupper(c) ((int) __ctype_toupper[(int) (c)])
	86
	87	#define __exctype(name) extern int name __P ((int))
	88
	89	/* The following names are all functions:
	90	int isCHARACTERISTIC(int c);
	91	which return nonzero iff C has CHARACTERISTIC.
	92	For the meaning of the characteristic names, see the `enum' above. */
	93	__exctype (isalnum);
	94	__exctype (isalpha);
	95	__exctype (iscntrl);
	96	__exctype (isdigit);
	97	__exctype (islower);
	98	__exctype (isgraph);
	99	__exctype (isprint);
	100	__exctype (ispunct);
	101	__exctype (isspace);
	102	__exctype (isupper);
	103	__exctype (isxdigit);
	104
	105	#ifdef __USE_GNU
	106	__exctype (isblank);
	107	#endif
	108
	109
	110	/* Return the lowercase version of C. */
	111	extern int tolower __P ((int __c));
	112
	113	/* Return the uppercase version of C. */
	114	extern int toupper __P ((int __c));
	115
	116
2c6fe0bd	117	#if defined(__USE_SVID) \|\| defined(__USE_MISC) \|\| defined(__USE_XOPEN)
28f540f4 RM	118
	119	/* Return nonzero iff C is in the ASCII set
	120	(i.e., is no more than 7 bits wide). */
	121	extern int isascii __P ((int __c));
	122
	123	/* Return the part of C that is in the ASCII set
	124	(i.e., the low-order 7 bits of C). */
	125	extern int toascii __P ((int __c));
	126
	127	#endif /* Use SVID or use misc. */
	128
2303f5fd	129	#if defined(__USE_SVID) \|\| defined(__USE_MISC) \|\| defined(__USE_XOPEN)
933e73fa	130	/* These are the same as `toupper' and `tolower'. */
28f540f4 RM	131	__exctype (_toupper);
	132	__exctype (_tolower);
	133	#endif
	134
	135	#ifndef __NO_CTYPE
	136	#define isalnum(c) __isctype((c), _ISalnum)
	137	#define isalpha(c) __isctype((c), _ISalpha)
	138	#define iscntrl(c) __isctype((c), _IScntrl)
	139	#define isdigit(c) __isctype((c), _ISdigit)
	140	#define islower(c) __isctype((c), _ISlower)
	141	#define isgraph(c) __isctype((c), _ISgraph)
	142	#define isprint(c) __isctype((c), _ISprint)
	143	#define ispunct(c) __isctype((c), _ISpunct)
	144	#define isspace(c) __isctype((c), _ISspace)
	145	#define isupper(c) __isctype((c), _ISupper)
	146	#define isxdigit(c) __isctype((c), _ISxdigit)
	147
	148	#ifdef __USE_GNU
	149	#define isblank(c) __isctype((c), _ISblank)
	150	#endif
	151
	152	#define tolower(c) __tolower(c)
	153	#define toupper(c) __toupper(c)
	154
2303f5fd	155	#if defined(__USE_SVID) \|\| defined(__USE_MISC) \|\| defined(__USE_XOPEN)
28f540f4 RM	156	#define isascii(c) __isascii(c)
	157	#define toascii(c) __toascii(c)
	158	#endif
	159
	160	#endif /* Not __NO_CTYPE. */
	161
c84142e8 UD	162
	163	#ifdef __USE_GNU
	164	/* The concept of one static locale per category is not very well
	165	thought out. Many applications will need to process its data using
	166	information from several different locales. Another application is
	167	the implementation of the internationalization handling in the
	168	upcoming ISO C++ standard library. To support this another set of
	169	the functions using locale data exist which have an additional
	170	argument.
	171
	172	Attention: all these functions are not standardized in any form.
	173	This is a proof-of-concept implementation. */
	174
	175	/* Structure for reentrant locale using functions. This is an
	176	(almost) opaque type for the user level programs. */
	177	# include <xlocale.h>
	178
	179	/* These definitions are similar to the ones above but all functions
	180	take as an argument a handle for the locale which shall be used. */
	181	#define __isctype_l(c, type, locale) \
	182	((locale)->__ctype_b[(int) (c)] & (unsigned short int) type)
	183
	184	#define __tolower_l(c, locale) ((int) (locale)->__ctype_tolower[(int) (c)])
	185	#define __toupper_l(c, locale) ((int) (locale)->__ctype_toupper[(int) (c)])
	186
	187	#define __exctype_l(name) extern int name __P ((int, __locale_t))
	188
	189	/* The following names are all functions:
	190	int isCHARACTERISTIC(int c, locale_t *locale);
	191	which return nonzero iff C has CHARACTERISTIC.
	192	For the meaning of the characteristic names, see the `enum' above. */
	193	__exctype_l (__isalnum_l);
	194	__exctype_l (__isalpha_l);
	195	__exctype_l (__iscntrl_l);
	196	__exctype_l (__isdigit_l);
	197	__exctype_l (__islower_l);
	198	__exctype_l (__isgraph_l);
	199	__exctype_l (__isprint_l);
	200	__exctype_l (__ispunct_l);
	201	__exctype_l (__isspace_l);
	202	__exctype_l (__isupper_l);
	203	__exctype_l (__isxdigit_l);
	204
	205	__exctype_l (__isblank_l);
	206
	207
	208	/* Return the lowercase version of C in locale L. */
	209	extern int __tolower_l __P ((int __c, __locale_t __l));
	210
	211	/* Return the uppercase version of C. */
	212	extern int __toupper_l __P ((int __c, __locale_t __l));
	213
	214
	215	#ifndef __NO_CTYPE
	216	#define __isalnum_l(c,l) __isctype_l((c), _ISalnum, (l))
	217	#define __isalpha_l(c,l) __isctype_l((c), _ISalpha, (l))
	218	#define __iscntrl_l(c,l) __isctype_l((c), _IScntrl, (l))
	219	#define __isdigit_l(c,l) __isctype_l((c), _ISdigit, (l))
	220	#define __islower_l(c,l) __isctype_l((c), _ISlower, (l))
	221	#define __isgraph_l(c,l) __isctype_l((c), _ISgraph, (l))
	222	#define __isprint_l(c,l) __isctype_l((c), _ISprint, (l))
	223	#define __ispunct_l(c,l) __isctype_l((c), _ISpunct, (l))
	224	#define __isspace_l(c,l) __isctype_l((c), _ISspace, (l))
	225	#define __isupper_l(c,l) __isctype_l((c), _ISupper, (l))
226	#define __isxdigit_l(c,l) __isctype_l((c), _ISxdigit, (l))
227
228	#define __isblank_l(c,l) __isctype_l((c), _ISblank, (l))
229
230	#if defined(__USE_SVID) \|\| defined(__USE_MISC) \|\| defined(__USE_XOPEN)
231	#define __isascii_l(c,l) __isascii(c)
232	#define __toascii_l(c,l) __toascii(c)
233	#endif
234
235	#endif /* Not __NO_CTYPE. */
236
237	#endif /* Use GNU. */
238
28f540f4 RM	239	__END_DECLS
	240
	241	#endif /* ctype.h */