[apple/libc.git] / include / _ctype.h

/*
 * Copyright (c) 2000, 2005, 2008 Apple Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
/*
 * Copyright (c) 1989, 1993
 *	The Regents of the University of California.  All rights reserved.
 * (c) UNIX System Laboratories, Inc.
 * All or some portions of this file are derived from material licensed
 * to the University of California by American Telephone and Telegraph
 * Co. or Unix System Laboratories, Inc. and are reproduced herein with
 * the permission of UNIX System Laboratories, Inc.
 *
 * This code is derived from software contributed to Berkeley by
 * Paul Borman at Krystal Technologies.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *	This product includes software developed by the University of
 *	California, Berkeley and its contributors.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 *	@(#)ctype.h	8.4 (Berkeley) 1/21/94
 */

//Begin-Libc
#include "xlocale_private.h"
//End-Libc
#ifndef	__CTYPE_H_
#define __CTYPE_H_

#include <sys/cdefs.h>
#include <runetype.h>

#define	_CTYPE_A	0x00000100L		/* Alpha */
#define	_CTYPE_C	0x00000200L		/* Control */
#define	_CTYPE_D	0x00000400L		/* Digit */
#define	_CTYPE_G	0x00000800L		/* Graph */
#define	_CTYPE_L	0x00001000L		/* Lower */
#define	_CTYPE_P	0x00002000L		/* Punct */
#define	_CTYPE_S	0x00004000L		/* Space */
#define	_CTYPE_U	0x00008000L		/* Upper */
#define	_CTYPE_X	0x00010000L		/* X digit */
#define	_CTYPE_B	0x00020000L		/* Blank */
#define	_CTYPE_R	0x00040000L		/* Print */
#define	_CTYPE_I	0x00080000L		/* Ideogram */
#define	_CTYPE_T	0x00100000L		/* Special */
#define	_CTYPE_Q	0x00200000L		/* Phonogram */
#define	_CTYPE_SW0	0x20000000L		/* 0 width character */
#define	_CTYPE_SW1	0x40000000L		/* 1 width character */
#define	_CTYPE_SW2	0x80000000L		/* 2 width character */
#define	_CTYPE_SW3	0xc0000000L		/* 3 width character */
#define	_CTYPE_SWM	0xe0000000L		/* Mask for screen width data */
#define	_CTYPE_SWS	30			/* Bits to shift to get width */

#ifdef _NONSTD_SOURCE
/*
 * Backward compatibility
 */
#define	_A		_CTYPE_A		/* Alpha */
#define	_C		_CTYPE_C		/* Control */
#define	_D		_CTYPE_D		/* Digit */
#define	_G		_CTYPE_G		/* Graph */
#define	_L		_CTYPE_L		/* Lower */
#define	_P		_CTYPE_P		/* Punct */
#define	_S		_CTYPE_S		/* Space */
#define	_U		_CTYPE_U		/* Upper */
#define	_X		_CTYPE_X		/* X digit */
#define	_B		_CTYPE_B		/* Blank */
#define	_R		_CTYPE_R		/* Print */
#define	_I		_CTYPE_I		/* Ideogram */
#define	_T		_CTYPE_T		/* Special */
#define	_Q		_CTYPE_Q		/* Phonogram */
#define	_SW0		_CTYPE_SW0		/* 0 width character */
#define	_SW1		_CTYPE_SW1		/* 1 width character */
#define	_SW2		_CTYPE_SW2		/* 2 width character */
#define	_SW3		_CTYPE_SW3		/* 3 width character */
#endif /* _NONSTD_SOURCE */

//Begin-Libc
/*
 * _EXTERNALIZE_CTYPE_INLINES_ is defined in locale/nomacros.c to tell us
 * to generate code for extern versions of all intermediate inline functions.
 */
#ifdef _EXTERNALIZE_CTYPE_INLINES_
#define _USE_CTYPE_INLINE_
#define __DARWIN_CTYPE_inline
#else /* !_EXTERNALIZE_CTYPE_INLINES_ */
//End-Libc
#define __DARWIN_CTYPE_inline		__header_inline
//Begin-Libc
#endif /* !_EXTERNALIZE_CTYPE_INLINES_ */
//End-Libc

