// @@@ START COPYRIGHT @@@
//
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.
//
// @@@ END COPYRIGHT @@@
/*
 * COPYRIGHT NOTICE
 * 
 * Copyright (c) 1990, 1991, 1992, 1993 Open Software Foundation, Inc.
 * ALL RIGHTS RESERVED (OSF/1).  See /usr/include/COPYRIGHT.OSF1 .
 */

#include <sys/types.h>

#ifndef NA_EIDPROC
#define NA_EIDPROC
#define _resident
#endif

/*
 * Macros
 */
#define MULTIBYTE	0x80
#define SS2		0x8e
#define SS3		0x8f

#define PLANE1		0x00200
#define PLANE2		(PLANE1+PLANE_SIZE)
#define PLANE3		(PLANE2+PLANE_SIZE)
#define PLANE4		(PLANE3+PLANE_SIZE)
#define PLANE5		(PLANE4+PLANE_SIZE)
#define PLANE6		(PLANE5+PLANE_SIZE)
#define PLANE7		(PLANE6+PLANE_SIZE)
#define PLANE8		-1		/* Not used */
#define PLANE9		-1		/* Not used */
#define PLANE10		-1		/* Not used */
#define PLANE11		-1		/* Not used */
#define PLANE12		-1		/* Not used */
#define PLANE13		-1		/* Not used */
#define PLANE14		-1		/* Not used */
#define PLANE15		(PLANE7 +PLANE_SIZE)
#define PLANE16		-1		/* Not used */
#define	PLANEU		(PLANE15+PLANE_SIZE)	/* UDC plane   */
#define	PLANEXU		(PLANEU +UCS_UCNT  )	/* XUDC planes */
#define	PLANE_SIZE	0x02300
#define	MAX_TIDX	(PLANEU+PLANE_SIZE)	/* Maximum table index value */

//#define BAD		-1

/*
 * Check for C1 control characters
 */
#define	ISC1CHAR(c)  ((0x80 <= (c)) && ((c) <= 0x9f))


/*
 * The following macros are used to detect if a certain byte is a valid 
 * first or second byte of a multibyte character. A table lookup mechanism
 * is used for efficient access of valid character information. The cvtab[]
 * table can be found in the mb_iconv.c module.
 *
 * Range bit :
 *	Bit  0 - 0x21 to 0x3f
 *	Bit  1 - 0x40
 *	Bit  2 - 0x41 to 0x5a
 *	Bit  3 - 0x5b to 0x60
 *	Bit  4 - 0x61 to 0x7a
 *	Bit  5 - 0x7b to 0x7d
 *	Bit  6 - 0x7e
 *	Bit  7 - 0x80
 *	Bit  8 - 0x81 to 0x8d
 *	Bit  9 - 0x8e to 0x9d
 *	Bit 10 - 0x9e
 *	Bit 11 - 0x9f
 *	Bit 12 - 0xa0
 *	Bit 13 - 0xa1 to 0xc6
 *	Bit 14 - 0xc7 to 0xdf
 *	Bit 15 - 0xe0 to 0xf9
 *	Bit 16 - 0xfa to 0xfc
 *	Bit 17 - 0xfd
 *	Bit 18 - 0xfe
 *	Bit 19 - 0x30 to 0x39
 */
#define	VBIT_21TO3F		0x00001
#define	VBIT_40			0x00002
#define	VBIT_41TO5A		0x00004
#define	VBIT_5BTO60		0x00008
#define	VBIT_61TO7A		0x00010
#define	VBIT_7BTO7D		0x00020
#define	VBIT_7E			0x00040
#define	VBIT_80			0x00080
#define	VBIT_81TO8D		0x00100
#define	VBIT_8ETO9D		0x00200
#define	VBIT_9E			0x00400
#define	VBIT_9F			0x00800
#define	VBIT_A0			0x01000
#define	VBIT_A1TOC6		0x02000
#define	VBIT_C7TODF		0x04000
#define	VBIT_E0TOF9		0x08000
#define	VBIT_FATOFC		0x10000
#define	VBIT_FD			0x20000
#define	VBIT_FE			0x40000
#define	VBIT_30TO39		0x80000

#define	RANGE_30TO39		(VBIT_30TO39 )
#define	RANGE_81TO8D		(VBIT_81TO8D )
#define	RANGE_A0TOC6		(VBIT_A0     | VBIT_A1TOC6 )
#define	RANGE_A1TODF		(VBIT_A1TOC6 | VBIT_C7TODF)
#define	RANGE_40TO7E		(VBIT_40     | VBIT_41TO5A | VBIT_5BTO60 | \
				 VBIT_61TO7A | VBIT_7BTO7D | VBIT_7E )
#define	RANGE_81TO9F		(VBIT_81TO8D | VBIT_8ETO9D | VBIT_9E | VBIT_9F)
#define	RANGE_8ETOA0		(VBIT_8ETO9D | VBIT_9E     | VBIT_9F | VBIT_A0)
#define	RANGE_21TO7E		(VBIT_21TO3F | RANGE_40TO7E)
#define	RANGE_80TOA0		(RANGE_81TO9F| VBIT_80     | VBIT_A0     )
#define	RANGE_81TOA0		(RANGE_81TO9F| VBIT_A0	   )
#define	RANGE_A1TOFC		(RANGE_A1TODF| VBIT_E0TOF9 | VBIT_FATOFC )
#define	RANGE_A1TOFE		(RANGE_A1TOFC| VBIT_FD     | VBIT_FE     )

#define	RANGE_80TOFC		(VBIT_80     | RANGE_81TOA0| RANGE_A1TOFC)
#define	RANGE_A1TOF9		(RANGE_A1TODF| VBIT_E0TOF9 )
#define	RANGE_E0TOFC		(VBIT_E0TOF9 | VBIT_FATOFC )
#define	RANGE_FATOFE		(VBIT_FATOFC | VBIT_FD     | VBIT_FE     )
#define	RANGE_81TO9F_E0TOFC	(RANGE_81TO9F| VBIT_E0TOF9 | VBIT_FATOFC )
#define	RANGE_21TO7E_A1TOFE	(RANGE_21TO7E| RANGE_A1TOFE)
#define	RANGE_81TOFE		(RANGE_81TOA0| RANGE_A1TOFE)
#define RANGE_40TO7E_80TOA0	(RANGE_40TO7E| RANGE_80TOA0)
#define	RANGE_40TO7E_80TOFC	(RANGE_40TO7E| RANGE_80TOFC)
#define	RANGE_40TO7E_80TOFE	(RANGE_40TO7E| RANGE_80TOFC | VBIT_FD | VBIT_FE)
#define	RANGE_40TO7E_A1TOFE	(RANGE_40TO7E| RANGE_A1TOFE)
#define	RANGE_81TOA0_FATOFE	(RANGE_81TOA0| RANGE_FATOFE)
#define	RANGE_41TO5A_61TO7A_81TOFE	\
				(VBIT_41TO5A | VBIT_61TO7A | RANGE_81TOFE)
#define	RANGE_41TO5A_61TO7A_81TOA0	\
				(VBIT_41TO5A | VBIT_61TO7A | RANGE_81TOA0)

