| // @@@ 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> |
| |
| /* |
| * 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[]; |