//Begin-Libc
/*
 * _EXTERNALIZE_CTYPE_INLINES_TOP_ is defined in locale/isctype.c to tell us
 * to generate code for extern versions of all top-level inline functions.
 */
#ifdef _EXTERNALIZE_CTYPE_INLINES_TOP_
#define _USE_CTYPE_INLINE_
#define __DARWIN_CTYPE_TOP_inline
#else /* !_EXTERNALIZE_CTYPE_INLINES_TOP_ */
//End-Libc
#define __DARWIN_CTYPE_TOP_inline	__header_inline
//Begin-Libc
#endif /* _EXTERNALIZE_CTYPE_INLINES_TOP_ */
//End-Libc

/*
 * Use inline functions if we are allowed to and the compiler supports them.
 */
#if !defined(_DONT_USE_CTYPE_INLINE_) && \
    (defined(_USE_CTYPE_INLINE_) || defined(__GNUC__) || defined(__cplusplus))

/* See comments in <machine/_type.h> about __darwin_ct_rune_t. */
__BEGIN_DECLS
unsigned long		___runetype(__darwin_ct_rune_t);
__darwin_ct_rune_t	___tolower(__darwin_ct_rune_t);
__darwin_ct_rune_t	___toupper(__darwin_ct_rune_t);
__END_DECLS

__DARWIN_CTYPE_TOP_inline int
isascii(int _c)
{
	return ((_c & ~0x7F) == 0);
}

#ifdef USE_ASCII
__DARWIN_CTYPE_inline int
__maskrune(__darwin_ct_rune_t _c, unsigned long _f)
{
	return (int)_DefaultRuneLocale.__runetype[_c & 0xff] & (__uint32_t)_f;
}
//Begin-Libc
#elif defined(__LIBC__)
__DARWIN_CTYPE_inline int
__maskrune(__darwin_ct_rune_t _c, unsigned long _f)
{
	/* _CurrentRuneLocale.__runetype[_c] is __uint32_t
	 * _f is unsigned long
	 * ___runetype(_c) is unsigned long
	 * retval is int
	 */
	return (int)((_c < 0 || _c >= _CACHED_RUNES) ? (__uint32_t)___runetype(_c) :
		__current_locale()->__lc_ctype->_CurrentRuneLocale.__runetype[_c]) & (__uint32_t)_f;
}
//End-Libc
#else /* !USE_ASCII */
__BEGIN_DECLS
int             	__maskrune(__darwin_ct_rune_t, unsigned long);
__END_DECLS
#endif /* USE_ASCII */

__DARWIN_CTYPE_inline int
__istype(__darwin_ct_rune_t _c, unsigned long _f)
{
#ifdef USE_ASCII
	return !!(__maskrune(_c, _f));
#else /* USE_ASCII */
	return (isascii(_c) ? !!(_DefaultRuneLocale.__runetype[_c] & _f)
		: !!__maskrune(_c, _f));
#endif /* USE_ASCII */
}

__DARWIN_CTYPE_inline __darwin_ct_rune_t
__isctype(__darwin_ct_rune_t _c, unsigned long _f)
{
#ifdef USE_ASCII
	return !!(__maskrune(_c, _f));
#else /* USE_ASCII */
	return (_c < 0 || _c >= _CACHED_RUNES) ? 0 :
		!!(_DefaultRuneLocale.__runetype[_c] & _f);
#endif /* USE_ASCII */
}

#ifdef USE_ASCII
__DARWIN_CTYPE_inline __darwin_ct_rune_t
__toupper(__darwin_ct_rune_t _c)
{
	return _DefaultRuneLocale.__mapupper[_c & 0xff];
}