#define	VBITS_EUCTW1		RANGE_A1TOFE
#define	VBITS_EUCTW2		RANGE_A1TOFE
#define	VBITS_DECHANYU1		RANGE_A1TOFE
#define	VBITS_DECHANYU2		RANGE_21TO7E_A1TOFE
#define	VBITS_EDPC1		RANGE_A1TOFE
#define	VBITS_EDPC2		RANGE_A1TOFE
#define	VBITS_DECHANZI1		RANGE_A1TOFE
#define	VBITS_DECHANZI2		RANGE_21TO7E_A1TOFE
#define	VBITS_DECKOREAN1	RANGE_A1TOFE
#define	VBITS_DECKOREAN2	RANGE_21TO7E_A1TOFE
#define	VBITS_BIG5_1		RANGE_81TOFE
#define	VBITS_BIG5_2		RANGE_40TO7E_A1TOFE
#define	VBITS_KANA		RANGE_A1TODF
#define	VBITS_DECKANJI1		RANGE_A1TOFE
#define	VBITS_DECKANJI2		RANGE_21TO7E_A1TOFE
#define	VBITS_EUCJP1		RANGE_A1TOFE
#define	VBITS_EUCJP2		RANGE_A1TOFE
#define	VBITS_SJIS1		RANGE_81TO9F_E0TOFC
#define	VBITS_SJIS2		RANGE_40TO7E_80TOFC
#define	VBITS_JIS1		RANGE_21TO7E
#define	VBITS_JIS2		RANGE_21TO7E
#define	VBITS_GBK1		RANGE_81TOFE
#define	VBITS_GBK2		RANGE_40TO7E_80TOFE

#define	VALID_EUCTW1(c)		(__cvtab[(unsigned)(c)] & VBITS_EUCTW1	  )
#define	VALID_EUCTW2(c)		(__cvtab[(unsigned)(c)] & VBITS_EUCTW2	  )
#define	VALID_DECHANYU1(c)	(__cvtab[(unsigned)(c)] & VBITS_DECHANYU1 )
#define	VALID_DECHANYU2(c)	(__cvtab[(unsigned)(c)] & VBITS_DECHANYU2 )
#define	VALID_EDPC1(c)		(__cvtab[(unsigned)(c)] & VBITS_EDPC1	  )
#define	VALID_EDPC2(c)		(__cvtab[(unsigned)(c)] & VBITS_EDPC2	  )
#define	VALID_DECHANZI1(c)	(__cvtab[(unsigned)(c)] & VBITS_DECHANZI1 )
#define	VALID_DECHANZI2(c)	(__cvtab[(unsigned)(c)] & VBITS_DECHANZI2 )
#define	VALID_DECKOREAN1(c)	(__cvtab[(unsigned)(c)] & VBITS_DECKOREAN1)
#define	VALID_DECKOREAN2(c)	(__cvtab[(unsigned)(c)] & VBITS_DECKOREAN2)
#define	VALID_KANA(c)		(__cvtab[(unsigned)(c)] & VBITS_KANA	  )
#define	VALID_DECKANJI1(c)	(__cvtab[(unsigned)(c)] & VBITS_DECKANJI1 )
#define	VALID_DECKANJI2(c)	(__cvtab[(unsigned)(c)] & VBITS_DECKANJI2 )
#define	VALID_EUCJP1(c)		(__cvtab[(unsigned)(c)] & VBITS_EUCJP1    )
#define	VALID_EUCJP2(c)		(__cvtab[(unsigned)(c)] & VBITS_EUCJP2    )
#define	VALID_JIS1(c)		(__cvtab[(unsigned)(c)] & VBITS_JIS1      )
#define	VALID_JIS2(c)		(__cvtab[(unsigned)(c)] & VBITS_JIS2      )
#define	VALID_GBK1(c)		(__cvtab[(unsigned)(c)] & VBITS_GBK1      )
#define	VALID_GBK2(c)		(__cvtab[(unsigned)(c)] & VBITS_GBK2      )
#define	VALID_EUCTWPLANE(c)	(__cvtab[(unsigned)(c)] & VBIT_EUCTWPLANE )

/*
 * SJIS related macros
 *
 * Valid SJIS first  byte: 0x81 - 0x9f, 0xe0 - 0xfc
 * Valid SJIS second byte: 0x40 - 0x7e, 0x80 - 0xfc
 * 
 * SJIS plane 0: 0xa1 <= 1st byte <= 0xdf	(JIS X 0201 - single byte)
 * SJIS plane 1: 0x81 <= 1st byte <= 0x9f	(JIS X 0208)
 * SJIS plane 2: 0xe0 <= 1st byte <= 0xea	(JIS X 0208)
 * SJIS plane U: 0xf0 <= 1st byte <= 0xfc	(UDC)
 *		 0xeb <= 1st byte <= 0xef
 *
 * The SJIS_ROW*, SJIS_COL & SJIS_IDX* macros are used to compute index
 * for accessing the cell table. The input values must be range checked
 * before using those macros.
 *
 * All unmapped codepoints will now map to the BMP UDC area.
 */
#define	SJIS_VALID1(c)	  (__cvtab[(unsigned)(c)] & VBITS_SJIS1 )
#define	SJIS_VALID2(c)	  (__cvtab[(unsigned)(c)] & VBITS_SJIS2 )
#define	SJIS_PLANE0(c)	  (__cvtab[(unsigned)(c)] & VBITS_KANA  )
#define	SJIS_PLANE1(c)	  (__cvtab[(unsigned)(c)] & RANGE_81TO9F)
#define	SJIS_PLANE2(c)	 ((__cvtab[(unsigned)(c)] & RANGE_E0TOFC) && \
			 ((unsigned)(c) <= 0xea))
#define	SJIS_PLANEU(c)	 ((__cvtab[(unsigned)(c)] & RANGE_E0TOFC) && \
			 ((c) >=  0xeb))
#define	SJIS_ROW1(c)	 ((c) - 0x81)
#define	SJIS_ROW2(c)	 ((c) - 0xe0)
#define	SJIS_ROW3(c)	 (((c) >= 0xf0) ? ((c) - 0xf0) : \
			  ((c)  - 0xeb + (0xfc - 0xf0 + 1)))
#define	SJIS_COL(c)	 sjis_to_idx[c]
#define	SJIS_COLSIZ	 (SJIS_COL(0xfc) + 1)
#define	SJIS_IDX0(c)	 ((c) + 0x100)
#define	SJIS_IDX1(c1,c2) (PLANE1 + SJIS_ROW1(c1) * SJIS_COLSIZ + SJIS_COL(c2))
#define	SJIS_IDX2(c1,c2) (PLANE2 + SJIS_ROW2(c1) * SJIS_COLSIZ + SJIS_COL(c2))
#define	SJIS_IDXU(c1,c2) (PLANEU + SJIS_ROW3(c1) * SJIS_COLSIZ + SJIS_COL(c2))
#define	UIDX1_SJIS(idx)	 ((((idx)/SJIS_COLSIZ + 0xf0) << 8) |\
			 idx_to_sjis[(idx)%SJIS_COLSIZ])
#define	UIDX2_SJIS(idx)	 ((((idx)/SJIS_COLSIZ + 0xeb) << 8) |\
			 idx_to_sjis[(idx)%SJIS_COLSIZ])
#define UIDX_SJIS(idx)	 (((idx)  < SJIS_UCNT1) ? UIDX1_SJIS(idx) : \
			 (((idx) -= SJIS_UCNT1), 		    \
			  ((idx)  < SJIS_UCNT2) ? UIDX2_SJIS(idx) : BAD))
#define	SJIS_UCNT1	 ((0xfc - 0xf0 + 1) * SJIS_COLSIZ)
#define	SJIS_UCNT2	 ((0xef - 0xeb + 1) * SJIS_COLSIZ)
#define	SJIS_UCNT	 (SJIS_UCNT1 + SJIS_UCNT2)

/*
 * BIG-5 related macros
 *
 * Valid BIG-5 first  byte: 0x81 - 0xfe
 * Valid BIG-5 second byte: 0x40 - 0x7e, 0xa1 - 0xfe
 *
 * BIG-5 plane 1: 0xa1 <= 1st byte <= 0xf9
 *		  0x40 <= 2nd byte <= 0x7e
 * BIG-5 plane 2: 0xa1 <= 1st byte <= 0xf9
 *		  0xa1 <= 2nd byte <= 0xfe
 * BIG-5 plane U: 0xfa <= 1st byte <= 0xfe (UDC level 1)
 *		  0x8e <= 1st byte <= 0xa0 (UDC level 2)
 *		  0x81 <= 1st byte <= 0x8d (UDC level 3)
 * 
 * All the non-UDC BIG-5 characters that have no mapping are now mapped
 * to the BMP UDC area after those occupied by the plane U characters.
 */
#define	BIG5_VALID1(c)	    (__cvtab[(unsigned)(c )] & VBITS_BIG5_1)
#define	BIG5_VALID2(c)	    (__cvtab[(unsigned)(c )] & VBITS_BIG5_2)
#define BIG5_PLANE1(c1,c2) ((__cvtab[(unsigned)(c1)] & RANGE_A1TOF9) && \
			    (__cvtab[(unsigned)(c2)] & RANGE_40TO7E))
#define BIG5_PLANE2(c1,c2) ((__cvtab[(unsigned)(c1)] & RANGE_A1TOF9) && \
			    (__cvtab[(unsigned)(c2)] & RANGE_A1TOFE))
#define BIG5_PLANEU(c1,c2)  (__cvtab[(unsigned)(c1)] & RANGE_81TOA0_FATOFE)
#define	BIG5_UDC1(c)	    (__cvtab[(unsigned)(c )] & RANGE_FATOFE)
#define	BIG5_UDC2(c)	    (__cvtab[(unsigned)(c )] & RANGE_8ETOA0)
#define	BIG5_UDC3(c)	    (__cvtab[(unsigned)(c )] & RANGE_81TO8D)
#define	BIG5_COLSIZ	     157
#define	BIG5_UCNT1	   ((0xfe - 0xfa + 1) * BIG5_COLSIZ)
#define	BIG5_UCNT2	   ((0xa0 - 0x8e + 1) * BIG5_COLSIZ)
#define	BIG5_UCNT3	   ((0x8d - 0x81 + 1) * BIG5_COLSIZ)
#define	BIG5_UCNT	    (BIG5_UCNT1 + BIG5_UCNT2 + BIG5_UCNT3)
#define	BIG5_UDC1IDX(c)	  (((c) - 0xfa) * BIG5_COLSIZ)
#define	BIG5_UDC2IDX(c)	  (((c) - 0x8e) * BIG5_COLSIZ + BIG5_UCNT1)
#define	BIG5_UDC3IDX(c)	  (((c) - 0x81) * BIG5_COLSIZ + BIG5_UCNT1 + BIG5_UCNT2)
#define	BIG5_IDX1(c1,c2)    (PLANE1 + ((c1) - 0xa1) * 63 + ((c2) - 0x40))
#define	BIG5_IDX2(c1,c2)    (PLANE2 + ((c1) - 0xa1) * 94 + ((c2) - 0xa1))
#define	BIG5_IDXU(c1,c2)    (PLANEU + (BIG5_UDC1(c1) ? BIG5_UDC1IDX(c1)	 \
				    :  BIG5_UDC2(c1) ? BIG5_UDC2IDX(c1)	 \
						     : BIG5_UDC3IDX(c1)) \
				    + big5_to_idx[c2])
#define	BIG5_UDC(c1,c2)	     BIG5_PLANEU(c1,c2)
#define	BIG5_UIDX(c1,c2)    (BIG5_IDXU(c1,c2) - PLANEU)
#define	UIDX1_BIG5(idx)	    ((((idx)/BIG5_COLSIZ + 0xfa) << 8) |\
			    idx_to_big5[(idx)%BIG5_COLSIZ])
#define	UIDX2_BIG5(idx)	    ((((idx)/BIG5_COLSIZ + 0x8e) << 8) |\
			    idx_to_big5[(idx)%BIG5_COLSIZ])
#define	UIDX3_BIG5(idx)	    ((((idx)/BIG5_COLSIZ + 0x81) << 8) |\
			    idx_to_big5[(idx)%BIG5_COLSIZ])
#define	UIDX_BIG5(idx)	    (((idx)  < BIG5_UCNT1) ? UIDX1_BIG5(idx) :	\
			    (((idx) -= BIG5_UCNT1),			\
			     ((idx)  < BIG5_UCNT2) ? UIDX2_BIG5(idx) :	\
			    (((idx) -= BIG5_UCNT2),			\
			     ((idx)  < BIG5_UCNT3) ? UIDX3_BIG5(idx) :	\
			       BAD)))
/* 
 * Number of big-5 characters remapped to the end of private use area.
 */
#define	BIG5_NUMREMAPCHAR   7

/*
 * HKSCS related macros
 *
 * Valid HKSCS first  byte: 0x81 - 0xfe
 * Valid HKSCS second byte: 0x40 - 0x7e, 0xa1 - 0xfe
 *
 * HKSCS is very similar to BIG-5. The major difference is the use of some
 * of the UDC regions to encode Hong Kong specific characters.
 *
 * HKSCS plane 1: 0xa1 <= 1st byte <= 0xfe
 *		  0x40 <= 2nd byte <= 0x7e
 * HKSCS plane 2: 0xa1 <= 1st byte <= 0xfe
 *		  0xa1 <= 2nd byte <= 0xfe
 * HKSCS plane 3: 0x88 <= 1st byte <= 0xa0
 */
#define	HKSCS_VALID1(c)	     (__cvtab[(unsigned)(c )] & VBITS_BIG5_1)
#define	HKSCS_VALID2(c)	     (__cvtab[(unsigned)(c )] & VBITS_BIG5_2)
#define HKSCS_PLANE1(c1,c2) ((__cvtab[(unsigned)(c1)] & RANGE_A1TOFE) && \
			     (__cvtab[(unsigned)(c2)] & RANGE_40TO7E))
#define HKSCS_PLANE2(c1,c2) ((__cvtab[(unsigned)(c1)] & RANGE_A1TOFE) && \
			     (__cvtab[(unsigned)(c2)] & RANGE_A1TOFE))
#define HKSCS_PLANE3(c1,c2) ((__cvtab[(unsigned)(c1)] & RANGE_81TOA0) && \
			    ((c1) >= 0x88))
#define	HKSCS_COLSIZ	     157
#define	HKSCS_IDX1(c1,c2)    (PLANE1 + ((c1) - 0xa1) * 63 + ((c2) - 0x40))
#define	HKSCS_IDX2(c1,c2)    (PLANE2 + ((c1) - 0xa1) * 94 + ((c2) - 0xa1))
#define	HKSCS_IDX3(c1,c2)    (PLANE3 + ((c1) - 0x88) * HKSCS_COLSIZ \
				     + big5_to_idx[c2])
#define	HKSCS_UROWSIZE	     32	/* Row size of UDC to HKSCS mapping table */

/*
 * DEC Hanyu related macros
 *
 * Valid DEC Hanyu first  byte: 0xa1 - 0xfe
 * Valid DEC Hanyu second byte: 0x21 - 0x7e, 0xa1 - 0xfe
 * Leading code of DTSCS      : 0xc2 0xcb
 * 
 * DEC Hanyu plane 1: 0xa1 <= 1st byte <= 0xfe
 *		      0xa1 <= 2nd byte <= 0xfe
 * DEC Hanyu plane 2: 0xa1 <= 1st byte <= 0xfe
 *		      0x21 <= 2nd byte <= 0x7e
 * DEC Hanyu plane 3: 1st byte = 0xc2
 *		      2nd byte = 0xcb
 * 		      0xa1 <= 3rd byte <= 0xfe
 *		      0xa1 <= 4th byte <= 0xfe
 * UDC		    : 0xfdcc-0xfefe, 0xaaa1-0xc1fe, 0xf245-0xfe7e
 *
 * The following codepoints will be mapped to XUDC areas:
 *	0xc2cbe5a1 - 0xc2cbfefe
 *	0xc2cba121 - 0xc2cbfe7e
 * The other non-mappable characters will be mapped to UDC areas beyond those
 * used by the three UDC regions listed above.
 */