__DARWIN_CTYPE_inline __darwin_ct_rune_t
__tolower(__darwin_ct_rune_t _c)
{
	return _DefaultRuneLocale.__maplower[_c & 0xff];
}
//Begin-Libc
#elif defined(__LIBC__)
/*
 * We can't do what we do for __toupper_l() (check for ASCII first, then call
 * ___toupper_l() otherwise) because versions of ___toupper() before Tiger
 * assume c >= _CACHED_RUNES.  So we are stuck making __toupper() a routine
 * to hide the extended locale details, outside of Libc.
 */
__DARWIN_CTYPE_inline __darwin_ct_rune_t
__toupper(__darwin_ct_rune_t _c)
{
	return (_c < 0 || _c >= _CACHED_RUNES) ? ___toupper(_c) :
		__current_locale()->__lc_ctype->_CurrentRuneLocale.__mapupper[_c];
}

__DARWIN_CTYPE_inline __darwin_ct_rune_t
__tolower(__darwin_ct_rune_t _c)
{
	return (_c < 0 || _c >= _CACHED_RUNES) ? ___tolower(_c) :
		__current_locale()->__lc_ctype->_CurrentRuneLocale.__maplower[_c];
}
//End-Libc
#else /* !USE_ASCII */
__BEGIN_DECLS
__darwin_ct_rune_t	__toupper(__darwin_ct_rune_t);
__darwin_ct_rune_t	__tolower(__darwin_ct_rune_t);
__END_DECLS
#endif /* USE_ASCII */

__DARWIN_CTYPE_inline int
__wcwidth(__darwin_ct_rune_t _c)
{
	unsigned int _x;

	if (_c == 0)
		return (0);
	_x = (unsigned int)__maskrune(_c, _CTYPE_SWM|_CTYPE_R);
	if ((_x & _CTYPE_SWM) != 0)
		return ((_x & _CTYPE_SWM) >> _CTYPE_SWS);
	return ((_x & _CTYPE_R) != 0 ? 1 : -1);
}

#ifndef _EXTERNALIZE_CTYPE_INLINES_

#define	_tolower(c)	__tolower(c)
#define	_toupper(c)	__toupper(c)

__DARWIN_CTYPE_TOP_inline int
isalnum(int _c)
{
	return (__istype(_c, _CTYPE_A|_CTYPE_D));
}

__DARWIN_CTYPE_TOP_inline int
isalpha(int _c)
{
	return (__istype(_c, _CTYPE_A));
}

__DARWIN_CTYPE_TOP_inline int
isblank(int _c)
{
	return (__istype(_c, _CTYPE_B));
}

__DARWIN_CTYPE_TOP_inline int
iscntrl(int _c)
{
	return (__istype(_c, _CTYPE_C));
}

/* ANSI -- locale independent */
__DARWIN_CTYPE_TOP_inline int
isdigit(int _c)
{
	return (__isctype(_c, _CTYPE_D));
}

__DARWIN_CTYPE_TOP_inline int
isgraph(int _c)
{
	return (__istype(_c, _CTYPE_G));
}

__DARWIN_CTYPE_TOP_inline int
islower(int _c)
{
	return (__istype(_c, _CTYPE_L));
}

__DARWIN_CTYPE_TOP_inline int
isprint(int _c)
{
	return (__istype(_c, _CTYPE_R));
}

__DARWIN_CTYPE_TOP_inline int
ispunct(int _c)
{
	return (__istype(_c, _CTYPE_P));
}

__DARWIN_CTYPE_TOP_inline int
isspace(int _c)
{
	return (__istype(_c, _CTYPE_S));
}

__DARWIN_CTYPE_TOP_inline int
isupper(int _c)
{
	return (__istype(_c, _CTYPE_U));
}

/* ANSI -- locale independent */
__DARWIN_CTYPE_TOP_inline int
isxdigit(int _c)
{
	return (__isctype(_c, _CTYPE_X));
}

__DARWIN_CTYPE_TOP_inline int
toascii(int _c)
{
	return (_c & 0x7F);
}

__DARWIN_CTYPE_TOP_inline int
tolower(int _c)
{
        return (__tolower(_c));
}