#define	DECHANYU_VALID1(c)	(__cvtab[(unsigned)(c)] & RANGE_A1TOFE)
#define	DECHANYU_VALID2(c)	(__cvtab[(unsigned)(c)] & RANGE_21TO7E_A1TOFE)
#define	DTSCS_VALID1(c)		(__cvtab[(unsigned)(c)] & RANGE_A1TOFE)
#define	DTSCS_VALID2(c)		(__cvtab[(unsigned)(c)] & RANGE_21TO7E_A1TOFE)
#define	DTSCS_LEADCODE(c1,c2)	(((c1) == 0xc2) && ((c2) == 0xcb))
#define	DECHANYU_PLANE1(c1,c2)	(__cvtab[(unsigned)(c2)] & RANGE_A1TOFE)
#define	DECHANYU_PLANE2(c1,c2)	(__cvtab[(unsigned)(c2)] & RANGE_21TO7E)
#define	DECHANYU_PLANE3(c1,c2)	DECHANYU_PLANE1(c1,c2)
#define	DECHANYU_PLANE4(c1,c2)	DECHANYU_PLANE2(c1,c2)
#define	DECHANYU_IDX1(c1,c2)	(PLANE1 + ((c1) - 0xa1) * 94 + ((c2) - 0xa1))
#define	DECHANYU_IDX2(c1,c2)	(PLANE2 + ((c1) - 0xa1) * 94 + ((c2) - 0x21))
#define	DECHANYU_IDX3(c1,c2)	(PLANE3 + ((c1) - 0xa1) * 94 + ((c2) - 0xa1))

#define	DECHANYU_UCNT11		((0xfe - 0xcc + 1) + 94)
#define	DECHANYU_UCNT12		((0xc1 - 0xaa + 1) * 94)
#define	DECHANYU_UCNT2		((0xfe - 0xf2 + 1) * 94 - (0x45 - 0x21))
#define	DECHANYU_UCNT		(DECHANYU_UCNT11+DECHANYU_UCNT12+DECHANYU_UCNT2)
#define	DECHANYU_START11	0
#define	DECHANYU_START12	DECHANYU_UCNT11
#define	DECHANYU_START2		DECHANYU_UCNT11 + DECHANYU_UCNT12
#define	DECHANYU_IDXU1(c1,c2)	(PLANEU + (((c1) >= 0xfd) \
		? ((((c1) - 0xfd) * 94 + (c2) - 0xcc) + DECHANYU_START11) \
		: ((((c1) - 0xaa) * 94 + (c2) - 0xa1) + DECHANYU_START12)))
#define	DECHANYU_IDXU2(c1,c2)	(PLANEU + (((c1) - 0xf2) * 94 + (c2) - 0x21) + \
				 DECHANYU_START2 - 0x24)

#define	UIDX11_DECHANYU(idx) ((((idx + 0x2b)/94 + 0xfd) << 8) |\
			       ((idx + 0x2b)%94 + 0xa1))
#define	UIDX12_DECHANYU(idx) ((((idx)/94 + 0xaa) << 8) | ((idx)%94 + 0xa1))
#define	UIDX2_DECHANYU(idx)  ((((idx + 0x24)/94 + 0xf2) << 8) |\
			       ((idx + 0x24)%94 + 0x21))
#define	UIDX_DECHANYU(idx)    (((idx)  < DECHANYU_UCNT11)?UIDX11_DECHANYU(idx):\
			      (((idx) -= DECHANYU_UCNT11),		       \
			       ((idx)  < DECHANYU_UCNT12)?UIDX12_DECHANYU(idx):\
			      (((idx) -= DECHANYU_UCNT12),		       \
			       ((idx)  < DECHANYU_UCNT2 )?UIDX2_DECHANYU(idx) :\
				 BAD)))
#define	DECHANYU_UDC11(c)	((0xaaa1 <= (c)) && ((c) <= 0xc1fe))
#define	DECHANYU_UDC12(c)	((0xfdcc <= (c)) && ((c) <= 0xfefe))
#define	DECHANYU_UDC1(c)	(DECHANYU_UDC11(c) || DECHANYU_UDC12(c))
#define	DECHANYU_UDC2(c)	((0xf245 <= (c)) && ((c) <= 0xfe7e))

#define	DECHANYU_ISXUDC3(c1)	 ((c1) >= 0xe5)
#define	DECHANYU_ISXUDC4(c1)	 (1)
#define	DECHANYU_XUDC3_CNT	 ((0xfe - 0xe5 + 1) * 94)
#define	DECHANYU_XUDC4_CNT	 (94 * 94)
#define	DECHANYU_TO_IDXU3(c1,c2) (PLANEXU + ((c1) - 0xe5) * 94 + (c2) - 0xa1)
#define	DECHANYU_TO_IDXU4(c1,c2) (PLANEXU + ((c1) - 0xa1) * 94 + \
				  DECHANYU_XUDC3_CNT + (c2) - 0x21)
#define	DECHANYU_FR_XUDC(ucs)	 (ucs -= UCS_XUDC_START, \
				 ((ucs) < DECHANYU_XUDC3_CNT) \
				 ? (0xc2cb0000 | (((ucs)/94 + 0xe5) << 8) |\
						  ((ucs)%94 + 0xa1)) : \
				 (ucs -= DECHANYU_XUDC3_CNT, \
				 ((ucs) < DECHANYU_XUDC4_CNT) \
				 ? (0xc2cb0000 | (((ucs)/94 + 0xa1) << 8) |\
						  ((ucs)%94 + 0x21)) : BAD))
/*
 * DEC Hanzi related macros
 *
 * Valid DEC Hanzi first  byte: 0xa1 - 0xfe
 * Valid DEC Hanzi second byte: 0x21 - 0x7e, 0xa1 - 0xfe
 * 
 * DEC Hanzi plane 1: 0xa1 <= 1st byte <= 0xfe
 *		      0xa1 <= 2nd byte <= 0xfe
 * DEC Hanzi plane U: 0xa1 <= 1st byte <= 0xfe	(UDC)
 *		      0x21 <= 2nd byte <= 0x7e
 *
 * The plane U is mapped to UDC plane 15. The other unmapped characters
 * are mapped to the BMP UDC area in the same way as GB2312.
 */
#define	DECHANZI_VALID1(c)	(__cvtab[(unsigned)(c )] & RANGE_A1TOFE)
#define	DECHANZI_VALID2(c)	(__cvtab[(unsigned)(c )] & RANGE_21TO7E_A1TOFE)
#define	DECHANZI_PLANE1(c1,c2)	(__cvtab[(unsigned)(c2)] & RANGE_A1TOFE)
#define	DECHANZI_PLANEU(c1,c2)	(__cvtab[(unsigned)(c2)] & RANGE_21TO7E)
#define	DECHANZI_IDX1(c1,c2)	(PLANE1  + ((c1) - 0xa1) * 94 + ((c2) - 0xa1))
#define	DECHANZI_IDXU(c1,c2)	(PLANEXU + ((c1) - 0xa1) * 94 + ((c2) - 0x21))
#define	UIDX_DECHANZI(idx)	(  (idx) < DECHANZI_UCNT) ? \
				((((idx)/94 + 0xa1) << 8) | (idx)%94 + 0x21) : BAD
#define	DECHANZI_UCNT		(94*94)

/*
 * GB2312 related macros
 *
 * Valid GB2312 first  byte: 0xa1 - 0xfe
 * Valid GB2312 second byte: 0xa1 - 0xfe
 *
 * GB2312 plane 1: 0xa1 <= 1st byte <= 0xfe
 *		   0xa1 <= 2nd byte <= 0xfe
 * UDC		 : 0xaaa1-0xaffe, 0xf8a1-0xfefe
 */