__DARWIN_CTYPE_TOP_inline int
toupper(int _c)
{
        return (__toupper(_c));
}

#if !defined(_ANSI_SOURCE) && (!defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE))
__DARWIN_CTYPE_TOP_inline int
digittoint(int _c)
{
	return (__maskrune(_c, 0x0F));
}

__DARWIN_CTYPE_TOP_inline int
ishexnumber(int _c)
{
	return (__istype(_c, _CTYPE_X));
}

__DARWIN_CTYPE_TOP_inline int
isideogram(int _c)
{
	return (__istype(_c, _CTYPE_I));
}

__DARWIN_CTYPE_TOP_inline int
isnumber(int _c)
{
	return (__istype(_c, _CTYPE_D));
}

__DARWIN_CTYPE_TOP_inline int
isphonogram(int _c)
{
	return (__istype(_c, _CTYPE_Q));
}

__DARWIN_CTYPE_TOP_inline int
isrune(int _c)
{
	return (__istype(_c, 0xFFFFFFF0L));
}

__DARWIN_CTYPE_TOP_inline int
isspecial(int _c)
{
	return (__istype(_c, _CTYPE_T));
}
#endif /* !_ANSI_SOURCE && (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
#endif /* _EXTERNALIZE_CTYPE_INLINES_ */

#else /* not using inlines */

__BEGIN_DECLS
int     isalnum(int);
int     isalpha(int);
int     isblank(int);
int     iscntrl(int);
int     isdigit(int);
int     isgraph(int);
int     islower(int);
int     isprint(int);
int     ispunct(int);
int     isspace(int);
int     isupper(int);
int     isxdigit(int);
int     tolower(int);
int     toupper(int);
int     isascii(int);
int     toascii(int);

#if !defined(_ANSI_SOURCE) && (!defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE))
int     _tolower(int);
int     _toupper(int);
int     digittoint(int);
int     ishexnumber(int);
int     isideogram(int);
int     isnumber(int);
int     isphonogram(int);
int     isrune(int);
int     isspecial(int);
#endif
__END_DECLS

#endif /* using inlines */

#ifdef _USE_EXTENDED_LOCALES_
#include <xlocale/_ctype.h>
#endif /* _USE_EXTENDED_LOCALES_ */

#endif /* !_CTYPE_H_ */
Commit	Line	Data
e07eda1a A	1	/*
	2	* Copyright (c) 2000, 2005, 2008 Apple Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
	6	* This file contains Original Code and/or Modifications of Original Code
	7	* as defined in and that are subject to the Apple Public Source License
	8	* Version 2.0 (the 'License'). You may not use this file except in
	9	* compliance with the License. Please obtain a copy of the License at
	10	* http://www.opensource.apple.com/apsl/ and read it before using this
	11	* file.
	12	*
	13	* The Original Code and all software distributed under the License are
	14	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	15	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	16	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	17	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	18	* Please see the License for the specific language governing rights and
	19	* limitations under the License.
	20	*
	21	* @APPLE_LICENSE_HEADER_END@
	22	*/
	23	/*
	24	* Copyright (c) 1989, 1993
	25	* The Regents of the University of California. All rights reserved.
	26	* (c) UNIX System Laboratories, Inc.
	27	* All or some portions of this file are derived from material licensed
	28	* to the University of California by American Telephone and Telegraph
	29	* Co. or Unix System Laboratories, Inc. and are reproduced herein with
	30	* the permission of UNIX System Laboratories, Inc.
	31	*
	32	* This code is derived from software contributed to Berkeley by
	33	* Paul Borman at Krystal Technologies.
	34	*
	35	* Redistribution and use in source and binary forms, with or without
	36	* modification, are permitted provided that the following conditions
	37	* are met:
	38	* 1. Redistributions of source code must retain the above copyright
	39	* notice, this list of conditions and the following disclaimer.
	40	* 2. Redistributions in binary form must reproduce the above copyright
	41	* notice, this list of conditions and the following disclaimer in the
	42	* documentation and/or other materials provided with the distribution.
	43	* 3. All advertising materials mentioning features or use of this software
	44	* must display the following acknowledgement:
	45	* This product includes software developed by the University of
	46	* California, Berkeley and its contributors.
	47	* 4. Neither the name of the University nor the names of its contributors
	48	* may be used to endorse or promote products derived from this software
	49	* without specific prior written permission.
	50	*
	51	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
	52	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	53	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	54	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
	55	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	56	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	57	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	58	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	59	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	60	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	61	* SUCH DAMAGE.
	62	*
	63	* @(#)ctype.h 8.4 (Berkeley) 1/21/94
	64	*/