#define	GB2312_VALID1(c)	(__cvtab[(unsigned)(c )] & RANGE_A1TOFE)
#define	GB2312_VALID2(c)	(__cvtab[(unsigned)(c )] & RANGE_A1TOFE)
#define	GB2312_IDX(c1,c2)	(PLANE1 + ((c1) - 0xa1) * 94 + ((c2) - 0xa1))
#define	GB2312_UCNT11		((0xaf - 0xaa + 1) * 94)
#define	GB2312_UCNT12		((0xfe - 0xf8 + 1) * 94)
#define	GB2312_UDC11(c1,c2)	((0xaa <= (c1)) && ((c1) <= 0xaf))
#define	GB2312_UDC12(c1,c2)	((0xf8 <= (c1)) && ((c1) <= 0xfe))
#define	GB2312_UDC1(c1,c2)	(GB2312_UDC11(c1,c2) || GB2312_UDC12(c1,c2))
#define	GB2312_START11		0
#define	GB2312_START12		GB2312_UCNT11
#define	GB2312_UCNT		(GB2312_UCNT11 + GB2312_UCNT12)
#define	GB2312_IDXU(c1,c2)	(PLANEU + (((c1) <= 0xaf) \
		? ((((c1) - 0xaa) * 94 + (c2) - 0xa1) + GBK_START11) \
		: ((((c1) - 0xf8) * 94 + (c2) - 0xa1) + GBK_START12)))

#define	UIDX11_GB2312(idx)	((((idx)/94 + 0xaa) << 8) | ((idx)%94 + 0xa1))
#define	UIDX12_GB2312(idx)	((((idx)/94 + 0xf8) << 8) | ((idx)%94 + 0xa1))
#define	UIDX_GB2312(idx)	(((idx)  < GB2312_UCNT11) ? UIDX11_GB2312(idx):\
				(((idx) -= GB2312_UCNT11),		    \
				 ((idx)  < GB2312_UCNT12) ? UIDX12_GB2312(idx):\
				   BAD))

/*
 * GBK related macros
 *
 * Valid GBK first  byte: 0x81 - 0xfe
 * Valid GBK second byte: 0x40 - 0x7e, 0x80 - 0xfe
 *
 * GBK plane 1: 0xa1 <= 1st byte <= 0xfe
 *		0xa1 <= 2nd byte <= 0xfe
 * GBK plane 2: 0x81 <= 1st byte <= 0xa0
 *		0x40 <= 2nd byte <= 0x7e & 0x80 <= 2nd byte <= 0xfe
 * GBK plane 3: 0xa1 <= 1st byte <= 0xfe
 *		0x40 <= 2nd byte <= 0x7e & 0x80 <= 2nd byte <= 0xa0
 * UDC	      : 0xaaa1-0xaffe, 0xf8a1-0xfefe, 0xa140-0xa7a0
 */

#define	GBK_VALID1(c)	   (__cvtab[(unsigned)(c )] & VBITS_GBK1)
#define	GBK_VALID2(c)	   (__cvtab[(unsigned)(c )] & VBITS_GBK2)
#define GBK_PLANE1(c1,c2) ((__cvtab[(unsigned)(c1)] & RANGE_A1TOFE) && \
			   (__cvtab[(unsigned)(c2)] & RANGE_A1TOFE))
#define GBK_PLANE2(c1,c2) ((__cvtab[(unsigned)(c1)] & RANGE_81TOA0) && \
			   (__cvtab[(unsigned)(c2)] & RANGE_40TO7E_80TOFE))
#define GBK_PLANE3(c1,c2) ((__cvtab[(unsigned)(c1)] & RANGE_A1TOFE) && \
			   (__cvtab[(unsigned)(c2)] & RANGE_40TO7E_80TOA0))
#define	GBK_IDX1(c1,c2)    (PLANE1 + ((c1) - 0xa1) *  94 + ((c2) - 0xa1))
#define	GBK_IDX2(c1,c2)    (PLANE2 + ((c1) - 0x81) * 190 + __gbk_2bidx[c2])
#define	GBK_IDX3(c1,c2)    (PLANE3 + ((c1) - 0xa1) *  96 + __gbk_2bidx[c2])

#define	GBK_UCNT11	  GB2312_UCNT11
#define	GBK_UCNT12	  GB2312_UCNT12
#define	GBK_UCNT3	  ((0xa7 - 0xa1 + 1) * 96)
#define	GBK_UCNT	  (GBK_UCNT11+GBK_UCNT12+GBK_UCNT3)
#define	GBK_START11	  0
#define	GBK_START12	  GBK_UCNT11
#define	GBK_START3	  GBK_UCNT11 + GBK_UCNT12
#define	GBK_IDXU1(c1,c2)  (PLANEU + (((c1) <= 0xaf) \
		? ((((c1) - 0xaa) * 94 + (c2) - 0xa1) + GBK_START11) \
		: ((((c1) - 0xf8) * 94 + (c2) - 0xa1) + GBK_START12)))
#define	GBK_IDXU3(c1,c2)  (PLANEU + ((c1) - 0xa1) * 96 + __gbk_2bidx[c2] + \
			   GBK_START3)

#define	UIDX11_GBK(idx)   ((((idx)/94 + 0xaa) << 8) | ((idx)%94 + 0xa1))
#define	UIDX12_GBK(idx)   ((((idx)/94 + 0xf8) << 8) | ((idx)%94 + 0xa1))
#define	UIDX3_GBK(idx)    ((((idx)/96 + 0xa1) << 8) | __gbk_idx2b[(idx)%96])
#define	UIDX_GBK(idx)      (((idx)  < GBK_UCNT11) ? UIDX11_GBK(idx):\
			   (((idx) -= GBK_UCNT11),		    \
			    ((idx)  < GBK_UCNT12) ? UIDX12_GBK(idx):\
			   (((idx) -= GBK_UCNT12),		    \
			    ((idx)  < GBK_UCNT3 ) ? UIDX3_GBK(idx) :\
			      BAD)))
#define	GBK_UDC11(c1,c2)  (GBK_PLANE1(c1,c2) && GB2312_UDC11(c1,c2))
#define	GBK_UDC12(c1,c2)  (GBK_PLANE1(c1,c2) && GB2312_UDC12(c1,c2))
#define	GBK_UDC3(c1,c2)	  (GBK_PLANE3(c1,c2) && (0xa1 <= (c1)) && ((c1) <= 0xa7))

/*
 * GB18030-2000 related macros
 *
 * The 2-byte form of GB18030 is a superset of GBK.
 *
 * Valid 2-byte GB18030 - first  byte: 0x81 - 0xfe
 * Valid 2-byte GB18030 - second byte: 0x40 - 0x7e, 0x80 - 0xfe
 *
 * GB18030 plane 1: 0xa1 <= 1st byte <= 0xfe
 *		    0xa1 <= 2nd byte <= 0xfe
 * GB18030 plane 2: 0x81 <= 1st byte <= 0xa0
 *		    0x40 <= 2nd byte <= 0x7e & 0x80 <= 2nd byte <= 0xfe
 * GB18030 plane 3: 0xa1 <= 1st byte <= 0xfe
 *		    0x40 <= 2nd byte <= 0x7e & 0x80 <= 2nd byte <= 0xa0
 *
 * There are also some UDC character mapping distributed in the non-allocated
 * spaces elsewhere in plane 1,2,3.
 *
 * Valid 4-byte GB18030 - 1st byte: 0x81-0xfe
 *			- 2nd byte: 0x30-0x39
 *			- 3rd byte: 0x81-0xfe
 *			- 4th byte: 0x30-0x39
 *
 * Please see from_GB18030.c for details about converting these 4-byte
 * code to Unicode and vice versa
 *
 * 2-byte GB18030 UDC mapping:
 * 	0xaaa1-0xaffe -> U+E000-U+E233
 *	0xf8a1-0xfefe -> U+E234-U+E4C5
 *	0xa140-0xa7a0 -> U+E4C6-U+E765
 *	0xa2ab-0xa2b0 -> U+E766-U+E76B
 *	0xa2e3-0xa2e4 -> U+E76C-U+E76D
 *	0xa2ef-0xa2f0 -> U+E76E-U+E76F
 *	0xa2fd-0xa2ff -> U+E770-U+E771
 *	0xa4f4-0xa4fe -> U+E772-U+E77C
 *	0xa5f7-0xa5fe -> U+E77D-U+E784
 *		     ....
 *
 * 4-byte GB18030 UDC mapping:
 *	0x8336d030-0x84308130 -> U+E865-U+F8FF
 *
 * The mapping between UDC and GB18030 will be done algorithmically if
 * 	UDC	= U+E000-U+E765 or U+E865-U+F8FF
 *	GB18030 = 0xaaa1-0xaffe, 0xf8a1-0xfefe, 0xa140-0xa7a0,
 *		  0x8336d030-0x84308130
 * Other will be done by mapping tables.
 *
 * Plane mapping:
 *	0x81308130-0x8439fe39 (50400   codepoints) -> BMP (plane 0)
 *	0x90308130-0xe339fe39 (1058400 codepoints) -> Plane 1-16
 */
#define	GB18030_1BYTE(c)      ((unsigned)(c) < 0x80)
#define	GB18030_2BYTE(c1,c2)  (GBK_VALID1(c1) && GBK_VALID2(c2))
#define	GB18030_4BYTE(c1,c2)  (GBK_VALID1(c1) && \
			      (__cvtab[(unsigned)(c2)] & VBIT_30TO39))
#define GB18030_PLANE1(c1,c2) GBK_PLANE1(c1,c2)
#define GB18030_PLANE2(c1,c2) GBK_PLANE2(c1,c2)
#define GB18030_PLANE3(c1,c2) GBK_PLANE3(c1,c2)
#define	GB18030_IDX1(c1,c2)   GBK_IDX1  (c1,c2)
#define	GB18030_IDX2(c1,c2)   GBK_IDX2  (c1,c2)
#define	GB18030_IDX3(c1,c2)   GBK_IDX3  (c1,c2)

#define	GB18030_UCNT11	      GBK_UCNT11
#define	GB18030_UCNT12	      GBK_UCNT12
#define	GB18030_UCNT3	      GBK_UCNT3
#define	GB18030_START11	      GBK_START11
#define	GB18030_START12	      GBK_START12
#define	GB18030_START3	      GBK_START3
#define	GB18030_IDXU1(c1,c2)  GBK_IDXU1(c1,c2)
#define	GB18030_IDXU3(c1,c2)  GBK_IDXU3(c1,c2)
#define	GB18030_UDC11(c1,c2)  GBK_UDC11(c1,c2)
#define	GB18030_UDC12(c1,c2)  GBK_UDC12(c1,c2)
#define	GB18030_UDC3(c1,c2)   GBK_UDC3 (c1,c2)
#define	UIDX_GB18030(idx)     UIDX_GBK(idx)

/*
 * DEC Kanji related macros
 *
 * Valid DEC Kanji first  byte: 0xa1 - 0xfe
 * Valid DEC Kanji second byte: 0x21 - 0x7e, 0xa1 - 0xfe
 * 
 * DEC Kanji plane 1: 0xa1 <= 1st byte <= 0xfe
 *		      0xa1 <= 2nd byte <= 0xfe
 * DEC Kanji plane U: 0xa1 <= 1st byte <= 0xfe (UDC)
 *		      0x21 <= 2nd byte <= 0x7e
 *
 * The plane U of DEC Kanji are mapped to plane 15 UDC area.
 * The other unmapped codepoints are mapped to BMP UDC area in the same
 * way as eucJP.
 */
#define	DECKANJI_VALID1(c)	(__cvtab[(unsigned)(c )] & RANGE_A1TOFE)
#define	DECKANJI_VALID2(c)	(__cvtab[(unsigned)(c )] & RANGE_21TO7E_A1TOFE)
#define	DECKANJI_PLANE1(c1,c2)	(__cvtab[(unsigned)(c2)] & RANGE_A1TOFE)
#define	DECKANJI_PLANEU(c1,c2)	(__cvtab[(unsigned)(c2)] & RANGE_21TO7E)
#define	DECKANJI_IDX1(c1,c2)	(PLANE1  + ((c1) - 0xa1) * 94 + ((c2) - 0xa1))
#define	DECKANJI_IDXU(c1,c2)	(PLANEXU + ((c1) - 0xa1) * 94 + ((c2) - 0x21))
#define	UIDX_DECKANJI(idx)	(  (idx) < DECKANJI_UCNT) ? \
				((((idx)/94 + 0xa1) << 8) | (idx)%94 + 0x21) : BAD
#define	DECKANJI_UCNT		(94*94)

/*
 * JISX-UDC macros
 *
 * Plane U: 0xa1 <= 1st byte <= 0xfe
 *	    0x21 <= 2nd byte <= 0x7e
 */
#define	JISXUDC_VALID1(c)	(__cvtab[(unsigned)(c)] & RANGE_A1TOFE)
#define	JISXUDC_VALID2(c)	(__cvtab[(unsigned)(c)] & RANGE_21TO7E)
#define	JISXUDC_IDX(c1,c2)	DECKANJI_IDXU(c1,c2)

/*
 * DEC Korean related macros
 *
 * Valid DEC Korean first  byte: 0xa1 - 0xfe
 * Valid DEC Korean second byte: 0xa1 - 0xfe
 * 
 * DEC Korean plane 2: 0xa1 <= 1st byte <= 0xfe
 *		       0xa1 <= 2nd byte <= 0xfe
 */
#define	DECKOREAN_VALID1(c)	(__cvtab[(unsigned)(c)] & RANGE_A1TOFE)
#define	DECKOREAN_VALID2(c)	(__cvtab[(unsigned)(c)] & RANGE_A1TOFE)
#define	DECKOREAN_IDX1(c1,c2)	(PLANE1 + ((c1) - 0xa1) * KSC5601_WIDTH1 + ((c2) - 0xa1))

/*
 * Taiwanese EUC related macros
 *
 * Valid eucTW 2nd last byte: 0xa1 - 0xfe
 * Valid eucTW     last	byte: 0xa1 - 0xfe
 * 
 * eucTW plane 1 : 0xa1 <= 1st byte <= 0xfe
 *		   0xa1 <= 2nd byte <= 0xfe
 * eucTW plane 2 : 1st byte = 0x8e
 *		   2nd byte = 0xa2
 * 		   0xa1 <= 3rd byte <= 0xfe
 *		   0xa1 <= 4th byte <= 0xfe
 * eucTW plane 3 : 1st byte = 0x8e
 *		   2nd byte = 0xa3
 * 		   0xa1 <= 3rd byte <= 0xfe
 *		   0xa1 <= 4th byte <= 0xfe
 * eucTW plane 4 : 1st byte = 0x8e
 *		   2nd byte = 0xa4
 * 		   0xa1 <= 3rd byte <= 0xfe
 *		   0xa1 <= 4th byte <= 0xfe
 * eucTW plane 5 : 1st byte = 0x8e
 *		   2nd byte = 0xa5
 * 		   0xa1 <= 3rd byte <= 0xfe
 *		   0xa1 <= 4th byte <= 0xfe
 * eucTW plane 6 : 1st byte = 0x8e
 *		   2nd byte = 0xa6
 * 		   0xa1 <= 3rd byte <= 0xfe
 *		   0xa1 <= 4th byte <= 0xfe
 * eucTW plane 7 : 1st byte = 0x8e
 *		   2nd byte = 0xa7
 * 		   0xa1 <= 3rd byte <= 0xfe
 *		   0xa1 <= 4th byte <= 0xfe
 * eucTW plane 15: 1st byte = 0x8e
 *		   2nd byte = 0xaf
 * 		   0xa1 <= 3rd byte <= 0xfe
 *		   0xa1 <= 4th byte <= 0xfe
 *
 * All the unmappable codepoints in plane 1-4 will be mapped to the characters
 * in the private use areas for preserving codepoints during roundtrip 
 * conversion. As the UDC area in BMP is not large enough, the following
 * codepoints will be mapped to Plane 15 UDC:
 *	0x8ea3e8a1 - 0x8ea3fefe
 *	0x8ea4efa1 - 0x8ea4fefe
 *
 * Codepoints that belong to the UDC area of DEC Hanyu will be mapped to 
 * UDC in the same way.
 */