65
66	//Begin-Libc
67	#include "xlocale_private.h"
68	//End-Libc
69	#ifndef __CTYPE_H_
70	#define __CTYPE_H_
71
72	#include <sys/cdefs.h>
73	#include <runetype.h>
74
75	#define _CTYPE_A 0x00000100L /* Alpha */
76	#define _CTYPE_C 0x00000200L /* Control */
77	#define _CTYPE_D 0x00000400L /* Digit */
78	#define _CTYPE_G 0x00000800L /* Graph */
79	#define _CTYPE_L 0x00001000L /* Lower */
80	#define _CTYPE_P 0x00002000L /* Punct */
81	#define _CTYPE_S 0x00004000L /* Space */
82	#define _CTYPE_U 0x00008000L /* Upper */
83	#define _CTYPE_X 0x00010000L /* X digit */
84	#define _CTYPE_B 0x00020000L /* Blank */
85	#define _CTYPE_R 0x00040000L /* Print */
86	#define _CTYPE_I 0x00080000L /* Ideogram */
87	#define _CTYPE_T 0x00100000L /* Special */
88	#define _CTYPE_Q 0x00200000L /* Phonogram */
89	#define _CTYPE_SW0 0x20000000L /* 0 width character */
90	#define _CTYPE_SW1 0x40000000L /* 1 width character */
91	#define _CTYPE_SW2 0x80000000L /* 2 width character */
92	#define _CTYPE_SW3 0xc0000000L /* 3 width character */
93	#define _CTYPE_SWM 0xe0000000L /* Mask for screen width data */
94	#define _CTYPE_SWS 30 /* Bits to shift to get width */
95
96	#ifdef _NONSTD_SOURCE
97	/*
98	* Backward compatibility
99	*/
100	#define _A _CTYPE_A /* Alpha */
101	#define _C _CTYPE_C /* Control */
102	#define _D _CTYPE_D /* Digit */
103	#define _G _CTYPE_G /* Graph */
104	#define _L _CTYPE_L /* Lower */
105	#define _P _CTYPE_P /* Punct */
106	#define _S _CTYPE_S /* Space */
107	#define _U _CTYPE_U /* Upper */
108	#define _X _CTYPE_X /* X digit */
109	#define _B _CTYPE_B /* Blank */
110	#define _R _CTYPE_R /* Print */
111	#define _I _CTYPE_I /* Ideogram */
112	#define _T _CTYPE_T /* Special */
113	#define _Q _CTYPE_Q /* Phonogram */
114	#define _SW0 _CTYPE_SW0 /* 0 width character */
115	#define _SW1 _CTYPE_SW1 /* 1 width character */
116	#define _SW2 _CTYPE_SW2 /* 2 width character */
117	#define _SW3 _CTYPE_SW3 /* 3 width character */
118	#endif /* _NONSTD_SOURCE */
119
120	//Begin-Libc
121	/*
122	* _EXTERNALIZE_CTYPE_INLINES_ is defined in locale/nomacros.c to tell us
123	* to generate code for extern versions of all intermediate inline functions.
124	*/
125	#ifdef _EXTERNALIZE_CTYPE_INLINES_
126	#define _USE_CTYPE_INLINE_
127	#define __DARWIN_CTYPE_inline
128	#else /* !_EXTERNALIZE_CTYPE_INLINES_ */
129	//End-Libc
130	#define __DARWIN_CTYPE_inline __header_inline
131	//Begin-Libc
132	#endif /* !_EXTERNALIZE_CTYPE_INLINES_ */
133	//End-Libc
134
135	//Begin-Libc
136	/*
137	* _EXTERNALIZE_CTYPE_INLINES_TOP_ is defined in locale/isctype.c to tell us
138	* to generate code for extern versions of all top-level inline functions.
139	*/
140	#ifdef _EXTERNALIZE_CTYPE_INLINES_TOP_
141	#define _USE_CTYPE_INLINE_
142	#define __DARWIN_CTYPE_TOP_inline
143	#else /* !_EXTERNALIZE_CTYPE_INLINES_TOP_ */
144	//End-Libc
145	#define __DARWIN_CTYPE_TOP_inline __header_inline
146	//Begin-Libc
147	#endif /* _EXTERNALIZE_CTYPE_INLINES_TOP_ */
148	//End-Libc
149
150	/*
151	* Use inline functions if we are allowed to and the compiler supports them.
152	*/
153	#if !defined(_DONT_USE_CTYPE_INLINE_) && \
154	(defined(_USE_CTYPE_INLINE_) \|\| defined(__GNUC__) \|\| defined(__cplusplus))
155
156	/* See comments in <machine/_type.h> about __darwin_ct_rune_t. */
157	__BEGIN_DECLS
158	unsigned long ___runetype(__darwin_ct_rune_t);
159	__darwin_ct_rune_t ___tolower(__darwin_ct_rune_t);
160	__darwin_ct_rune_t ___toupper(__darwin_ct_rune_t);
161	__END_DECLS
162
163	__DARWIN_CTYPE_TOP_inline int
164	isascii(int _c)
165	{
166	return ((_c & ~0x7F) == 0);
167	}
168
169	#ifdef USE_ASCII
170	__DARWIN_CTYPE_inline int
171	__maskrune(__darwin_ct_rune_t _c, unsigned long _f)
172	{
173	return (int)_DefaultRuneLocale.__runetype[_c & 0xff] & (__uint32_t)_f;
174	}
175	//Begin-Libc
176	#elif defined(__LIBC__)
177	__DARWIN_CTYPE_inline int
178	__maskrune(__darwin_ct_rune_t _c, unsigned long _f)
179	{
180	/* _CurrentRuneLocale.__runetype[_c] is __uint32_t
181	* _f is unsigned long
182	* ___runetype(_c) is unsigned long
183	* retval is int
184	*/
185	return (int)((_c < 0 \|\| _c >= _CACHED_RUNES) ? (__uint32_t)___runetype(_c) :
186	__current_locale()->__lc_ctype->_CurrentRuneLocale.__runetype[_c]) & (__uint32_t)_f;
187	}
188	//End-Libc
189	#else /* !USE_ASCII */
190	__BEGIN_DECLS
191	int __maskrune(__darwin_ct_rune_t, unsigned long);
192	__END_DECLS
193	#endif /* USE_ASCII */
194
195	__DARWIN_CTYPE_inline int
196	__istype(__darwin_ct_rune_t _c, unsigned long _f)
197	{
198	#ifdef USE_ASCII
199	return !!(__maskrune(_c, _f));
200	#else /* USE_ASCII */
201	return (isascii(_c) ? !!(_DefaultRuneLocale.__runetype[_c] & _f)
202	: !!__maskrune(_c, _f));
203	#endif /* USE_ASCII */
204	}
205
206	__DARWIN_CTYPE_inline __darwin_ct_rune_t
207	__isctype(__darwin_ct_rune_t _c, unsigned long _f)
208	{
209	#ifdef USE_ASCII
210	return !!(__maskrune(_c, _f));
211	#else /* USE_ASCII */
212	return (_c < 0 \|\| _c >= _CACHED_RUNES) ? 0 :
213	!!(_DefaultRuneLocale.__runetype[_c] & _f);
214	#endif /* USE_ASCII */
215	}
216
217	#ifdef USE_ASCII
218	__DARWIN_CTYPE_inline __darwin_ct_rune_t
219	__toupper(__darwin_ct_rune_t _c)
220	{
221	return _DefaultRuneLocale.__mapupper[_c & 0xff];
222	}
223
224	__DARWIN_CTYPE_inline __darwin_ct_rune_t
225	__tolower(__darwin_ct_rune_t _c)
226	{
227	return _DefaultRuneLocale.__maplower[_c & 0xff];
228	}
229	//Begin-Libc
230	#elif defined(__LIBC__)
231	/*
232	* We can't do what we do for __toupper_l() (check for ASCII first, then call
233	* ___toupper_l() otherwise) because versions of ___toupper() before Tiger
234	* assume c >= _CACHED_RUNES. So we are stuck making __toupper() a routine
235	* to hide the extended locale details, outside of Libc.
236	*/
237	__DARWIN_CTYPE_inline __darwin_ct_rune_t
238	__toupper(__darwin_ct_rune_t _c)
239	{
240	return (_c < 0 \|\| _c >= _CACHED_RUNES) ? ___toupper(_c) :
241	__current_locale()->__lc_ctype->_CurrentRuneLocale.__mapupper[_c];
242	}
243
244	__DARWIN_CTYPE_inline __darwin_ct_rune_t
245	__tolower(__darwin_ct_rune_t _c)
246	{
247	return (_c < 0 \|\| _c >= _CACHED_RUNES) ? ___tolower(_c) :
248	__current_locale()->__lc_ctype->_CurrentRuneLocale.__maplower[_c];
249	}
250	//End-Libc
251	#else /* !USE_ASCII */
252	__BEGIN_DECLS
253	__darwin_ct_rune_t __toupper(__darwin_ct_rune_t);
254	__darwin_ct_rune_t __tolower(__darwin_ct_rune_t);
255	__END_DECLS
256	#endif /* USE_ASCII */
257
258	__DARWIN_CTYPE_inline int
259	__wcwidth(__darwin_ct_rune_t _c)
260	{
261	unsigned int _x;
262
263	if (_c == 0)
264	return (0);
265	_x = (unsigned int)__maskrune(_c, _CTYPE_SWM\|_CTYPE_R);
266	if ((_x & _CTYPE_SWM) != 0)
267	return ((_x & _CTYPE_SWM) >> _CTYPE_SWS);
268	return ((_x & _CTYPE_R) != 0 ? 1 : -1);
269	}
270
271	#ifndef _EXTERNALIZE_CTYPE_INLINES_
272
273	#define _tolower(c) __tolower(c)
274	#define _toupper(c) __toupper(c)
275
276	__DARWIN_CTYPE_TOP_inline int
277	isalnum(int _c)
278	{
279	return (__istype(_c, _CTYPE_A\|_CTYPE_D));
280	}
281
282	__DARWIN_CTYPE_TOP_inline int
283	isalpha(int _c)
284	{
285	return (__istype(_c, _CTYPE_A));
286	}
287
288	__DARWIN_CTYPE_TOP_inline int
289	isblank(int _c)
290	{
291	return (__istype(_c, _CTYPE_B));
292	}
293
294	__DARWIN_CTYPE_TOP_inline int
295	iscntrl(int _c)
296	{
297	return (__istype(_c, _CTYPE_C));
298	}
299
300	/* ANSI -- locale independent */
301	__DARWIN_CTYPE_TOP_inline int
302	isdigit(int _c)
303	{
304	return (__isctype(_c, _CTYPE_D));
305	}
306
307	__DARWIN_CTYPE_TOP_inline int
308	isgraph(int _c)
309	{
310	return (__istype(_c, _CTYPE_G));
311	}
312
313	__DARWIN_CTYPE_TOP_inline int
314	islower(int _c)
315	{
316	return (__istype(_c, _CTYPE_L));
317	}
318
319	__DARWIN_CTYPE_TOP_inline int
320	isprint(int _c)
321	{
322	return (__istype(_c, _CTYPE_R));
323	}
324
325	__DARWIN_CTYPE_TOP_inline int
326	ispunct(int _c)
327	{
328	return (__istype(_c, _CTYPE_P));
329	}
330
331	__DARWIN_CTYPE_TOP_inline int
332	isspace(int _c)
333	{
334	return (__istype(_c, _CTYPE_S));
335	}
336
337	__DARWIN_CTYPE_TOP_inline int
338	isupper(int _c)
339	{
340	return (__istype(_c, _CTYPE_U));
341	}
342
343	/* ANSI -- locale independent */
344	__DARWIN_CTYPE_TOP_inline int
345	isxdigit(int _c)
346	{
347	return (__isctype(_c, _CTYPE_X));
348	}
349
350	__DARWIN_CTYPE_TOP_inline int
351	toascii(int _c)
352	{
353	return (_c & 0x7F);
354	}
355
356	__DARWIN_CTYPE_TOP_inline int
357	tolower(int _c)
358	{
359	return (__tolower(_c));
360	}
361
362	__DARWIN_CTYPE_TOP_inline int
363	toupper(int _c)
364	{
365	return (__toupper(_c));
366	}
367
368	#if !defined(_ANSI_SOURCE) && (!defined(_POSIX_C_SOURCE) \|\| defined(_DARWIN_C_SOURCE))
369	__DARWIN_CTYPE_TOP_inline int
370	digittoint(int _c)
371	{
372	return (__maskrune(_c, 0x0F));
373	}
374
375	__DARWIN_CTYPE_TOP_inline int
376	ishexnumber(int _c)
377	{
378	return (__istype(_c, _CTYPE_X));
379	}
380
381	__DARWIN_CTYPE_TOP_inline int
382	isideogram(int _c)
383	{
384	return (__istype(_c, _CTYPE_I));
385	}
386
387	__DARWIN_CTYPE_TOP_inline int
388	isnumber(int _c)
389	{
390	return (__istype(_c, _CTYPE_D));
391	}
392
393	__DARWIN_CTYPE_TOP_inline int
394	isphonogram(int _c)
395	{
396	return (__istype(_c, _CTYPE_Q));
397	}
398
399	__DARWIN_CTYPE_TOP_inline int
400	isrune(int _c)
401	{
402	return (__istype(_c, 0xFFFFFFF0L));
403	}
404
405	__DARWIN_CTYPE_TOP_inline int
406	isspecial(int _c)
407	{
408	return (__istype(_c, _CTYPE_T));
409	}
410	#endif /* !_ANSI_SOURCE && (!_POSIX_C_SOURCE \|\| _DARWIN_C_SOURCE) */
411	#endif /* _EXTERNALIZE_CTYPE_INLINES_ */
412
413	#else /* not using inlines */
414
415	__BEGIN_DECLS
416	int isalnum(int);
417	int isalpha(int);
418	int isblank(int);
419	int iscntrl(int);
420	int isdigit(int);
421	int isgraph(int);
422	int islower(int);
423	int isprint(int);
424	int ispunct(int);
425	int isspace(int);
426	int isupper(int);
427	int isxdigit(int);
428	int tolower(int);
429	int toupper(int);
430	int isascii(int);
431	int toascii(int);
432
433	#if !defined(_ANSI_SOURCE) && (!defined(_POSIX_C_SOURCE) \|\| defined(_DARWIN_C_SOURCE))
434	int _tolower(int);
435	int _toupper(int);
436	int digittoint(int);
437	int ishexnumber(int);
438	int isideogram(int);
439	int isnumber(int);
440	int isphonogram(int);
441	int isrune(int);
442	int isspecial(int);
443	#endif
444	__END_DECLS
445
446	#endif /* using inlines */
447
448	#ifdef _USE_EXTENDED_LOCALES_
449	#include <xlocale/_ctype.h>
450	#endif /* _USE_EXTENDED_LOCALES_ */
451
452	#endif /* !_CTYPE_H_ */