#define	EUCTW_VALID1(c)	   (__cvtab[(unsigned)(c)] & RANGE_A1TOFE)
#define	EUCTW_VALID2(c)	   (__cvtab[(unsigned)(c)] & RANGE_A1TOFE)
#define	EUCTW_IDX1(c1,c2)  (PLANE1  + ((c1) - 0xa1) * 94 + ((c2) - 0xa1))
#define	EUCTW_IDX2(c1,c2)  (PLANE2  + ((c1) - 0xa1) * 94 + ((c2) - 0xa1))
#define	EUCTW_IDX3(c1,c2)  (PLANE3  + ((c1) - 0xa1) * 94 + ((c2) - 0xa1))
#define	EUCTW_IDX4(c1,c2)  (PLANE4  + ((c1) - 0xa1) * 94 + ((c2) - 0xa1))
#define	EUCTW_IDX5(c1,c2)  (PLANE5  + ((c1) - 0xa1) * 94 + ((c2) - 0xa1))
#define	EUCTW_IDX6(c1,c2)  (PLANE6  + ((c1) - 0xa1) * 94 + ((c2) - 0xa1))
#define	EUCTW_IDX7(c1,c2)  (PLANE7  + ((c1) - 0xa1) * 94 + ((c2) - 0xa1))
#define	EUCTW_IDXF(c1,c2)  (PLANE15 + ((c1) - 0xa1) * 94 + ((c2) - 0xa1))
#define	EUCTW_ISXUDC3(c1)  ((c1) >= 0xe8)
#define	EUCTW_ISXUDC4(c1)  ((c1) >= 0xef)
#define	EUCTW_XUDC3_CNT	   ((0xfe - 0xe8 + 1) * 94)
#define	EUCTW_XUDC4_CNT	   ((0xfe - 0xef + 1) * 94)

#define	EUCTW_TO_IDXU3(c1,c2)	(PLANEXU + ((c1) - 0xe8) * 94 + (c2) - 0xa1)
#define	EUCTW_TO_IDXU4(c1,c2)	(PLANEXU + ((c1) - 0xef) * 94 + \
				EUCTW_XUDC3_CNT +  (c2) - 0xa1)
#define	EUCTW_FR_XUDC(ucs)	(ucs -= UCS_XUDC_START, \
				((ucs) < EUCTW_XUDC3_CNT) \
				? (0x8ea30000 | (((ucs)/94 + 0xe8) << 8) |\
						 ((ucs)%94 + 0xa1)) : \
				(ucs -= EUCTW_XUDC3_CNT, \
				((ucs) < EUCTW_XUDC4_CNT) \
				? (0x8ea40000 | (((ucs)/94 + 0xef) << 8) |\
						 ((ucs)%94 + 0xa1)) : BAD))
#define	EUCTW_ISUDC1(c)		DECHANYU_UDC1(c)
#define	EUCTW_ISUDC2(c)		((0xf2c5 <= (c)) && ((c) <= 0xfefe))
#define	EUCTW_UCNT		DECHANYU_UCNT
#define	EUCTW_TO_IDXU1(c1,c2)	DECHANYU_IDXU1(c1, c2)
#define	EUCTW_TO_IDXU2(c1,c2)	DECHANYU_IDXU2(c1, (c2 & 0x7f))
#define	UIDX2_TO_EUCTW(idx)	(UIDX2_DECHANYU(idx) | 0x8ea20080)
#define	UDC_TO_EUCTW(ucs)      ((ucs) -= UCS_UDC_START,\
			      (((ucs)  < DECHANYU_UCNT11)?UIDX11_DECHANYU(ucs):\
			      (((ucs) -= DECHANYU_UCNT11),		       \
			       ((ucs)  < DECHANYU_UCNT12)?UIDX12_DECHANYU(ucs):\
			      (((ucs) -= DECHANYU_UCNT12),		       \
			       ((ucs)  < DECHANYU_UCNT2 )?UIDX2_TO_EUCTW(ucs) :\
				 BAD))))

/*
 * Japanese EUC related macros
 *
 * Valid eucJP first  byte: 0xa1 - 0xfe
 * Valid eucJP second byte: 0xa1 - 0xfe
 * 
 * eucJP plane 0 : 1st byte = 0x8e
 *		   0xa1 <= 2nd byte <= 0xfe
 * eucJP plane 1 : 0xa1 <= 1st byte <= 0xfe
 *		   0xa1 <= 2nd byte <= 0xfe
 * eucJP plane 2 : 1st byte = 0x8f
 * 		   0xa1 <= 2nd byte <= 0xfe
 *		   0xa1 <= 3rd byte <= 0xfe
 * eucJP UDC	 : 0xf5a1-0xfefe, 0x8ff5a1-0x8ffefe, 0x8feea1-0x8ff4fe
 *
 * All unmapped codepoints will now map to the BMP UDC area.
 */
#define	EUCJP_VALID1(c)	   (__cvtab[(unsigned)(c)] & RANGE_A1TOFE)
#define	EUCJP_VALID2(c)	   (__cvtab[(unsigned)(c)] & RANGE_A1TOFE)
#define	EUCJP_IDX0(c)      ((c) + 0x100)
#define	EUCJP_IDX1(c1,c2)  (PLANE1  + ((c1) - 0xa1) * 94 + ((c2) - 0xa1))
#define	EUCJP_IDX2(c1,c2)  (PLANE2  + ((c1) - 0xa1) * 94 + ((c2) - 0xa1))

#define	EUCJP_UCNT1	   ((0xfe - 0xf5 + 1) * 94)
#define	EUCJP_UCNT21	   ((0xfe - 0xf5 + 1) * 94)
#define	EUCJP_UCNT22	   ((0xf4 - 0xee + 1) * 94)
#define	EUCJP_UCNT	   (EUCJP_UCNT1 + EUCJP_UCNT21 + EUCJP_UCNT22)
#define	EUCJP_UDC1(c1,c2)  ((c1) >= 0xf5)
#define	EUCJP_UDC2(c1,c2)  ((c1) >= 0xee)
#define	EUCJP_IDXU1(c1,c2) (PLANEU +  ((c1) - 0xf5) * 94 + ((c2) - 0xa1))
#define	EUCJP_IDXU2(c1,c2) (PLANEU + (((c1) >= 0xf5) \
		? ((((c1) - 0xf5) * 94 + ((c2) - 0xa1)) + EUCJP_UCNT1) \
		: ((((c1) - 0xee) * 94 + ((c2) - 0xa1)) + EUCJP_UCNT1 + EUCJP_UCNT21)))

#define	UIDX1_EUCJP(idx)   ((((idx)/94 + 0xf5) << 8) | ((idx)%94 + 0xa1))
#define	UIDX21_EUCJP(idx)  ((((idx)/94 + 0xf5) << 8) | ((idx)%94 + 0xa1) | 0x8f0000)
#define	UIDX22_EUCJP(idx)  ((((idx)/94 + 0xee) << 8) | ((idx)%94 + 0xa1) | 0x8f0000)
#define	UIDX_EUCJP(idx)	   (((idx)  < EUCJP_UCNT1 ) ? UIDX1_EUCJP(idx) :\
			   (((idx) -= EUCJP_UCNT1 ), 		        \
			    ((idx)  < EUCJP_UCNT21) ? UIDX21_EUCJP(idx):\
			   (((idx) -= EUCJP_UCNT21),		        \
			    ((idx)  < EUCJP_UCNT22) ? UIDX22_EUCJP(idx):\
			      BAD)))

/*
 * Super DEC Kanji related macros
 *
 * Valid sdeckanji first  byte: 0xa1 - 0xfe
 * Valid sdeckanji second byte: 0xa1 - 0xfe, 0x21 - 0x7e
 * 
 * sdeckanji plane 0 : 1st byte = 0x8e
 *		       0xa1 <= 2nd byte <= 0xfe
 * sdeckanji plane 1 : 0xa1 <= 1st byte <= 0xfe
 *		       0xa1 <= 2nd byte <= 0xfe
 * sdeckanji plane 2 : 1st byte = 0x8f
 * 		       0xa1 <= 2nd byte <= 0xfe
 *		       0xa1 <= 3rd byte <= 0xfe
 * sdeckanji plane U : 0xa1 <= 1st byte <= 0xfe
 *		       0x21 <= 2nd byte <= 0x7e
 *
 * The plane U of Super DEC Kanji are mapped to plane 15 UDC area.
 * The other unmapped codepoints are mapped to BMP UDC area in the same
 * way as eucJP.
 */
#define	SDECKANJI_VALID1(c)	(__cvtab[(unsigned)(c)] & RANGE_A1TOFE)
#define	SDECKANJI_VALID2(c)	(__cvtab[(unsigned)(c)] & RANGE_A1TOFE)
#define	SDECKANJI_UDC2(c)	(__cvtab[(unsigned)(c)] & RANGE_21TO7E)
#define	SDECKANJI_IDX0(c)	EUCJP_IDX0(c)
#define	SDECKANJI_IDX1(c1,c2)	EUCJP_IDX1(c1,c2)
#define	SDECKANJI_IDX2(c1,c2)	EUCJP_IDX2(c1,c2)
#define	SDECKANJI_IDXU(c1,c2)	DECKANJI_IDXU(c1,c2)
#define	UIDX_SDECKANJI(idx)	UIDX_DECKANJI(idx)

/*
 * Unified Hangul (KSC 5601-1992)
 *
 * It includes 2,350 characters same as Wansung (KSC 5601-1987)
 *	1st Byte = 0xa1-0xfe with 2nd Byte = 0xa1-0xfe
 * plus 8,822 characters :
 *	1st Byte = 0x81-0xa0 with 2nd Byte = 0x41-0x5a, 0x61-0x7a, 0x81-0xfe
 *	1st Byte = 0xa1-0xc6 with 2nd Byte = 0x41-0x5a, 0x61-0x7a, 0x81-0xa0
 *
 * KSC5601 plane 1 : 1st byte = 0xa1 - 0xfe
 *		     2nd byte = 0xa1 - 0xfe
 * KSC5601 plane 2 : 1st Byte = 0x81 - 0xa0
 *		     2nd Byte = 0x41 - 0x5a, 0x61 - 0x7a, 0x81 - 0xfe
 * KSC5601 plane 3 : 1st Byte = 0xa1 - 0xc6
 *		     2nd Byte = 0x41 - 0x5a, 0x61 - 0x7a, 0x81 - 0xa0
 */
#define	KSC5601_VALID1(c)	(__cvtab[(unsigned)(c)] & RANGE_81TOFE)
#define	KSC5601_VALID2(c)	(__cvtab[(unsigned)(c)] & RANGE_41TO5A_61TO7A_81TOFE)
#define	KSC5601_1_VALID1(c)	(__cvtab[(unsigned)(c)] & RANGE_A1TOFE)
#define	KSC5601_1_VALID2(c)	(__cvtab[(unsigned)(c)] & RANGE_A1TOFE)
#define	KSC5601_2_VALID1(c)	(__cvtab[(unsigned)(c)] & RANGE_81TOA0)
#define	KSC5601_2_VALID2(c)	(__cvtab[(unsigned)(c)] & RANGE_41TO5A_61TO7A_81TOFE)
#define	KSC5601_3_VALID1(c)	(__cvtab[(unsigned)(c)] & RANGE_A0TOC6)
#define	KSC5601_3_VALID2(c)	(__cvtab[(unsigned)(c)] & RANGE_41TO5A_61TO7A_81TOA0)
#define	KSC5601_IDX1(c1, c2)	(PLANE1 + ((c1) - 0xa1) * KSC5601_WIDTH1 + ((c2) - 0xa1))
#define	KSC5601_IDX2(c1, c2)	(PLANE2 + ((c1) - 0x81) * KSC5601_WIDTH2 + ((c2) - 0x41))
#define	KSC5601_IDX3(c1, c2)	(PLANE3 + ((c1) - 0xa1) * KSC5601_WIDTH3 + ((c2) - 0x41))
#define	KSC5601_WIDTH1		(0xfe - 0xa1 + 1)
#define	KSC5601_WIDTH2		(0xfe - 0x41 + 1)
#define	KSC5601_WIDTH3		(0xa0 - 0x41 + 1)

/*
 * UDC Mappings
 * ------------
 *
 * Japanese:
 *  - eucJP	0xf5a1-0xfefe, 0x8ff5a1-0x8ffefe, 0x8feea1-0x8ff4fe
 *  - deckanji	0xa121-0xfe7e
 *  - sdeckanji	0xa121-0xfe7e + eucJP UDC
 *  - SJIS	0xf040-0xfcfc
 *
 * Chinese:
 *  - dechanzi	0xa121-0xfe7e
 *  - dechanyu	0xf321-0xfe7e, 0xaaa1-0xc1fe, 0xfdcc-0xfefe
 *  - big5	0xfa40-0xfefe, 0x8e40-0xa0fe
 *
 * Unicode:	U+E000-U+F8FF, U-000F0000-U-0010FFFF
 *
 * IDXU = UIDX + PLANEU
 */
#define	UCS_UDC_START	0xe000
#define	UCS_UDC_END	0xf8ff
#define	UCS_XUDC_START	0x0f0000 /* Plane 15 & 16 are addtional UDC planes */
#define	UCS_XUDC_END	0x10ffff
#define	UCS_UCNT	(0xf8ff - 0xe000 + 1)

#define	UCS_UIDX(ucs)	(((ucs) >= UCS_XUDC_START) ? \
			 ((ucs)  - UCS_XUDC_START+UCS_UCNT) : ((ucs) - 0xe000))
#define	UCS_UDC(ucs)	(((0xe000 <= (ucs)) && ((ucs) <= 0xf8ff)) ||\
			 ((ucs)   >= UCS_XUDC_START))
#define	IDXU_UCS(idx)	(((idx) >= PLANEXU) ? \
			 ((idx)  + UCS_XUDC_START - PLANEXU) : \
			 ((idx)  + UCS_UDC_START  - PLANEU))
#define	ISIDXU(idx)	((idx) >= PLANEU)

/*
 * Macros for the mb*towc*() and wc*tomb*() routines to be used by the
 * @ucs4 locales.
 */


/*
 * External reference
 */
extern const unsigned int  __cvtab[]	;  //BRL
extern const short __gbk_2bidx[];
extern const short __gbk_idx2b[];