+

+LIBRARY = libwc.a

+CC = cc

+CPPFLAGS = -I. -I.. -I../gc/include

+CFLAGS = -g -O -Wall -DUSE_UNICODE $(CPPFLAGS)

+AR = ar

+RANLIB = ranlib

+

+SRCS = big5.c \

+ ces.c \

+ char_conv.c \

+ charset.c \

+ combining.c \

+ conv.c \

+ detect.c \

+ gb18030.c \

+ gbk.c \

+ hkscs.c \

+ hz.c \

+ iso2022.c \

+ jis.c \

+ johab.c \

+ priv.c \

+ putc.c \

+ search.c \

+ sjis.c \

+ status.c \

+ ucs.c \

+ uhc.c \

+ utf7.c \

+ utf8.c \

+ viet.c \

+ wtf.c

+HDRS = big5.h \

+ ccs.h \

+ ces.h \

+ gb18030.h \

+ gbk.h \

+ hkscs.h \

+ hz.h \

+ iso2022.h \

+ jis.h \

+ johab.h \

+ priv.h \

+ search.h \

+ sjis.h \

+ ucs.h \

+ uhc.h \

+ utf7.h \

+ utf8.h \

+ viet.h \

+ wc.h \

+ wc_types.h \

+ wtf.h

+OBJS = big5.o \

+ ces.o \

+ char_conv.o \

+ charset.o \

+ combining.o \

+ conv.o \

+ detect.o \

+ gb18030.o \

+ gbk.o \

+ hkscs.o \

+ hz.o \

+ iso2022.o \

+ jis.o \

+ johab.o \

+ priv.o \

+ putc.o \

+ search.o \

+ sjis.o \

+ status.o \

+ ucs.o \

+ uhc.o \

+ utf7.o \

+ utf8.o \

+ viet.o \

+ wtf.o

+

+all: $(LIBRARY)

+

+dist:

+ (cd ..; tar -czf libwc.tar.gz libwc/Makefile libwc/*.[ch] libwc/*.map libwc/map)

+

+$(LIBRARY): $(OBJS)

+ $(AR) rv $(LIBRARY) $(OBJS)

+ $(RANLIB) $(LIBRARY)

+

+test: $(LIBRARY) test.o ../Str.o ../myctype.o

+ $(CC) -o wctest test.o ../Str.o ../myctype.o $(LIBRARY) ../gc/gc.a

+

+###

+big5.o: wc.h wc_types.h ces.h ccs.h iso2022.h priv.h big5.h search.h wtf.h \

+ ucs.h

+ces.o: wc.h wc_types.h ces.h ccs.h iso2022.h priv.h sjis.h hz.h big5.h \

+ hkscs.h johab.h gbk.h gb18030.h uhc.h viet.h utf8.h utf7.h

+char_conv.o: wc.h wc_types.h ces.h ccs.h iso2022.h priv.h

+charset.o: wc.h wc_types.h ces.h ccs.h iso2022.h priv.h

+combining.o: wc.h wc_types.h ces.h ccs.h iso2022.h priv.h ucs.h \

+ map/iso88596_combining.map map/iso885911_combining.map \

+ map/cp864_combining.map map/cp874_combining.map \

+ map/cp1255_combining.map map/cp1256_combining.map \

+ map/cp1258_combining.map map/tcvn5712_combining.map

+conv.o: wc.h wc_types.h ces.h ccs.h iso2022.h priv.h wtf.h hz.h ucs.h utf8.h \

+ utf7.h

+detect.o: wc.h wc_types.h ces.h ccs.h iso2022.h priv.h sjis.h big5.h hz.h \

+ viet.h utf8.h

+gb18030.o: wc.h wc_types.h ces.h ccs.h iso2022.h priv.h gb18030.h gbk.h \

+ search.h wtf.h ucs.h map/gb18030_ucs.map

+gbk.o: wc.h wc_types.h ces.h ccs.h iso2022.h priv.h gbk.h search.h wtf.h \

+ ucs.h map/gb2312_gbk.map

+hkscs.o: wc.h wc_types.h ces.h ccs.h iso2022.h priv.h big5.h hkscs.h search.h \

+ wtf.h ucs.h

+hz.o: wc.h wc_types.h ces.h ccs.h iso2022.h priv.h hz.h wtf.h ucs.h

+iso2022.o: wc.h wc_types.h ces.h ccs.h iso2022.h priv.h jis.h big5.h johab.h \

+ wtf.h ucs.h

+jis.o: wc.h wc_types.h ces.h ccs.h iso2022.h priv.h jis.h search.h ucs.h \

+ map/jisx0201k_jisx0208.map map/jisx0208_jisx02131.map

+johab.o: wc.h wc_types.h ces.h ccs.h iso2022.h priv.h johab.h wtf.h ucs.h

+priv.o: wc.h wc_types.h ces.h ccs.h iso2022.h priv.h wtf.h

+putc.o: wc.h wc_types.h ces.h ccs.h iso2022.h priv.h wtf.h

+search.o: wc.h wc_types.h ces.h ccs.h iso2022.h priv.h

+sjis.o: wc.h wc_types.h ces.h ccs.h iso2022.h priv.h sjis.h jis.h wtf.h ucs.h \

+ map/jisx02132_sjis.map

+status.o: wc.h wc_types.h ces.h ccs.h iso2022.h priv.h ucs.h

+test.o: wc.h wc_types.h ces.h ccs.h iso2022.h priv.h

+ucs.o: wc.h wc_types.h ces.h ccs.h iso2022.h priv.h ucs.h search.h big5.h \

+ hkscs.h sjis.h johab.h gbk.h gb18030.h uhc.h viet.h wtf.h ucs.map \

+ map/jisx0201k_ucs.map map/iso88591_ucs.map map/iso88592_ucs.map \

+ map/iso88593_ucs.map map/iso88594_ucs.map map/iso88595_ucs.map \

+ map/iso88596_ucs.map map/iso88597_ucs.map map/iso88598_ucs.map \

+ map/iso88599_ucs.map map/iso885910_ucs.map map/iso885911_ucs.map \

+ map/iso885913_ucs.map map/iso885914_ucs.map map/iso885915_ucs.map \

+ map/iso885916_ucs.map map/cp437_ucs.map map/cp737_ucs.map \

+ map/cp775_ucs.map map/cp850_ucs.map map/cp852_ucs.map \

+ map/cp855_ucs.map map/cp856_ucs.map map/cp857_ucs.map \

+ map/cp860_ucs.map map/cp861_ucs.map map/cp862_ucs.map \

+ map/cp863_ucs.map map/cp864_ucs.map map/cp865_ucs.map \

+ map/cp866_ucs.map map/cp869_ucs.map map/cp874_ucs.map \

+ map/cp1006_ucs.map map/cp1250_ucs.map map/cp1251_ucs.map \

+ map/cp1252_ucs.map map/cp1253_ucs.map map/cp1254_ucs.map \

+ map/cp1255_ucs.map map/cp1256_ucs.map map/cp1257_ucs.map \

+ map/cp1258_ucs.map map/tcvn5712_ucs.map map/viscii11_ucs.map \

+ map/vps_ucs.map map/koi8r_ucs.map map/koi8u_ucs.map \

+ map/nextstep_ucs.map map/jisx0208x0212x0213_ucs.map \

+ map/jisx0213_ucs_p2.map map/gb2312_ucs.map map/cns11643_ucs.map \

+ map/ksx1001_ucs.map map/big5_ucs.map map/hkscs_ucs.map \

+ map/hkscs_ucs_p2.map map/gb12345_ucs.map map/johab_ucs.map \

+ map/sjis_ext_ucs.map map/gbk_ucs.map map/uhc_ucs.map map/ucs_wide.map \

+ map/ucs_combining.map map/ucs_precompose.map map/ucs_hangul.map \

+ map/ucs_fullwidth.map

+uhc.o: wc.h wc_types.h ces.h ccs.h iso2022.h priv.h uhc.h wtf.h ucs.h

+utf7.o: wc.h wc_types.h ces.h ccs.h iso2022.h priv.h ucs.h utf7.h wtf.h

+utf8.o: wc.h wc_types.h ces.h ccs.h iso2022.h priv.h ucs.h utf8.h wtf.h

+viet.o: wc.h wc_types.h ces.h ccs.h iso2022.h priv.h viet.h wtf.h search.h \

+ ucs.h map/tcvn57123_tcvn5712.map

+wtf.o: wc.h wc_types.h ces.h ccs.h iso2022.h priv.h wtf.h sjis.h big5.h \

+ hkscs.h johab.h jis.h viet.h gbk.h gb18030.h uhc.h ucs.h utf8.h

+

+#include "wc.h"

+#include "big5.h"

+#include "search.h"

+#include "wtf.h"

+#ifdef USE_UNICODE

+#include "ucs.h"

+#endif

+

+#define C0 WC_BIG5_MAP_C0

+#define GL WC_BIG5_MAP_GL

+#define C1 WC_BIG5_MAP_C1

+#define LB WC_BIG5_MAP_LB

+#define UB WC_BIG5_MAP_UB

+

+wc_uint8 WC_BIG5_MAP[ 0x100 ] = {

+ C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0,

+ C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0,

+ GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL,

+ GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL,

+ LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB,

+ LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB,

+ LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB,

+ LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, C0,

+

+ C1, C1, C1, C1, C1, C1, C1, C1, C1, C1, C1, C1, C1, C1, C1, C1,

+ C1, C1, C1, C1, C1, C1, C1, C1, C1, C1, C1, C1, C1, C1, C1, C1,

+ C1, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB,

+ UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB,

+ UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB,

+ UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB,

+ UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB,

+ UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, C1,

+};

+

+wc_wchar_t

+wc_big5_to_cs94w(wc_wchar_t cc)

+{

+ cc.code = WC_BIG5_N(cc.code);

+ if (cc.code < WC_C_BIG5_2_BASE)

+ cc.ccs = WC_CCS_BIG5_1;

+ else {

+ cc.ccs = WC_CCS_BIG5_2;

+ cc.code -= WC_C_BIG5_2_BASE;

+ }

+ cc.code = WC_N_CS94W(cc.code);

+ return cc;

+}

+

+wc_wchar_t

+wc_cs94w_to_big5(wc_wchar_t cc)

+{

+ cc.code = WC_CS94W_N(cc.code);

+ if (cc.ccs == WC_CCS_BIG5_2)

+ cc.code += WC_C_BIG5_2_BASE;

+ cc.code = WC_N_BIG5(cc.code);

+ cc.ccs = WC_CCS_BIG5;

+ return cc;

+}

+

+Str

+wc_conv_from_big5(Str is, wc_ces ces)

+{

+ Str os;

+ wc_uchar *sp = (wc_uchar *)is->ptr;

+ wc_uchar *ep = sp + is->length;

+ wc_uchar *p;

+ int state = WC_BIG5_NOSTATE;

+

+ for (p = sp; p < ep && *p < 0x80; p++)

+ ;

+ if (p == ep)

+ return is;

+ os = Strnew_size(is->length);

+ if (p > sp)

+ Strcat_charp_n(os, (char *)is->ptr, (int)(p - sp));

+

+ for (; p < ep; p++) {

+ switch (state) {

+ case WC_BIG5_NOSTATE:

+ switch (WC_BIG5_MAP[*p]) {

+ case UB:

+ state = WC_BIG5_MBYTE1;

+ break;

+ case C1:

+ wtf_push_unknown(os, p, 1);

+ break;

+ default:

+ Strcat_char(os, (char)*p);

+ break;

+ }

+ break;

+ case WC_BIG5_MBYTE1:

+ if (WC_BIG5_MAP[*p] & LB)

+ wtf_push(os, WC_CCS_BIG5, ((wc_uint32)*(p-1) << 8) | *p);

+ else

+ wtf_push_unknown(os, p-1, 2);

+ state = WC_BIG5_NOSTATE;

+ break;

+ }

+ }

+ switch (state) {

+ case WC_BIG5_MBYTE1:

+ wtf_push_unknown(os, p-1, 1);

+ break;

+ }

+ return os;

+}

+

+void

+wc_push_to_big5(Str os, wc_wchar_t cc, wc_status *st)

+{

+ while (1) {

+ switch (cc.ccs) {

+ case WC_CCS_US_ASCII:

+ Strcat_char(os, (char)cc.code);

+ return;

+ case WC_CCS_BIG5_1:

+ case WC_CCS_BIG5_2:

+ cc = wc_cs94w_to_big5(cc);

+ case WC_CCS_BIG5:

+ Strcat_char(os, (char)(cc.code >> 8));

+ Strcat_char(os, (char)(cc.code & 0xff));

+ return;

+ case WC_CCS_UNKNOWN_W:

+ if (!WcOption.no_replace)

+ Strcat_charp(os, WC_REPLACE_W);

+ return;

+ case WC_CCS_UNKNOWN:

+ if (!WcOption.no_replace)

+ Strcat_charp(os, WC_REPLACE);

+ return;

+ default:

+#ifdef USE_UNICODE

+ if (WcOption.ucs_conv)

+ cc = wc_any_to_any_ces(cc, st);

+ else

+#endif

+ cc.ccs = WC_CCS_IS_WIDE(cc.ccs) ? WC_CCS_UNKNOWN_W : WC_CCS_UNKNOWN;

+ continue;

+ }

+ }

+}

+

+Str

+wc_char_conv_from_big5(wc_uchar c, wc_status *st)

+{

+ static Str os;

+ static wc_uchar big5u;

+

+ if (st->state == -1) {

+ st->state = WC_BIG5_NOSTATE;

+ os = Strnew_size(8);

+ }

+

+ switch (st->state) {

+ case WC_BIG5_NOSTATE:

+ switch (WC_BIG5_MAP[c]) {

+ case UB:

+ big5u = c;

+ st->state = WC_BIG5_MBYTE1;

+ return NULL;

+ case C1:

+ break;

+ default:

+ Strcat_char(os, (char)c);

+ break;

+ }

+ break;

+ case WC_BIG5_MBYTE1:

+ if (WC_BIG5_MAP[c] & LB)

+ wtf_push(os, WC_CCS_BIG5, ((wc_uint32)big5u << 8) | c);

+ break;

+ }

+ st->state = -1;

+ return os;

+}

+

+#ifndef _WC_BIG5_H

+#define _WC_BIG5_H

+

+#define WC_C_BIG5_2_BASE (0x28 * 0x9D)

+

+#define WC_BIG5_NOSTATE 0

+#define WC_BIG5_MBYTE1 1 /* 0xA1 - 0xFE */

+

+#define WC_BIG5_MAP_C0 0x0

+#define WC_BIG5_MAP_GL 0x1

+#define WC_BIG5_MAP_C1 0x2

+#define WC_BIG5_MAP_LB 0x4

+#define WC_BIG5_MAP_UB (0x3 | WC_BIG5_MAP_LB)

+

+#define WC_BIG5UL_N(U,L) (((U) - 0xA1) * 0x9D \

+ + (L) - (((L) < 0xA1) ? 0x40 : 0x62))

+#define WC_BIG5_N(c) WC_BIG5UL_N(((c) >> 8) & 0xFF, (c) & 0xFF)

+#define WC_N_BIG5U(c) ((c) / 0x9D + 0xA1)

+#define WC_N_BIG5L(c) ((c) % 0x9D + (((c) % 0x9D < 0x3F) ? 0x40 : 0x62))

+#define WC_N_BIG5(c) ((WC_N_BIG5U(c) << 8) + WC_N_BIG5L(c))

+

+extern wc_uchar WC_BIG5_MAP[];

+

+extern wc_wchar_t wc_big5_to_cs94w(wc_wchar_t cc);

+extern wc_wchar_t wc_cs94w_to_big5(wc_wchar_t cc);

+extern Str wc_conv_from_big5(Str is, wc_ces ces);

+extern void wc_push_to_big5(Str os, wc_wchar_t cc, wc_status *st);

+extern Str wc_char_conv_from_big5(wc_uchar c, wc_status *st);

+

+#endif

+

+#ifndef _WC_CCS_H

+#define _WC_CCS_H

+

+#include "iso2022.h"

+#include "priv.h"

+

+#define WC_F_ISO_BASE 0x40

+#define WC_F_PCS_BASE 0x01

+#define WC_F_WCS_BASE 0x00

+

+#define WC_F_CS94_END WC_F_GB_1988

+#define WC_F_CS96_END WC_F_ISO_8859_16

+#define WC_F_CS94W_END WC_F_JIS_X_0213_2

+#define WC_F_CS96W_END 0

+#define WC_F_CS942_END 0

+#define WC_F_PCS_END WC_F_RAW

+#define WC_F_PCSW_END WC_F_HKSCS_2

+#define WC_F_WCS16_END WC_F_UCS2

+#define WC_F_WCS16W_END WC_F_UCS2

+#define WC_F_WCS32_END WC_F_GB18030

+#define WC_F_WCS32W_END WC_F_GB18030

+

+#define WC_CCS_A_SET 0x0FFFF

+#define WC_CCS_A_TYPE 0x0FF00

+#define WC_CCS_A_INDEX 0x000FF

+#define WC_CCS_A_MBYTE 0x08000

+#define WC_CCS_A_WIDE 0x10000

+#define WC_CCS_A_COMB 0x20000

+#define WC_CCS_A_ISO_2022 0x00700

+

+#define WC_CCS_A_CS94 0x00100

+#define WC_CCS_A_CS96 0x00200

+#define WC_CCS_A_CS942 0x00400

+#define WC_CCS_A_PCS 0x00800

+#define WC_CCS_A_WCS16 0x01000

+#define WC_CCS_A_WCS32 0x02000

+#define WC_CCS_A_UNKNOWN 0x04000

+#define WC_CCS_A_CS94W (WC_CCS_A_CS94|WC_CCS_A_MBYTE)

+#define WC_CCS_A_CS96W (WC_CCS_A_CS96|WC_CCS_A_MBYTE)

+#define WC_CCS_A_PCSW (WC_CCS_A_PCS|WC_CCS_A_MBYTE)

+#define WC_CCS_A_WCS16W (WC_CCS_A_WCS16|WC_CCS_A_WIDE)

+#define WC_CCS_A_WCS32W (WC_CCS_A_WCS32|WC_CCS_A_WIDE)

+#define WC_CCS_A_UNKNOWN_W (WC_CCS_A_UNKNOWN|WC_CCS_A_MBYTE)

+#define WC_CCS_A_CS94_C (WC_CCS_A_CS94|WC_CCS_A_COMB)

+#define WC_CCS_A_CS96_C (WC_CCS_A_CS96|WC_CCS_A_COMB)

+#define WC_CCS_A_CS942_C (WC_CCS_A_CS942|WC_CCS_A_COMB)

+#define WC_CCS_A_PCS_C (WC_CCS_A_PCS|WC_CCS_A_COMB)

+#define WC_CCS_A_WCS16_C (WC_CCS_A_WCS16|WC_CCS_A_COMB)

+#define WC_CCS_A_WCS32_C (WC_CCS_A_WCS32|WC_CCS_A_COMB)

+#define WC_CCS_A_CS94W_C (WC_CCS_A_CS94W|WC_CCS_A_COMB)

+#define WC_CCS_A_CS96W_C (WC_CCS_A_CS96W|WC_CCS_A_COMB)

+#define WC_CCS_A_PCSW_C (WC_CCS_A_PCSW|WC_CCS_A_COMB)

+#define WC_CCS_A_WCS16W_C (WC_CCS_A_WCS16W|WC_CCS_A_COMB)

+#define WC_CCS_A_WCS32W_C (WC_CCS_A_WCS32W|WC_CCS_A_COMB)

+

+#define WC_CCS_SET_CS94(c) ((c)|WC_CCS_A_CS94)

+#define WC_CCS_SET_CS94W(c) ((c)|WC_CCS_A_CS94W)

+#define WC_CCS_SET_CS96(c) ((c)|WC_CCS_A_CS96)

+#define WC_CCS_SET_CS96W(c) ((c)|WC_CCS_A_CS96W)

+#define WC_CCS_SET_CS942(c) ((c)|WC_CCS_A_CS942)

+#define WC_CCS_SET_PCS(c) ((c)|WC_CCS_A_PCS)

+#define WC_CCS_SET_PCSW(c) ((c)|WC_CCS_A_PCSW)

+#define WC_CCS_SET_WCS16(c) ((c)|WC_CCS_A_WCS16)

+#define WC_CCS_SET_WCS16W(c) ((c)|WC_CCS_A_WCS16W)

+#define WC_CCS_SET_WCS32(c) ((c)|WC_CCS_A_WCS32)

+#define WC_CCS_SET_WCS32W(c) ((c)|WC_CCS_A_WCS32W)

+

+#define WC_CCS_IS_WIDE(c) ((c)&(WC_CCS_A_MBYTE|WC_CCS_A_WIDE))

+#define WC_CCS_IS_COMB(c) ((c)&WC_CCS_A_COMB)

+#define WC_CCS_IS_ISO_2022(c) ((c)&WC_CCS_A_ISO_2022)

+#define WC_CCS_IS_UNKNOWN(c) ((c)&WC_CCS_A_UNKNOWN)

+

+#define WC_CCS_SET(c) ((c)&WC_CCS_A_SET)

+#define WC_CCS_TYPE(c) ((c)&WC_CCS_A_TYPE)

+#define WC_CCS_INDEX(c) ((c)&WC_CCS_A_INDEX)

+#define WC_CCS_GET_F(c) WC_CCS_INDEX(c)

+

+#define WC_CCS_US_ASCII WC_CCS_SET_CS94(WC_F_US_ASCII)

+#define WC_CCS_JIS_X_0201 WC_CCS_SET_CS94(WC_F_JIS_X_0201)

+#define WC_CCS_JIS_X_0201K WC_CCS_SET_CS94(WC_F_JIS_X_0201K)

+#define WC_CCS_GB_1988 WC_CCS_SET_CS94(WC_F_GB_1988)

+

+#define WC_CCS_ISO_8859_1 WC_CCS_SET_CS96(WC_F_ISO_8859_1)

+#define WC_CCS_ISO_8859_2 WC_CCS_SET_CS96(WC_F_ISO_8859_2)

+#define WC_CCS_ISO_8859_3 WC_CCS_SET_CS96(WC_F_ISO_8859_3)

+#define WC_CCS_ISO_8859_4 WC_CCS_SET_CS96(WC_F_ISO_8859_4)

+#define WC_CCS_ISO_8859_5 WC_CCS_SET_CS96(WC_F_ISO_8859_5)

+#define WC_CCS_ISO_8859_6 WC_CCS_SET_CS96(WC_F_ISO_8859_6)

+#define WC_CCS_ISO_8859_7 WC_CCS_SET_CS96(WC_F_ISO_8859_7)

+#define WC_CCS_ISO_8859_8 WC_CCS_SET_CS96(WC_F_ISO_8859_8)

+#define WC_CCS_ISO_8859_9 WC_CCS_SET_CS96(WC_F_ISO_8859_9)

+#define WC_CCS_ISO_8859_10 WC_CCS_SET_CS96(WC_F_ISO_8859_10)

+#define WC_CCS_ISO_8859_11 WC_CCS_SET_CS96(WC_F_ISO_8859_11)

+#define WC_CCS_TIS_620 WC_CCS_ISO_8859_11

+#define WC_CCS_ISO_8859_13 WC_CCS_SET_CS96(WC_F_ISO_8859_13)

+#define WC_CCS_ISO_8859_14 WC_CCS_SET_CS96(WC_F_ISO_8859_14)

+#define WC_CCS_ISO_8859_15 WC_CCS_SET_CS96(WC_F_ISO_8859_15)

+#define WC_CCS_ISO_8859_16 WC_CCS_SET_CS96(WC_F_ISO_8859_16)

+

+#define WC_CCS_SPECIAL WC_CCS_SET_PCS(WC_F_SPECIAL)

+#define WC_CCS_CP437 WC_CCS_SET_PCS(WC_F_CP437)

+#define WC_CCS_CP737 WC_CCS_SET_PCS(WC_F_CP737)

+#define WC_CCS_CP775 WC_CCS_SET_PCS(WC_F_CP775)

+#define WC_CCS_CP850 WC_CCS_SET_PCS(WC_F_CP850)

+#define WC_CCS_CP852 WC_CCS_SET_PCS(WC_F_CP852)

+#define WC_CCS_CP855 WC_CCS_SET_PCS(WC_F_CP855)

+#define WC_CCS_CP856 WC_CCS_SET_PCS(WC_F_CP856)

+#define WC_CCS_CP857 WC_CCS_SET_PCS(WC_F_CP857)

+#define WC_CCS_CP860 WC_CCS_SET_PCS(WC_F_CP860)

+#define WC_CCS_CP861 WC_CCS_SET_PCS(WC_F_CP861)

+#define WC_CCS_CP862 WC_CCS_SET_PCS(WC_F_CP862)

+#define WC_CCS_CP863 WC_CCS_SET_PCS(WC_F_CP863)

+#define WC_CCS_CP864 WC_CCS_SET_PCS(WC_F_CP864)

+#define WC_CCS_CP865 WC_CCS_SET_PCS(WC_F_CP865)

+#define WC_CCS_CP866 WC_CCS_SET_PCS(WC_F_CP866)

+#define WC_CCS_CP869 WC_CCS_SET_PCS(WC_F_CP869)

+#define WC_CCS_CP874 WC_CCS_SET_PCS(WC_F_CP874)

+#define WC_CCS_CP1006 WC_CCS_SET_PCS(WC_F_CP1006)

+#define WC_CCS_CP1250 WC_CCS_SET_PCS(WC_F_CP1250)

+#define WC_CCS_CP1251 WC_CCS_SET_PCS(WC_F_CP1251)

+#define WC_CCS_CP1252 WC_CCS_SET_PCS(WC_F_CP1252)

+#define WC_CCS_CP1253 WC_CCS_SET_PCS(WC_F_CP1253)

+#define WC_CCS_CP1254 WC_CCS_SET_PCS(WC_F_CP1254)

+#define WC_CCS_CP1255 WC_CCS_SET_PCS(WC_F_CP1255)

+#define WC_CCS_CP1256 WC_CCS_SET_PCS(WC_F_CP1256)

+#define WC_CCS_CP1257 WC_CCS_SET_PCS(WC_F_CP1257)

+#define WC_CCS_CP1258_1 WC_CCS_SET_PCS(WC_F_CP1258_1)

+#define WC_CCS_CP1258_2 WC_CCS_SET_PCS(WC_F_CP1258_2)

+#define WC_CCS_TCVN_5712_1 WC_CCS_SET_PCS(WC_F_TCVN_5712_1)

+#define WC_CCS_TCVN_5712_2 WC_CCS_SET_PCS(WC_F_TCVN_5712_2)

+#define WC_CCS_TCVN_5712_3 WC_CCS_SET_PCS(WC_F_TCVN_5712_3)

+#define WC_CCS_VISCII_11_1 WC_CCS_SET_PCS(WC_F_VISCII_11_1)

+#define WC_CCS_VISCII_11_2 WC_CCS_SET_PCS(WC_F_VISCII_11_2)

+#define WC_CCS_VPS_1 WC_CCS_SET_PCS(WC_F_VPS_1)

+#define WC_CCS_VPS_2 WC_CCS_SET_PCS(WC_F_VPS_2)

+#define WC_CCS_KOI8_R WC_CCS_SET_PCS(WC_F_KOI8_R)

+#define WC_CCS_KOI8_U WC_CCS_SET_PCS(WC_F_KOI8_U)

+#define WC_CCS_NEXTSTEP WC_CCS_SET_PCS(WC_F_NEXTSTEP)

+#define WC_CCS_GBK_80 WC_CCS_SET_PCS(WC_F_GBK_80)

+#define WC_CCS_RAW WC_CCS_SET_PCS(WC_F_RAW)

+

+#define WC_CCS_JIS_C_6226 WC_CCS_SET_CS94W(WC_F_JIS_C_6226)

+#define WC_CCS_JIS_X_0208 WC_CCS_SET_CS94W(WC_F_JIS_X_0208)

+#define WC_CCS_JIS_X_0212 WC_CCS_SET_CS94W(WC_F_JIS_X_0212)

+#define WC_CCS_GB_2312 WC_CCS_SET_CS94W(WC_F_GB_2312)

+#define WC_CCS_ISO_IR_165 WC_CCS_SET_CS94W(WC_F_ISO_IR_165)

+#define WC_CCS_CNS_11643_1 WC_CCS_SET_CS94W(WC_F_CNS_11643_1)

+#define WC_CCS_CNS_11643_2 WC_CCS_SET_CS94W(WC_F_CNS_11643_2)

+#define WC_CCS_CNS_11643_3 WC_CCS_SET_CS94W(WC_F_CNS_11643_3)

+#define WC_CCS_CNS_11643_4 WC_CCS_SET_CS94W(WC_F_CNS_11643_4)

+#define WC_CCS_CNS_11643_5 WC_CCS_SET_CS94W(WC_F_CNS_11643_5)

+#define WC_CCS_CNS_11643_6 WC_CCS_SET_CS94W(WC_F_CNS_11643_6)

+#define WC_CCS_CNS_11643_7 WC_CCS_SET_CS94W(WC_F_CNS_11643_7)

+#define WC_CCS_KS_X_1001 WC_CCS_SET_CS94W(WC_F_KS_X_1001)

+#define WC_CCS_KPS_9566 WC_CCS_SET_CS94W(WC_F_KPS_9566)

+#define WC_CCS_JIS_X_0213_1 WC_CCS_SET_CS94W(WC_F_JIS_X_0213_1)

+#define WC_CCS_JIS_X_0213_2 WC_CCS_SET_CS94W(WC_F_JIS_X_0213_2)

+

+#define WC_CCS_SPECIAL_W WC_CCS_SET_PCSW(WC_F_SPECIAL_W)

+#define WC_CCS_BIG5 WC_CCS_SET_PCSW(WC_F_BIG5)

+#define WC_CCS_BIG5_1 WC_CCS_SET_PCSW(WC_F_BIG5_1)

+#define WC_CCS_BIG5_2 WC_CCS_SET_PCSW(WC_F_BIG5_2)

+#define WC_CCS_CNS_11643_8 WC_CCS_SET_PCSW(WC_F_CNS_11643_8)

+#define WC_CCS_CNS_11643_9 WC_CCS_SET_PCSW(WC_F_CNS_11643_9)

+#define WC_CCS_CNS_11643_10 WC_CCS_SET_PCSW(WC_F_CNS_11643_10)

+#define WC_CCS_CNS_11643_11 WC_CCS_SET_PCSW(WC_F_CNS_11643_11)

+#define WC_CCS_CNS_11643_12 WC_CCS_SET_PCSW(WC_F_CNS_11643_12)

+#define WC_CCS_CNS_11643_13 WC_CCS_SET_PCSW(WC_F_CNS_11643_13)

+#define WC_CCS_CNS_11643_14 WC_CCS_SET_PCSW(WC_F_CNS_11643_14)

+#define WC_CCS_CNS_11643_15 WC_CCS_SET_PCSW(WC_F_CNS_11643_15)

+#define WC_CCS_CNS_11643_16 WC_CCS_SET_PCSW(WC_F_CNS_11643_16)

+#define WC_CCS_CNS_11643_X WC_CCS_SET_PCSW(WC_F_CNS_11643_X)

+#define WC_CCS_GB_12345 WC_CCS_SET_PCSW(WC_F_GB_12345)

+#define WC_CCS_JOHAB WC_CCS_SET_PCSW(WC_F_JOHAB)

+#define WC_CCS_JOHAB_1 WC_CCS_SET_PCSW(WC_F_JOHAB_1)

+#define WC_CCS_JOHAB_2 WC_CCS_SET_PCSW(WC_F_JOHAB_2)

+#define WC_CCS_JOHAB_3 WC_CCS_SET_PCSW(WC_F_JOHAB_3)

+#define WC_CCS_SJIS_EXT WC_CCS_SET_PCSW(WC_F_SJIS_EXT)

+#define WC_CCS_SJIS_EXT_1 WC_CCS_SET_PCSW(WC_F_SJIS_EXT_1)

+#define WC_CCS_SJIS_EXT_2 WC_CCS_SET_PCSW(WC_F_SJIS_EXT_2)

+#define WC_CCS_GBK WC_CCS_SET_PCSW(WC_F_GBK)

+#define WC_CCS_GBK_1 WC_CCS_SET_PCSW(WC_F_GBK_1)

+#define WC_CCS_GBK_2 WC_CCS_SET_PCSW(WC_F_GBK_2)

+#define WC_CCS_GBK_EXT WC_CCS_SET_PCSW(WC_F_GBK_EXT)

+#define WC_CCS_GBK_EXT_1 WC_CCS_SET_PCSW(WC_F_GBK_EXT_1)

+#define WC_CCS_GBK_EXT_2 WC_CCS_SET_PCSW(WC_F_GBK_EXT_2)

+#define WC_CCS_UHC WC_CCS_SET_PCSW(WC_F_UHC)

+#define WC_CCS_UHC_1 WC_CCS_SET_PCSW(WC_F_UHC_1)

+#define WC_CCS_UHC_2 WC_CCS_SET_PCSW(WC_F_UHC_2)

+#define WC_CCS_HKSCS WC_CCS_SET_PCSW(WC_F_HKSCS)

+#define WC_CCS_HKSCS_1 WC_CCS_SET_PCSW(WC_F_HKSCS_1)

+#define WC_CCS_HKSCS_2 WC_CCS_SET_PCSW(WC_F_HKSCS_2)

+

+#define WC_CCS_UCS2 WC_CCS_SET_WCS16(WC_F_UCS2)

+#define WC_CCS_UCS4 WC_CCS_SET_WCS32(WC_F_UCS4)

+#define WC_CCS_UCS_TAG WC_CCS_SET_WCS32(WC_F_UCS_TAG)

+#define WC_CCS_GB18030 WC_CCS_SET_WCS32(WC_F_GB18030)

+#define WC_CCS_UCS2_W WC_CCS_SET_WCS16W(WC_F_UCS2)

+#define WC_CCS_UCS4_W WC_CCS_SET_WCS32W(WC_F_UCS4)

+#define WC_CCS_UCS_TAG_W WC_CCS_SET_WCS32W(WC_F_UCS_TAG)

+#define WC_CCS_GB18030_W WC_CCS_SET_WCS32W(WC_F_GB18030)

+

+#define WC_CCS_UNKNOWN WC_CCS_A_UNKNOWN

+#define WC_CCS_C1 (WC_CCS_A_UNKNOWN|WC_F_C1)

+#define WC_CCS_UNKNOWN_W WC_CCS_A_UNKNOWN_W

+

+#define WC_CCS_IS_UNICODE(c) (WC_CCS_SET(c) == WC_CCS_UCS2 || WC_CCS_SET(c) == WC_CCS_UCS4 || WC_CCS_SET(c) == WC_CCS_UCS_TAG)

+

+extern wc_bool wc_is_combining(wc_wchar_t cc);

+

+#endif

+

+#include "wc.h"

+#include "iso2022.h"

+#include "sjis.h"

+#include "hz.h"

+#include "big5.h"

+#include "hkscs.h"

+#include "johab.h"

+#include "gbk.h"

+#include "gb18030.h"

+#include "uhc.h"

+#include "viet.h"

+#include "priv.h"

+#ifdef USE_UNICODE

+#include "utf8.h"

+#include "utf7.h"

+#endif

+

+static wc_gset gset_usascii[] = {

+ { WC_CCS_US_ASCII, WC_C_G0_CS94, 1 },

+ { 0, 0, 0 },

+};

+

+#define gset_iso8859(no) \

+static wc_gset gset_iso8859##no[] = { \

+ { WC_CCS_US_ASCII, WC_C_G0_CS94, 1 }, \

+ { WC_CCS_ISO_8859_##no, WC_C_G1_CS96 | 0x80, 1 }, \

+ { 0, 0, 0 }, \

+}

+gset_iso8859(1); gset_iso8859(2); gset_iso8859(3); gset_iso8859(4);

+gset_iso8859(5); gset_iso8859(6); gset_iso8859(7); gset_iso8859(8);

+gset_iso8859(9); gset_iso8859(10); gset_iso8859(11);

+gset_iso8859(13); gset_iso8859(14); gset_iso8859(15); gset_iso8859(16);

+

+#define gset_cp(no) gset_priv1(CP##no, cp##no)

+#define gset_priv1(ccs, ces) \

+static wc_gset gset_##ces[] = { \

+ { WC_CCS_US_ASCII, 0, 1 }, \

+ { WC_CCS_##ccs, 0x80, 1 }, \

+ { 0, 0, 0 }, \

+}

+gset_cp(437); gset_cp(737); gset_cp(775); gset_cp(850); gset_cp(852);

+gset_cp(855); gset_cp(856); gset_cp(857); gset_cp(860); gset_cp(861);

+gset_cp(862); gset_cp(863); gset_cp(864); gset_cp(865); gset_cp(866);

+gset_cp(869); gset_cp(874); gset_cp(1006);

+gset_cp(1250); gset_cp(1251); gset_cp(1252); gset_cp(1253); gset_cp(1254);

+gset_cp(1255); gset_cp(1256); gset_cp(1257);

+gset_priv1(KOI8_R, koi8r);

+gset_priv1(KOI8_U, koi8u);

+gset_priv1(NEXTSTEP, nextstep);

+

+static wc_gset gset_iso2022jp[] = {

+ { WC_CCS_US_ASCII, WC_C_G0_CS94, 1 },

+ { WC_CCS_JIS_X_0208, WC_C_G0_CS94, 0 },

+ { 0, 0, 0 },

+};

+static wc_gset gset_iso2022jp2[] = {

+ { WC_CCS_US_ASCII, WC_C_G0_CS94, 1 },

+ { WC_CCS_JIS_X_0208, WC_C_G0_CS94, 0 },

+ { WC_CCS_JIS_X_0212, WC_C_G0_CS94, 0 },

+ { WC_CCS_GB_2312, WC_C_G0_CS94, 0 },

+ { WC_CCS_KS_X_1001, WC_C_G0_CS94, 0 },

+ { WC_CCS_ISO_8859_1, WC_C_G2_CS96, 0 },

+ { WC_CCS_ISO_8859_7, WC_C_G2_CS96, 0 },

+ { 0, 0, 0 },

+};

+static wc_gset gset_iso2022jp3[] = {

+ { WC_CCS_US_ASCII, WC_C_G0_CS94, 1 },

+ { WC_CCS_JIS_X_0208, WC_C_G0_CS94, 0 },

+ { WC_CCS_JIS_X_0213_1, WC_C_G0_CS94, 0 },

+ { WC_CCS_JIS_X_0213_2, WC_C_G0_CS94, 0 },

+ { 0, 0, 0 },

+};

+static wc_gset gset_iso2022cn[] = {

+ { WC_CCS_US_ASCII, WC_C_G0_CS94, 1 },

+ { WC_CCS_GB_2312, WC_C_G1_CS94, 1 },

+ { WC_CCS_ISO_IR_165, WC_C_G1_CS94, 0 },

+ { WC_CCS_CNS_11643_1, WC_C_G1_CS94, 0 },

+ { WC_CCS_CNS_11643_2, WC_C_G2_CS94, 0 },

+ { WC_CCS_CNS_11643_3, WC_C_G3_CS94, 0 },

+ { WC_CCS_CNS_11643_4, WC_C_G3_CS94, 0 },

+ { WC_CCS_CNS_11643_5, WC_C_G3_CS94, 0 },

+ { WC_CCS_CNS_11643_6, WC_C_G3_CS94, 0 },

+ { WC_CCS_CNS_11643_7, WC_C_G3_CS94, 0 },

+ { 0, 0, 0 },

+};

+static wc_gset gset_iso2022kr[] = {

+ { WC_CCS_US_ASCII, WC_C_G0_CS94, 1 },

+ { WC_CCS_KS_X_1001, WC_C_G1_CS94, 1 },

+ { 0, 0, 0 },

+};

+static wc_uchar gset_ext_iso2022jp[] = {

+ WC_C_G0_CS94, WC_C_G2_CS96, WC_C_G0_CS94, WC_C_G2_CS96

+};

+static wc_uchar gset_ext_iso2022cn[] = {

+ WC_C_G2_CS94, WC_C_G2_CS96, WC_C_G2_CS94, WC_C_G2_CS96

+};

+static wc_uchar gset_ext_iso2022kr[] = {

+ WC_C_G1_CS94, WC_C_G1_CS96, WC_C_G1_CS94, WC_C_G1_CS96

+};

+static wc_gset gset_eucjp[] = {

+ { WC_CCS_US_ASCII, WC_C_G0_CS94, 1 },

+ { WC_CCS_JIS_X_0208, WC_C_G1_CS94 | 0x80, 1 },

+ { WC_CCS_JIS_X_0201K, WC_C_G2_CS94 | 0x80, 1 },

+ { WC_CCS_JIS_X_0213_1, WC_C_G1_CS94 | 0x80, 0 },

+ { WC_CCS_JIS_X_0213_2, WC_C_G3_CS94 | 0x80, 0 },

+ { WC_CCS_JIS_X_0212, WC_C_G3_CS94 | 0x80, 1 },

+ { 0, 0, 0 },

+};

+static wc_gset gset_euccn[] = {

+ { WC_CCS_US_ASCII, WC_C_G0_CS94, 1 },

+ { WC_CCS_GB_2312, WC_C_G1_CS94 | 0x80, 1 },

+ { 0, 0, 0 },

+};

+static wc_gset gset_euctw[] = {

+ { WC_CCS_US_ASCII, WC_C_G0_CS94, 1 },

+ { WC_CCS_CNS_11643_1, WC_C_G1_CS94 | 0x80, 1 },

+ { WC_CCS_CNS_11643_X, WC_C_G2_CS94 | 0x80, 1 },

+ { 0, 0, 0 },

+};

+static wc_gset gset_euckr[] = {

+ { WC_CCS_US_ASCII, WC_C_G0_CS94, 1 },

+ { WC_CCS_KS_X_1001, WC_C_G1_CS94 | 0x80, 1 },

+ { 0, 0, 0 },

+};

+static wc_gset gset_sjis[] = {

+ { WC_CCS_US_ASCII, 0, 1 },

+ { WC_CCS_JIS_X_0208, 0x80, 1 },

+ { WC_CCS_JIS_X_0201K, 0x80, 1 },

+ { WC_CCS_SJIS_EXT_1, 0x80, 1 },

+ { WC_CCS_SJIS_EXT_2, 0x80, 1 },

+ { WC_CCS_SJIS_EXT, 0x80, 1 },

+ { 0, 0, 0 },

+};

+static wc_gset gset_sjisx0213[] = {

+ { WC_CCS_US_ASCII, 0, 1 },

+ { WC_CCS_JIS_X_0208, 0x80, 1 },

+ { WC_CCS_JIS_X_0201K, 0x80, 1 },

+ { WC_CCS_JIS_X_0213_1, 0x80, 1 },

+ { WC_CCS_JIS_X_0213_2, 0x80, 1 },

+ { 0, 0, 0 },

+};

+static wc_gset gset_hz[] = {

+ { WC_CCS_US_ASCII, 0, 1 },

+ { WC_CCS_GB_2312, 0, 0 },

+ { 0, 0, 0 },

+};

+static wc_gset gset_big5[] = {

+ { WC_CCS_US_ASCII, 0, 1 },

+ { WC_CCS_BIG5_1, 0x80, 1 },

+ { WC_CCS_BIG5_2, 0x80, 1 },

+ { WC_CCS_BIG5, 0x80, 1 },

+ { 0, 0, 0 },

+};

+static wc_gset gset_hkscs[] = {

+ { WC_CCS_US_ASCII, 0, 1 },

+ { WC_CCS_BIG5_1, 0x80, 1 },

+ { WC_CCS_BIG5_2, 0x80, 1 },

+ { WC_CCS_BIG5, 0x80, 1 },

+ { WC_CCS_HKSCS_1, 0x80, 1 },

+ { WC_CCS_HKSCS_2, 0x80, 1 },

+ { WC_CCS_HKSCS, 0x80, 1 },

+ { 0, 0, 0 },

+};

+static wc_gset gset_johab[] = {

+ { WC_CCS_US_ASCII, 0, 1 },

+ { WC_CCS_JOHAB_1, 0x80, 1 },

+ { WC_CCS_JOHAB_2, 0x80, 1 },

+ { WC_CCS_JOHAB_3, 0x80, 1 },

+ { WC_CCS_JOHAB, 0x80, 1 },

+ { 0, 0, 0 },

+};

+static wc_gset gset_gbk[] = {

+ { WC_CCS_US_ASCII, 0, 1 },

+ { WC_CCS_GB_2312, 0x80, 1 },

+ { WC_CCS_GBK_80, 0x80, 1 },

+ { WC_CCS_GBK_1, 0x80, 1 },

+ { WC_CCS_GBK_2, 0x80, 1 },

+ { WC_CCS_GBK, 0x80, 1 },

+ { 0, 0, 0 },

+};

+static wc_gset gset_gb18030[] = {

+ { WC_CCS_US_ASCII, 0, 1 },

+ { WC_CCS_GB_2312, 0x80, 1 },

+ { WC_CCS_GBK_1, 0x80, 1 },

+ { WC_CCS_GBK_2, 0x80, 1 },

+ { WC_CCS_GBK, 0x80, 1 },

+ { WC_CCS_GBK_EXT_1, 0x80, 1 },

+ { WC_CCS_GBK_EXT_2, 0x80, 1 },

+ { WC_CCS_GBK_EXT, 0x80, 1 },

+ { WC_CCS_GB18030, 0x80, 1 },

+ { 0, 0, 0 },

+};

+static wc_gset gset_uhc[] = {

+ { WC_CCS_US_ASCII, 0, 1 },

+ { WC_CCS_KS_X_1001, 0x80, 1 },

+ { WC_CCS_UHC_1, 0x80, 1 },

+ { WC_CCS_UHC_2, 0x80, 1 },

+ { WC_CCS_UHC, 0x80, 1 },

+ { 0, 0, 0 },

+};

+#define gset_priv2(ccs, ces) \

+static wc_gset gset_##ces[] = { \

+ { WC_CCS_US_ASCII, 0, 1 }, \

+ { WC_CCS_##ccs##_1, 0x80, 1 }, \

+ { WC_CCS_##ccs##_2, 0x80, 1 }, \

+ { 0, 0, 0 }, \

+}

+gset_priv2(CP1258, cp1258);

+gset_priv2(VISCII_11, viscii11);

+gset_priv2(VPS, vps);

+static wc_gset gset_tcvn5712[] = {

+ { WC_CCS_US_ASCII, 0, 1 },

+ { WC_CCS_TCVN_5712_1, 0x80, 1 },

+ { WC_CCS_TCVN_5712_2, 0x80, 1 },

+ { WC_CCS_TCVN_5712_3, 0x80, 1 },

+ { 0, 0, 0 },

+};

+

+#ifdef USE_UNICODE

+static wc_gset gset_utf8[] = {

+ { WC_CCS_US_ASCII, 0, 1 },

+ { WC_CCS_UCS2, 0x80, 1 },

+ { WC_CCS_UCS4, 0x80, 1 },

+ { WC_CCS_UCS_TAG, 0x80, 1 },

+ { 0, 0, 0 },

+};

+static wc_gset gset_utf7[] = {

+ { WC_CCS_US_ASCII, 0, 1 },

+ { WC_CCS_UCS2, 0x80, 1 },

+ { WC_CCS_UCS4, 0x80, 1 },

+ { WC_CCS_UCS_TAG, 0x80, 1 },

+ { 0, 0, 0 },

+};

+#endif

+

+static wc_gset gset_raw[] = {

+ { WC_CCS_US_ASCII, 0, 1 },

+ { WC_CCS_RAW, 0x80, 1 },

+ { 0, 0, 0 },

+};

+

+#define ces_ascii(id,name,desc) \

+ { WC_CES_##id, name, desc, gset_usascii, NULL, \

+ (void *)wc_conv_from_ascii, (void *)wc_push_to_iso8859, \

+ (void *)wc_char_conv_from_iso2022 }

+#define ces_iso8859(id,name,desc,no) \

+ { WC_CES_##id, name, desc, gset_iso8859##no, NULL, \

+ (void *)wc_conv_from_iso2022, (void *)wc_push_to_iso8859, \

+ (void *)wc_char_conv_from_iso2022 }

+#define ces_priv1(id,name,desc,ces) \

+ { WC_CES_##id, name, desc, gset_##ces, NULL, \

+ (void *)wc_conv_from_priv1, (void *)wc_push_to_priv1, \

+ (void *)wc_char_conv_from_priv1 }

+#define ces_iso2022(id,name,desc,terr) \

+ { WC_CES_##id, name, desc, gset_iso2022##terr, gset_ext_iso2022##terr, \

+ (void *)wc_conv_from_iso2022, (void *)wc_push_to_iso2022, \

+ (void *)wc_char_conv_from_iso2022 }

+#define ces_euc(id,name,desc,terr) \

+ { WC_CES_##id, name, desc, gset_euc##terr, NULL, \

+ (void *)wc_conv_from_iso2022, (void *)wc_push_to_euc##terr, \

+ (void *)wc_char_conv_from_iso2022 }

+#define ces_priv2(id,name,desc,ces) \

+ { WC_CES_##id, name, desc, gset_##ces, NULL, \

+ (void *)wc_conv_from_##ces, (void *)wc_push_to_##ces, \

+ (void *)wc_char_conv_from_##ces }

+

+#define gset_ext_iso2022jp2 gset_ext_iso2022jp

+#define gset_ext_iso2022jp3 gset_ext_iso2022jp

+#define wc_push_to_euckr wc_push_to_euc

+#define wc_push_to_euccn wc_push_to_euc

+#define wc_push_to_priv1 wc_push_to_iso8859

+#define wc_push_to_cp1258 wc_push_to_viet

+#define wc_push_to_tcvn5712 wc_push_to_viet

+#define wc_push_to_viscii11 wc_push_to_viet

+#define wc_push_to_vps wc_push_to_viet

+#define wc_conv_from_cp1258 wc_conv_from_priv1

+#define wc_conv_from_tcvn5712 wc_conv_from_viet

+#define wc_conv_from_viscii11 wc_conv_from_viet

+#define wc_conv_from_vps wc_conv_from_viet

+#define wc_conv_from_raw wc_conv_from_priv1

+#define wc_char_conv_from_hz wc_char_conv_from_iso2022

+#define wc_char_conv_from_cp1258 wc_char_conv_from_priv1

+#define wc_char_conv_from_tcvn5712 wc_char_conv_from_viet

+#define wc_char_conv_from_viscii11 wc_char_conv_from_viet

+#define wc_char_conv_from_vps wc_char_conv_from_viet

+#define wc_char_conv_from_raw wc_char_conv_from_priv1

+

+wc_ces_info WcCesInfo[] = {

+ ces_ascii(US_ASCII, "US-ASCII", "Latin (US-ASCII)"),

+

+ ces_iso8859(ISO_8859_1, "ISO-8859-1", "Latin 1 (ISO-8859-1)", 1),

+ ces_iso8859(ISO_8859_2, "ISO-8859-2", "Latin 2 (ISO-8859-2)", 2),

+ ces_iso8859(ISO_8859_3, "ISO-8859-3", "Latin 3 (ISO-8859-3)", 3),

+ ces_iso8859(ISO_8859_4, "ISO-8859-4", "Latin 4 (ISO-8859-4)", 4),

+ ces_iso8859(ISO_8859_5, "ISO-8859-5", "Cyrillic (ISO-8859-5)", 5),

+ ces_iso8859(ISO_8859_6, "ISO-8859-6", "Arabic (ISO-8859-6)", 6),

+ ces_iso8859(ISO_8859_7, "ISO-8859-7", "Greek (ISO-8859-7)", 7),

+ ces_iso8859(ISO_8859_8, "ISO-8859-8", "Hebrew (ISO-8859-8)", 8),

+ ces_iso8859(ISO_8859_9, "ISO-8859-9", "Turkish (ISO-8859-9)", 9),

+ ces_iso8859(ISO_8859_10, "ISO-8859-10", "Nordic (ISO-8859-10)", 10),

+ ces_iso8859(ISO_8859_11, "ISO-8859-11", "Thai (ISO-8859-11, TIS-620)", 11),

+ { WC_CES_ISO_8859_12, NULL, NULL, NULL, NULL, NULL, NULL, NULL },

+ ces_iso8859(ISO_8859_13, "ISO-8859-13", "Baltic Rim (ISO-8859-13)", 13),

+ ces_iso8859(ISO_8859_14, "ISO-8859-14", "Celtic (ISO-8859-14)", 14),

+ ces_iso8859(ISO_8859_15, "ISO-8859-15", "Latin 9 (ISO-8859-15)", 15),

+ ces_iso8859(ISO_8859_16, "ISO-8859-16", "Romanian (ISO-8859-16)", 16),

+

+ ces_iso2022(ISO_2022_JP, "ISO-2022-JP", "Japanese (ISO-2022-JP)", jp),

+ ces_iso2022(ISO_2022_JP_2, "ISO-2022-JP-2", "Japanese (ISO-2022-JP-2)", jp2),

+ ces_iso2022(ISO_2022_JP_3, "ISO-2022-JP-3", "Japanese (ISO-2022-JP-3)", jp3),

+ ces_iso2022(ISO_2022_CN, "ISO-2022-CN", "Chinese (ISO-2022-CN)", cn),

+ ces_iso2022(ISO_2022_KR, "ISO-2022-KR", "Korean (ISO-2022-KR)", kr),

+

+ ces_euc(EUC_JP, "EUC-JP", "Japanese (EUC-JP)", jp),

+ ces_euc(EUC_CN, "EUC-CN", "Chinese (EUC-CN, GB2312)", cn),

+ ces_euc(EUC_TW, "EUC-TW", "Chinese Taiwan (EUC-TW)", tw),

+ ces_euc(EUC_KR, "EUC-KR", "Korean (EUC-KR)", kr),

+

+ ces_priv1(CP437, "CP437", "Latin (CP437)", cp437),

+ ces_priv1(CP737, "CP737", "Greek (CP737)", cp737),

+ ces_priv1(CP775, "CP775", "Baltic Rim (CP775)", cp775),

+ ces_priv1(CP850, "CP850", "Latin 1 (CP850)", cp850),

+ ces_priv1(CP852, "CP852", "Latin 2 (CP852)", cp852),

+ ces_priv1(CP855, "CP855", "Cyrillic (CP855)", cp855),

+ ces_priv1(CP856, "CP856", "Hebrew (CP856)", cp856),

+ ces_priv1(CP857, "CP857", "Turkish (CP857)", cp857),

+ ces_priv1(CP860, "CP860", "Portuguese (CP860)", cp860),

+ ces_priv1(CP861, "CP861", "Icelandic (CP861)", cp861),

+ ces_priv1(CP862, "CP862", "Hebrew (CP862)", cp862),

+ ces_priv1(CP863, "CP863", "Canada French (CP863)", cp863),

+ ces_priv1(CP864, "CP864", "Arabic (CP864)", cp864),

+ ces_priv1(CP865, "CP865", "Nordic (CP865)", cp865),

+ ces_priv1(CP866, "CP866", "Cyrillic (CP866)", cp866),

+ ces_priv1(CP869, "CP869", "Greek 2 (CP869)", cp869),

+ ces_priv1(CP874, "CP874", "Thai (CP874)", cp874),

+ ces_priv1(CP1006, "CP1006", "Arabic (CP1006)", cp1006),

+ ces_priv1(CP1250, "CP1250", "Latin 2 (CP1250)", cp1250),

+ ces_priv1(CP1251, "CP1251", "Cyrillic (CP1251)", cp1251),

+ ces_priv1(CP1252, "CP1252", "Latin 1 (CP1252)", cp1252),

+ ces_priv1(CP1253, "CP1253", "Greek (CP1253)", cp1253),

+ ces_priv1(CP1254, "CP1254", "Turkish (CP1254)", cp1254),

+ ces_priv1(CP1255, "CP1255", "Hebrew (CP1255)", cp1255),

+ ces_priv1(CP1256, "CP1256", "Arabic (CP1256)", cp1256),

+ ces_priv1(CP1257, "CP1257", "Baltic Rim (CP1257)", cp1257),

+ ces_priv1(KOI8_R, "KOI8-R", "Cyrillic (KOI8-R)", koi8r),

+ ces_priv1(KOI8_U, "KOI8-U", "Ukrainian (KOI8-U)", koi8u),

+ ces_priv1(NEXTSTEP, "NeXTSTEP", "NeXTSTEP", nextstep),

+

+ ces_priv2(RAW, "Raw", "8bit Raw", raw),

+

+ ces_priv2(SHIFT_JIS, "Shift_JIS", "Japanese (Shift_JIS, CP932)", sjis),

+ ces_priv2(SHIFT_JISX0213, "Shift_JISX0213", "Japanese (Shift_JISX0213)", sjisx0213),

+ ces_priv2(GBK, "GBK", "Chinese (GBK, CP936)", gbk),

+ ces_priv2(GB18030, "GB18030", "Chinese (GB18030)", gb18030),

+ ces_priv2(HZ_GB_2312, "HZ-GB-2312", "Chinese (HZ-GB-2312)", hz),

+ ces_priv2(BIG5, "Big5", "Chinese Taiwan (Big5, CP950)", big5),

+ ces_priv2(HKSCS, "HKSCS", "Chinese Hong Kong (HKSCS)", hkscs),

+ ces_priv2(UHC, "UHC", "Korean (UHC, CP949)", uhc),

+ ces_priv2(JOHAB, "Johab", "Korean (Johab)", johab),

+

+ ces_priv2(CP1258, "CP1258", "Vietnamese (CP1258)", cp1258),

+ ces_priv2(TCVN_5712, "TCVN-5712", "Vietnamese (TCVN-5712)", tcvn5712),

+ ces_priv2(VISCII_11, "VISCII-1.1", "Vietnamese (VISCII 1.1)", viscii11),

+ ces_priv2(VPS, "VPS", "Vietnamese (VPS)", vps),

+

+#ifdef USE_UNICODE

+ ces_priv2(UTF_8, "UTF-8", "Unicode (UTF-8)", utf8),

+ ces_priv2(UTF_7, "UTF-7", "Unicode (UTF-7)", utf7),

+#else

+ { WC_CES_UTF_8, NULL, NULL, NULL, NULL, NULL, NULL, NULL },

+ { WC_CES_UTF_7, NULL, NULL, NULL, NULL, NULL, NULL, NULL },

+#endif

+ { 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL },

+};

+

+#ifndef _WC_CES_H

+#define _WC_CES_H

+

+#include "ccs.h"

+

+#define WC_CES_T_INDEX 0x0000ff

+#define WC_CES_T_TYPE 0x31ff00

+#define WC_CES_T_NASCII 0x01fe00

+#define WC_CES_T_8BIT 0x100000

+#define WC_CES_T_MBYTE 0x200000

+#define WC_CES_T_ASCII 0x000100

+#define WC_CES_T_ISO_8859 0x000200

+#define WC_CES_T_PRIV1 0x000400

+#define WC_CES_T_ISO_2022 0x000800

+#define WC_CES_T_EUC 0x001000

+#define WC_CES_T_PRIV2 0x002000

+#define WC_CES_T_VIET 0x004000

+#define WC_CES_T_UTF 0x008000

+#define WC_CES_T_WTF 0x010000

+#define WC_CES_E_ISO_8859 (WC_CES_T_ISO_8859|WC_CES_T_8BIT)

+#define WC_CES_E_PRIV1 (WC_CES_T_PRIV1|WC_CES_T_8BIT)

+#define WC_CES_E_ISO_2022 (WC_CES_T_ISO_2022|WC_CES_T_MBYTE)

+#define WC_CES_E_EUC (WC_CES_T_EUC|WC_CES_T_8BIT|WC_CES_T_MBYTE)

+#define WC_CES_E_PRIV2 (WC_CES_T_PRIV2|WC_CES_T_8BIT|WC_CES_T_MBYTE)

+#define WC_CES_E_VIET (WC_CES_T_VIET|WC_CES_T_PRIV1|WC_CES_T_8BIT)

+

+#define WC_CES_WTF (WC_CES_T_WTF|WC_CES_T_8BIT|WC_CES_T_MBYTE)

+

+#define WC_CES_INDEX(c) ((c)&WC_CES_T_INDEX)

+#define WC_CES_TYPE(c) ((c)&WC_CES_T_TYPE)

+

+enum {

+ WC_CES_N_US_ASCII,

+

+ WC_CES_N_ISO_8859_1,

+ WC_CES_N_ISO_8859_2,

+ WC_CES_N_ISO_8859_3,

+ WC_CES_N_ISO_8859_4,

+ WC_CES_N_ISO_8859_5,

+ WC_CES_N_ISO_8859_6,

+ WC_CES_N_ISO_8859_7,

+ WC_CES_N_ISO_8859_8,

+ WC_CES_N_ISO_8859_9,

+ WC_CES_N_ISO_8859_10,

+ WC_CES_N_ISO_8859_11,

+ WC_CES_N_ISO_8859_12,

+ WC_CES_N_ISO_8859_13,

+ WC_CES_N_ISO_8859_14,

+ WC_CES_N_ISO_8859_15,

+ WC_CES_N_ISO_8859_16,

+

+ WC_CES_N_ISO_2022_JP,

+ WC_CES_N_ISO_2022_JP_2,

+ WC_CES_N_ISO_2022_JP_3,

+ WC_CES_N_ISO_2022_CN,

+ WC_CES_N_ISO_2022_KR,

+

+ WC_CES_N_EUC_JP,

+ WC_CES_N_EUC_CN,

+ WC_CES_N_EUC_TW,

+ WC_CES_N_EUC_KR,

+

+ WC_CES_N_CP437,

+ WC_CES_N_CP737,

+ WC_CES_N_CP775,

+ WC_CES_N_CP850,

+ WC_CES_N_CP852,

+ WC_CES_N_CP855,

+ WC_CES_N_CP856,

+ WC_CES_N_CP857,

+ WC_CES_N_CP860,

+ WC_CES_N_CP861,

+ WC_CES_N_CP862,

+ WC_CES_N_CP863,

+ WC_CES_N_CP864,

+ WC_CES_N_CP865,

+ WC_CES_N_CP866,

+ WC_CES_N_CP869,

+ WC_CES_N_CP874,

+ WC_CES_N_CP1006,

+ WC_CES_N_CP1250,

+ WC_CES_N_CP1251,

+ WC_CES_N_CP1252,

+ WC_CES_N_CP1253,

+ WC_CES_N_CP1254,

+ WC_CES_N_CP1255,

+ WC_CES_N_CP1256,

+ WC_CES_N_CP1257,

+ WC_CES_N_KOI8_R,

+ WC_CES_N_KOI8_U,

+ WC_CES_N_NEXTSTEP,

+ WC_CES_N_RAW,

+

+ WC_CES_N_SHIFT_JIS,

+ WC_CES_N_SHIFT_JISX0213,

+ WC_CES_N_GBK,

+ WC_CES_N_GB18030,

+ WC_CES_N_HZ_GB_2312,

+ WC_CES_N_BIG5,

+ WC_CES_N_HKSCS,

+ WC_CES_N_UHC,

+ WC_CES_N_JOHAB,

+

+ WC_CES_N_CP1258,

+ WC_CES_N_TCVN_5712,

+ WC_CES_N_VISCII_11,

+ WC_CES_N_VPS,

+

+ WC_CES_N_UTF_8,

+ WC_CES_N_UTF_7

+};

+

+#define WC_CES_US_ASCII (WC_CES_T_ASCII|WC_CES_N_US_ASCII)

+

+#define WC_CES_ISO_8859_1 (WC_CES_E_ISO_8859|WC_CES_N_ISO_8859_1)

+#define WC_CES_ISO_8859_2 (WC_CES_E_ISO_8859|WC_CES_N_ISO_8859_2)

+#define WC_CES_ISO_8859_3 (WC_CES_E_ISO_8859|WC_CES_N_ISO_8859_3)

+#define WC_CES_ISO_8859_4 (WC_CES_E_ISO_8859|WC_CES_N_ISO_8859_4)

+#define WC_CES_ISO_8859_5 (WC_CES_E_ISO_8859|WC_CES_N_ISO_8859_5)

+#define WC_CES_ISO_8859_6 (WC_CES_E_ISO_8859|WC_CES_N_ISO_8859_6)

+#define WC_CES_ISO_8859_7 (WC_CES_E_ISO_8859|WC_CES_N_ISO_8859_7)

+#define WC_CES_ISO_8859_8 (WC_CES_E_ISO_8859|WC_CES_N_ISO_8859_8)

+#define WC_CES_ISO_8859_9 (WC_CES_E_ISO_8859|WC_CES_N_ISO_8859_9)

+#define WC_CES_ISO_8859_10 (WC_CES_E_ISO_8859|WC_CES_N_ISO_8859_10)

+#define WC_CES_ISO_8859_11 (WC_CES_E_ISO_8859|WC_CES_N_ISO_8859_11)

+#define WC_CES_TIS_620 WC_CES_ISO_8859_11

+#define WC_CES_ISO_8859_12 (WC_CES_E_ISO_8859|WC_CES_N_ISO_8859_12)

+ /* not yet exist */

+#define WC_CES_ISO_8859_13 (WC_CES_E_ISO_8859|WC_CES_N_ISO_8859_13)

+#define WC_CES_ISO_8859_14 (WC_CES_E_ISO_8859|WC_CES_N_ISO_8859_14)

+#define WC_CES_ISO_8859_15 (WC_CES_E_ISO_8859|WC_CES_N_ISO_8859_15)

+#define WC_CES_ISO_8859_16 (WC_CES_E_ISO_8859|WC_CES_N_ISO_8859_16)

+

+#define WC_CES_ISO_2022_JP (WC_CES_E_ISO_2022|WC_CES_N_ISO_2022_JP)

+#define WC_CES_ISO_2022_JP_2 (WC_CES_E_ISO_2022|WC_CES_N_ISO_2022_JP_2)

+#define WC_CES_ISO_2022_JP_3 (WC_CES_E_ISO_2022|WC_CES_N_ISO_2022_JP_3)

+#define WC_CES_ISO_2022_CN (WC_CES_E_ISO_2022|WC_CES_N_ISO_2022_CN)

+#define WC_CES_ISO_2022_KR (WC_CES_E_ISO_2022|WC_CES_N_ISO_2022_KR)

+

+#define WC_CES_EUC_JP (WC_CES_E_EUC|WC_CES_N_EUC_JP)

+#define WC_CES_EUC_CN (WC_CES_E_EUC|WC_CES_N_EUC_CN)

+#define WC_CES_EUC_TW (WC_CES_E_EUC|WC_CES_N_EUC_TW)

+#define WC_CES_EUC_KR (WC_CES_E_EUC|WC_CES_N_EUC_KR)

+

+#define WC_CES_CP437 (WC_CES_E_PRIV1|WC_CES_N_CP437)

+#define WC_CES_CP737 (WC_CES_E_PRIV1|WC_CES_N_CP737)

+#define WC_CES_CP775 (WC_CES_E_PRIV1|WC_CES_N_CP775)

+#define WC_CES_CP850 (WC_CES_E_PRIV1|WC_CES_N_CP850)

+#define WC_CES_CP852 (WC_CES_E_PRIV1|WC_CES_N_CP852)

+#define WC_CES_CP855 (WC_CES_E_PRIV1|WC_CES_N_CP855)

+#define WC_CES_CP856 (WC_CES_E_PRIV1|WC_CES_N_CP856)

+#define WC_CES_CP857 (WC_CES_E_PRIV1|WC_CES_N_CP857)

+#define WC_CES_CP860 (WC_CES_E_PRIV1|WC_CES_N_CP860)

+#define WC_CES_CP861 (WC_CES_E_PRIV1|WC_CES_N_CP861)

+#define WC_CES_CP862 (WC_CES_E_PRIV1|WC_CES_N_CP862)

+#define WC_CES_CP863 (WC_CES_E_PRIV1|WC_CES_N_CP863)

+#define WC_CES_CP864 (WC_CES_E_PRIV1|WC_CES_N_CP864)

+#define WC_CES_CP865 (WC_CES_E_PRIV1|WC_CES_N_CP865)

+#define WC_CES_CP866 (WC_CES_E_PRIV1|WC_CES_N_CP866)

+#define WC_CES_CP869 (WC_CES_E_PRIV1|WC_CES_N_CP869)

+#define WC_CES_CP874 (WC_CES_E_PRIV1|WC_CES_N_CP874)

+#define WC_CES_CP1006 (WC_CES_E_PRIV1|WC_CES_N_CP1006)

+#define WC_CES_CP1250 (WC_CES_E_PRIV1|WC_CES_N_CP1250)

+#define WC_CES_CP1251 (WC_CES_E_PRIV1|WC_CES_N_CP1251)

+#define WC_CES_CP1252 (WC_CES_E_PRIV1|WC_CES_N_CP1252)

+#define WC_CES_CP1253 (WC_CES_E_PRIV1|WC_CES_N_CP1253)

+#define WC_CES_CP1254 (WC_CES_E_PRIV1|WC_CES_N_CP1254)

+#define WC_CES_CP1255 (WC_CES_E_PRIV1|WC_CES_N_CP1255)

+#define WC_CES_CP1256 (WC_CES_E_PRIV1|WC_CES_N_CP1256)

+#define WC_CES_CP1257 (WC_CES_E_PRIV1|WC_CES_N_CP1257)

+#define WC_CES_KOI8_R (WC_CES_E_PRIV1|WC_CES_N_KOI8_R)

+#define WC_CES_KOI8_U (WC_CES_E_PRIV1|WC_CES_N_KOI8_U)

+#define WC_CES_NEXTSTEP (WC_CES_E_PRIV1|WC_CES_N_NEXTSTEP)

+#define WC_CES_RAW (WC_CES_E_PRIV1|WC_CES_N_RAW)

+

+#define WC_CES_SHIFT_JIS (WC_CES_E_PRIV2|WC_CES_N_SHIFT_JIS)

+#define WC_CES_CP932 WC_CES_SHIFT_JIS

+#define WC_CES_SHIFT_JISX0213 (WC_CES_E_PRIV2|WC_CES_N_SHIFT_JISX0213)

+#define WC_CES_GBK (WC_CES_E_PRIV2|WC_CES_N_GBK)

+#define WC_CES_CP936 WC_CES_GBK

+#define WC_CES_GB18030 (WC_CES_E_PRIV2|WC_CES_N_GB18030)

+#define WC_CES_HZ_GB_2312 (WC_CES_T_PRIV2|WC_CES_T_MBYTE|WC_CES_N_HZ_GB_2312)

+#define WC_CES_BIG5 (WC_CES_E_PRIV2|WC_CES_N_BIG5)

+#define WC_CES_CP950 WC_CES_BIG5

+#define WC_CES_HKSCS (WC_CES_E_PRIV2|WC_CES_N_HKSCS)

+#define WC_CES_UHC (WC_CES_E_PRIV2|WC_CES_N_UHC)

+#define WC_CES_CP949 WC_CES_UHC

+#define WC_CES_JOHAB (WC_CES_E_PRIV2|WC_CES_N_JOHAB)

+

+#define WC_CES_CP1258 (WC_CES_E_PRIV1|WC_CES_N_CP1258)

+#define WC_CES_TCVN_5712 (WC_CES_E_VIET|WC_CES_N_TCVN_5712)

+#define WC_CES_VISCII_11 (WC_CES_E_VIET|WC_CES_N_VISCII_11)

+#define WC_CES_VPS (WC_CES_E_VIET|WC_CES_N_VPS)

+

+#define WC_CES_UTF_8 (WC_CES_T_UTF|WC_CES_T_8BIT|WC_CES_T_MBYTE|WC_CES_N_UTF_8)

+#define WC_CES_UTF_7 (WC_CES_T_UTF|WC_CES_T_MBYTE|WC_CES_N_UTF_7)

+

+#define WC_CES_END WC_CES_N_UTF_7

+

+#endif

+

+#include "wc.h"

+

+static wc_ces char_conv_f_ces = 0, char_conv_t_ces = WC_CES_WTF;

+static wc_status char_conv_st;

+

+void

+wc_char_conv_init(wc_ces f_ces, wc_ces t_ces)

+{

+ wc_input_init(f_ces, &char_conv_st);

+ char_conv_st.state = -1;

+ char_conv_f_ces = f_ces;

+ char_conv_t_ces = t_ces;

+}

+

+Str

+wc_char_conv(char c)

+{

+ return wc_Str_conv((*char_conv_st.ces_info->char_conv)((wc_uchar)c, &char_conv_st),

+ WC_CES_WTF, char_conv_t_ces);

+}

+

+#include <stdlib.h>

+#include <ctype.h>

+#include <gc.h>

+#define New_N(type,n) ((type*)GC_MALLOC((n)*sizeof(type)))

+

+#include "wc.h"

+

+wc_locale WcLocale = 0;

+

+static struct {

+ char *lang;

+ wc_ces ces;

+} lang_ces_table[] = {

+ { "cs", WC_CES_ISO_8859_2 }, /* cs_CZ */

+ { "el", WC_CES_ISO_8859_7 }, /* el_GR */

+ { "iw", WC_CES_ISO_8859_8 }, /* iw_IL */

+ { "ja", WC_CES_EUC_JP }, /* ja_JP */

+ { "ko", WC_CES_EUC_KR }, /* ko_KR */

+ { "hu", WC_CES_ISO_8859_2 }, /* hu_HU */

+ { "pl", WC_CES_ISO_8859_2 }, /* pl_PL */

+ { "ro", WC_CES_ISO_8859_2 }, /* ro_RO */

+ { "ru", WC_CES_ISO_8859_5 }, /* ru_SU */

+ { "sk", WC_CES_ISO_8859_2 }, /* sk_SK */

+ { "sl", WC_CES_ISO_8859_2 }, /* sl_CS */

+ { "tr", WC_CES_ISO_8859_9 }, /* tr_TR */

+ { "zh", WC_CES_EUC_CN }, /* zh_CN */

+ { NULL, 0 }

+};

+

+wc_ces

+wc_guess_charset(char *charset, wc_ces orig)

+{

+ wc_ces guess;

+

+ if (charset == NULL || *charset == '\0')

+ return orig;

+ guess = wc_charset_to_ces(charset);

+ return guess ? guess : orig;

+}

+

+wc_ces

+wc_guess_charset_short(char *charset, wc_ces orig)

+{

+ wc_ces guess;

+

+ if (charset == NULL || *charset == '\0')

+ return orig;

+ guess = wc_charset_short_to_ces(charset);

+ return guess ? guess : orig;

+}

+

+wc_ces

+wc_guess_locale_charset(char *locale, wc_ces orig)

+{

+ wc_ces guess;

+

+ if (locale == NULL || *locale == '\0')

+ return orig;

+ guess = wc_locale_to_ces(locale);

+ return guess ? guess : orig;

+}

+

+wc_ces

+wc_charset_to_ces(char *charset)

+{

+ char *p = charset;

+ char buf[16];

+ int n;

+

+ if (tolower(*p) == 'x' && *(p+1) == '-')

+ p += 2;

+ for (n = 0; *p && n < 15; p++) {

+ if ((unsigned char)*p > 0x20 && *p != '_' && *p != '-')

+ buf[n++] = tolower(*p);

+ }

+ buf[n] = 0;

+ p = buf;

+ switch (*p) {

+ case 'e':

+ if (! strncmp(p, "euc", 3)) {

+ p += 3;

+ switch (*p) {

+ case 'j': return WC_CES_EUC_JP;

+ case 'c': return WC_CES_EUC_CN;

+ case 't': return WC_CES_EUC_TW;

+ case 'k': return WC_CES_EUC_KR;

+ }

+ switch (WcLocale) {

+ case WC_LOCALE_JA_JP: return WC_CES_EUC_JP;

+ case WC_LOCALE_ZH_CN: return WC_CES_EUC_CN;

+ case WC_LOCALE_ZH_TW: return WC_CES_EUC_TW;

+ case WC_LOCALE_ZH_HK: return WC_CES_EUC_CN;

+ case WC_LOCALE_KO_KR: return WC_CES_EUC_KR;

+ }

+ return WC_CES_EUC_JP;

+ }

+ break;

+ case 'i':

+ if (! strncmp(p, "iso2022", 7)) {

+ p += 7;

+ switch (*p) {

+ case 'j':

+ if (! strncmp(p, "jp2", 3))

+ return WC_CES_ISO_2022_JP_2;

+ if (! strncmp(p, "jp3", 3))

+ return WC_CES_ISO_2022_JP_3;

+ return WC_CES_ISO_2022_JP;

+ case 'c': return WC_CES_ISO_2022_CN;

+ case 'k': return WC_CES_ISO_2022_KR;

+ }

+ return WC_CES_ISO_2022_JP;

+ } else if (! strncmp(p, "iso8859", 7)) {

+ n = atoi(p + 7);

+ if (n >= 1 && n <= 16 && n != 12)

+ return (WC_CES_E_ISO_8859 | n);

+ return WC_CES_ISO_8859_1;

+ }

+ break;

+ case 'j':

+ if (! strncmp(p, "johab", 5))

+ return WC_CES_JOHAB;

+ if (! strncmp(p, "jis", 3))

+ return WC_CES_ISO_2022_JP;

+ break;

+ case 's':

+ if (! strncmp(p, "shiftjisx0213", 13) ||

+ ! strncmp(p, "sjisx0213", 9))

+ return WC_CES_SHIFT_JISX0213;

+ if (! strncmp(p, "shiftjis", 8) ||

+ ! strncmp(p, "sjis", 4))

+ return WC_CES_SHIFT_JIS;

+ break;

+ case 'g':

+ if (! strncmp(p, "gb18030", 7) ||

+ ! strncmp(p, "gbk2k", 5))

+ return WC_CES_GB18030;

+ if (! strncmp(p, "gbk", 3))

+ return WC_CES_GBK;

+ if (! strncmp(p, "gb2312", 6))

+ return WC_CES_EUC_CN;

+ break;

+ case 'b':

+ if (! strncmp(p, "big5hkscs", 9))

+ return WC_CES_HKSCS;

+ if (! strncmp(p, "big5", 4))

+ return WC_CES_BIG5;

+ break;

+ case 'h':

+ if (! strncmp(p, "hz", 2))

+ return WC_CES_HZ_GB_2312;

+ if (! strncmp(p, "hkscs", 5))

+ return WC_CES_HKSCS;

+ break;

+ case 'k':

+ if (! strncmp(p, "koi8r", 5))

+ return WC_CES_KOI8_R;

+ if (! strncmp(p, "koi8u", 5))

+ return WC_CES_KOI8_U;

+ if (! strncmp(p, "ksx1001", 7))

+ return WC_CES_EUC_KR;

+ if (! strncmp(p, "ksc5601", 7))

+ return WC_CES_EUC_KR;

+ break;

+ case 't':

+ if (! strncmp(p, "tis620", 6))

+ return WC_CES_TIS_620;

+ if (! strncmp(p, "tcvn", 4))

+ return WC_CES_TCVN_5712;

+ break;

+ case 'n':

+ if (! strncmp(p, "next", 4))

+ return WC_CES_NEXTSTEP;

+ break;

+ case 'v':

+ if (! strncmp(p, "viet", 4)) {

+ p += 4;

+ if (! strncmp(p, "tcvn", 4))

+ return WC_CES_TCVN_5712;

+ }

+ if (! strncmp(p, "viscii", 6))

+ return WC_CES_VISCII_11;

+ if (! strncmp(p, "vps", 3))

+ return WC_CES_VPS;

+ break;

+ case 'u':

+#ifdef USE_UNICODE

+ if (! strncmp(p, "utf8", 4))

+ return WC_CES_UTF_8;

+ if (! strncmp(p, "utf7", 4))

+ return WC_CES_UTF_7;

+#endif

+ if (! strncmp(p, "uhc", 3))

+ return WC_CES_UHC;

+ if (! strncmp(p, "ujis", 4))

+ return WC_CES_EUC_JP;

+ if (! strncmp(p, "usascii", 7))

+ return WC_CES_US_ASCII;

+ break;

+ case 'a':

+ if (! strncmp(p, "ascii", 5))

+ return WC_CES_US_ASCII;

+ break;

+ case 'c':

+ if (! strncmp(p, "cngb", 4))

+ return WC_CES_EUC_CN;

+ if (*(p+1) != 'p')

+ break;

+ n = atoi(p + 2);

+ switch (n) {

+ case 437: return WC_CES_CP437;

+ case 737: return WC_CES_CP737;

+ case 775: return WC_CES_CP775;

+ case 850: return WC_CES_CP850;

+ case 852: return WC_CES_CP852;

+ case 855: return WC_CES_CP855;

+ case 856: return WC_CES_CP856;

+ case 857: return WC_CES_CP857;

+ case 860: return WC_CES_CP860;

+ case 861: return WC_CES_CP861;

+ case 862: return WC_CES_CP862;

+ case 863: return WC_CES_CP863;

+ case 864: return WC_CES_CP864;

+ case 865: return WC_CES_CP865;

+ case 866: return WC_CES_CP866;

+ case 869: return WC_CES_CP869;

+ case 874: return WC_CES_CP874;

+ case 932: return WC_CES_CP932; /* CP932 = Shift_JIS */

+ case 936: return WC_CES_CP936; /* CP936 = GBK > EUC_CN */

+ case 949: return WC_CES_CP949; /* CP949 = UHC > EUC_KR */

+ case 950: return WC_CES_CP950; /* CP950 = Big5 */

+ case 1006: return WC_CES_CP1006;

+ case 1250: return WC_CES_CP1250;

+ case 1251: return WC_CES_CP1251;

+ case 1252: return WC_CES_CP1252;

+ case 1253: return WC_CES_CP1253;

+ case 1254: return WC_CES_CP1254;

+ case 1255: return WC_CES_CP1255;

+ case 1256: return WC_CES_CP1256;

+ case 1257: return WC_CES_CP1257;

+ case 1258: return WC_CES_CP1258;

+ }

+ break;

+ case 'w':

+ if (strncmp(p, "windows", 7))

+ break;

+ if (! strncmp(p, "31j", 3))

+ return WC_CES_CP932;

+ n = atoi(p + 7);

+ switch (n) {

+ case 1250: return WC_CES_CP1250;

+ case 1251: return WC_CES_CP1251;

+ case 1252: return WC_CES_CP1252;

+ case 1253: return WC_CES_CP1253;

+ case 1254: return WC_CES_CP1254;

+ case 1255: return WC_CES_CP1255;

+ case 1256: return WC_CES_CP1256;

+ case 1257: return WC_CES_CP1257;

+ case 1258: return WC_CES_CP1258;

+ }

+ break;

+ }

+ return 0;

+}

+

+wc_ces

+wc_charset_short_to_ces(char *charset)

+{

+ char *p = charset;

+ char buf[16];

+ wc_ces ces;

+ int n;

+

+ ces = wc_charset_to_ces(charset);

+ if (ces)

+ return ces;

+

+ for (n = 0; *p && n < 15; p++) {

+ if ((unsigned char)*p > 0x20 && *p != '_' && *p != '-')

+ buf[n++] = tolower(*p);

+ }

+ buf[n] = 0;

+ p = buf;

+ switch (*p) {

+ case 'e':

+ switch (*(p+1)) {

+ case 'j': return WC_CES_EUC_JP;

+ case 'c': return WC_CES_EUC_CN;

+ case 't': return WC_CES_EUC_TW;

+ case 'k': return WC_CES_EUC_KR;

+ }

+ return WC_CES_EUC_JP;

+ case 'j':

+ p++;

+ if (*p == 'o')

+ return WC_CES_JOHAB;

+ if (*p == 'p')

+ p++;

+ if (*p == '2')

+ return WC_CES_ISO_2022_JP_2;

+ if (*p == '3')

+ return WC_CES_ISO_2022_JP_3;

+ return WC_CES_ISO_2022_JP;

+ case 's':

+ return WC_CES_SHIFT_JIS;

+ case 'g':

+ return WC_CES_EUC_CN;

+ case 'b':

+ return WC_CES_BIG5;

+ case 'h':

+ if (*(p+1) == 'k')

+ return WC_CES_HKSCS;

+ return WC_CES_HZ_GB_2312;

+ case 'k':

+ if (*(p+1) == 'o')

+ return WC_CES_KOI8_R;

+ return WC_CES_ISO_2022_KR;

+ case 'l':

+ n = atoi(p + 1);

+ if (n >= 1 && n <= 16 && n != 12)

+ return (WC_CES_E_ISO_8859 | n);

+ return WC_CES_ISO_8859_1;

+ case 't':

+ if (*(p+1) == 'c')

+ return WC_CES_TCVN_5712;

+ return WC_CES_TIS_620;

+ case 'n':

+ return WC_CES_NEXTSTEP;

+ case 'v':

+ if (*(p+1) == 'p')

+ return WC_CES_VPS;

+ return WC_CES_VISCII_11;

+#ifdef USE_UNICODE

+ case 'u':

+ if (*(p+1) == '7')

+ return WC_CES_UTF_7;

+ return WC_CES_UTF_8;

+#endif

+ case 'a':

+ return WC_CES_US_ASCII;

+ case 'c':

+ return WC_CES_ISO_2022_CN;

+ case 'w':

+ n = atoi(p + 1);

+ switch (n) {

+ case 1250: return WC_CES_CP1250;

+ case 1251: return WC_CES_CP1251;

+ case 1252: return WC_CES_CP1252;

+ case 1253: return WC_CES_CP1253;

+ case 1254: return WC_CES_CP1254;

+ case 1255: return WC_CES_CP1255;

+ case 1256: return WC_CES_CP1256;

+ case 1257: return WC_CES_CP1257;

+ case 1258: return WC_CES_CP1258;

+ }

+ break;

+ case 'r':

+ return WC_CES_RAW;

+ }

+ return 0;

+}

+

+wc_ces

+wc_locale_to_ces(char *locale)

+{

+ char *p = locale;

+ char buf[6];

+ int n;

+

+ if (*p == 'C' && *(p+1) == '\0')

+ return WC_CES_US_ASCII;

+ for (n = 0; *p && *p != '.' && n < 5; p++) {

+ if ((unsigned char)*p > 0x20)

+ buf[n++] = tolower(*p);

+ }

+ buf[n] = 0;

+ if (*p == '.') {

+ p++;

+ if (! strcasecmp(p, "euc")) {

+ switch (buf[0]) {

+ case 'j':

+ WcLocale = WC_LOCALE_JA_JP;

+ break;

+ case 'k':

+ WcLocale = WC_LOCALE_KO_KR;

+ break;

+ case 'z':

+ if (!strcmp(buf, "zh_tw"))

+ WcLocale = WC_LOCALE_ZH_TW;

+ else if (!strcmp(buf, "zh_hk"))

+ WcLocale = WC_LOCALE_ZH_HK;

+ else

+ WcLocale = WC_LOCALE_ZH_CN;

+ break;

+ default:

+ WcLocale = 0;

+ break;

+ }

+ }

+ return wc_charset_to_ces(p);

+ }

+

+ if (!strcmp(buf, "japanese"))

+ return WC_CES_SHIFT_JIS;

+ if (!strcmp(buf, "zh_tw") ||

+ !strcmp(buf, "zh_hk"))

+ return WC_CES_BIG5;

+ for (n = 0; lang_ces_table[n].lang; n++) {

+ if (!strncmp(buf, lang_ces_table[n].lang, 2))

+ return lang_ces_table[n].ces;

+ }

+ return WC_CES_ISO_8859_1;

+}

+

+char *

+wc_ces_to_charset(wc_ces ces)

+{

+ if (ces == WC_CES_WTF)

+ return "WTF";

+ return WcCesInfo[WC_CES_INDEX(ces)].name;

+}

+

+char *

+wc_ces_to_charset_desc(wc_ces ces)

+{

+ if (ces == WC_CES_WTF)

+ return "W3M Transfer Format";

+ return WcCesInfo[WC_CES_INDEX(ces)].desc;

+}

+

+wc_ces

+wc_guess_8bit_charset(wc_ces orig)

+{

+ switch (orig) {

+ case WC_CES_ISO_2022_JP:

+ case WC_CES_ISO_2022_JP_2:

+ case WC_CES_ISO_2022_JP_3:

+ return WC_CES_EUC_JP;

+ case WC_CES_ISO_2022_KR:

+ return WC_CES_EUC_KR;

+ case WC_CES_ISO_2022_CN:

+ case WC_CES_HZ_GB_2312:

+ return WC_CES_EUC_CN;

+ case WC_CES_US_ASCII:

+ return WC_CES_ISO_8859_1;

+ }

+ return orig;

+}

+

+wc_bool

+wc_check_ces(wc_ces ces)

+{

+ size_t i = WC_CES_INDEX(ces);

+

+ return (i <= WC_CES_END && WcCesInfo[i].id == ces);

+}

+

+static int

+wc_ces_list_cmp(const void *a, const void *b)

+{

+ return strcasecmp(((wc_ces_list *)a)->desc, ((wc_ces_list *)b)->desc);

+}

+

+static wc_ces_list *list = NULL;

+

+wc_ces_list *

+wc_get_ces_list(void)

+{

+ wc_ces_info *info;

+ size_t n;

+

+ if (list)

+ return list;

+ for (info = WcCesInfo, n = 0; info->id; info++) {

+ if (info->name != NULL)

+ n++;

+ }

+ list = New_N(wc_ces_list, n + 1);

+ for (info = WcCesInfo, n = 0; info->id; info++) {

+ if (info->name != NULL) {

+ list[n].id = info->id;

+ list[n].name = info->name;

+ list[n].desc = info->desc;

+ n++;

+ }

+ }

+ list[n].id = 0;

+ list[n].name = NULL;

+ list[n].desc = NULL;

+ qsort(list, n, sizeof(wc_ces_list), wc_ces_list_cmp);

+ return list;

+}

+

+#include "wc.h"

+#ifdef USE_UNICODE

+#include "ucs.h"

+#endif

+#include "map/iso88596_combining.map"

+#include "map/iso885911_combining.map"

+#include "map/cp864_combining.map"

+#include "map/cp874_combining.map"

+#include "map/cp1255_combining.map"

+#include "map/cp1256_combining.map"

+#include "map/cp1258_combining.map"

+#include "map/tcvn5712_combining.map"

+

+wc_bool

+wc_is_combining(wc_wchar_t cc)

+{

+ switch (WC_CCS_SET(cc.ccs)) {

+ case WC_CCS_ISO_8859_6:

+ return iso88596_combining_map[cc.code & 0x7f];

+ case WC_CCS_ISO_8859_11:

+ return iso885911_combining_map[cc.code & 0x7f];

+ case WC_CCS_CP864:

+ return cp864_combining_map[cc.code & 0x7f];

+ case WC_CCS_CP874:

+ return cp874_combining_map[cc.code & 0x7f];

+ case WC_CCS_CP1255:

+ return cp1255_combining_map[cc.code & 0x7f];

+ case WC_CCS_CP1256:

+ return cp1256_combining_map[cc.code & 0x7f];

+ case WC_CCS_CP1258_1:

+ return cp1258_combining_map[cc.code & 0x7f];

+ case WC_CCS_TCVN_5712_1:

+ return tcvn5712_combining_map[cc.code & 0x7f];

+#ifdef USE_UNICODE

+ case WC_CCS_UCS2:

+ case WC_CCS_UCS4:

+ case WC_CCS_UCS_TAG:

+ return wc_is_ucs_combining(cc.code);

+#endif

+ }

+ return WC_FALSE;

+}

+

+#include "wc.h"

+#include "wtf.h"

+#include "iso2022.h"

+#include "hz.h"

+#ifdef USE_UNICODE

+#include "ucs.h"

+#include "utf8.h"

+#include "utf7.h"

+#endif

+

+char *WcReplace = "?";

+char *WcReplaceW = "??";

+

+static Str wc_conv_to_ces(Str is, wc_ces ces);

+

+Str

+wc_Str_conv(Str is, wc_ces f_ces, wc_ces t_ces)

+{

+ if (f_ces != WC_CES_WTF)

+ is = (*WcCesInfo[WC_CES_INDEX(f_ces)].conv_from)(is, f_ces);

+ if (t_ces != WC_CES_WTF)

+ return wc_conv_to_ces(is, t_ces);

+ else

+ return is;

+}

+

+Str

+wc_Str_conv_strict(Str is, wc_ces f_ces, wc_ces t_ces)

+{

+ Str os;

+ wc_option opt = WcOption;

+

+ WcOption.strict_iso2022 = WC_TRUE;

+ WcOption.no_replace = WC_TRUE;

+ WcOption.fix_width_conv = WC_FALSE;

+ os = wc_Str_conv(is, f_ces, t_ces);

+ WcOption = opt;

+ return os;

+}

+

+static Str

+wc_conv_to_ces(Str is, wc_ces ces)

+{

+ Str os;

+ wc_uchar *sp = (wc_uchar *)is->ptr;

+ wc_uchar *ep = sp + is->length;

+ wc_uchar *p;

+ wc_status st;

+

+ switch (ces) {

+ case WC_CES_HZ_GB_2312:

+ for (p = sp; p < ep && *p != '~' && *p < 0x80; p++)

+ ;

+ break;

+ case WC_CES_TCVN_5712:

+ case WC_CES_VISCII_11:

+ case WC_CES_VPS:

+ for (p = sp; p < ep && 0x20 <= *p && *p < 0x80; p++)

+ ;

+ break;

+ default:

+ for (p = sp; p < ep && *p < 0x80; p++)

+ ;

+ break;

+ }

+ if (p == ep)

+ return is;

+

+ os = Strnew_size(is->length);

+ if (p > sp)

+ p--; /* for precompose */

+ if (p > sp)

+ Strcat_charp_n(os, is->ptr, (int)(p - sp));

+

+ wc_output_init(ces, &st);

+

+ switch (ces) {

+ case WC_CES_ISO_2022_JP:

+ case WC_CES_ISO_2022_JP_2:

+ case WC_CES_ISO_2022_JP_3:

+ case WC_CES_ISO_2022_CN:

+ case WC_CES_ISO_2022_KR:

+ case WC_CES_HZ_GB_2312:

+ case WC_CES_TCVN_5712:

+ case WC_CES_VISCII_11:

+ case WC_CES_VPS:

+#ifdef USE_UNICODE

+ case WC_CES_UTF_8:

+ case WC_CES_UTF_7:

+#endif

+ while (p < ep)

+ (*st.ces_info->push_to)(os, wtf_parse(&p), &st);

+ break;

+ default:

+ while (p < ep) {

+ if (*p < 0x80 && wtf_width(p + 1)) {

+ Strcat_char(os, (char)*p);

+ p++;

+ } else

+ (*st.ces_info->push_to)(os, wtf_parse(&p), &st);

+ }

+ break;

+ }

+

+ wc_push_end(os, &st);

+

+ return os;

+}

+

+Str

+wc_Str_conv_with_detect(Str is, wc_ces *f_ces, wc_ces hint, wc_ces t_ces)

+{

+ wc_ces detect;

+

+ if (*f_ces == WC_CES_WTF || hint == WC_CES_WTF) {

+ *f_ces = WC_CES_WTF;

+ detect = WC_CES_WTF;

+ } else if (WcOption.auto_detect == WC_OPT_DETECT_OFF) {

+ *f_ces = hint;

+ detect = hint;

+ } else {

+ if (*f_ces & WC_CES_T_8BIT)

+ hint = *f_ces;

+ detect = wc_auto_detect(is->ptr, is->length, hint);

+ if (WcOption.auto_detect == WC_OPT_DETECT_ON) {

+ if ((detect & WC_CES_T_8BIT) ||

+ ((detect & WC_CES_T_NASCII) && ! (*f_ces & WC_CES_T_8BIT)))

+ *f_ces = detect;

+ } else {

+ if ((detect & WC_CES_T_ISO_2022) && ! (*f_ces & WC_CES_T_8BIT))

+ *f_ces = detect;

+ }

+ }

+ return wc_Str_conv(is, detect, t_ces);

+}

+

+void

+wc_push_end(Str os, wc_status *st)

+{

+ if (st->ces_info->id & WC_CES_T_ISO_2022)

+ wc_push_to_iso2022_end(os, st);

+ else if (st->ces_info->id == WC_CES_HZ_GB_2312)

+ wc_push_to_hz_end(os, st);

+#ifdef USE_UNICODE

+ else if (st->ces_info->id == WC_CES_UTF_8)

+ wc_push_to_utf8_end(os, st);

+ else if (st->ces_info->id == WC_CES_UTF_7)

+ wc_push_to_utf7_end(os, st);

+#endif

+}

+

+

+#include "wc.h"

+#include "iso2022.h"

+#include "sjis.h"

+#include "big5.h"

+#include "hz.h"

+#include "viet.h"

+#ifdef USE_UNICODE

+#include "utf8.h"

+#include "utf7.h"

+#endif

+

+wc_uint8 WC_DETECT_MAP[ 0x100 ] = {

+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

+};

+

+#define DETECT_NORMAL 0

+#define DETECT_POSSIBLE 1

+#define DETECT_OK 2

+#define DETECT_BROKEN 4

+#define DETECT_ERROR 8

+#define SET_DETECT(x,y) ((x) |= (y))

+#define SET_BROKEN_ERROR(x) ((x) = ((x) & DETECT_BROKEN) ? DETECT_ERROR : ((x) | DETECT_BROKEN))

+

+void

+wc_create_detect_map(wc_ces ces, wc_bool esc)

+{

+ static wc_ces detect_ces = WC_CES_US_ASCII;

+ int i;

+

+ if (ces != detect_ces) {

+ if (ces & WC_CES_T_VIET) {

+ wc_uint8 *map = NULL;

+ switch (ces) {

+ case WC_CES_TCVN_5712:

+ map = wc_c0_tcvn57122_map;

+ break;

+ case WC_CES_VISCII_11:

+ map = wc_c0_viscii112_map;

+ break;

+ case WC_CES_VPS:

+ map = wc_c0_vps2_map;

+ break;

+ }

+ for (i = 0; i < 0x20; i++)

+ WC_DETECT_MAP[i] = map[i] ? 1 : 0;

+ } else {

+ for (i = 0; i < 0x20; i++)

+ WC_DETECT_MAP[i] = 0;

+ WC_DETECT_MAP[WC_C_HZ_TILDA] = (ces == WC_CES_HZ_GB_2312) ? 1 : 0;

+ WC_DETECT_MAP[WC_C_UTF7_PLUS] = (ces == WC_CES_UTF_7) ? 1 : 0;

+ }

+ detect_ces = ces;

+ }

+ WC_DETECT_MAP[WC_C_ESC] = (esc || (ces & WC_CES_T_ISO_2022)) ? 1 : 0;

+ return;

+}

+

+wc_ces

+wc_auto_detect(char *is, size_t len, wc_ces hint)

+{

+ wc_uchar *p = (wc_uchar *)is;

+ wc_uchar *ep = p + len;

+ wc_uchar *q;

+ wc_ces euc = 0, priv = 0;

+ wc_status st;

+ int euc_state = 0, sjis_state = 0, big5_state = 0, hz_state = 0;

+ int iso_detect = DETECT_ERROR, euc_detect = DETECT_ERROR,

+ sjis_detect = DETECT_ERROR, big5_detect = DETECT_ERROR,

+ hz_detect = DETECT_ERROR, latin_detect = DETECT_ERROR,

+ priv_detect = DETECT_ERROR;

+ int possible = 0;

+ wc_bool iso2022jp2 = WC_FALSE, iso2022jp3 = WC_FALSE,

+ iso2022cn = WC_FALSE, iso2022kr = WC_FALSE, ok = WC_FALSE;

+#ifdef USE_UNICODE

+ int utf8_state = 0;

+ int utf8_detect = DETECT_ERROR;

+ int utf8_next = 0;

+#endif

+

+ wc_create_detect_map(hint, WC_TRUE);

+ for (; p < ep && ! WC_DETECT_MAP[*p]; p++)

+ ;

+ if (p == ep)

+ return WC_CES_US_ASCII;

+

+ switch (hint) {

+ case WC_CES_ISO_2022_JP:

+ case WC_CES_ISO_2022_JP_2:

+ case WC_CES_ISO_2022_JP_3:

+ case WC_CES_EUC_JP:

+ case WC_CES_SHIFT_JIS:

+ case WC_CES_SHIFT_JISX0213:

+ euc = WC_CES_EUC_JP;

+ euc_state = WC_EUC_NOSTATE;

+ sjis_state = WC_SJIS_NOSTATE;

+ iso_detect = euc_detect = sjis_detect = DETECT_NORMAL;

+ possible = 3;

+ break;

+ case WC_CES_ISO_2022_CN:

+ case WC_CES_EUC_CN:

+ euc = WC_CES_EUC_CN;

+ euc_state = WC_EUC_NOSTATE;

+ big5_state = WC_BIG5_NOSTATE;

+ iso_detect = euc_detect = big5_detect = DETECT_NORMAL;

+ possible = 3;

+ break;

+ case WC_CES_EUC_TW:

+ case WC_CES_BIG5:

+ euc = WC_CES_EUC_TW;

+ euc_state = WC_EUC_NOSTATE;

+ big5_state = WC_BIG5_NOSTATE;

+ iso_detect = euc_detect = big5_detect = DETECT_NORMAL;

+ possible = 3;

+ break;

+ case WC_CES_HZ_GB_2312:

+ euc = WC_CES_EUC_CN;

+ euc_state = WC_EUC_NOSTATE;

+ hz_state = WC_HZ_NOSTATE;

+ iso_detect = euc_detect = big5_detect = hz_detect = DETECT_NORMAL;

+ possible = 4;

+ break;

+ case WC_CES_ISO_2022_KR:

+ case WC_CES_EUC_KR:

+ euc = WC_CES_EUC_KR;

+ euc_state = WC_EUC_NOSTATE;

+ iso_detect = euc_detect = DETECT_NORMAL;

+ possible = 3;

+ break;

+#ifdef USE_UNICODE

+ case WC_CES_UTF_8:

+ iso_detect = DETECT_NORMAL;

+ possible = 1;

+ break;

+#endif

+ case WC_CES_US_ASCII:

+ iso_detect = latin_detect = DETECT_NORMAL;

+ possible = 2;

+ break;

+ default:

+ if (hint & WC_CES_T_ISO_8859) {

+ iso_detect = latin_detect = DETECT_NORMAL;

+ possible = 2;

+ } else {

+ iso_detect = priv_detect = DETECT_NORMAL;

+ priv = hint; /* for TVCN, VISCII, VPS */

+ possible = 2;

+ }

+ break;

+ }

+#ifdef USE_UNICODE

+ if (priv_detect == DETECT_ERROR) {

+ utf8_detect = DETECT_NORMAL;

+ possible++;

+ }

+#endif

+

+ wc_input_init(WC_CES_US_ASCII, &st);

+

+ for (; p < ep; p++) {

+ if (possible == 0 || (possible == 1 && ok))

+ break;

+ if (iso_detect != DETECT_ERROR) {

+ switch (*p) {

+ case WC_C_ESC:

+ if (*(p+1) == WC_C_MBCS) {

+ q = p;

+ if (! wc_parse_iso2022_esc(&q, &st))

+ break;

+ if (st.design[0] == WC_CCS_JIS_C_6226 ||

+ st.design[0] == WC_CCS_JIS_X_0208)

+ ;

+ else if (st.design[0] == WC_CCS_JIS_X_0213_1 ||

+ st.design[0] == WC_CCS_JIS_X_0213_2)

+ iso2022jp3 = WC_TRUE;

+ else if (WC_CCS_TYPE(st.design[0]) == WC_CCS_A_CS94W)

+ iso2022jp2 = WC_TRUE;

+ if (st.design[1] == WC_CCS_KS_X_1001)

+ iso2022kr = WC_TRUE;

+ else if (st.design[1] == WC_CCS_GB_2312 ||

+ st.design[1] == WC_CCS_ISO_IR_165 ||

+ st.design[1] == WC_CCS_CNS_11643_1)

+ iso2022cn = WC_TRUE;

+ if (WC_CCS_TYPE(st.design[2]) == WC_CCS_A_CS94W ||

+ WC_CCS_TYPE(st.design[3]) == WC_CCS_A_CS94W)

+ iso2022cn = WC_TRUE;

+ } else if (*(p+1) == WC_C_G2_CS96) {

+ q = p;

+ if (! wc_parse_iso2022_esc(&q, &st))

+ break;

+ if (WC_CCS_TYPE(st.design[2]) == WC_CCS_A_CS96)

+ iso2022jp2 = WC_TRUE;

+ } else if (*(p+1) == WC_C_CSWSR) {

+ q = p;

+ if (! wc_parse_iso2022_esc(&q, &st))

+ break;

+ possible = 0;

+ iso_detect = DETECT_BROKEN;

+ continue;

+ }

+ iso_detect = DETECT_OK;

+ ok = WC_TRUE;

+ break;

+ case WC_C_SI:

+ case WC_C_SO:

+ iso_detect = DETECT_OK;

+ ok = WC_TRUE;

+ iso2022cn = WC_TRUE;

+ iso2022kr = WC_TRUE;

+ break;

+ default:

+ if (*p & 0x80) {

+ iso_detect = DETECT_ERROR;

+ possible--;

+ }

+ break;

+ }

+ }

+ if (euc_detect != DETECT_ERROR) {

+ switch (euc_state) {

+ case WC_EUC_NOSTATE:

+ switch (WC_ISO_MAP[*p]) {

+ case WC_ISO_MAP_GR:

+ euc_state = WC_EUC_MBYTE1;

+ break;

+ case WC_ISO_MAP_SS2:

+ if (euc == WC_CES_EUC_JP)

+ euc_state = WC_EUC_MBYTE1;

+ else if (euc == WC_CES_EUC_TW)

+ euc_state = WC_EUC_TW_SS2;

+ else

+ euc_detect = DETECT_ERROR;

+ break;

+ case WC_ISO_MAP_SS3:

+ if (euc == WC_CES_EUC_JP &&

+ WC_ISO_MAP[*(p+1)] == WC_ISO_MAP_GR)

+ ;

+ else

+ euc_detect = DETECT_ERROR;

+ break;

+ case WC_ISO_MAP_C1:

+ case WC_ISO_MAP_GR96:

+ euc_detect = DETECT_ERROR;

+ break;

+ }

+ break;

+ case WC_EUC_MBYTE1:

+ if (WC_ISO_MAP[*p] == WC_ISO_MAP_GR) {

+ SET_DETECT(euc_detect, DETECT_OK);

+ ok = WC_TRUE;

+ } else

+ SET_BROKEN_ERROR(euc_detect);

+ euc_state = WC_EUC_NOSTATE;

+ break;

+ case WC_EUC_TW_SS2:

+ if (!( 0xa0 <= *p && *p <= 0xb0) ||

+ WC_ISO_MAP[*(p+1)] != WC_ISO_MAP_GR)

+ euc_detect = DETECT_ERROR;

+ euc_state = WC_EUC_NOSTATE;

+ break;

+ }

+ if (euc_detect == DETECT_ERROR)

+ possible--;

+ }

+ if (sjis_detect != DETECT_ERROR) {

+ switch (sjis_state) {

+ case WC_SJIS_NOSTATE:

+ switch (WC_SJIS_MAP[*p]) {

+ case WC_SJIS_MAP_SL:

+ case WC_SJIS_MAP_SH:

+ sjis_state = WC_SJIS_SHIFT_L;

+ break;

+ case WC_SJIS_MAP_SK:

+ SET_DETECT(sjis_detect, DETECT_POSSIBLE);

+ break;

+ case WC_SJIS_MAP_SX:

+ if (WcOption.use_jisx0213) {

+ sjis_state = WC_SJIS_SHIFT_X;

+ break;

+ }

+ case WC_SJIS_MAP_80:

+ case WC_SJIS_MAP_A0:

+ case WC_SJIS_MAP_C1:

+ sjis_detect = DETECT_ERROR;

+ break;

+ }

+ break;

+ case WC_SJIS_SHIFT_L:

+ if (WC_SJIS_MAP[*p] & WC_SJIS_MAP_LB) {

+ SET_DETECT(sjis_detect, DETECT_OK);

+ ok = WC_TRUE;

+ } else

+ SET_BROKEN_ERROR(sjis_detect);

+ sjis_state = WC_SJIS_NOSTATE;

+ break;

+ case WC_SJIS_SHIFT_X:

+ if (WC_SJIS_MAP[*p] & WC_SJIS_MAP_LB)

+ SET_DETECT(sjis_detect, DETECT_POSSIBLE);

+ else

+ sjis_detect = DETECT_ERROR;

+ sjis_state = WC_SJIS_NOSTATE;

+ break;

+ }

+ if (sjis_detect == DETECT_ERROR)

+ possible--;

+ }

+ if (big5_detect != DETECT_ERROR) {

+ switch (big5_state) {

+ case WC_BIG5_NOSTATE:

+ switch (WC_BIG5_MAP[*p]) {

+ case WC_BIG5_MAP_UB:

+ big5_state = WC_BIG5_MBYTE1;

+ break;

+ case WC_BIG5_MAP_C1:

+ big5_detect = DETECT_ERROR;

+ break;

+ }

+ break;

+ case WC_BIG5_MBYTE1:

+ if (WC_BIG5_MAP[*p] & WC_BIG5_MAP_LB) {

+ SET_DETECT(big5_detect, DETECT_OK);

+ ok = WC_TRUE;

+ } else

+ SET_BROKEN_ERROR(big5_detect);

+ big5_state = WC_BIG5_NOSTATE;

+ break;

+ }

+ if (big5_detect == DETECT_ERROR)

+ possible--;

+ }

+ if (hz_detect != DETECT_ERROR) {

+ if (*p & 0x80) {

+ hz_detect = DETECT_ERROR;

+ possible--;

+ } else {

+ switch (hz_state) {

+ case WC_HZ_NOSTATE:

+ if (*p == WC_C_HZ_TILDA)

+ hz_state = WC_HZ_TILDA;

+ break;

+ case WC_HZ_TILDA:

+ if (*p == WC_C_HZ_SI)

+ hz_state = WC_HZ_MBYTE;

+ else

+ hz_state = WC_HZ_NOSTATE;

+ break;

+ case WC_HZ_TILDA_MB:

+ if (*p == WC_C_HZ_SO)

+ hz_state = WC_HZ_NOSTATE;

+ else

+ hz_state = WC_HZ_MBYTE;

+ break;

+ case WC_HZ_MBYTE:

+ if (*p == WC_C_HZ_TILDA)

+ hz_state = WC_HZ_TILDA_MB;

+ else

+ hz_state = WC_HZ_MBYTE1;

+ break;

+ case WC_HZ_MBYTE1:

+ hz_detect = DETECT_OK;

+ ok = WC_TRUE;

+ hz_state = WC_HZ_NOSTATE;

+ break;

+ }

+ }

+ }

+ if (latin_detect != DETECT_ERROR) {

+ switch (WC_ISO_MAP[*p] & WC_ISO_MAP_CG) {

+ case WC_ISO_MAP_GR:

+ case WC_ISO_MAP_GR96:

+ SET_DETECT(latin_detect, DETECT_OK);

+ ok = WC_TRUE;

+ break;

+ case WC_ISO_MAP_C1:

+ latin_detect = DETECT_ERROR;

+ break;

+ }

+ if (latin_detect == DETECT_ERROR)

+ possible--;

+ }

+ if (priv_detect != DETECT_ERROR) {

+ if (*p != WC_C_ESC && WC_DETECT_MAP[*p]) {

+ SET_DETECT(priv_detect, DETECT_OK);

+ ok = WC_TRUE;

+ }

+/*

+ if (priv_detect == DETECT_ERROR)

+ possible--;

+*/

+ }

+#ifdef USE_UNICODE

+ if (utf8_detect != DETECT_ERROR) {

+ switch (utf8_state) {

+ case WC_UTF8_NOSTATE:

+ switch (utf8_next = WC_UTF8_MAP[*p]) {

+ case 1:

+ case 8:

+ break;

+ case 0:

+ case 7:

+ utf8_detect = DETECT_ERROR;

+ break;

+ default:

+ utf8_next--;

+ utf8_state = WC_UTF8_NEXT;

+ break;

+ }

+ break;

+ case WC_UTF8_NEXT:

+ if (WC_UTF8_MAP[*p]) {

+ utf8_detect = DETECT_ERROR;

+ utf8_state = WC_UTF8_NOSTATE;

+ break;

+ }

+ utf8_next--;

+ if (! utf8_next) {

+ SET_DETECT(utf8_detect, DETECT_OK);

+ ok = WC_TRUE;

+ utf8_state = WC_UTF8_NOSTATE;

+ }

+ break;

+ }

+ if (utf8_detect == DETECT_ERROR)

+ possible--;

+ }

+#endif

+ }

+

+ if (iso_detect != DETECT_ERROR) {

+ if (iso_detect == DETECT_NORMAL) {

+ if (hz_detect == DETECT_OK)

+ return WC_CES_HZ_GB_2312;

+ if (priv_detect == DETECT_OK)

+ return priv;

+ return WC_CES_US_ASCII;

+ }

+ switch (euc) {

+ case WC_CES_EUC_CN:

+ case WC_CES_EUC_TW:

+ if (iso2022cn)

+ return WC_CES_ISO_2022_CN;

+ break;

+ case WC_CES_EUC_KR:

+ if (iso2022kr)

+ return WC_CES_ISO_2022_KR;

+ break;

+ }

+ if (iso2022jp3)

+ return WC_CES_ISO_2022_JP_3;

+ if (iso2022jp2)

+ return WC_CES_ISO_2022_JP_2;

+ if (iso2022cn)

+ return WC_CES_ISO_2022_CN;

+ if (iso2022kr)

+ return WC_CES_ISO_2022_KR;

+ return WC_CES_ISO_2022_JP;

+ }

+ switch (hint) {

+ case WC_CES_ISO_2022_JP:

+ case WC_CES_ISO_2022_JP_2:

+ case WC_CES_ISO_2022_JP_3:

+ case WC_CES_ISO_2022_KR:

+ case WC_CES_ISO_2022_CN:

+ break;

+ case WC_CES_EUC_JP:

+ case WC_CES_EUC_CN:

+ case WC_CES_EUC_TW:

+ case WC_CES_EUC_KR:

+ if (euc_detect != DETECT_ERROR)

+ return hint;

+ break;

+ case WC_CES_SHIFT_JIS:

+ case WC_CES_SHIFT_JISX0213:

+ if (sjis_detect != DETECT_ERROR)

+ return hint;

+ break;

+ case WC_CES_BIG5:

+ if (big5_detect != DETECT_ERROR)

+ return hint;

+ break;

+#ifdef USE_UNICODE

+ case WC_CES_UTF_8:

+ return hint;

+#endif

+ case WC_CES_US_ASCII:

+#ifdef USE_UNICODE

+ if (utf8_detect != DETECT_ERROR)

+ return hint;

+#endif

+ if (latin_detect != DETECT_ERROR)

+ return WC_CES_ISO_8859_1;

+ return hint;

+ default:

+ if (latin_detect != DETECT_ERROR)

+ return hint;

+ if (priv_detect != DETECT_ERROR)

+ return hint;

+#ifdef USE_UNICODE

+ if (utf8_detect != DETECT_ERROR)

+ return WC_CES_UTF_8;

+#endif

+ return hint;

+ }

+ if (euc_detect == DETECT_OK)

+ return euc;

+ if (sjis_detect == DETECT_OK)

+ return WC_CES_SHIFT_JIS;

+ if (big5_detect == DETECT_OK)

+ return WC_CES_BIG5;

+#ifdef USE_UNICODE

+ if (utf8_detect == DETECT_OK)

+ return WC_CES_UTF_8;

+ if (sjis_detect & DETECT_POSSIBLE)

+ return WC_CES_SHIFT_JIS;

+#endif

+ if (euc_detect != DETECT_ERROR)

+ return euc;

+ if (sjis_detect != DETECT_ERROR)

+ return WC_CES_SHIFT_JIS;

+ if (big5_detect != DETECT_ERROR)

+ return WC_CES_BIG5;

+#ifdef USE_UNICODE

+ if (utf8_detect != DETECT_ERROR)

+ return WC_CES_UTF_8;

+#endif

+ return hint;

+}

+

+#include "wc.h"

+#include "gb18030.h"

+#include "search.h"

+#include "wtf.h"

+#ifdef USE_UNICODE

+#include "ucs.h"

+#endif

+#include "map/gb18030_ucs.map"

+

+#define C0 WC_GB18030_MAP_C0

+#define GL WC_GB18030_MAP_GL

+#define C1 WC_GB18030_MAP_C1

+#define LB WC_GB18030_MAP_LB

+#define UB WC_GB18030_MAP_UB

+#define L4 WC_GB18030_MAP_L4

+

+wc_uint8 WC_GB18030_MAP[ 0x100 ] = {

+ C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0,

+ C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0,

+ GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL,

+ L4, L4, L4, L4, L4, L4, L4, L4, L4, L4, GL, GL, GL, GL, GL, GL,

+ LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB,

+ LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB,

+ LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB,

+ LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, C0,

+

+ LB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB,

+ UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB,

+ UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB,

+ UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB,

+ UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB,

+ UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB,

+ UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB,

+ UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, C1,

+};

+

+wc_wchar_t

+wc_gbk_ext_to_cs128w(wc_wchar_t cc)

+{

+ cc.code = WC_GBK_N(cc.code);

+ if (cc.code < 0x4000)

+ cc.ccs = WC_CCS_GBK_EXT_1;

+ else {

+ cc.ccs = WC_CCS_GBK_EXT_2;

+ cc.code -= 0x4000;

+ }

+ cc.code = WC_N_CS128W(cc.code);

+ return cc;

+}

+

+wc_wchar_t

+wc_cs128w_to_gbk_ext(wc_wchar_t cc)

+{

+ cc.code = WC_CS128W_N(cc.code);

+ if (cc.ccs == WC_CCS_GBK_EXT_2)

+ cc.code += 0x4000;

+ cc.ccs = WC_CCS_GBK_EXT;

+ cc.code = WC_N_GBK(cc.code);

+ return cc;

+}

+

+static wc_ccs

+wc_gbk_or_gbk_ext(wc_uint16 code) {

+ return wc_map3_range_search(code,

+ gbk_ext_ucs_map, N_gbk_ext_ucs_map)

+ ? WC_CCS_GBK_EXT : WC_CCS_GBK;

+}

+

+#ifdef USE_UNICODE

+wc_uint32

+wc_gb18030_to_ucs(wc_wchar_t cc)

+{

+ wc_map3 *map;

+

+ switch (WC_CCS_SET(cc.ccs)) {

+ case WC_CCS_GBK_EXT_1:

+ case WC_CCS_GBK_EXT_2:

+ cc = wc_cs128w_to_gbk_ext(cc);

+ case WC_CCS_GBK_EXT:

+ map = wc_map3_range_search((wc_uint16)cc.code,

+ gbk_ext_ucs_map, N_gbk_ext_ucs_map);

+ if (map)

+ return map->code3 + WC_GBK_N(cc.code) - WC_GBK_N(map->code2);

+ return WC_C_UCS4_ERROR;

+ case WC_CCS_GB18030:

+ break;

+ default:

+ return wc_any_to_ucs(cc);

+ }

+ if (cc.code >= WC_C_GB18030_UCS2 && cc.code <= WC_C_GB18030_UCS2_END) {

+ int i, min = 0, max = N_ucs_gb18030_map - 1;

+

+ cc.code = WC_GB18030_N(cc.code) - WC_GB18030_N(WC_C_GB18030_UCS2);

+ if (cc.code >= ucs_gb18030_map[max].code3)

+ i = max;

+ else {

+ while(1) {

+ i = (min + max) / 2;

+ if (min == max)

+ break;

+ if (cc.code < ucs_gb18030_map[i].code3)

+ max = i - 1;

+ else if (cc.code >= ucs_gb18030_map[i+1].code3)

+ min = i + 1;

+ else

+ break;

+ }

+ }

+ return ucs_gb18030_map[i].code + cc.code - ucs_gb18030_map[i].code3;

+ }

+ if (cc.code >= WC_C_GB18030_UCS4 && cc.code <= WC_C_GB18030_UCS4_END)

+ return WC_GB18030_N(cc.code) - WC_GB18030_N(WC_C_GB18030_UCS4)

+ + 0x10000;

+ return WC_C_UCS4_ERROR;

+}

+

+wc_wchar_t

+wc_ucs_to_gb18030(wc_uint32 ucs)

+{

+ wc_wchar_t cc;

+ wc_map3 *map;

+

+ if (ucs <= WC_C_UCS2_END) {

+ map = wc_map3_range_search((wc_uint16)ucs,

+ ucs_gbk_ext_map, N_ucs_gbk_ext_map);

+ if (map) {

+ cc.code = WC_GBK_N(map->code3) + ucs - map->code;

+ cc.code = WC_N_GBK(cc.code);

+ cc.ccs = WC_CCS_GBK_EXT;

+ return cc;

+ }

+ map = wc_map3_range_search((wc_uint16)ucs,

+ ucs_gb18030_map, N_ucs_gb18030_map);

+ if (map) {

+ cc.code = map->code3 + ucs - map->code + WC_GB18030_N(WC_C_GB18030_UCS2);

+ cc.code = WC_N_GB18030(cc.code);

+ if (WcOption.gb18030_as_ucs)

+ cc.ccs = WC_CCS_GB18030 | (wc_ucs_to_ccs(ucs) & ~WC_CCS_A_SET);

+ else

+ cc.ccs = WC_CCS_GB18030_W;

+ return cc;

+ }

+ } else if (ucs <= WC_C_UNICODE_END) {

+ cc.code = ucs - 0x10000 + WC_GB18030_N(WC_C_GB18030_UCS4);

+ cc.code = WC_N_GB18030(cc.code);

+ if (WcOption.gb18030_as_ucs)

+ cc.ccs = WC_CCS_GB18030 | (wc_ucs_to_ccs(ucs) & ~WC_CCS_A_SET);

+ else

+ cc.ccs = WC_CCS_GB18030_W;

+ return cc;

+ }

+ cc.ccs = WC_CCS_UNKNOWN;

+ return cc;

+}

+#endif

+

+Str

+wc_conv_from_gb18030(Str is, wc_ces ces)

+{

+ Str os;

+ wc_uchar *sp = (wc_uchar *)is->ptr;

+ wc_uchar *ep = sp + is->length;

+ wc_uchar *p;

+ int state = WC_GB18030_NOSTATE;

+ wc_uint32 gbk;

+ wc_wchar_t cc;

+#ifdef USE_UNICODE

+ wc_uint32 ucs;

+#endif

+

+ for (p = sp; p < ep && *p < 0x80; p++)

+ ;

+ if (p == ep)

+ return is;

+ os = Strnew_size(is->length);

+ if (p > sp)

+ Strcat_charp_n(os, (char *)is->ptr, (int)(p - sp));

+

+ for (; p < ep; p++) {

+ switch (state) {

+ case WC_GB18030_NOSTATE:

+ switch (WC_GB18030_MAP[*p]) {

+ case UB:

+ state = WC_GB18030_MBYTE1;

+ break;

+ case C1:

+ wtf_push_unknown(os, p, 1);

+ break;

+ default:

+ Strcat_char(os, (char)*p);

+ break;

+ }

+ break;

+ case WC_GB18030_MBYTE1:

+ if (WC_GB18030_MAP[*p] & LB) {

+ gbk = ((wc_uint32)*(p-1) << 8) | *p;

+ if (wc_gbk_or_gbk_ext(gbk) == WC_CCS_GBK_EXT)

+ wtf_push(os, WC_CCS_GBK_EXT, gbk);

+ else if (*(p-1) >= 0xA1 && *p >= 0xA1)

+ wtf_push(os, wc_gb2312_or_gbk(gbk), gbk);

+ else

+ wtf_push(os, WC_CCS_GBK, gbk);

+ } else if (WC_GB18030_MAP[*p] == L4) {

+ state = WC_GB18030_MBYTE2;

+ break;

+ } else

+ wtf_push_unknown(os, p-1, 2);

+ state = WC_GB18030_NOSTATE;

+ break;

+ case WC_GB18030_MBYTE2:

+ if (WC_GB18030_MAP[*p] == UB) {

+ state = WC_GB18030_MBYTE3;

+ break;

+ } else

+ wtf_push_unknown(os, p-2, 3);

+ state = WC_GB18030_NOSTATE;

+ break;

+ case WC_GB18030_MBYTE3:

+ if (WC_GB18030_MAP[*p] == L4) {

+ cc.ccs = WC_CCS_GB18030_W;

+ cc.code = ((wc_uint32)*(p-3) << 24)

+ | ((wc_uint32)*(p-2) << 16)

+ | ((wc_uint32)*(p-1) << 8)

+ | *p;

+#ifdef USE_UNICODE

+ if (WcOption.gb18030_as_ucs &&

+ (ucs = wc_gb18030_to_ucs(cc)) != WC_C_UCS4_ERROR)

+ wtf_push(os, WC_CCS_GB18030 | (wc_ucs_to_ccs(ucs) & ~WC_CCS_A_SET), cc.code);

+ else

+#endif

+ wtf_push(os, cc.ccs, cc.code);

+ } else

+ wtf_push_unknown(os, p-3, 4);

+ state = WC_GB18030_NOSTATE;

+ break;

+ }

+ }

+ switch (state) {

+ case WC_GB18030_MBYTE1:

+ wtf_push_unknown(os, p-1, 1);

+ break;

+ case WC_GB18030_MBYTE2:

+ wtf_push_unknown(os, p-2, 2);

+ break;

+ case WC_GB18030_MBYTE3:

+ wtf_push_unknown(os, p-3, 3);

+ break;

+ }

+ return os;

+}

+

+void

+wc_push_to_gb18030(Str os, wc_wchar_t cc, wc_status *st)

+{

+ while (1) {

+ switch (WC_CCS_SET(cc.ccs)) {

+ case WC_CCS_US_ASCII:

+ Strcat_char(os, (char)cc.code);

+ return;

+ case WC_CCS_GB_2312:

+ Strcat_char(os, (char)((cc.code >> 8) | 0x80));

+ Strcat_char(os, (char)((cc.code & 0xff) | 0x80));

+ return;

+ case WC_CCS_GBK_1:

+ case WC_CCS_GBK_2:

+ cc = wc_cs128w_to_gbk(cc);

+ case WC_CCS_GBK:

+ Strcat_char(os, (char)(cc.code >> 8));

+ Strcat_char(os, (char)(cc.code & 0xff));

+ return;

+ case WC_CCS_GBK_EXT_1:

+ case WC_CCS_GBK_EXT_2:

+ cc = wc_cs128w_to_gbk(cc);

+ case WC_CCS_GBK_EXT:

+ Strcat_char(os, (char)(cc.code >> 8));

+ Strcat_char(os, (char)(cc.code & 0xff));

+ return;

+ case WC_CCS_GB18030:

+ Strcat_char(os, (char)((cc.code >> 24) & 0xff));

+ Strcat_char(os, (char)((cc.code >> 16) & 0xff));

+ Strcat_char(os, (char)((cc.code >> 8) & 0xff));

+ Strcat_char(os, (char)(cc.code & 0xff));

+ return;

+ case WC_CCS_UNKNOWN_W:

+ if (!WcOption.no_replace)

+ Strcat_charp(os, WC_REPLACE_W);

+ return;

+ case WC_CCS_UNKNOWN:

+ if (!WcOption.no_replace)

+ Strcat_charp(os, WC_REPLACE);

+ return;

+ default:

+#ifdef USE_UNICODE

+ if (WcOption.ucs_conv)

+ cc = wc_any_to_any_ces(cc, st);

+ else

+#endif

+ cc.ccs = WC_CCS_IS_WIDE(cc.ccs) ? WC_CCS_UNKNOWN_W : WC_CCS_UNKNOWN;

+ continue;

+ }

+ }

+}

+

+Str

+wc_char_conv_from_gb18030(wc_uchar c, wc_status *st)

+{

+ static Str os;

+ static wc_uchar gb[4];

+ wc_uint32 gbk;

+ wc_wchar_t cc;

+#ifdef USE_UNICODE

+ wc_uint32 ucs;

+#endif

+

+ if (st->state == -1) {

+ st->state = WC_GB18030_NOSTATE;

+ os = Strnew_size(8);

+ }

+

+ switch (st->state) {

+ case WC_GB18030_NOSTATE:

+ switch (WC_GB18030_MAP[c]) {

+ case UB:

+ gb[0] = c;

+ st->state = WC_GB18030_MBYTE1;

+ return NULL;

+ case C1:

+ break;

+ default:

+ Strcat_char(os, (char)c);

+ break;

+ }

+ break;

+ case WC_GB18030_MBYTE1:

+ if (WC_GB18030_MAP[c] & LB) {

+ gbk = ((wc_uint32)gb[0] << 8) | c;

+ if (wc_gbk_or_gbk_ext(gbk) == WC_CCS_GBK_EXT)

+ wtf_push(os, WC_CCS_GBK_EXT, gbk);

+ else if (gb[0] >= 0xA1 && c >= 0xA1)

+ wtf_push(os, wc_gb2312_or_gbk(gbk), gbk);

+ else

+ wtf_push(os, WC_CCS_GBK, gbk);

+ } else if (WC_GB18030_MAP[c] == L4) {

+ gb[1] = c;

+ st->state = WC_GB18030_MBYTE2;

+ return NULL;

+ }

+ break;

+ case WC_GB18030_MBYTE2:

+ if (WC_GB18030_MAP[c] == UB) {

+ gb[2] = c;

+ st->state = WC_GB18030_MBYTE3;

+ return NULL;

+ }

+ break;

+ case WC_GB18030_MBYTE3:

+ if (WC_GB18030_MAP[c] == L4) {

+ cc.ccs = WC_CCS_GB18030_W;

+ cc.code = ((wc_uint32)gb[0] << 24)

+ | ((wc_uint32)gb[1] << 16)

+ | ((wc_uint32)gb[2] << 8)

+ | c;

+#ifdef USE_UNICODE

+ if (WcOption.gb18030_as_ucs &&

+ (ucs = wc_gb18030_to_ucs(cc)) != WC_C_UCS4_ERROR)

+ wtf_push(os, WC_CCS_GB18030 | (wc_ucs_to_ccs(ucs) & ~WC_CCS_A_SET), cc.code);

+ else

+#endif

+ wtf_push(os, cc.ccs, cc.code);

+ }

+ break;

+ }

+ st->state = -1;

+ return os;

+}

+

+#ifndef _WC_GB18030_H

+#define _WC_GB18030_H

+

+#include "gbk.h"

+

+#define WC_C_GB18030_UCS2 0x81308130U

+#define WC_C_GB18030_UCS2_END 0x8431A439U

+#define WC_C_GB18030_UCS4 0x90308130U

+#define WC_C_GB18030_UCS4_END 0xE3329A35U

+

+#define WC_GB18030_NOSTATE 0

+#define WC_GB18030_MBYTE1 1 /* 0x81 - 0xA0, 0xA1 - 0xFE */

+#define WC_GB18030_MBYTE2 2 /* 0x30 - 0x39 */

+#define WC_GB18030_MBYTE3 3 /* 0x81 - 0xA0, 0xA1 - 0xFE */

+

+#define WC_GB18030_MAP_C0 0x0

+#define WC_GB18030_MAP_GL 0x1

+#define WC_GB18030_MAP_C1 0x2

+#define WC_GB18030_MAP_LB 0x4

+#define WC_GB18030_MAP_UB (0x8 | WC_GB18030_MAP_LB)

+#define WC_GB18030_MAP_L4 0x10

+

+#define WC_GB18030_N(c) \

+ (((((((c) >> 24) & 0xff) - 0x81) * 0x0A \

+ + (((c) >> 16) & 0xff) - 0x30) * 0x7E \

+ + (((c) >> 8) & 0xff) - 0x81) * 0x0A \

+ + ( (c) & 0xff) - 0x30)

+#define WC_N_GB18030(c) \

+ ((((c) / 0x0A / 0x7E / 0xA + 0x81) << 24) \

+ + (((c) / 0x0A / 0x7E % 0xA + 0x30) << 16) \

+ + (((c) / 0x0A % 0x7E + 0x81) << 8) \

+ + (c) % 0xA + 0x30 )

+

+extern wc_uchar WC_GB18030_MAP[];

+

+extern wc_wchar_t wc_gbk_ext_to_cs128w(wc_wchar_t cc);

+extern wc_wchar_t wc_cs128w_to_gbk_ext(wc_wchar_t cc);

+#ifdef USE_UNICODE

+extern wc_uint32 wc_gb18030_to_ucs(wc_wchar_t cc);

+extern wc_wchar_t wc_ucs_to_gb18030(wc_uint32 ucs);

+#endif

+extern Str wc_conv_from_gb18030(Str is, wc_ces ces);

+extern void wc_push_to_gb18030(Str os, wc_wchar_t cc, wc_status *st);

+extern Str wc_char_conv_from_gb18030(wc_uchar c, wc_status *st);

+

+#endif

+

+#include "wc.h"

+#include "gbk.h"

+#include "search.h"

+#include "wtf.h"

+#ifdef USE_UNICODE

+#include "ucs.h"

+#endif

+

+#include "map/gb2312_gbk.map"

+

+#define C0 WC_GBK_MAP_C0

+#define GL WC_GBK_MAP_GL

+#define C1 WC_GBK_MAP_C1

+#define LB WC_GBK_MAP_LB

+#define UB WC_GBK_MAP_UB

+#define C80 WC_GBK_MAP_80

+

+wc_uint8 WC_GBK_MAP[ 0x100 ] = {

+ C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0,

+ C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0,

+ GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL,

+ GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL,

+ LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB,

+ LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB,

+ LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB,

+ LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, C0,

+

+ C80,UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB,

+ UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB,

+ UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB,

+ UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB,

+ UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB,

+ UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB,

+ UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB,

+ UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, C1,

+};

+

+wc_ccs

+wc_gb2312_or_gbk(wc_uint16 code) {

+ return wc_map_range_search(code,

+ gb2312_gbk_map, N_gb2312_gbk_map)

+ ? WC_CCS_GBK : WC_CCS_GB_2312;

+}

+

+wc_wchar_t

+wc_gbk_to_cs128w(wc_wchar_t cc)

+{

+ cc.code = WC_GBK_N(cc.code);

+ if (cc.code < 0x4000)

+ cc.ccs = WC_CCS_GBK_1;

+ else {

+ cc.ccs = WC_CCS_GBK_2;

+ cc.code -= 0x4000;

+ }

+ cc.code = WC_N_CS128W(cc.code);

+ return cc;

+}

+

+wc_wchar_t

+wc_cs128w_to_gbk(wc_wchar_t cc)

+{

+ cc.code = WC_CS128W_N(cc.code);

+ if (cc.ccs == WC_CCS_GBK_2)

+ cc.code += 0x4000;

+ cc.ccs = WC_CCS_GBK;

+ cc.code = WC_N_GBK(cc.code);

+ return cc;

+}

+

+wc_uint32

+wc_gbk_to_N(wc_uint32 c)

+{

+ if (c <= 0xA1A0) /* 0x8140 - 0xA1A0 */

+ return WC_GBK_N(c);

+ if (c <= 0xA2AA) /* 0xA240 - 0xA2A0, 0xA2A1 - 0xA2AA */

+ return WC_GBK_N(c) - ((c >> 8) - 0xA1) * 0x5E;

+ if (c <= 0xA6A0) /* 0xA240 - 0xA6A0 */

+ return WC_GBK_N(c) - ((c >> 8) - 0xA1) * 0x5E + 0x0A;

+ if (c <= 0xA6F5) /* 0xA6E0 - 0xA6F5 */

+ return WC_GBK_N(c) - ((c >> 8) - 0xA1) * 0x5E + 0x0A - 0x3F;

+ if (c <= 0xA8A0) /* 0xA7A0 - 0xA8A0 */

+ return WC_GBK_N(c) - ((c >> 8) - 0xA1) * 0x5E + 0x0A + 0x16;

+ if (c <= 0xA8C0) /* 0xA8BB - 0xA8C0 */

+ return WC_GBK_N(c) - ((c >> 8) - 0xA1) * 0x5E + 0x0A + 0x16 - 0x1A;

+ /* 0xA940 - 0xFEA0 */

+ return WC_GBK_N(c) - ((c >> 8) - 0xA1) * 0x5E + 0x0A + 0x16 + 0x06;

+}

+

+Str

+wc_conv_from_gbk(Str is, wc_ces ces)

+{

+ Str os;

+ wc_uchar *sp = (wc_uchar *)is->ptr;

+ wc_uchar *ep = sp + is->length;

+ wc_uchar *p;

+ int state = WC_GBK_NOSTATE;

+ wc_uint32 gbk;

+

+ for (p = sp; p < ep && *p < 0x80; p++)

+ ;

+ if (p == ep)

+ return is;

+ os = Strnew_size(is->length);

+ if (p > sp)

+ Strcat_charp_n(os, (char *)is->ptr, (int)(p - sp));

+

+ for (; p < ep; p++) {

+ switch (state) {

+ case WC_GBK_NOSTATE:

+ switch (WC_GBK_MAP[*p]) {

+ case UB:

+ state = WC_GBK_MBYTE1;

+ break;

+ case C80:

+ wtf_push(os, WC_CCS_GBK_80, *p);

+ break;

+ case C1:

+ wtf_push_unknown(os, p, 1);

+ break;

+ default:

+ Strcat_char(os, (char)*p);

+ break;

+ }

+ break;

+ case WC_GBK_MBYTE1:

+ if (WC_GBK_MAP[*p] & LB) {

+ gbk = ((wc_uint32)*(p-1) << 8) | *p;

+ if (*(p-1) >= 0xA1 && *p >= 0xA1)

+ wtf_push(os, wc_gb2312_or_gbk(gbk), gbk);

+ else

+ wtf_push(os, WC_CCS_GBK, gbk);

+ } else

+ wtf_push_unknown(os, p-1, 2);

+ state = WC_GBK_NOSTATE;

+ break;

+ }

+ }

+ switch (state) {

+ case WC_GBK_MBYTE1:

+ wtf_push_unknown(os, p-1, 1);

+ break;

+ }

+ return os;

+}

+

+void

+wc_push_to_gbk(Str os, wc_wchar_t cc, wc_status *st)

+{

+ while (1) {

+ switch (cc.ccs) {

+ case WC_CCS_US_ASCII:

+ Strcat_char(os, (char)cc.code);

+ return;

+ case WC_CCS_GB_2312:

+ Strcat_char(os, (char)((cc.code >> 8) | 0x80));

+ Strcat_char(os, (char)((cc.code & 0xff) | 0x80));

+ return;

+ case WC_CCS_GBK_80:

+ Strcat_char(os, (char)(cc.code | 0x80));

+ return;

+ case WC_CCS_GBK_1:

+ case WC_CCS_GBK_2:

+ cc = wc_cs128w_to_gbk(cc);

+ case WC_CCS_GBK:

+ Strcat_char(os, (char)(cc.code >> 8));

+ Strcat_char(os, (char)(cc.code & 0xff));

+ return;

+ case WC_CCS_UNKNOWN_W:

+ if (!WcOption.no_replace)

+ Strcat_charp(os, WC_REPLACE_W);

+ return;

+ case WC_CCS_UNKNOWN:

+ if (!WcOption.no_replace)

+ Strcat_charp(os, WC_REPLACE);

+ return;

+ default:

+#ifdef USE_UNICODE

+ if (WcOption.ucs_conv)

+ cc = wc_any_to_any_ces(cc, st);

+ else

+#endif

+ cc.ccs = WC_CCS_IS_WIDE(cc.ccs) ? WC_CCS_UNKNOWN_W : WC_CCS_UNKNOWN;

+ continue;

+ }

+ }

+}

+

+Str

+wc_char_conv_from_gbk(wc_uchar c, wc_status *st)

+{

+ static Str os;

+ static wc_uchar gbku;

+ wc_uint32 gbk;

+

+ if (st->state == -1) {

+ st->state = WC_GBK_NOSTATE;

+ os = Strnew_size(8);

+ }

+

+ switch (st->state) {

+ case WC_GBK_NOSTATE:

+ switch (WC_GBK_MAP[c]) {

+ case UB:

+ gbku = c;

+ st->state = WC_GBK_MBYTE1;

+ return NULL;

+ case C80:

+ wtf_push(os, WC_CCS_GBK_80, c);

+ break;

+ case C1:

+ break;

+ default:

+ Strcat_char(os, (char)c);

+ break;

+ }

+ break;

+ case WC_GBK_MBYTE1:

+ if (WC_GBK_MAP[c] & LB) {

+ gbk = ((wc_uint32)gbku << 8) | c;

+ if (gbku >= 0xA1 && c >= 0xA1)

+ wtf_push(os, wc_gb2312_or_gbk(gbk), gbk);

+ else

+ wtf_push(os, WC_CCS_GBK, gbk);

+ }

+ break;

+ }

+ st->state = -1;

+ return os;

+}

+

+#ifndef _WC_GBK_H

+#define _WC_GBK_H

+

+#define WC_GBK_NOSTATE 0

+#define WC_GBK_MBYTE1 1 /* 0x81 - 0xA0, 0xA1 - 0xFE */

+

+#define WC_GBK_MAP_C0 0x0

+#define WC_GBK_MAP_GL 0x1

+#define WC_GBK_MAP_C1 0x2

+#define WC_GBK_MAP_LB 0x4

+#define WC_GBK_MAP_UB (0x8 | WC_GBK_MAP_LB)

+#define WC_GBK_MAP_80 (0x10 | WC_GBK_MAP_LB)

+

+#define WC_GBKUL_N(U,L) (((U) - 0x81) * 0xBE + (L) - (((L) < 0x80) ? 0x40 : 0x41))

+#define WC_GBK_N(c) WC_GBKUL_N(((c) >> 8) & 0xFF, (c) & 0xFF)

+#define WC_N_GBKU(c) ((c) / 0xBE + 0x81)

+#define WC_N_GBKL(c) ((c) % 0xBE + (((c) % 0xBE < 0x3F) ? 0x40 : 0x41))

+#define WC_N_GBK(c) ((WC_N_GBKU(c) << 8) + WC_N_GBKL(c))

+#ifndef WC_CS128W_N

+#define WC_CS128WUL_N(U,L) ((U) * 0x80 + (L))

+#define WC_CS128W_N(c) WC_CS128WUL_N(((c) >> 8) & 0x7F, (c) & 0x7F)

+#define WC_N_CS128WU(c) ((c) / 0x80)

+#define WC_N_CS128WL(c) ((c) % 0x80)

+#define WC_N_CS128W(c) ((WC_N_CS128WU(c) << 8) + WC_N_CS128WL(c))

+#endif

+

+extern wc_uchar WC_GBK_MAP[];

+

+extern wc_ccs wc_gb2312_or_gbk(wc_uint16 code);

+extern wc_wchar_t wc_gbk_to_cs128w(wc_wchar_t cc);

+extern wc_wchar_t wc_cs128w_to_gbk(wc_wchar_t cc);

+extern wc_uint32 wc_gbk_to_N(wc_uint32 c);

+extern Str wc_conv_from_gbk(Str is, wc_ces ces);

+extern void wc_push_to_gbk(Str os, wc_wchar_t cc, wc_status *st);

+extern Str wc_char_conv_from_gbk(wc_uchar c, wc_status *st);

+

+#endif

+

+#include "wc.h"

+#include "big5.h"

+#include "hkscs.h"

+#include "search.h"

+#include "wtf.h"

+#ifdef USE_UNICODE

+#include "ucs.h"

+#endif

+

+#define C0 WC_HKSCS_MAP_C0

+#define GL WC_HKSCS_MAP_GL

+#define C1 WC_HKSCS_MAP_C1

+#define LB WC_HKSCS_MAP_LB

+#define UB WC_HKSCS_MAP_UB

+#define UH WC_HKSCS_MAP_UH

+

+wc_uint8 WC_HKSCS_MAP[ 0x100 ] = {

+ C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0,

+ C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0,

+ GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL,

+ GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL,

+ LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB,

+ LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB,

+ LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB,

+ LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, C0,

+

+ C1, C1, C1, C1, C1, C1, C1, C1, UH, UH, UH, UH, UH, UH, UH, UH,

+ UH, UH, UH, UH, UH, UH, UH, UH, UH, UH, UH, UH, UH, UH, UH, UH,

+ UH, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB,

+ UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB,

+ UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB,

+ UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB,

+ UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB,

+ UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, C1,

+};

+

+wc_wchar_t

+wc_hkscs_to_cs128w(wc_wchar_t cc)

+{

+ cc.code = WC_HKSCS_N(cc.code);

+ if (cc.code < 0x4000)

+ cc.ccs = WC_CCS_HKSCS_1;

+ else {

+ cc.ccs = WC_CCS_HKSCS_2;

+ cc.code -= 0x4000;

+ }

+ cc.code = WC_N_CS128W(cc.code);

+ return cc;

+}

+

+wc_wchar_t

+wc_cs128w_to_hkscs(wc_wchar_t cc)

+{

+ cc.code = WC_CS128W_N(cc.code);

+ if (cc.ccs == WC_CCS_HKSCS_2)

+ cc.code += 0x4000;

+ cc.ccs = WC_CCS_HKSCS;

+ cc.code = WC_N_HKSCS(cc.code);

+ return cc;

+}

+

+wc_uint32

+wc_hkscs_to_N(wc_uint32 c)

+{

+ if (c < 0xA140) /* 0x8840 - 0xA0FE */

+ return WC_HKSCS_N(c);

+ /* 0xFA40 - 0xFEFE */

+ return WC_HKSCS_N(c) - 0x59 * 0x9D;

+}

+

+Str

+wc_conv_from_hkscs(Str is, wc_ces ces)

+{

+ Str os;

+ wc_uchar *sp = (wc_uchar *)is->ptr;

+ wc_uchar *ep = sp + is->length;

+ wc_uchar *p;

+ int state = WC_HKSCS_NOSTATE;

+ wc_uint32 hkscs;

+

+ for (p = sp; p < ep && *p < 0x80; p++)

+ ;

+ if (p == ep)

+ return is;

+ os = Strnew_size(is->length);

+ if (p > sp)

+ Strcat_charp_n(os, (char *)is->ptr, (int)(p - sp));

+

+ for (; p < ep; p++) {

+ switch (state) {

+ case WC_HKSCS_NOSTATE:

+ switch (WC_HKSCS_MAP[*p]) {

+ case UB:

+ case UH:

+ state = WC_HKSCS_MBYTE1;

+ break;

+ case C1:

+ wtf_push_unknown(os, p, 1);

+ break;

+ default:

+ Strcat_char(os, (char)*p);

+ break;

+ }

+ break;

+ case WC_HKSCS_MBYTE1:

+ if (WC_HKSCS_MAP[*p] & LB) {

+ hkscs = ((wc_uint32)*(p-1) << 8) | *p;

+ if (*(p-1) >= 0xA1 && *(p-1) <= 0xF9)

+ wtf_push(os, WC_CCS_BIG5, hkscs);

+ else

+ wtf_push(os, WC_CCS_HKSCS, hkscs);

+ } else

+ wtf_push_unknown(os, p-1, 2);

+ state = WC_HKSCS_NOSTATE;

+ break;

+ }

+ }

+ switch (state) {

+ case WC_HKSCS_MBYTE1:

+ wtf_push_unknown(os, p-1, 1);

+ break;

+ }

+ return os;

+}

+

+void

+wc_push_to_hkscs(Str os, wc_wchar_t cc, wc_status *st)

+{

+ while (1) {

+ switch (cc.ccs) {

+ case WC_CCS_US_ASCII:

+ Strcat_char(os, (char)cc.code);

+ return;

+ case WC_CCS_BIG5_1:

+ case WC_CCS_BIG5_2:

+ cc = wc_cs94w_to_big5(cc);

+ case WC_CCS_BIG5:

+ Strcat_char(os, (char)(cc.code >> 8));

+ Strcat_char(os, (char)(cc.code & 0xff));

+ return;

+ case WC_CCS_HKSCS_1:

+ case WC_CCS_HKSCS_2:

+ cc = wc_cs128w_to_hkscs(cc);

+ case WC_CCS_HKSCS:

+ Strcat_char(os, (char)(cc.code >> 8));

+ Strcat_char(os, (char)(cc.code & 0xff));

+ return;

+ case WC_CCS_UNKNOWN_W:

+ if (!WcOption.no_replace)

+ Strcat_charp(os, WC_REPLACE_W);

+ return;

+ case WC_CCS_UNKNOWN:

+ if (!WcOption.no_replace)

+ Strcat_charp(os, WC_REPLACE);

+ return;

+ default:

+#ifdef USE_UNICODE

+ if (WcOption.ucs_conv)

+ cc = wc_any_to_any_ces(cc, st);

+ else

+#endif

+ cc.ccs = WC_CCS_IS_WIDE(cc.ccs) ? WC_CCS_UNKNOWN_W : WC_CCS_UNKNOWN;

+ continue;

+ }

+ }

+}

+

+Str

+wc_char_conv_from_hkscs(wc_uchar c, wc_status *st)

+{

+ static Str os;

+ static wc_uchar hkscsu;

+ wc_uint32 hkscs;

+

+ if (st->state == -1) {

+ st->state = WC_HKSCS_NOSTATE;

+ os = Strnew_size(8);

+ }

+

+ switch (st->state) {

+ case WC_HKSCS_NOSTATE:

+ switch (WC_HKSCS_MAP[c]) {

+ case UB:

+ case UH:

+ hkscsu = c;

+ st->state = WC_HKSCS_MBYTE1;

+ return NULL;

+ case C1:

+ break;

+ default:

+ Strcat_char(os, (char)c);

+ break;

+ }

+ break;

+ case WC_HKSCS_MBYTE1:

+ if (WC_HKSCS_MAP[c] & LB) {

+ hkscs = ((wc_uint32)hkscsu << 8) | c;

+ if (hkscsu >= 0xA1 && hkscsu <= 0xF9 && c >= 0xA1)

+ wtf_push(os, WC_CCS_BIG5, hkscs);

+ else

+ wtf_push(os, WC_CCS_HKSCS, hkscs);

+ }

+ break;

+ }

+ st->state = -1;

+ return os;

+}

+

+#ifndef _WC_HKSCS_H

+#define _WC_HKSCS_H

+

+#define WC_HKSCS_NOSTATE 0

+#define WC_HKSCS_MBYTE1 1 /* 0x88 - 0xFE */

+

+#define WC_HKSCS_MAP_C0 0x0

+#define WC_HKSCS_MAP_GL 0x1

+#define WC_HKSCS_MAP_C1 0x2

+#define WC_HKSCS_MAP_LB 0x4

+#define WC_HKSCS_MAP_UB (0x8 | WC_HKSCS_MAP_LB)

+#define WC_HKSCS_MAP_UH 0x10

+

+#define WC_HKSCSUL_N(U,L) (((U) - 0x88) * 0x9D \

+ + (L) - (((L) < 0xA1) ? 0x40 : 0x62))

+#define WC_HKSCS_N(c) WC_HKSCSUL_N(((c) >> 8) & 0xFF, (c) & 0xFF)

+#define WC_N_HKSCSU(c) ((c) / 0x9D + 0x88)

+#define WC_N_HKSCSL(c) ((c) % 0x9D + (((c) % 0x9D < 0x3F) ? 0x40 : 0x62))

+#define WC_N_HKSCS(c) ((WC_N_HKSCSU(c) << 8) + WC_N_HKSCSL(c))

+#ifndef WC_CS128W_N

+#define WC_CS128WUL_N(U,L) ((U) * 0x80 + (L))

+#define WC_CS128W_N(c) WC_CS128WUL_N(((c) >> 8) & 0x7F, (c) & 0x7F)

+#define WC_N_CS128WU(c) ((c) / 0x80)

+#define WC_N_CS128WL(c) ((c) % 0x80)

+#define WC_N_CS128W(c) ((WC_N_CS128WU(c) << 8) + WC_N_CS128WL(c))

+#endif

+

+extern wc_uchar WC_HKSCS_MAP[];

+

+extern wc_wchar_t wc_hkscs_to_cs128w(wc_wchar_t cc);

+extern wc_wchar_t wc_cs128w_to_hkscs(wc_wchar_t cc);

+extern wc_uint32 wc_hkscs_to_N(wc_uint32 c);

+extern Str wc_conv_from_hkscs(Str is, wc_ces ces);

+extern void wc_push_to_hkscs(Str os, wc_wchar_t cc, wc_status *st);

+extern Str wc_char_conv_from_hkscs(wc_uchar c, wc_status *st);

+

+#endif

+

+#include "wc.h"

+#include "iso2022.h"

+#include "hz.h"

+#include "wtf.h"

+#ifdef USE_UNICODE

+#include "ucs.h"

+#endif

+

+Str

+wc_conv_from_hz(Str is, wc_ces ces)

+{

+ Str os;

+ wc_uchar *sp = (wc_uchar *)is->ptr;

+ wc_uchar *ep = sp + is->length;

+ wc_uchar *p;

+ int state = WC_HZ_NOSTATE;

+

+ for (p = sp; p < ep && *p < 0x80 && *p != WC_C_HZ_TILDA; p++)

+ ;

+ if (p == ep)

+ return is;

+ os = Strnew_size(is->length);

+ if (p > sp)

+ Strcat_charp_n(os, is->ptr, (int)(p - sp));

+

+ for (; p < ep; p++) {

+ switch (state) {

+ case WC_HZ_NOSTATE:

+ if (*p == WC_C_HZ_TILDA)

+ state = WC_HZ_TILDA;

+ else if (WC_ISO_MAP[*p] == WC_ISO_MAP_GR)

+ state = WC_HZ_MBYTE1_GR; /* GB 2312 ? */

+ else if (*p & 0x80)

+ wtf_push_unknown(os, p, 1);

+ else

+ Strcat_char(os, (char)*p);

+ break;

+ case WC_HZ_TILDA:

+ if (*p == WC_C_HZ_SI) {

+ state = WC_HZ_MBYTE;

+ break;

+ } else if (*p == WC_C_HZ_TILDA)

+ Strcat_char(os, (char)*p);

+ else if (*p == '\n')

+ break;

+ else

+ wtf_push_unknown(os, p-1, 2);

+ state = WC_HZ_NOSTATE;

+ break;

+ case WC_HZ_TILDA_MB:

+ if (*p == WC_C_HZ_SO || *p == '\n') {

+ state = WC_HZ_NOSTATE;

+ break;

+ }

+ else if (WC_ISO_MAP[*p & 0x7f] == WC_ISO_MAP_GL)

+ wtf_push(os, WC_CCS_GB_2312, ((wc_uint32)*(p-1) << 8) | *p);

+ else

+ wtf_push_unknown(os, p-1, 2);

+ state = WC_HZ_MBYTE;

+ break;

+ case WC_HZ_MBYTE:

+ if (*p == WC_C_HZ_TILDA)

+ state = WC_HZ_TILDA_MB;

+ else if (WC_ISO_MAP[*p & 0x7f] == WC_ISO_MAP_GL)

+ state = WC_HZ_MBYTE1;

+ else

+ wtf_push_unknown(os, p, 1);

+ break;

+ case WC_HZ_MBYTE1:

+ if (WC_ISO_MAP[*p & 0x7f] == WC_ISO_MAP_GL)

+ wtf_push(os, WC_CCS_GB_2312, ((wc_uint32)*(p-1) << 8) | *p);

+ else

+ wtf_push_unknown(os, p-1, 2);

+ state = WC_HZ_MBYTE;

+ break;

+ case WC_HZ_MBYTE1_GR:

+ if (WC_ISO_MAP[*p] == WC_ISO_MAP_GR)

+ wtf_push(os, WC_CCS_GB_2312, ((wc_uint32)*(p-1) << 8) | *p);

+ else

+ wtf_push_unknown(os, p-1, 2);

+ state = WC_HZ_NOSTATE;

+ break;

+ }

+ }

+ switch (state) {

+ case WC_HZ_TILDA:

+ case WC_HZ_TILDA_MB:

+ case WC_HZ_MBYTE1:

+ case WC_HZ_MBYTE1_GR:

+ wtf_push_unknown(os, p-1, 1);

+ break;

+ }

+ return os;

+}

+

+void

+wc_push_to_hz(Str os, wc_wchar_t cc, wc_status *st)

+{

+ while (1) {

+ switch (cc.ccs) {

+ case WC_CCS_US_ASCII:

+ if (st->gl) {

+ Strcat_char(os, WC_C_HZ_TILDA);

+ Strcat_char(os, WC_C_HZ_SO);

+ st->gl = 0;

+ }

+ if ((char)cc.code == WC_C_HZ_TILDA)

+ Strcat_char(os, WC_C_HZ_TILDA);

+ Strcat_char(os, (char)cc.code);

+ return;

+ case WC_CCS_GB_2312:

+ if (! st->gl) {

+ Strcat_char(os, WC_C_HZ_TILDA);

+ Strcat_char(os, WC_C_HZ_SI);

+ st->gl = 1;

+ }

+ Strcat_char(os, (char)((cc.code >> 8) & 0x7f));

+ Strcat_char(os, (char)(cc.code & 0x7f));

+ return;

+ case WC_CCS_UNKNOWN_W:

+ if (WcOption.no_replace)

+ return;

+ if (st->gl) {

+ Strcat_char(os, WC_C_HZ_TILDA);

+ Strcat_char(os, WC_C_HZ_SO);

+ st->gl = 0;

+ }

+ Strcat_charp(os, WC_REPLACE_W);

+ return;

+ case WC_CCS_UNKNOWN:

+ if (WcOption.no_replace)

+ return;

+ if (st->gl) {

+ Strcat_char(os, WC_C_HZ_TILDA);

+ Strcat_char(os, WC_C_HZ_SO);

+ st->gl = 0;

+ }

+ Strcat_charp(os, WC_REPLACE);

+ return;

+ default:

+#ifdef USE_UNICODE

+ if (WcOption.ucs_conv)

+ cc = wc_any_to_any_ces(cc, st);

+ else

+#endif

+ cc.ccs = WC_CCS_IS_WIDE(cc.ccs) ? WC_CCS_UNKNOWN_W : WC_CCS_UNKNOWN;

+ continue;

+ }

+ }

+}

+

+void

+wc_push_to_hz_end(Str os, wc_status *st)

+{

+ if (st->gl) {

+ Strcat_char(os, WC_C_HZ_TILDA);

+ Strcat_char(os, WC_C_HZ_SO);

+ st->gl = 0;

+ }

+}

+

+#ifndef _WC_HZ_H

+#define _WC_HZ_H

+

+#define WC_C_HZ_TILDA '~'

+#define WC_C_HZ_SI '{'

+#define WC_C_HZ_SO '}'

+

+#define WC_HZ_NOSTATE 0

+#define WC_HZ_TILDA 1

+#define WC_HZ_TILDA_MB 2

+#define WC_HZ_MBYTE 3

+#define WC_HZ_MBYTE1 4

+#define WC_HZ_MBYTE1_GR 5

+

+extern Str wc_conv_from_hz(Str is, wc_ces ces);

+extern void wc_push_to_hz(Str os, wc_wchar_t cc, wc_status *st);

+extern void wc_push_to_hz_end(Str os, wc_status *st);

+

+#endif

+

+#include "wc.h"

+#include "iso2022.h"

+#include "jis.h"

+#include "big5.h"

+#include "johab.h"

+#include "wtf.h"

+#ifdef USE_UNICODE

+#include "ucs.h"

+#endif

+

+#define C0 WC_ISO_MAP_C0

+#define C1 WC_ISO_MAP_C1

+#define GL WC_ISO_MAP_GL

+#define GR WC_ISO_MAP_GR

+#define GL2 WC_ISO_MAP_GL96

+#define GR2 WC_ISO_MAP_GR96

+#define SO WC_ISO_MAP_SO

+#define SI WC_ISO_MAP_SI

+#define ESC WC_ISO_MAP_ESC

+#define SS2 WC_ISO_MAP_SS2

+#define SS3 WC_ISO_MAP_SS3

+

+wc_uint8 WC_ISO_MAP[ 0x100 ] = {

+ C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, SO, SI,

+ C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, ESC,C0, C0, C0, C0,

+ GL2,GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL,

+ GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL,

+ GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL,

+ GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL,

+ GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL,

+ GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL2,

+

+ C1, C1, C1, C1, C1, C1, C1, C1, C1, C1, C1, C1, C1, C1, SS2,SS3,

+ C1, C1, C1, C1, C1, C1, C1, C1, C1, C1, C1, C1, C1, C1, C1, C1,

+ GR2,GR, GR, GR, GR, GR, GR, GR, GR, GR, GR, GR, GR, GR, GR, GR,

+ GR, GR, GR, GR, GR, GR, GR, GR, GR, GR, GR, GR, GR, GR, GR, GR,

+ GR, GR, GR, GR, GR, GR, GR, GR, GR, GR, GR, GR, GR, GR, GR, GR,

+ GR, GR, GR, GR, GR, GR, GR, GR, GR, GR, GR, GR, GR, GR, GR, GR,

+ GR, GR, GR, GR, GR, GR, GR, GR, GR, GR, GR, GR, GR, GR, GR, GR,

+ GR, GR, GR, GR, GR, GR, GR, GR, GR, GR, GR, GR, GR, GR, GR, GR2,

+};

+

+static wc_uchar cs94_gmap[ 0x80 - WC_F_ISO_BASE ];

+static wc_uchar cs94w_gmap[ 0x80 - WC_F_ISO_BASE ];

+static wc_uchar cs96_gmap[ 0x80 - WC_F_ISO_BASE ];

+static wc_uchar cs96w_gmap[ 0x80 - WC_F_ISO_BASE ];

+static wc_uchar cs942_gmap[ 0x80 - WC_F_ISO_BASE ];

+

+static void

+wtf_push_iso2022(Str os, wc_ccs ccs, wc_uint32 code)

+{

+ switch (ccs) {

+ case WC_CCS_JIS_C_6226:

+ case WC_CCS_JIS_X_0208:

+ case WC_CCS_JIS_X_0213_1:

+ ccs = wc_jisx0208_or_jisx02131(code);

+ break;

+ case WC_CCS_JIS_X_0212:

+ case WC_CCS_JIS_X_0213_2:

+ ccs = wc_jisx0212_or_jisx02132(code);

+ break;

+ case WC_CCS_JIS_X_0201:

+ case WC_CCS_GB_1988:

+ ccs = WC_CCS_US_ASCII;

+ break;

+ }

+ wtf_push(os, ccs, code);

+}

+

+Str

+wc_conv_from_iso2022(Str is, wc_ces ces)

+{

+ Str os;

+ wc_uchar *sp = (wc_uchar *)is->ptr;

+ wc_uchar *ep = sp + is->length;

+ wc_uchar *p, *q = NULL;

+ int state = WC_ISO_NOSTATE;

+ wc_status st;

+ wc_ccs gl_ccs, gr_ccs;

+

+ for (p = sp; p < ep && !(WC_ISO_MAP[*p] & WC_ISO_MAP_DETECT); p++)

+ ;

+ if (p == ep)

+ return is;

+ os = Strnew_size(is->length);

+ if (p > sp)

+ Strcat_charp_n(os, is->ptr, (int)(p - sp));

+

+ wc_input_init(ces, &st);

+ gl_ccs = st.design[st.gl];

+ gr_ccs = st.design[st.gr];

+

+ for (; p < ep; p++) {

+ switch (state) {

+ case WC_ISO_NOSTATE:

+ switch (WC_ISO_MAP[*p]) {

+ case GL2:

+ gl_ccs = st.ss ? st.design[st.ss]

+ : st.design[st.gl];

+ if (!(WC_CCS_TYPE(gl_ccs) & WC_CCS_A_CS96)) {

+ Strcat_char(os, (char)*p);

+ break;

+ }

+ case GL:

+ gl_ccs = st.ss ? st.design[st.ss]

+ : st.design[st.gl];

+ if (WC_CCS_IS_WIDE(gl_ccs)) {

+ q = p;

+ state = WC_ISO_MBYTE1;

+ continue;

+ } else if (gl_ccs == WC_CES_US_ASCII)

+ Strcat_char(os, (char)*p);

+ else

+ wtf_push_iso2022(os, gl_ccs, (wc_uint32)*p);

+ break;

+ case GR2:

+ gr_ccs = st.ss ? st.design[st.ss]

+ : st.design[st.gr];

+ if (!(WC_CCS_TYPE(gr_ccs) & WC_CCS_A_CS96)) {

+ wtf_push_unknown(os, p, 1);

+ break;

+ }

+ case GR:

+ gr_ccs = st.ss ? st.design[st.ss]

+ : st.design[st.gr];

+ if (WC_CCS_IS_WIDE(gr_ccs)) {

+ q = p;

+ state = WC_EUC_MBYTE1;

+ continue;

+ } else if (gr_ccs)

+ wtf_push_iso2022(os, gr_ccs, (wc_uint32)*p);

+ else

+ wtf_push_unknown(os, p, 1);

+ break;

+ case C0:

+ Strcat_char(os, (char)*p);

+ break;

+ case C1:

+ wtf_push(os, WC_CCS_C1, (wc_uint32)*p);

+ break;

+ case ESC:

+ st.ss = 0;

+ if (wc_parse_iso2022_esc(&p, &st))

+ state = st.state;

+ else

+ Strcat_char(os, (char)*p);

+ continue;

+ case SI:

+ st.gl = 0;

+ break;

+ case SO:

+ st.gl = 1;

+ break;

+ case SS2:

+ if (! st.design[2]) {

+ wtf_push_unknown(os, p, 1);

+ break;

+ }

+ st.ss = 2;

+ continue;

+ case SS3:

+ if (! st.design[3]) {

+ wtf_push_unknown(os, p, 1);

+ break;

+ }

+ st.ss = 3;

+ continue;

+ }

+ break;

+ case WC_ISO_MBYTE1:

+ switch (WC_ISO_MAP[*p]) {

+ case GL2:

+ if (!(WC_CCS_TYPE(gl_ccs) & WC_CCS_A_CS96)) {

+ Strcat_char(os, (char)*q);

+ Strcat_char(os, (char)*p);

+ break;

+ }

+ case GL:

+ wtf_push_iso2022(os, gl_ccs, ((wc_uint32)*q << 8) | *p);

+ break;

+ default:

+ wtf_push_unknown(os, q, 2);

+ break;

+ }

+ break;

+ case WC_EUC_MBYTE1:

+ switch (WC_ISO_MAP[*p]) {

+ case GR2:

+ if (!(WC_CCS_TYPE(gr_ccs) & WC_CCS_A_CS96)) {

+ wtf_push_unknown(os, q, 2);

+ break;

+ }

+ case GR:

+ if (gr_ccs == WC_CCS_CNS_11643_X) {

+ state = WC_EUC_TW_MBYTE2;

+ continue;

+ }

+ wtf_push_iso2022(os, gr_ccs, ((wc_uint32)*q << 8) | *p);

+ break;

+ default:

+ wtf_push_unknown(os, q, 2);

+ break;

+ }

+ break;

+ case WC_EUC_TW_MBYTE2:

+ if (WC_ISO_MAP[*p] == GR) {

+ if (0xa1 <= *q && *q <= 0xa7) {

+ wtf_push_iso2022(os, WC_CCS_CNS_11643_1 + (*q - 0xa1),

+ ((wc_uint32)*(q+1) << 8) | *p);

+ break;

+ }

+ if (0xa8 <= *q && *q <= 0xb0) {

+ wtf_push_iso2022(os, WC_CCS_CNS_11643_8 + (*q - 0xa8),

+ ((wc_uint32)*(q+1) << 8) | *p);

+ break;

+ }

+ }

+ wtf_push_unknown(os, q, 3);

+ break;

+ case WC_ISO_CSWSR:

+ if (*p == WC_C_ESC && *(p+1) == WC_C_CSWSR) {

+ if (*(p+2) == WC_F_ISO_BASE) {

+ state = st.state = WC_ISO_NOSTATE;

+ p += 2;

+ continue;

+ } else if (*(p+2) > WC_F_ISO_BASE && *(p+2) <= 0x7e) {

+ p += 2;

+ continue;

+ }

+ }

+ wtf_push_unknown(os, p, 1);

+ continue;

+ case WC_ISO_CSWOSR:

+ wtf_push_unknown(os, p, ep - p);

+ return os;

+ break;

+ }

+ st.ss = 0;

+ state = WC_ISO_NOSTATE;

+ }

+ switch (state) {

+ case WC_ISO_MBYTE1:

+ case WC_EUC_MBYTE1:

+ wtf_push_unknown(os, p-1, 1);

+ break;

+ case WC_EUC_TW_MBYTE1:

+ wtf_push_unknown(os, p-2, 2);

+ break;

+ }

+ return os;

+}

+

+int

+wc_parse_iso2022_esc(wc_uchar **ptr, wc_status *st)

+{

+ wc_uchar *p = *ptr, state, f = 0, g = 0, cs = 0;

+

+ if (*p != WC_C_ESC)

+ return 0;

+ state = *p;

+ for (p++; *p && state; p++) {

+ switch (state) {

+ case WC_C_ESC: /* ESC */

+ switch (*p) {

+ case WC_C_MBCS: /* ESC '$' */

+ state = *p;

+ continue;

+ case WC_C_G0_CS94: /* ESC '(' */

+ case WC_C_G1_CS94: /* ESC ')' */

+ case WC_C_G2_CS94: /* ESC '*' */

+ case WC_C_G3_CS94: /* ESC '+' */

+ state = cs = WC_C_G0_CS94;

+ g = *p & 0x03;

+ continue;

+ case WC_C_G0_CS96: /* ESC ',' */ /* ISO 2022 does not permit */

+ case WC_C_G1_CS96: /* ESC '-' */

+ case WC_C_G2_CS96: /* ESC '.' */

+ case WC_C_G3_CS96: /* ESC '/' */

+ state = cs = WC_C_G0_CS96;

+ g = *p & 0x03;

+ continue;

+ case WC_C_C0: /* ESC '!' */ /* not suported */

+ case WC_C_C1: /* ESC '"' */ /* not suported */

+ case WC_C_REP: /* ESC '&' */ /* not suported */

+ state = cs = WC_C_C0;

+ continue;

+ case WC_C_CSWSR: /* ESC '%' */ /* not suported */

+ state = cs = WC_C_CSWSR;

+ continue;

+ case WC_C_SS2: /* ESC 'N' */

+ st->ss = 2; *ptr = p; return 1;

+ case WC_C_SS3: /* ESC 'O' */

+ st->ss = 3; *ptr = p; return 1;

+ case WC_C_LS2: /* ESC 'n' */

+ st->gl = 2; *ptr = p; return 1;

+ case WC_C_LS3: /* ESC 'o' */

+ st->gl = 3; *ptr = p; return 1;

+ case WC_C_LS1R: /* ESC '~' */

+ st->gr = 1; *ptr = p; return 1;

+ case WC_C_LS2R: /* ESC '}' */

+ st->gr = 2; *ptr = p; return 1;

+ case WC_C_LS3R: /* ESC '|' */

+ st->gr = 3; *ptr = p; return 1;

+ default:

+ return 0;

+ }

+ break;

+ case WC_C_MBCS: /* ESC '$' */

+ switch (*p) {

+ case WC_F_JIS_C_6226: /* ESC '$' @ */

+ case WC_F_JIS_X_0208: /* ESC '$' B */

+ case WC_F_GB_2312: /* ESC '$' A */

+ state = 0;

+ cs = WC_C_G0_CS94 | 0x80;

+ g = 0;

+ f = *p;

+ break;

+ case WC_C_G0_CS94: /* ESC '$' '(' */

+ case WC_C_G1_CS94: /* ESC '$' ')' */

+ case WC_C_G2_CS94: /* ESC '$' '*' */

+ case WC_C_G3_CS94: /* ESC '$' '+' */

+ state = cs = WC_C_G0_CS94 | 0x80;

+ g = *p & 0x03;

+ continue;

+ case WC_C_G0_CS96: /* ESC '$' ',' */ /* ISO 2022 does not permit */

+ case WC_C_G1_CS96: /* ESC '$' '-' */

+ case WC_C_G2_CS96: /* ESC '$' '.' */

+ case WC_C_G3_CS96: /* ESC '$' '/' */

+ state = cs = WC_C_G0_CS96 | 0x80;

+ g = *p & 0x03;

+ continue;

+ default:

+ return 0;

+ }

+ break;

+ case WC_C_G0_CS94: /* ESC [()*+] F */

+ if (*p == WC_C_CS942) { /* ESC [()*+] '!' */

+ state = cs = WC_C_CS942 | 0x80;

+ g = *p & 0x03;

+ continue;

+ }

+ case WC_C_G0_CS96: /* ESC [,-./] F */

+ case WC_C_G0_CS94 | 0x80: /* ESC '$' [()*+] F */

+ case WC_C_G0_CS96 | 0x80: /* ESC '$' [,-./] F */

+ case WC_C_CS942 | 0x80: /* ESC [()*+] '!' F */

+ case WC_C_C0: /* ESC [!"&] F */

+ case WC_C_CSWSR | 0x80: /* ESC '%' '/' F */

+ state = 0;

+ f = *p;

+ break;

+ case WC_C_CSWSR: /* ESC '%' F */

+ if (*p == WC_C_CSWOSR) { /* ESC '%' '/' */

+ state = cs = WC_C_CSWSR | 0x80;

+ continue;

+ }

+ state = 0;

+ f = *p;

+ break;

+ default:

+ return 0;

+ }

+ }

+ if (f < WC_F_ISO_BASE || f > 0x7e)

+ return 0;

+ switch (cs) {

+ case WC_C_G0_CS94:

+ st->design[g] = WC_CCS_SET_CS94(f);

+ break;

+ case WC_C_G0_CS94 | 0x80:

+ st->design[g] = WC_CCS_SET_CS94W(f);

+ break;

+ case WC_C_G0_CS96:

+ st->design[g] = WC_CCS_SET_CS96(f);

+ break;

+ case WC_C_G0_CS96 | 0x80:

+ st->design[g] = WC_CCS_SET_CS96W(f);

+ break;

+ case WC_C_CS942 | 0x80:

+ st->design[g] = WC_CCS_SET_CS942(f);

+ break;

+ case WC_C_CSWSR:

+ if (f == WC_F_ISO_BASE)

+ st->state = WC_ISO_NOSTATE;

+ else

+ st->state = WC_ISO_CSWSR;

+ break;

+ case WC_C_CSWOSR:

+ st->state = WC_ISO_CSWOSR;

+ break;

+ }

+ *ptr = p - 1;

+ return 1;

+}

+

+void

+wc_push_to_iso2022(Str os, wc_wchar_t cc, wc_status *st)

+{

+ wc_uchar g = 0;

+ wc_bool is_wide = WC_FALSE, retry = WC_FALSE;

+ wc_wchar_t cc2;

+

+ while (1) {

+ switch (WC_CCS_TYPE(cc.ccs)) {

+ case WC_CCS_A_CS94:

+ if (cc.ccs == WC_CCS_US_ASCII)

+ cc.ccs = st->g0_ccs;

+ g = cs94_gmap[WC_CCS_INDEX(cc.ccs) - WC_F_ISO_BASE];

+ break;

+ case WC_CCS_A_CS94W:

+ is_wide = 1;

+ switch (cc.ccs) {

+#ifdef USE_UNICODE

+ case WC_CCS_JIS_X_0212:

+ if (!WcOption.use_jisx0212 && WcOption.use_jisx0213 &&

+ WcOption.ucs_conv) {

+ cc2 = wc_jisx0212_to_jisx0213(cc);

+ if (cc2.ccs == WC_CCS_JIS_X_0213_1 ||

+ cc2.ccs == WC_CCS_JIS_X_0213_2) {

+ cc = cc2;

+ continue;

+ }

+ }

+ break;

+ case WC_CCS_JIS_X_0213_1:

+ case WC_CCS_JIS_X_0213_2:

+ if (!WcOption.use_jisx0213 && WcOption.use_jisx0212 &&

+ WcOption.ucs_conv) {

+ cc2 = wc_jisx0213_to_jisx0212(cc);

+ if (cc2.ccs == WC_CCS_JIS_X_0212) {

+ cc = cc2;

+ continue;

+ }

+ }

+ break;

+#endif

+ }

+ g = cs94w_gmap[WC_CCS_INDEX(cc.ccs) - WC_F_ISO_BASE];

+ break;

+ case WC_CCS_A_CS96:

+ g = cs96_gmap[WC_CCS_INDEX(cc.ccs) - WC_F_ISO_BASE];

+ break;

+ case WC_CCS_A_CS96W:

+ is_wide = 1;

+ g = cs96w_gmap[WC_CCS_INDEX(cc.ccs) - WC_F_ISO_BASE];

+ break;

+ case WC_CCS_A_CS942:

+ g = cs942_gmap[WC_CCS_INDEX(cc.ccs) - WC_F_ISO_BASE];

+ break;

+ case WC_CCS_A_UNKNOWN_W:

+ if (WcOption.no_replace)

+ return;

+ is_wide = 1;

+ cc.ccs = WC_CCS_US_ASCII;

+ g = cs94_gmap[WC_CCS_INDEX(cc.ccs) - WC_F_ISO_BASE];

+ cc.code = ((wc_uint32)WC_REPLACE_W[0] << 8) | WC_REPLACE_W[1];

+ break;

+ case WC_CCS_A_UNKNOWN:

+ if (WcOption.no_replace)

+ return;

+ cc.ccs = WC_CCS_US_ASCII;

+ g = cs94_gmap[WC_CCS_INDEX(cc.ccs) - WC_F_ISO_BASE];

+ cc.code = (wc_uint32)WC_REPLACE[0];

+ break;

+ default:

+ if ((cc.ccs == WC_CCS_JOHAB || WC_CCS_JOHAB_1 ||

+ cc.ccs == WC_CCS_JOHAB_2 || cc.ccs == WC_CCS_JOHAB_3) &&

+ cs94w_gmap[WC_F_KS_X_1001 - WC_F_ISO_BASE]) {

+ wc_wchar_t cc2 = wc_johab_to_ksx1001(cc);

+ if (cc2.ccs == WC_CCS_KS_X_1001) {

+ cc = cc2;

+ continue;

+ }

+ }

+#ifdef USE_UNICODE

+ if (WcOption.ucs_conv)

+ cc = wc_any_to_iso2022(cc, st);

+ else

+#endif

+ cc.ccs = WC_CCS_IS_WIDE(cc.ccs) ? WC_CCS_UNKNOWN_W : WC_CCS_UNKNOWN;

+ continue;

+ }

+ if (! g) {

+#ifdef USE_UNICODE

+ if (WcOption.ucs_conv && ! retry)

+ cc = wc_any_to_any_ces(cc, st);

+ else

+#endif

+ cc.ccs = WC_CCS_IS_WIDE(cc.ccs) ? WC_CCS_UNKNOWN_W : WC_CCS_UNKNOWN;

+ retry = WC_TRUE;

+ continue;

+ }

+

+ wc_push_iso2022_esc(os, cc.ccs, g, 1, st);

+ if (is_wide)

+ Strcat_char(os, (char)((cc.code >> 8) & 0x7f));

+ Strcat_char(os, (char)(cc.code & 0x7f));

+ return;

+ }

+}

+

+void

+wc_push_to_iso2022_end(Str os, wc_status *st)

+{

+ if (st->design[1] != 0 && st->design[1] != st->g1_ccs)

+ wc_push_iso2022_esc(os, st->g1_ccs, WC_C_G1_CS94, 0, st);

+ wc_push_iso2022_esc(os, st->g0_ccs, WC_C_G0_CS94, 1, st);

+}

+

+void

+wc_push_iso2022_esc(Str os, wc_ccs ccs, wc_uchar g, wc_uint8 invoke, wc_status *st)

+{

+ wc_uint8 g_invoke = g & 0x03;

+

+ if (st->design[g_invoke] != ccs) {

+ Strcat_char(os, WC_C_ESC);

+ if (WC_CCS_IS_WIDE(ccs)) {

+ Strcat_char(os, WC_C_MBCS);

+ if (g_invoke != 0 ||

+ (ccs != WC_CCS_JIS_C_6226 &&

+ ccs != WC_CCS_JIS_X_0208 &&

+ ccs != WC_CCS_GB_2312))

+ Strcat_char(os, (char)g);

+ } else {

+ Strcat_char(os, (char)g);

+ if ((ccs & WC_CCS_A_ISO_2022) == WC_CCS_A_CS942)

+ Strcat_char(os, WC_C_CS942);

+ }

+ Strcat_char(os, (char)WC_CCS_GET_F(ccs));

+ st->design[g_invoke] = ccs;

+ }

+ if (! invoke)

+ return;

+

+ switch (g_invoke) {

+ case 0:

+ if (st->gl != 0) {

+ Strcat_char(os, WC_C_SI);

+ st->gl = 0;

+ }

+ break;

+ case 1:

+ if (st->gl != 1) {

+ Strcat_char(os, WC_C_SO);

+ st->gl = 1;

+ }

+ break;

+ case 2:

+ Strcat_char(os, WC_C_ESC);

+ Strcat_char(os, WC_C_SS2);

+ break;

+ case 3:

+ Strcat_char(os, WC_C_ESC);

+ Strcat_char(os, WC_C_SS3);

+ break;

+ }

+}

+

+void

+wc_push_to_euc(Str os, wc_wchar_t cc, wc_status *st)

+{

+ wc_ccs g1_ccs = st->ces_info->gset[1].ccs;

+

+ while (1) {

+ if (cc.ccs == g1_ccs) {

+ Strcat_char(os, (char)((cc.code >> 8) | 0x80));

+ Strcat_char(os, (char)((cc.code & 0xff) | 0x80));

+ return;

+ }

+ switch (cc.ccs) {

+ case WC_CCS_US_ASCII:

+ Strcat_char(os, (char)cc.code);

+ return;

+ case WC_CCS_C1:

+ Strcat_char(os, (char)(cc.code | 0x80));

+ return;

+ case WC_CCS_UNKNOWN_W:

+ if (!WcOption.no_replace)

+ Strcat_charp(os, WC_REPLACE_W);

+ return;

+ case WC_CCS_UNKNOWN:

+ if (!WcOption.no_replace)

+ Strcat_charp(os, WC_REPLACE);

+ return;

+ case WC_CCS_JOHAB:

+ case WC_CCS_JOHAB_1:

+ case WC_CCS_JOHAB_2:

+ case WC_CCS_JOHAB_3:

+ if (st->ces_info->id == WC_CES_EUC_KR) {

+ cc = wc_johab_to_ksx1001(cc);

+ continue;

+ }

+ default:

+#ifdef USE_UNICODE

+ if (WcOption.ucs_conv)

+ cc = wc_any_to_any_ces(cc, st);

+ else

+#endif

+ cc.ccs = WC_CCS_IS_WIDE(cc.ccs) ? WC_CCS_UNKNOWN_W : WC_CCS_UNKNOWN;

+ continue;

+ }

+ }

+}

+

+void

+wc_push_to_eucjp(Str os, wc_wchar_t cc, wc_status *st)

+{

+ while (1) {

+ switch (cc.ccs) {

+ case WC_CCS_US_ASCII:

+ Strcat_char(os, (char)cc.code);

+ return;

+ case WC_CCS_JIS_X_0201K:

+ if (WcOption.use_jisx0201k) {

+ Strcat_char(os, WC_C_SS2R);

+ Strcat_char(os, (char)(cc.code | 0x80));

+ return;

+ } else if (WcOption.fix_width_conv)

+ cc.ccs = WC_CCS_UNKNOWN;

+ else

+ cc = wc_jisx0201k_to_jisx0208(cc);

+ continue;

+ case WC_CCS_JIS_X_0208:

+ break;

+ case WC_CCS_JIS_X_0213_1:

+ if (WcOption.use_jisx0213)

+ break;

+#ifdef USE_UNICODE

+ else if (WcOption.ucs_conv && WcOption.use_jisx0212)

+ cc = wc_jisx0213_to_jisx0212(cc);

+#endif

+ else

+ cc.ccs = WC_CCS_UNKNOWN_W;

+ continue;

+ case WC_CCS_JIS_X_0212:

+ if (WcOption.use_jisx0212) {

+ Strcat_char(os, WC_C_SS3R);

+ break;

+ }

+#ifdef USE_UNICODE

+ else if (WcOption.ucs_conv && WcOption.use_jisx0213)

+ cc = wc_jisx0212_to_jisx0213(cc);

+#endif

+ else

+ cc.ccs = WC_CCS_UNKNOWN_W;

+ continue;

+ case WC_CCS_JIS_X_0213_2:

+ if (WcOption.use_jisx0213) {

+ Strcat_char(os, WC_C_SS3R);

+ break;

+ }

+#ifdef USE_UNICODE

+ else if (WcOption.ucs_conv && WcOption.use_jisx0212)

+ cc = wc_jisx0213_to_jisx0212(cc);

+#endif

+ else

+ cc.ccs = WC_CCS_UNKNOWN_W;

+ continue;

+ case WC_CCS_C1:

+ Strcat_char(os, (char)(cc.code | 0x80));

+ return;

+ case WC_CCS_UNKNOWN_W:

+ if (!WcOption.no_replace)

+ Strcat_charp(os, WC_REPLACE_W);

+ return;

+ case WC_CCS_UNKNOWN:

+ if (!WcOption.no_replace)

+ Strcat_charp(os, WC_REPLACE);

+ return;

+ default:

+#ifdef USE_UNICODE

+ if (WcOption.ucs_conv)

+ cc = wc_any_to_any_ces(cc, st);

+ else

+#endif

+ cc.ccs = WC_CCS_IS_WIDE(cc.ccs) ? WC_CCS_UNKNOWN_W : WC_CCS_UNKNOWN;

+ continue;

+ }

+ Strcat_char(os, (char)((cc.code >> 8) | 0x80));

+ Strcat_char(os, (char)((cc.code & 0xff) | 0x80));

+ return;

+ }

+}

+

+void

+wc_push_to_euctw(Str os, wc_wchar_t cc, wc_status *st)

+{

+ while (1) {

+ switch (cc.ccs) {

+ case WC_CCS_US_ASCII:

+ Strcat_char(os, (char)cc.code);

+ return;

+ case WC_CCS_CNS_11643_1:

+ break;

+ case WC_CCS_CNS_11643_2:

+ case WC_CCS_CNS_11643_3:

+ case WC_CCS_CNS_11643_4:

+ case WC_CCS_CNS_11643_5:

+ case WC_CCS_CNS_11643_6:

+ case WC_CCS_CNS_11643_7:

+ Strcat_char(os, WC_C_SS2R);

+ Strcat_char(os, (char)(0xA1 + (cc.ccs - WC_CCS_CNS_11643_1)));

+ break;

+ case WC_CCS_CNS_11643_8:

+ case WC_CCS_CNS_11643_9:

+ case WC_CCS_CNS_11643_10:

+ case WC_CCS_CNS_11643_11:

+ case WC_CCS_CNS_11643_12:

+ case WC_CCS_CNS_11643_13:

+ case WC_CCS_CNS_11643_14:

+ case WC_CCS_CNS_11643_15:

+ case WC_CCS_CNS_11643_16:

+ Strcat_char(os, WC_C_SS2R);

+ Strcat_char(os, (char)(0xA8 + (cc.ccs - WC_CCS_CNS_11643_8)));

+ break;

+ case WC_CCS_C1:

+ Strcat_char(os, (char)(cc.code | 0x80));

+ return;

+ case WC_CCS_UNKNOWN_W:

+ if (!WcOption.no_replace)

+ Strcat_charp(os, WC_REPLACE_W);

+ return;

+ case WC_CCS_UNKNOWN:

+ if (!WcOption.no_replace)

+ Strcat_charp(os, WC_REPLACE);

+ return;

+ default:

+#ifdef USE_UNICODE

+ if (WcOption.ucs_conv)

+ cc = wc_any_to_any_ces(cc, st);

+ else

+#endif

+ cc.ccs = WC_CCS_IS_WIDE(cc.ccs) ? WC_CCS_UNKNOWN_W : WC_CCS_UNKNOWN;

+ continue;

+ }

+ Strcat_char(os, (char)((cc.code >> 8) | 0x80));

+ Strcat_char(os, (char)((cc.code & 0xff) | 0x80));

+ return;

+ }

+}

+

+void

+wc_push_to_iso8859(Str os, wc_wchar_t cc, wc_status *st)

+{

+ wc_ccs g1_ccs = st->ces_info->gset[1].ccs;

+

+ while (1) {

+ if (cc.ccs == g1_ccs) {

+ Strcat_char(os, (char)(cc.code | 0x80));

+ return;

+ }

+ switch (cc.ccs) {

+ case WC_CCS_US_ASCII:

+ Strcat_char(os, (char)cc.code);

+ return;

+ case WC_CCS_C1:

+ Strcat_char(os, (char)(cc.code | 0x80));

+ return;

+ case WC_CCS_UNKNOWN_W:

+ if (!WcOption.no_replace)

+ Strcat_charp(os, WC_REPLACE_W);

+ return;

+ case WC_CCS_UNKNOWN:

+ if (!WcOption.no_replace)

+ Strcat_charp(os, WC_REPLACE);

+ return;

+ default:

+#ifdef USE_UNICODE

+ if (WcOption.ucs_conv)

+ cc = wc_any_to_any_ces(cc, st);

+ else

+#endif

+ cc.ccs = WC_CCS_IS_WIDE(cc.ccs) ? WC_CCS_UNKNOWN_W : WC_CCS_UNKNOWN;

+ continue;

+ }

+ }

+}

+

+void

+wc_create_gmap(wc_status *st)

+{

+ wc_gset *gset = st->ces_info->gset;

+ wc_uchar *gset_ext = st->ces_info->gset_ext;

+ int i, f;

+

+ if (WcOption.strict_iso2022) {

+ for (i = 0; i < WC_F_ISO_BASE; i++) {

+ cs94_gmap[i] = 0;

+ cs96_gmap[i] = 0;

+ cs94w_gmap[i] = 0;

+ cs96w_gmap[i] = 0;

+ cs942_gmap[i] = 0;

+ }

+ } else {

+ for (i = 0; i < WC_F_ISO_BASE; i++) {

+ cs94_gmap[i] = gset_ext[0];

+ cs96_gmap[i] = gset_ext[1];

+ cs94w_gmap[i] = gset_ext[2];

+ cs96w_gmap[i] = gset_ext[3];

+ cs942_gmap[i] = gset_ext[0];

+ }

+ }

+ for (i = 0; gset[i].ccs; i++) {

+ f = WC_CCS_GET_F(gset[i].ccs) - WC_F_ISO_BASE;

+ switch (WC_CCS_TYPE(gset[i].ccs)) {

+ case WC_CCS_A_CS94:

+ switch (gset[i].ccs) {

+ case WC_CCS_JIS_X_0201K:

+ if (!WcOption.use_jisx0201k)

+ continue;

+ break;

+ }

+ cs94_gmap[f] = gset[i].g;

+ break;

+ case WC_CCS_A_CS94W:

+ switch (gset[i].ccs) {

+ case WC_CCS_JIS_X_0212:

+ if (!WcOption.use_jisx0212)

+ continue;

+ break;

+ case WC_CCS_JIS_X_0213_1:

+ case WC_CCS_JIS_X_0213_2:

+ if (!WcOption.use_jisx0213)

+ continue;

+ break;

+ }

+ cs94w_gmap[f] = gset[i].g;

+ break;

+ case WC_CCS_A_CS96:

+ cs96_gmap[f] = gset[i].g;

+ break;

+ case WC_CCS_A_CS96W:

+ cs96w_gmap[f] = gset[i].g;

+ break;

+ case WC_CCS_A_CS942:

+ cs942_gmap[f] = gset[i].g;

+ break;

+ }

+ }

+}

+

+Str

+wc_char_conv_from_iso2022(wc_uchar c, wc_status *st)

+{

+ static Str os;

+ static wc_uchar buf[4];

+ static size_t nbuf;

+ wc_uchar *p;

+ wc_ccs gl_ccs, gr_ccs;

+

+ if (st->state == -1) {

+ st->state = WC_ISO_NOSTATE;

+ os = Strnew_size(8);

+ nbuf = 0;

+ }

+

+ gl_ccs = st->ss ? st->design[st->ss] : st->design[st->gl];

+ gr_ccs = st->ss ? st->design[st->ss] : st->design[st->gr];

+

+ switch (st->state) {

+ case WC_ISO_NOSTATE:

+ switch (WC_ISO_MAP[c]) {

+ case GL2:

+ if (!(WC_CCS_TYPE(gl_ccs) & WC_CCS_A_CS96)) {

+ Strcat_char(os, (char)c);

+ break;

+ }

+ case GL:

+ if (WC_CCS_IS_WIDE(gl_ccs)) {

+ buf[nbuf++] = c;

+ st->state = WC_ISO_MBYTE1;

+ return NULL;

+ } else if (gl_ccs == WC_CES_US_ASCII)

+ Strcat_char(os, (char)c);

+ else

+ wtf_push_iso2022(os, gl_ccs, (wc_uint32)c);

+ break;

+ case GR2:

+ if (!(WC_CCS_TYPE(gr_ccs) & WC_CCS_A_CS96))

+ break;

+ case GR:

+ if (WC_CCS_IS_WIDE(gr_ccs)) {

+ buf[nbuf++] = c;

+ st->state = WC_EUC_MBYTE1;

+ return NULL;

+ } else if (gr_ccs)

+ wtf_push_iso2022(os, gr_ccs, (wc_uint32)c);

+ break;

+ case C0:

+ Strcat_char(os, (char)c);

+ break;

+ case C1:

+ break;

+ case ESC:

+ buf[nbuf++] = c;

+ st->state = WC_C_ESC;

+ return NULL;

+ case SI:

+ st->gl = 0;

+ break;

+ case SO:

+ st->gl = 1;

+ break;

+ case SS2:

+ if (! st->design[2])

+ return os;

+ st->ss = 2;

+ return NULL;

+ case SS3:

+ if (! st->design[3])

+ return os;

+ st->ss = 3;

+ return NULL;

+ }

+ break;

+ case WC_ISO_MBYTE1:

+ switch (WC_ISO_MAP[c]) {

+ case GL2:

+ if (!(WC_CCS_TYPE(gl_ccs) & WC_CCS_A_CS96))

+ break;

+ case GL:

+ buf[nbuf++] = c;

+ wtf_push_iso2022(os, gl_ccs, ((wc_uint32)buf[0] << 8) | buf[1]);

+ break;

+ }

+ st->state = WC_ISO_NOSTATE;

+ break;

+ case WC_EUC_MBYTE1:

+ switch (WC_ISO_MAP[c]) {

+ case GR2:

+ if (!(WC_CCS_TYPE(gr_ccs) & WC_CCS_A_CS96))

+ break;

+ case GR:

+ if (gr_ccs == WC_CCS_CNS_11643_X) {

+ buf[nbuf++] = c;

+ st->state = WC_EUC_TW_MBYTE2;

+ return NULL;

+ }

+ buf[nbuf++] = c;

+ wtf_push_iso2022(os, gr_ccs, ((wc_uint32)buf[0] << 8) | buf[1]);

+ break;

+ }

+ st->state = WC_ISO_NOSTATE;

+ break;

+ case WC_EUC_TW_MBYTE2:

+ if (WC_ISO_MAP[c] == GR) {

+ buf[nbuf++] = c;

+ c = buf[0];

+ if (0xa1 <= c && c <= 0xa7) {

+ wtf_push_iso2022(os, WC_CCS_CNS_11643_1 + (c - 0xa1),

+ ((wc_uint32)buf[1] << 8) | buf[2]);

+ break;

+ }

+ if (0xa8 <= c && c <= 0xb0) {

+ wtf_push_iso2022(os, WC_CCS_CNS_11643_8 + (c - 0xa8),

+ ((wc_uint32)buf[1] << 8) | buf[2]);

+ break;

+ }

+ }

+ st->state = WC_ISO_NOSTATE;

+ break;

+ case WC_C_ESC:

+ switch (c) {

+ case WC_C_G0_CS94:

+ case WC_C_G1_CS94:

+ case WC_C_G2_CS94:

+ case WC_C_G3_CS94:

+ buf[nbuf++] = c;

+ st->state = WC_C_G0_CS94;

+ return NULL;

+ case WC_C_G0_CS96:

+ case WC_C_G1_CS96:

+ case WC_C_G2_CS96:

+ case WC_C_G3_CS96:

+ case WC_C_C0:

+ case WC_C_C1:

+ case WC_C_REP:

+ buf[nbuf++] = c;

+ st->state = WC_C_G0_CS96;

+ return NULL;

+ case WC_C_MBCS:

+ case WC_C_CSWSR:

+ buf[nbuf++] = c;

+ st->state = c;

+ return NULL;

+ case WC_C_SS2:

+ st->ss = 2;

+ st->state = WC_ISO_NOSTATE;

+ return NULL;

+ case WC_C_SS3:

+ st->ss = 3;

+ st->state = WC_ISO_NOSTATE;

+ return NULL;

+ case WC_C_LS2:

+ st->gl = 2;

+ break;

+ case WC_C_LS3:

+ st->gl = 3;

+ break;

+ case WC_C_LS2R:

+ st->gr = 2;

+ break;

+ case WC_C_LS3R:

+ st->gr = 3;

+ break;

+ default:

+ break;

+ }

+ break;

+ case WC_C_MBCS:

+ switch (c) {

+ case WC_F_JIS_C_6226:

+ case WC_F_JIS_X_0208:

+ case WC_F_GB_2312:

+ buf[nbuf++] = c;

+ p = buf;

+ wc_parse_iso2022_esc(&p, st);

+ break;

+ case WC_C_G0_CS94:

+ case WC_C_G1_CS94:

+ case WC_C_G2_CS94:

+ case WC_C_G3_CS94:

+ case WC_C_G0_CS96:

+ case WC_C_G1_CS96:

+ case WC_C_G2_CS96:

+ case WC_C_G3_CS96:

+ buf[nbuf++] = c;

+ st->state = WC_C_G0_CS96;

+ return NULL;

+ }

+ break;

+ case WC_C_CSWSR:

+ switch (c) {

+ case WC_C_CSWOSR:

+ buf[nbuf++] = c;

+ st->state = WC_C_G1_CS94;

+ return NULL;

+ }

+ buf[nbuf++] = c;

+ p = buf;

+ wc_parse_iso2022_esc(&p, st);

+ break;

+ case WC_C_G0_CS94:

+ switch (c) {

+ case WC_C_CS942:

+ buf[nbuf++] = c;

+ st->state = WC_C_G0_CS96;

+ return NULL;

+ }

+ case WC_C_G0_CS96:

+ buf[nbuf++] = c;

+ p = buf;

+ wc_parse_iso2022_esc(&p, st);

+ break;

+ }

+ st->ss = 0;

+ st->state = -1;

+ return os;

+}

+

+#ifndef _WC_ISO2022_H

+#define _WC_ISO2022_H

+

+#define WC_C_ESC 0x1B /* '\033' */

+#define WC_C_SS2 0x4E /* ESC 'N' */

+#define WC_C_SS3 0x4F /* ESC 'O' */

+#define WC_C_LS2 0x6E /* ESC 'n' */

+#define WC_C_LS3 0x6F /* ESC 'o' */

+#define WC_C_LS1R 0x7E /* ESC '~' */

+#define WC_C_LS2R 0x7D /* ESC '}' */

+#define WC_C_LS3R 0x7C /* ESC '|' */

+#define WC_C_G0_CS94 0x28 /* ESC '(' F */

+#define WC_C_G1_CS94 0x29 /* ESC ')' F */

+#define WC_C_G2_CS94 0x2A /* ESC '*' F */

+#define WC_C_G3_CS94 0x2B /* ESC '+' F */

+#define WC_C_G0_CS96 0x2C /* ESC ',' F */ /* ISO 2022 does not permit */

+#define WC_C_G1_CS96 0x2D /* ESC '-' F */

+#define WC_C_G2_CS96 0x2E /* ESC '.' F */

+#define WC_C_G3_CS96 0x2F /* ESC '/' F */

+#define WC_C_MBCS 0x24 /* ESC '$' G F */

+#define WC_C_CS942 0x21 /* ESC G '!' F */

+#define WC_C_C0 0x21 /* ESC '!' F */

+#define WC_C_C1 0x22 /* ESC '"' F */

+#define WC_C_REP 0x26 /* ESC '&' F ESC '"' F */

+#define WC_C_CSWSR 0x25 /* ESC '%' F */

+#define WC_C_CSWOSR 0x2F /* ESC '%' '/' F */

+

+#define WC_C_SO 0x0E /* '\016' */

+#define WC_C_SI 0x0F /* '\017' */

+#define WC_C_SS2R 0x8E

+#define WC_C_SS3R 0x8F

+

+#define WC_F_ISO_646_US 0x42 /* 'B' */

+#define WC_F_ISO_646_IRV WC_F_ISO_646_US

+#define WC_F_US_ASCII WC_F_ISO_646_US

+#define WC_F_JIS_X_0201K 0x49 /* 'I' */

+#define WC_F_JIS_X_0201 0x4A /* 'J' */

+#define WC_F_GB_1988 0x54 /* 'T' */

+

+#define WC_F_ISO_8859_1 0x41 /* 'A' */

+#define WC_F_ISO_8859_2 0x42 /* 'B' */

+#define WC_F_ISO_8859_3 0x43 /* 'C' */

+#define WC_F_ISO_8859_4 0x44 /* 'D' */

+#define WC_F_ISO_8859_5 0x4C /* 'L' */

+#define WC_F_ISO_8859_6 0x47 /* 'G' */

+#define WC_F_ISO_8859_7 0x46 /* 'F' */

+#define WC_F_ISO_8859_8 0x48 /* 'H' */

+#define WC_F_ISO_8859_9 0x4D /* 'M' */

+#define WC_F_ISO_8859_10 0x56 /* 'V' */

+#define WC_F_ISO_8859_11 0x54 /* 'T' */

+#define WC_F_TIS_620 WC_F_ISO_8859_11

+#define WC_F_ISO_8859_13 0x59 /* 'Y' */

+#define WC_F_ISO_8859_14 0x5F /* '_' */

+#define WC_F_ISO_8859_15 0x62 /* 'b' */

+#define WC_F_ISO_8859_16 0x66 /* 'f' */

+

+#define WC_F_JIS_C_6226 0x40 /* '@' */

+#define WC_F_GB_2312 0x41 /* 'A' */

+#define WC_F_JIS_X_0208 0x42 /* 'B' */

+#define WC_F_KS_X_1001 0x43 /* 'C' */

+#define WC_F_KS_C_5601 WC_F_KS_X_1001

+#define WC_F_JIS_X_0212 0x44 /* 'D' */

+#define WC_F_ISO_IR_165 0x45 /* 'E' */

+#define WC_F_CCITT_GB WC_F_ISO_IR_165

+#define WC_F_CNS_11643_1 0x47 /* 'G' */

+#define WC_F_CNS_11643_2 0x48 /* 'H' */

+#define WC_F_CNS_11643_3 0x49 /* 'I' */

+#define WC_F_CNS_11643_4 0x4A /* 'J' */

+#define WC_F_CNS_11643_5 0x4B /* 'K' */

+#define WC_F_CNS_11643_6 0x4C /* 'L' */

+#define WC_F_CNS_11643_7 0x4D /* 'M' */

+#define WC_F_KPS_9566 0x4E /* 'N' */

+#define WC_F_JIS_X_0213_1 0x4F /* 'O' */

+#define WC_F_JIS_X_0213_2 0x50 /* 'P' */

+

+#define WC_ISO_NOSTATE 0

+#define WC_ISO_MBYTE1 1

+#define WC_EUC_NOSTATE 0

+#define WC_EUC_MBYTE1 2 /* for EUC (G1) */

+#define WC_EUC_TW_SS2 3 /* for EUC_TW (G2) */

+#define WC_EUC_TW_MBYTE1 4 /* for EUC_TW (G2) */

+#define WC_EUC_TW_MBYTE2 5 /* for EUC_TW (G2) */

+#define WC_ISO_ESC 6

+#define WC_ISO_CSWSR 0x10

+#define WC_ISO_CSWOSR 0x20

+

+#define WC_ISO_MAP_CG 0xF0

+#define WC_ISO_MAP_C0 0x10 /* 0x00 - 0x1F */

+#define WC_ISO_MAP_GL 0x00 /* 0x21 - 0x7E */

+#define WC_ISO_MAP_GL96 0x20 /* 0x20, 0x7F */

+#define WC_ISO_MAP_C1 0x50 /* 0x80 - 0x9F */

+#define WC_ISO_MAP_GR 0x40 /* 0xA1 - 0xFE */

+#define WC_ISO_MAP_GR96 0x60 /* 0xA0, 0xFF */

+#define WC_ISO_MAP_SO (0x1 | WC_ISO_MAP_C0) /* 0x0E */

+#define WC_ISO_MAP_SI (0x2 | WC_ISO_MAP_C0) /* 0x0F */

+#define WC_ISO_MAP_ESC (0x3 | WC_ISO_MAP_C0) /* 0x1B */

+#define WC_ISO_MAP_SS2 (0x4 | WC_ISO_MAP_C1) /* 0x8E */

+#define WC_ISO_MAP_SS3 (0x5 | WC_ISO_MAP_C1) /* 0x8F */

+#define WC_ISO_MAP_DETECT 0x4F

+

+#define WC_CS94WUL_N(U,L) (((U) - 0x21) * 0x5E + (L) - 0x21)

+#define WC_CS94W_N(c) WC_CS94WUL_N(((c) >> 8) & 0x7F, (c) & 0x7F)

+#define WC_CS96WUL_N(U,L) (((U) - 0x20) * 0x60 + (L) - 0x20)

+#define WC_CS96W_N(c) WC_CS96WUL_N(((c) >> 8) & 0x7F, (c) & 0x7F)

+#define WC_N_CS94WU(c) ((c) / 0x5E + 0x21)

+#define WC_N_CS94WL(c) ((c) % 0x5E + 0x21)

+#define WC_N_CS94W(c) ((WC_N_CS94WU(c) << 8) + WC_N_CS94WL(c))

+#define WC_N_CS96WU(c) ((c) / 0x60 + 0x20)

+#define WC_N_CS96WL(c) ((c) % 0x60 + 0x20)

+#define WC_N_CS96W(c) ((WC_N_CS96WU(c) << 8) + WC_N_CS96WL(c))

+

+extern wc_uint8 WC_ISO_MAP[];

+

+extern Str wc_conv_from_iso2022(Str is, wc_ces ces);

+extern void wc_push_to_iso2022(Str os, wc_wchar_t cc, wc_status *st);

+extern void wc_push_to_euc(Str os, wc_wchar_t cc, wc_status *st);

+extern void wc_push_to_eucjp(Str os, wc_wchar_t cc, wc_status *st);

+extern void wc_push_to_euctw(Str os, wc_wchar_t cc, wc_status *st);

+extern void wc_push_to_iso8859(Str os, wc_wchar_t cc, wc_status *st);

+extern void wc_push_to_iso2022_end(Str os, wc_status *st);

+extern int wc_parse_iso2022_esc(wc_uchar **ptr, wc_status *st);

+extern void wc_push_iso2022_esc(Str os, wc_ccs ccs, wc_uchar g, wc_uint8 invoke, wc_status *st);

+extern void wc_create_gmap(wc_status *st);

+extern Str wc_char_conv_from_iso2022(wc_uchar c, wc_status *st);

+

+#endif

+

+#include "wc.h"

+#include "jis.h"

+#include "search.h"

+#ifdef USE_UNICODE

+#include "ucs.h"

+#endif

+

+#include "map/jisx0201k_jisx0208.map"

+#include "map/jisx0208_jisx02131.map"

+

+wc_wchar_t

+wc_jisx0201k_to_jisx0208(wc_wchar_t cc)

+{

+ cc.code = jisx0201k_jisx0208_map[cc.code & 0x7f];

+ cc.ccs = cc.code ? WC_CCS_JIS_X_0208 : WC_CCS_UNKNOWN_W;

+ return cc;

+}

+

+wc_wchar_t

+wc_jisx0212_to_jisx0213(wc_wchar_t cc)

+{

+#ifdef USE_UNICODE

+ wc_wchar_t cc2;

+ static wc_table *t1 = NULL;

+ static wc_table *t2 = NULL;

+

+ if (t1 == NULL) {

+ t1 = wc_get_ucs_table(WC_CCS_JIS_X_0213_1);

+ t2 = wc_get_ucs_table(WC_CCS_JIS_X_0213_2);

+ }

+ cc2 = wc_any_to_any(cc, t2);

+ if (cc2.ccs == WC_CCS_JIS_X_0212)

+ return cc2;

+ return wc_any_to_any(cc, t1);

+#else

+ cc.ccs = WC_CCS_UNKNOWN_W;

+ return cc;

+#endif

+}

+

+wc_wchar_t

+wc_jisx0213_to_jisx0212(wc_wchar_t cc)

+{

+#ifdef USE_UNICODE

+ static wc_table *t = NULL;

+

+ if (t == NULL)

+ t = wc_get_ucs_table(WC_CCS_JIS_X_0212);

+ return wc_any_to_any(cc, t);

+#else

+ cc.ccs = WC_CCS_UNKNOWN_W;

+ return cc;

+#endif

+}

+

+wc_ccs

+wc_jisx0208_or_jisx02131(wc_uint16 code)

+{

+ return wc_map_range_search(code & 0x7f7f,

+ jisx0208_jisx02131_map, N_jisx0208_jisx02131_map)

+ ? WC_CCS_JIS_X_0213_1 : WC_CCS_JIS_X_0208;

+}

+

+wc_ccs

+wc_jisx0212_or_jisx02132(wc_uint16 code)

+{

+ return wc_jisx0212_jisx02132_map[(code >> 8) & 0x7f]

+ ? WC_CCS_JIS_X_0213_2 : WC_CCS_JIS_X_0212;

+}

+

+#ifndef _WC_JIS_H

+#define _WC_JIS_H

+

+extern wc_uchar *wc_jisx0212_jisx02132_map;

+

+extern wc_wchar_t wc_jisx0201k_to_jisx0208(wc_wchar_t cc);

+extern wc_wchar_t wc_jisx0212_to_jisx0213(wc_wchar_t cc);

+extern wc_wchar_t wc_jisx0213_to_jisx0212(wc_wchar_t cc);

+extern wc_ccs wc_jisx0208_or_jisx02131(wc_uint16 code);

+extern wc_ccs wc_jisx0212_or_jisx02132(wc_uint16 code);

+

+#endif

+

+#include "wc.h"

+#include "johab.h"

+#include "wtf.h"

+#ifdef USE_UNICODE

+#include "ucs.h"

+#endif

+

+#define C0 WC_JOHAB_MAP_C0

+#define GL WC_JOHAB_MAP_GL

+#define C1 WC_JOHAB_MAP_C1

+#define GH WC_JOHAB_MAP_GH

+#define GB WC_JOHAB_MAP_GB

+#define JJ WC_JOHAB_MAP_JJ

+#define JB WC_JOHAB_MAP_JB

+#define HB WC_JOHAB_MAP_HB

+#define CJ WC_JOHAB_MAP_CJ

+#define CB WC_JOHAB_MAP_CB

+

+/*

+ 00-1F 20-30 31-40 41-7E 7F 80 81-83 84-90 91-D3 D4-D7 D8-DE DF E0-F9 FA-FE FF

+ C0 GL GL GL C0 - - J J - H - H - -

+ - - J B - - J J B B B B B B -

+

+ C0 GL GH GB C0 C1 CJ JJ JB CB HB CB HB CB C1

+*/

+

+wc_uint8 WC_JOHAB_MAP[ 0x100 ] = {

+ C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0,

+ C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0,

+/* 20 */

+ GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL,

+/* 30 31 */

+ GL, GH, GH, GH, GH, GH, GH, GH, GH, GH, GH, GH, GH, GH, GH, GH,

+/* 40 41 */

+ GH, GB, GB, GB, GB, GB, GB, GB, GB, GB, GB, GB, GB, GB, GB, GB,

+ GB, GB, GB, GB, GB, GB, GB, GB, GB, GB, GB, GB, GB, GB, GB, GB,

+ GB, GB, GB, GB, GB, GB, GB, GB, GB, GB, GB, GB, GB, GB, GB, GB,

+ GB, GB, GB, GB, GB, GB, GB, GB, GB, GB, GB, GB, GB, GB, GB, C0,

+

+/* 80 83 84 */

+ C1, CJ, CJ, CJ, JJ, JJ, JJ, JJ, JJ, JJ, JJ, JJ, JJ, JJ, JJ, JJ,

+/* 90 91 */

+ JJ, JB, JB, JB, JB, JB, JB, JB, JB, JB, JB, JB, JB, JB, JB, JB,

+ JB, JB, JB, JB, JB, JB, JB, JB, JB, JB, JB, JB, JB, JB, JB, JB,

+ JB, JB, JB, JB, JB, JB, JB, JB, JB, JB, JB, JB, JB, JB, JB, JB,

+ JB, JB, JB, JB, JB, JB, JB, JB, JB, JB, JB, JB, JB, JB, JB, JB,

+/* D3 D4 D7 D8 DF */

+ JB, JB, JB, JB, CB, CB, CB, CB, HB, HB, HB, HB, HB, HB, HB, CB,

+ HB, HB, HB, HB, HB, HB, HB, HB, HB, HB, HB, HB, HB, HB, HB, HB,

+/* F9 FA FE FF */

+ HB, HB, HB, HB, HB, HB, HB, HB, HB, HB, CB, CB, CB, CB, CB, C1,

+};

+

+static wc_uint8 johab1_N_map[ 3 ][ 32 ] = {

+ { 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,

+ 15,16,17,18,19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },

+ { 0, 0, 0, 1, 2, 3, 4, 5, 0, 0, 6, 7, 8, 9,10,11,

+ 0, 0,12,13,14,15,16,17, 0, 0,18,19,20,21, 0, 0 },

+ { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,

+ 16,17, 0,18,19,20,21,22,23,24,25,26,27,28, 0, 0 }

+};

+

+static wc_uint8 N_johab1_map[ 3 ][ 32 ] = {

+ { 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,

+ 18,19,20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },

+ { 3, 4, 5, 6, 7,10,11,12,13,14,15,18,19,20,21,22,

+ 23,26,27,28,29, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },

+ { 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,

+ 17,19,20,21,22,23,24,25,26,27,28,29, 0, 0, 0, 0 }

+};

+

+wc_wchar_t

+wc_johab_to_ksx1001(wc_wchar_t cc)

+{

+#ifdef USE_UNICODE

+ static wc_table *t = NULL;

+#endif

+

+ switch (cc.ccs) {

+ case WC_CCS_JOHAB:

+ return wc_johab_to_ksx1001(wc_johab_to_cs128w(cc));

+ case WC_CCS_JOHAB_1:

+ case WC_CCS_JOHAB_2:

+#ifdef USE_UNICODE

+ if (WcOption.ucs_conv) {

+ if (t == NULL)

+ t = wc_get_ucs_table(WC_CCS_KS_X_1001);

+ cc = wc_any_to_any(cc, t);

+ } else

+#endif

+ cc.ccs = WC_CCS_UNKNOWN_W;

+ break;

+ case WC_CCS_JOHAB_3:

+ if (cc.code >= 0x2121)

+ cc.ccs = WC_CCS_KS_X_1001;

+ else

+ cc.ccs = WC_CCS_UNKNOWN_W;

+ break;

+ }

+ return cc;

+}

+

+wc_wchar_t

+wc_ksx1001_to_johab(wc_wchar_t cc)

+{

+ cc.code &= 0x7f7f;

+ if ((cc.code >= 0x2121 && cc.code < 0x2421) ||

+ (cc.code > 0x2453 && cc.code <= 0x2C7E) ||

+ (cc.code >= 0x4A21 && cc.code <= 0x7D7E)) {

+ cc.ccs = WC_CCS_JOHAB_3;

+ return cc;

+ }

+#ifdef USE_UNICODE

+ if (WcOption.ucs_conv)

+ cc = wc_ucs_to_johab(wc_any_to_ucs(cc));

+ else

+#endif

+ cc.ccs = WC_CCS_UNKNOWN_W;

+ return cc;

+}

+

+#ifdef USE_UNICODE

+wc_wchar_t

+wc_ucs_to_johab(wc_uint32 ucs)

+{

+ wc_table *t;

+ wc_wchar_t cc;

+

+ if (ucs >= WC_C_UCS2_HANGUL && ucs <= WC_C_UCS2_HANGUL_END) {

+ ucs -= WC_C_UCS2_HANGUL;

+ cc.code = WC_N_JOHAB1(ucs);

+ cc.ccs = WC_CCS_JOHAB;

+ } else if (ucs >= 0x3131 && ucs <= 0x3163) {

+ t = wc_get_ucs_table(WC_CCS_JOHAB_2);

+ cc = wc_ucs_to_any(ucs, t);

+ } else {

+ t = wc_get_ucs_table(WC_CCS_JOHAB_3);

+ cc = wc_ucs_to_any(ucs, t);

+ }

+ return cc;

+}

+#endif

+

+wc_uint32

+wc_johab1_to_N(wc_uint32 code)

+{

+ wc_uint32 a, b, c;

+

+ a = johab1_N_map[0][(code >> 10) & 0x1F];

+ b = johab1_N_map[1][(code >> 5) & 0x1F];

+ c = johab1_N_map[2][ code & 0x1F];

+ if (a && b && c)

+ return ((a - 1) * 21 + (b - 1)) * 28 + (c - 1);

+ return WC_C_JOHAB_ERROR;

+}

+

+wc_uint32

+wc_N_to_johab1(wc_uint32 code)

+{

+ wc_uint32 a, b, c;

+

+ a = N_johab1_map[0][(code / 28) / 21];

+ b = N_johab1_map[1][(code / 28) % 21];

+ c = N_johab1_map[2][ code % 28 ];

+ return 0x8000 | (a << 10) | (b << 5) | c;

+}

+

+/* 0x1F21 - 0x2C7E, 0x4A21 - 0x7C7E

+ (0x1F21 - 0x207E are not in KS X 1001) */

+#define johab3_to_ksx1001(ub, lb) \

+{ \

+ if (ub < 0xe0) { \

+ ub = ((ub - 0xd8) << 1) + 0x1f; \

+ } else { \

+ ub = ((ub - 0xe0) << 1) + 0x4a; \

+ } \

+ if (lb < 0xa1) { \

+ lb -= (lb < 0x91) ? 0x10 : 0x22; \

+ } else { \

+ ub++; \

+ lb -= 0x80; \

+ } \

+}

+

+#define ksx1001_to_johab3(ub, lb) \

+{ \

+ if (ub < 0x4a) { \

+ ub -= 0x1f; \

+ lb += (ub & 0x1) ? 0x80 : ((lb < 0x6f) ? 0x10 : 0x22); \

+ ub = (ub >> 1) + 0xd8; \

+ } else { \

+ ub -= 0x4a; \

+ lb += (ub & 0x1) ? 0x80 : ((lb < 0x6f) ? 0x10 : 0x22); \

+ ub = (ub >> 1) + 0xe0; \

+ } \

+}

+

+wc_wchar_t

+wc_johab_to_cs128w(wc_wchar_t cc)

+{

+ wc_uint32 n;

+ wc_uchar ub, lb;

+

+ if (cc.code < 0xD800) {

+ n = WC_JOHAB1_N(cc.code);

+ if (n != WC_C_JOHAB_ERROR) {

+ cc.code = WC_N_CS94x128(n);

+ cc.ccs = WC_CCS_JOHAB_1;

+ } else {

+ n = WC_JOHAB2_N(cc.code);

+ cc.code = WC_N_CS128W(n);

+ cc.ccs = WC_CCS_JOHAB_2;

+ }

+ } else {

+ ub = cc.code >> 8;

+ lb = cc.code & 0xff;

+ johab3_to_ksx1001(ub, lb);

+ cc.code = ((wc_uint32)ub << 8) | lb;

+ cc.ccs = WC_CCS_JOHAB_3;

+ }

+ return cc;

+}

+

+wc_wchar_t

+wc_cs128w_to_johab(wc_wchar_t cc)

+{

+ wc_uint32 n;

+ wc_uchar ub, lb;

+

+ switch (cc.ccs) {

+ case WC_CCS_JOHAB_1:

+ n = WC_CS94x128_N(cc.code);

+ cc.code = WC_N_JOHAB1(n);

+ break;

+ case WC_CCS_JOHAB_2:

+ n = WC_CS128W_N(cc.code);

+ cc.code = WC_N_JOHAB2(n);

+ break;

+ case WC_CCS_JOHAB_3:

+ ub = (cc.code >> 8) & 0x7f;

+ lb = cc.code & 0x7f;

+ ksx1001_to_johab3(ub, lb);

+ cc.code = ((wc_uint32)ub << 8) | lb;

+ }

+ cc.ccs = WC_CCS_JOHAB;

+ return cc;

+}

+

+Str

+wc_conv_from_johab(Str is, wc_ces ces)

+{

+ Str os;

+ wc_uchar *sp = (wc_uchar *)is->ptr;

+ wc_uchar *ep = sp + is->length;

+ wc_uchar *p;

+ int state = WC_JOHAB_NOSTATE;

+

+ for (p = sp; p < ep && *p < 0x80; p++)

+ ;

+ if (p == ep)

+ return is;

+ os = Strnew_size(is->length);

+ if (p > sp)

+ Strcat_charp_n(os, is->ptr, (int)(p - sp));

+

+ for (; p < ep; p++) {

+ switch (state) {

+ case WC_JOHAB_NOSTATE:

+ switch (WC_JOHAB_MAP[*p] & WC_JOHAB_MAP_1) {

+ case WC_JOHAB_MAP_UJ:

+ state = WC_JOHAB_HANGUL1;

+ break;

+ case WC_JOHAB_MAP_UH:

+ state = WC_JOHAB_HANJA1;

+ break;

+ case WC_JOHAB_MAP_C1:

+ wtf_push_unknown(os, p, 1);

+ break;

+ default:

+ Strcat_char(os, (char)*p);

+ break;

+ }

+ break;

+ case WC_JOHAB_HANGUL1:

+ if (WC_JOHAB_MAP[*p] & WC_JOHAB_MAP_LJ)

+ wtf_push(os, WC_CCS_JOHAB, ((wc_uint32)*(p-1) << 8) | *p);

+ else

+ wtf_push_unknown(os, p-1, 2);

+ state = WC_JOHAB_NOSTATE;

+ break;

+ case WC_JOHAB_HANJA1:

+ if (WC_JOHAB_MAP[*p] & WC_JOHAB_MAP_LH)

+ wtf_push(os, WC_CCS_JOHAB, ((wc_uint32)*(p-1) << 8) | *p);

+ else

+ wtf_push_unknown(os, p-1, 2);

+ state = WC_JOHAB_NOSTATE;

+ break;

+ }

+ }

+ switch (state) {

+ case WC_JOHAB_HANGUL1:

+ case WC_JOHAB_HANJA1:

+ wtf_push_unknown(os, p-1, 1);

+ break;

+ }

+ return os;

+}

+

+void

+wc_push_to_johab(Str os, wc_wchar_t cc, wc_status *st)

+{

+ while (1) {

+ switch (cc.ccs) {

+ case WC_CCS_US_ASCII:

+ Strcat_char(os, (char)cc.code);

+ return;

+ case WC_CCS_JOHAB_1:

+ case WC_CCS_JOHAB_2:

+ case WC_CCS_JOHAB_3:

+ cc = wc_cs128w_to_johab(cc);

+ case WC_CCS_JOHAB:

+ Strcat_char(os, (char)(cc.code >> 8));

+ Strcat_char(os, (char)(cc.code & 0xff));

+ return;

+ case WC_CCS_KS_X_1001:

+ cc = wc_ksx1001_to_johab(cc);

+ continue;

+ case WC_CCS_UNKNOWN_W:

+ if (!WcOption.no_replace)

+ Strcat_charp(os, WC_REPLACE_W);

+ return;

+ case WC_CCS_UNKNOWN:

+ if (!WcOption.no_replace)

+ Strcat_charp(os, WC_REPLACE);

+ return;

+ default:

+#ifdef USE_UNICODE

+ if (WcOption.ucs_conv)

+ cc = wc_any_to_any_ces(cc, st);

+ else

+#endif

+ cc.ccs = WC_CCS_IS_WIDE(cc.ccs) ? WC_CCS_UNKNOWN_W : WC_CCS_UNKNOWN;

+ continue;

+ }

+ }

+}

+

+Str

+wc_char_conv_from_johab(wc_uchar c, wc_status *st)

+{

+ static Str os;

+ static wc_uchar johabu;

+

+ if (st->state == -1) {

+ st->state = WC_JOHAB_NOSTATE;

+ os = Strnew_size(8);

+ }

+

+ switch (st->state) {

+ case WC_JOHAB_NOSTATE:

+ switch (WC_JOHAB_MAP[c] & WC_JOHAB_MAP_1) {

+ case WC_JOHAB_MAP_UJ:

+ johabu = c;

+ st->state = WC_JOHAB_HANGUL1;

+ return NULL;

+ case WC_JOHAB_MAP_UH:

+ johabu = c;

+ st->state = WC_JOHAB_HANJA1;

+ return NULL;

+ case WC_JOHAB_MAP_C1:

+ break;

+ default:

+ Strcat_char(os, (char)c);

+ break;

+ }

+ break;

+ case WC_JOHAB_HANGUL1:

+ if (WC_JOHAB_MAP[c] & WC_JOHAB_MAP_LJ)

+ wtf_push(os, WC_CCS_JOHAB, ((wc_uint32)johabu << 8) | c);

+ break;

+ case WC_JOHAB_HANJA1:

+ if (WC_JOHAB_MAP[c] & WC_JOHAB_MAP_LH)

+ wtf_push(os, WC_CCS_JOHAB, ((wc_uint32)johabu << 8) | c);

+ break;

+ }

+ st->state = -1;

+ return os;

+}

+

+#ifndef _WC_JOHAB_H

+#define _WC_JOHAB_H

+

+#define WC_C_JOHAB_ERROR 0xFFFFFFFFU

+

+#define WC_JOHAB_NOSTATE 0

+#define WC_JOHAB_HANGUL1 1 /* 0x84 - 0xD3 */

+#define WC_JOHAB_HANJA1 2 /* 0xD8 - 0xDE, 0xE0 - 0xF9 */

+

+#define WC_JOHAB_MAP_C0 0x0

+#define WC_JOHAB_MAP_GL 0x1

+#define WC_JOHAB_MAP_UJ 0x2

+#define WC_JOHAB_MAP_UH 0x4

+#define WC_JOHAB_MAP_C1 0x8

+#define WC_JOHAB_MAP_LJ 0x10

+#define WC_JOHAB_MAP_LH 0x20

+

+#define WC_JOHAB_MAP_GH (WC_JOHAB_MAP_GL|WC_JOHAB_MAP_LH)

+#define WC_JOHAB_MAP_GB (WC_JOHAB_MAP_GL|WC_JOHAB_MAP_LJ|WC_JOHAB_MAP_LH)

+#define WC_JOHAB_MAP_JJ (WC_JOHAB_MAP_UJ|WC_JOHAB_MAP_LJ)

+#define WC_JOHAB_MAP_JB (WC_JOHAB_MAP_UJ|WC_JOHAB_MAP_LJ|WC_JOHAB_MAP_LH)

+#define WC_JOHAB_MAP_HB (WC_JOHAB_MAP_UH|WC_JOHAB_MAP_LJ|WC_JOHAB_MAP_LH)

+#define WC_JOHAB_MAP_CJ (WC_JOHAB_MAP_C1|WC_JOHAB_MAP_LJ)

+#define WC_JOHAB_MAP_CB (WC_JOHAB_MAP_C1|WC_JOHAB_MAP_LJ|WC_JOHAB_MAP_LH)

+

+#define WC_JOHAB_MAP_1 0xF

+#define WC_JOHAB_MAP_2 0x30

+

+#define WC_JOHAB1_N(c) wc_johab1_to_N(c)

+#define WC_N_JOHAB1(c) wc_N_to_johab1(c)

+#define WC_CS94x128UL_N(U,L) (((U) - 0x21) * 0x80 + (L))

+#define WC_CS94x128_N(c) WC_CS94x128UL_N(((c) >> 8) & 0x7F, (c) & 0x7F)

+#define WC_N_CS94x128U(c) ((c) / 0x80 + 0x21)

+#define WC_N_CS94x128L(c) ((c) % 0x80)

+#define WC_N_CS94x128(c) ((WC_N_CS94x128U(c) << 8) + WC_N_CS94x128L(c))

+#define WC_JOHAB2UL_N(U,L) (((U) - 0x84) * 0xBC + (L) - (((L) < 0x81) ? 0x41 : 0x43))

+#define WC_JOHAB2_N(c) WC_JOHAB2UL_N(((c) >> 8) & 0xFF, (c) & 0xFF)

+#define WC_N_JOHAB2U(c) ((c) / 0xBC + 0x84)

+#define WC_N_JOHAB2L(c) ((c) % 0xBC + (((c) % 0xBC < 0x3E) ? 0x41 : 0x43))

+#define WC_N_JOHAB2(c) ((WC_N_JOHAB2U(c) << 8) + WC_N_JOHAB2L(c))

+#ifndef WC_CS128W_N

+#define WC_CS128WUL_N(U,L) ((U) * 0x80 + (L))

+#define WC_CS128W_N(c) WC_CS128WUL_N(((c) >> 8) & 0x7F, (c) & 0x7F)

+#define WC_N_CS128WU(c) ((c) / 0x80)

+#define WC_N_CS128WL(c) ((c) % 0x80)

+#define WC_N_CS128W(c) ((WC_N_CS128WU(c) << 8) + WC_N_CS128WL(c))

+#endif

+

+extern wc_uchar WC_JOHAB_MAP[];

+

+extern wc_wchar_t wc_johab_to_ksx1001(wc_wchar_t cc);

+extern wc_wchar_t wc_ksx1001_to_johab(wc_wchar_t cc);

+extern wc_wchar_t wc_ucs_to_johab(wc_uint32 ucs);

+extern wc_uint32 wc_johab1_to_N(wc_uint32 cc);

+extern wc_uint32 wc_N_to_johab1(wc_uint32 ucs);

+extern wc_wchar_t wc_johab_to_cs128w(wc_wchar_t cc);

+extern wc_wchar_t wc_cs128w_to_johab(wc_wchar_t cc);

+extern Str wc_conv_from_johab(Str is, wc_ces ces);

+extern void wc_push_to_johab(Str os, wc_wchar_t cc, wc_status *st);

+extern Str wc_char_conv_from_johab(wc_uchar c, wc_status *st);

+

+#endif

+/* Big5 (Chinese Taiwan) */

+

+static wc_uint16 big5_ucs_map[ 0x59 * 0x9D ] = {

+ 0x3000, /* 0xA140 */

+ 0xFF0C, /* 0xA141 */

+ 0x3001, /* 0xA142 */

+ 0x3002, /* 0xA143 */

+ 0xFF0E, /* 0xA144 */

+ 0x2027, /* 0xA145 */

+ 0xFF1B, /* 0xA146 */

+ 0xFF1A, /* 0xA147 */

+ 0xFF1F, /* 0xA148 */

+ 0xFF01, /* 0xA149 */

+ 0xFE30, /* 0xA14A */

+ 0x2026, /* 0xA14B */

+ 0x2025, /* 0xA14C */

+ 0xFE50, /* 0xA14D */

+ 0xFE51, /* 0xA14E */

+ 0xFE52, /* 0xA14F */

+ 0x00B7, /* 0xA150 */

+ 0xFE54, /* 0xA151 */

+ 0xFE55, /* 0xA152 */

+ 0xFE56, /* 0xA153 */

+ 0xFE57, /* 0xA154 */

+ 0xFF5C, /* 0xA155 */

+ 0x2013, /* 0xA156 */

+ 0xFE31, /* 0xA157 */

+ 0x2014, /* 0xA158 */

+ 0xFE33, /* 0xA159 */

+ 0x2574, /* 0xA15A */

+ 0xFE34, /* 0xA15B */

+ 0xFE4F, /* 0xA15C */

+ 0xFF08, /* 0xA15D */

+ 0xFF09, /* 0xA15E */

+ 0xFE35, /* 0xA15F */

+ 0xFE36, /* 0xA160 */

+ 0xFF5B, /* 0xA161 */

+ 0xFF5D, /* 0xA162 */

+ 0xFE37, /* 0xA163 */

+ 0xFE38, /* 0xA164 */

+ 0x3014, /* 0xA165 */

+ 0x3015, /* 0xA166 */

+ 0xFE39, /* 0xA167 */

+ 0xFE3A, /* 0xA168 */

+ 0x3010, /* 0xA169 */

+ 0x3011, /* 0xA16A */

+ 0xFE3B, /* 0xA16B */

+ 0xFE3C, /* 0xA16C */

+ 0x300A, /* 0xA16D */

+ 0x300B, /* 0xA16E */

+ 0xFE3D, /* 0xA16F */

+ 0xFE3E, /* 0xA170 */

+ 0x3008, /* 0xA171 */

+ 0x3009, /* 0xA172 */

+ 0xFE3F, /* 0xA173 */

+ 0xFE40, /* 0xA174 */

+ 0x300C, /* 0xA175 */

+ 0x300D, /* 0xA176 */

+ 0xFE41, /* 0xA177 */

+ 0xFE42, /* 0xA178 */

+ 0x300E, /* 0xA179 */

+ 0x300F, /* 0xA17A */

+ 0xFE43, /* 0xA17B */

+ 0xFE44, /* 0xA17C */

+ 0xFE59, /* 0xA17D */

+ 0xFE5A, /* 0xA17E */

+ 0xFE5B, /* 0xA1A1 */

+ 0xFE5C, /* 0xA1A2 */

+ 0xFE5D, /* 0xA1A3 */

+ 0xFE5E, /* 0xA1A4 */

+ 0x2018, /* 0xA1A5 */

+ 0x2019, /* 0xA1A6 */

+ 0x201C, /* 0xA1A7 */

+ 0x201D, /* 0xA1A8 */

+ 0x301D, /* 0xA1A9 */

+ 0x301E, /* 0xA1AA */

+ 0x2035, /* 0xA1AB */

+ 0x2032, /* 0xA1AC */

+ 0xFF03, /* 0xA1AD */

+ 0xFF06, /* 0xA1AE */

+ 0xFF0A, /* 0xA1AF */

+ 0x203B, /* 0xA1B0 */

+ 0x00A7, /* 0xA1B1 */

+ 0x3003, /* 0xA1B2 */

+ 0x25CB, /* 0xA1B3 */

+ 0x25CF, /* 0xA1B4 */

+ 0x25B3, /* 0xA1B5 */

+ 0x25B2, /* 0xA1B6 */

+ 0x25CE, /* 0xA1B7 */

+ 0x2606, /* 0xA1B8 */

+ 0x2605, /* 0xA1B9 */

+ 0x25C7, /* 0xA1BA */

+ 0x25C6, /* 0xA1BB */

+ 0x25A1, /* 0xA1BC */

+ 0x25A0, /* 0xA1BD */

+ 0x25BD, /* 0xA1BE */

+ 0x25BC, /* 0xA1BF */

+ 0x32A3, /* 0xA1C0 */

+ 0x2105, /* 0xA1C1 */

+ 0x00AF, /* 0xA1C2 */

+ 0xFFE3, /* 0xA1C3 */

+ 0xFF3F, /* 0xA1C4 */

+ 0x02CD, /* 0xA1C5 */

+ 0xFE49, /* 0xA1C6 */

+ 0xFE4A, /* 0xA1C7 */

+ 0xFE4D, /* 0xA1C8 */

+ 0xFE4E, /* 0xA1C9 */

+ 0xFE4B, /* 0xA1CA */

+ 0xFE4C, /* 0xA1CB */

+ 0xFE5F, /* 0xA1CC */

+ 0xFE60, /* 0xA1CD */

+ 0xFE61, /* 0xA1CE */

+ 0xFF0B, /* 0xA1CF */

+ 0xFF0D, /* 0xA1D0 */

+ 0x00D7, /* 0xA1D1 */

+ 0x00F7, /* 0xA1D2 */

+ 0x00B1, /* 0xA1D3 */

+ 0x221A, /* 0xA1D4 */

+ 0xFF1C, /* 0xA1D5 */

+ 0xFF1E, /* 0xA1D6 */

+ 0xFF1D, /* 0xA1D7 */

+ 0x2266, /* 0xA1D8 */

+ 0x2267, /* 0xA1D9 */

+ 0x2260, /* 0xA1DA */

+ 0x221E, /* 0xA1DB */

+ 0x2252, /* 0xA1DC */

+ 0x2261, /* 0xA1DD */

+ 0xFE62, /* 0xA1DE */

+ 0xFE63, /* 0xA1DF */

+ 0xFE64, /* 0xA1E0 */

+ 0xFE65, /* 0xA1E1 */

+ 0xFE66, /* 0xA1E2 */

+ 0xFF5E, /* 0xA1E3 */

+ 0x2229, /* 0xA1E4 */

+ 0x222A, /* 0xA1E5 */

+ 0x22A5, /* 0xA1E6 */

+ 0x2220, /* 0xA1E7 */

+ 0x221F, /* 0xA1E8 */

+ 0x22BF, /* 0xA1E9 */

+ 0x33D2, /* 0xA1EA */

+ 0x33D1, /* 0xA1EB */

+ 0x222B, /* 0xA1EC */

+ 0x222E, /* 0xA1ED */

+ 0x2235, /* 0xA1EE */

+ 0x2234, /* 0xA1EF */

+ 0x2640, /* 0xA1F0 */

+ 0x2642, /* 0xA1F1 */

+ 0x2295, /* 0xA1F2 */

+ 0x2299, /* 0xA1F3 */

+ 0x2191, /* 0xA1F4 */

+ 0x2193, /* 0xA1F5 */

+ 0x2190, /* 0xA1F6 */

+ 0x2192, /* 0xA1F7 */

+ 0x2196, /* 0xA1F8 */

+ 0x2197, /* 0xA1F9 */

+ 0x2199, /* 0xA1FA */

+ 0x2198, /* 0xA1FB */

+ 0x2225, /* 0xA1FC */

+ 0x2223, /* 0xA1FD */

+ 0xFF0F, /* 0xA1FE */

+ 0xFF3C, /* 0xA240 */

+ 0x2215, /* 0xA241 */

+ 0xFE68, /* 0xA242 */

+ 0xFF04, /* 0xA243 */

+ 0xFFE5, /* 0xA244 */

+ 0x3012, /* 0xA245 */

+ 0xFFE0, /* 0xA246 */

+ 0xFFE1, /* 0xA247 */

+ 0xFF05, /* 0xA248 */

+ 0xFF20, /* 0xA249 */

+ 0x2103, /* 0xA24A */

+ 0x2109, /* 0xA24B */

+ 0xFE69, /* 0xA24C */

+ 0xFE6A, /* 0xA24D */

+ 0xFE6B, /* 0xA24E */

+ 0x33D5, /* 0xA24F */

+ 0x339C, /* 0xA250 */

+ 0x339D, /* 0xA251 */

+ 0x339E, /* 0xA252 */

+ 0x33CE, /* 0xA253 */

+ 0x33A1, /* 0xA254 */

+ 0x338E, /* 0xA255 */

+ 0x338F, /* 0xA256 */

+ 0x33C4, /* 0xA257 */

+ 0x00B0, /* 0xA258 */

+ 0x5159, /* 0xA259 */

+ 0x515B, /* 0xA25A */

+ 0x515E, /* 0xA25B */

+ 0x515D, /* 0xA25C */

+ 0x5161, /* 0xA25D */

+ 0x5163, /* 0xA25E */

+ 0x55E7, /* 0xA25F */

+ 0x74E9, /* 0xA260 */

+ 0x7CCE, /* 0xA261 */

+ 0x2581, /* 0xA262 */

+ 0x2582, /* 0xA263 */

+ 0x2583, /* 0xA264 */

+ 0x2584, /* 0xA265 */

+ 0x2585, /* 0xA266 */

+ 0x2586, /* 0xA267 */

+ 0x2587, /* 0xA268 */

+ 0x2588, /* 0xA269 */

+ 0x258F, /* 0xA26A */

+ 0x258E, /* 0xA26B */

+ 0x258D, /* 0xA26C */

+ 0x258C, /* 0xA26D */

+ 0x258B, /* 0xA26E */

+ 0x258A, /* 0xA26F */

+ 0x2589, /* 0xA270 */

+ 0x253C, /* 0xA271 */

+ 0x2534, /* 0xA272 */

+ 0x252C, /* 0xA273 */

+ 0x2524, /* 0xA274 */

+ 0x251C, /* 0xA275 */

+ 0x2594, /* 0xA276 */

+ 0x2500, /* 0xA277 */

+ 0x2502, /* 0xA278 */

+ 0x2595, /* 0xA279 */

+ 0x250C, /* 0xA27A */

+ 0x2510, /* 0xA27B */

+ 0x2514, /* 0xA27C */

+ 0x2518, /* 0xA27D */

+ 0x256D, /* 0xA27E */

+ 0x256E, /* 0xA2A1 */

+ 0x2570, /* 0xA2A2 */

+ 0x256F, /* 0xA2A3 */

+ 0x2550, /* 0xA2A4 */

+ 0x255E, /* 0xA2A5 */

+ 0x256A, /* 0xA2A6 */

+ 0x2561, /* 0xA2A7 */

+ 0x25E2, /* 0xA2A8 */

+ 0x25E3, /* 0xA2A9 */

+ 0x25E5, /* 0xA2AA */

+ 0x25E4, /* 0xA2AB */

+ 0x2571, /* 0xA2AC */

+ 0x2572, /* 0xA2AD */

+ 0x2573, /* 0xA2AE */

+ 0xFF10, /* 0xA2AF */

+ 0xFF11, /* 0xA2B0 */

+ 0xFF12, /* 0xA2B1 */

+ 0xFF13, /* 0xA2B2 */

+ 0xFF14, /* 0xA2B3 */

+ 0xFF15, /* 0xA2B4 */

+ 0xFF16, /* 0xA2B5 */

+ 0xFF17, /* 0xA2B6 */

+ 0xFF18, /* 0xA2B7 */

+ 0xFF19, /* 0xA2B8 */

+ 0x2160, /* 0xA2B9 */

+ 0x2161, /* 0xA2BA */

+ 0x2162, /* 0xA2BB */

+ 0x2163, /* 0xA2BC */

+ 0x2164, /* 0xA2BD */

+ 0x2165, /* 0xA2BE */

+ 0x2166, /* 0xA2BF */

+ 0x2167, /* 0xA2C0 */

+ 0x2168, /* 0xA2C1 */

+ 0x2169, /* 0xA2C2 */

+ 0x3021, /* 0xA2C3 */

+ 0x3022, /* 0xA2C4 */

+ 0x3023, /* 0xA2C5 */

+ 0x3024, /* 0xA2C6 */

+ 0x3025, /* 0xA2C7 */

+ 0x3026, /* 0xA2C8 */

+ 0x3027, /* 0xA2C9 */

+ 0x3028, /* 0xA2CA */

+ 0x3029, /* 0xA2CB */

+ 0x5341, /* 0xA2CC */

+ 0x5344, /* 0xA2CD */

+ 0x5345, /* 0xA2CE */

+ 0xFF21, /* 0xA2CF */

+ 0xFF22, /* 0xA2D0 */

+ 0xFF23, /* 0xA2D1 */

+ 0xFF24, /* 0xA2D2 */

+ 0xFF25, /* 0xA2D3 */

+ 0xFF26, /* 0xA2D4 */

+ 0xFF27, /* 0xA2D5 */

+ 0xFF28, /* 0xA2D6 */

+ 0xFF29, /* 0xA2D7 */

+ 0xFF2A, /* 0xA2D8 */

+ 0xFF2B, /* 0xA2D9 */

+ 0xFF2C, /* 0xA2DA */

+ 0xFF2D, /* 0xA2DB */

+ 0xFF2E, /* 0xA2DC */

+ 0xFF2F, /* 0xA2DD */

+ 0xFF30, /* 0xA2DE */

+ 0xFF31, /* 0xA2DF */

+ 0xFF32, /* 0xA2E0 */

+ 0xFF33, /* 0xA2E1 */

+ 0xFF34, /* 0xA2E2 */

+ 0xFF35, /* 0xA2E3 */

+ 0xFF36, /* 0xA2E4 */

+ 0xFF37, /* 0xA2E5 */

+ 0xFF38, /* 0xA2E6 */

+ 0xFF39, /* 0xA2E7 */

+ 0xFF3A, /* 0xA2E8 */

+ 0xFF41, /* 0xA2E9 */

+ 0xFF42, /* 0xA2EA */

+ 0xFF43, /* 0xA2EB */

+ 0xFF44, /* 0xA2EC */

+ 0xFF45, /* 0xA2ED */

+ 0xFF46, /* 0xA2EE */

+ 0xFF47, /* 0xA2EF */

+ 0xFF48, /* 0xA2F0 */

+ 0xFF49, /* 0xA2F1 */

+ 0xFF4A, /* 0xA2F2 */

+ 0xFF4B, /* 0xA2F3 */

+ 0xFF4C, /* 0xA2F4 */

+ 0xFF4D, /* 0xA2F5 */

+ 0xFF4E, /* 0xA2F6 */

+ 0xFF4F, /* 0xA2F7 */

+ 0xFF50, /* 0xA2F8 */

+ 0xFF51, /* 0xA2F9 */

+ 0xFF52, /* 0xA2FA */

+ 0xFF53, /* 0xA2FB */

+ 0xFF54, /* 0xA2FC */

+ 0xFF55, /* 0xA2FD */

+ 0xFF56, /* 0xA2FE */

+ 0xFF57, /* 0xA340 */

+ 0xFF58, /* 0xA341 */

+ 0xFF59, /* 0xA342 */

+ 0xFF5A, /* 0xA343 */

+ 0x0391, /* 0xA344 */

+ 0x0392, /* 0xA345 */

+ 0x0393, /* 0xA346 */

+ 0x0394, /* 0xA347 */

+ 0x0395, /* 0xA348 */

+ 0x0396, /* 0xA349 */

+ 0x0397, /* 0xA34A */

+ 0x0398, /* 0xA34B */

+ 0x0399, /* 0xA34C */

+ 0x039A, /* 0xA34D */

+ 0x039B, /* 0xA34E */

+ 0x039C, /* 0xA34F */

+ 0x039D, /* 0xA350 */

+ 0x039E, /* 0xA351 */

+ 0x039F, /* 0xA352 */

+ 0x03A0, /* 0xA353 */

+ 0x03A1, /* 0xA354 */

+ 0x03A3, /* 0xA355 */

+ 0x03A4, /* 0xA356 */

+ 0x03A5, /* 0xA357 */

+ 0x03A6, /* 0xA358 */

+ 0x03A7, /* 0xA359 */

+ 0x03A8, /* 0xA35A */

+ 0x03A9, /* 0xA35B */

+ 0x03B1, /* 0xA35C */

+ 0x03B2, /* 0xA35D */

+ 0x03B3, /* 0xA35E */

+ 0x03B4, /* 0xA35F */

+ 0x03B5, /* 0xA360 */

+ 0x03B6, /* 0xA361 */

+ 0x03B7, /* 0xA362 */

+ 0x03B8, /* 0xA363 */

+ 0x03B9, /* 0xA364 */

+ 0x03BA, /* 0xA365 */

+ 0x03BB, /* 0xA366 */

+ 0x03BC, /* 0xA367 */

+ 0x03BD, /* 0xA368 */

+ 0x03BE, /* 0xA369 */

+ 0x03BF, /* 0xA36A */

+ 0x03C0, /* 0xA36B */

+ 0x03C1, /* 0xA36C */

+ 0x03C3, /* 0xA36D */

+ 0x03C4, /* 0xA36E */

+ 0x03C5, /* 0xA36F */

+ 0x03C6, /* 0xA370 */

+ 0x03C7, /* 0xA371 */

+ 0x03C8, /* 0xA372 */

+ 0x03C9, /* 0xA373 */

+ 0x3105, /* 0xA374 */

+ 0x3106, /* 0xA375 */

+ 0x3107, /* 0xA376 */

+ 0x3108, /* 0xA377 */

+ 0x3109, /* 0xA378 */

+ 0x310A, /* 0xA379 */

+ 0x310B, /* 0xA37A */

+ 0x310C, /* 0xA37B */

+ 0x310D, /* 0xA37C */

+ 0x310E, /* 0xA37D */

+ 0x310F, /* 0xA37E */

+ 0x3110, /* 0xA3A1 */

+ 0x3111, /* 0xA3A2 */

+ 0x3112, /* 0xA3A3 */

+ 0x3113, /* 0xA3A4 */

+ 0x3114, /* 0xA3A5 */

+ 0x3115, /* 0xA3A6 */

+ 0x3116, /* 0xA3A7 */

+ 0x3117, /* 0xA3A8 */

+ 0x3118, /* 0xA3A9 */

+ 0x3119, /* 0xA3AA */

+ 0x311A, /* 0xA3AB */

+ 0x311B, /* 0xA3AC */

+ 0x311C, /* 0xA3AD */

+ 0x311D, /* 0xA3AE */

+ 0x311E, /* 0xA3AF */

+ 0x311F, /* 0xA3B0 */

+ 0x3120, /* 0xA3B1 */

+ 0x3121, /* 0xA3B2 */

+ 0x3122, /* 0xA3B3 */

+ 0x3123, /* 0xA3B4 */

+ 0x3124, /* 0xA3B5 */

+ 0x3125, /* 0xA3B6 */

+ 0x3126, /* 0xA3B7 */

+ 0x3127, /* 0xA3B8 */

+ 0x3128, /* 0xA3B9 */

+ 0x3129, /* 0xA3BA */

+ 0x02D9, /* 0xA3BB */

+ 0x02C9, /* 0xA3BC */

+ 0x02CA, /* 0xA3BD */

+ 0x02C7, /* 0xA3BE */

+ 0x02CB, /* 0xA3BF */

+ 0, /* 0xA3C0 */

+ 0, /* 0xA3C1 */

+ 0, /* 0xA3C2 */

+ 0, /* 0xA3C3 */

+ 0, /* 0xA3C4 */

+ 0, /* 0xA3C5 */

+ 0, /* 0xA3C6 */

+ 0, /* 0xA3C7 */

+ 0, /* 0xA3C8 */

+ 0, /* 0xA3C9 */

+ 0, /* 0xA3CA */

+ 0, /* 0xA3CB */

+ 0, /* 0xA3CC */

+ 0, /* 0xA3CD */

+ 0, /* 0xA3CE */

+ 0, /* 0xA3CF */

+ 0, /* 0xA3D0 */

+ 0, /* 0xA3D1 */

+ 0, /* 0xA3D2 */

+ 0, /* 0xA3D3 */

+ 0, /* 0xA3D4 */

+ 0, /* 0xA3D5 */

+ 0, /* 0xA3D6 */

+ 0, /* 0xA3D7 */

+ 0, /* 0xA3D8 */

+ 0, /* 0xA3D9 */

+ 0, /* 0xA3DA */

+ 0, /* 0xA3DB */

+ 0, /* 0xA3DC */

+ 0, /* 0xA3DD */

+ 0, /* 0xA3DE */

+ 0, /* 0xA3DF */

+ 0, /* 0xA3E0 */

+ 0x20AC, /* 0xA3E1 */

+ 0, /* 0xA3E2 */

+ 0, /* 0xA3E3 */

+ 0, /* 0xA3E4 */

+ 0, /* 0xA3E5 */

+ 0, /* 0xA3E6 */

+ 0, /* 0xA3E7 */

+ 0, /* 0xA3E8 */

+ 0, /* 0xA3E9 */

+ 0, /* 0xA3EA */

+ 0, /* 0xA3EB */

+ 0, /* 0xA3EC */

+ 0, /* 0xA3ED */

+ 0, /* 0xA3EE */

+ 0, /* 0xA3EF */

+ 0, /* 0xA3F0 */

+ 0, /* 0xA3F1 */

+ 0, /* 0xA3F2 */

+ 0, /* 0xA3F3 */

+ 0, /* 0xA3F4 */

+ 0, /* 0xA3F5 */

+ 0, /* 0xA3F6 */

+ 0, /* 0xA3F7 */

+ 0, /* 0xA3F8 */

+ 0, /* 0xA3F9 */

+ 0, /* 0xA3FA */

+ 0, /* 0xA3FB */

+ 0, /* 0xA3FC */

+ 0, /* 0xA3FD */

+ 0, /* 0xA3FE */

+ 0x4E00, /* 0xA440 */

+ 0x4E59, /* 0xA441 */

+ 0x4E01, /* 0xA442 */

+ 0x4E03, /* 0xA443 */

+ 0x4E43, /* 0xA444 */

+ 0x4E5D, /* 0xA445 */

+ 0x4E86, /* 0xA446 */

+ 0x4E8C, /* 0xA447 */

+ 0x4EBA, /* 0xA448 */

+ 0x513F, /* 0xA449 */

+ 0x5165, /* 0xA44A */

+ 0x516B, /* 0xA44B */

+ 0x51E0, /* 0xA44C */

+ 0x5200, /* 0xA44D */

+ 0x5201, /* 0xA44E */

+ 0x529B, /* 0xA44F */

+ 0x5315, /* 0xA450 */

+ 0x5341, /* 0xA451 */

+ 0x535C, /* 0xA452 */

+ 0x53C8, /* 0xA453 */

+ 0x4E09, /* 0xA454 */

+ 0x4E0B, /* 0xA455 */

+ 0x4E08, /* 0xA456 */

+ 0x4E0A, /* 0xA457 */

+ 0x4E2B, /* 0xA458 */

+ 0x4E38, /* 0xA459 */

+ 0x51E1, /* 0xA45A */

+ 0x4E45, /* 0xA45B */

+ 0x4E48, /* 0xA45C */

+ 0x4E5F, /* 0xA45D */

+ 0x4E5E, /* 0xA45E */

+ 0x4E8E, /* 0xA45F */

+ 0x4EA1, /* 0xA460 */

+ 0x5140, /* 0xA461 */

+ 0x5203, /* 0xA462 */

+ 0x52FA, /* 0xA463 */

+ 0x5343, /* 0xA464 */

+ 0x53C9, /* 0xA465 */

+ 0x53E3, /* 0xA466 */

+ 0x571F, /* 0xA467 */

+ 0x58EB, /* 0xA468 */

+ 0x5915, /* 0xA469 */

+ 0x5927, /* 0xA46A */

+ 0x5973, /* 0xA46B */

+ 0x5B50, /* 0xA46C */

+ 0x5B51, /* 0xA46D */

+ 0x5B53, /* 0xA46E */

+ 0x5BF8, /* 0xA46F */

+ 0x5C0F, /* 0xA470 */

+ 0x5C22, /* 0xA471 */

+ 0x5C38, /* 0xA472 */

+ 0x5C71, /* 0xA473 */

+ 0x5DDD, /* 0xA474 */

+ 0x5DE5, /* 0xA475 */

+ 0x5DF1, /* 0xA476 */

+ 0x5DF2, /* 0xA477 */

+ 0x5DF3, /* 0xA478 */

+ 0x5DFE, /* 0xA479 */

+ 0x5E72, /* 0xA47A */

+ 0x5EFE, /* 0xA47B */

+ 0x5F0B, /* 0xA47C */

+ 0x5F13, /* 0xA47D */

+ 0x624D, /* 0xA47E */

+ 0x4E11, /* 0xA4A1 */

+ 0x4E10, /* 0xA4A2 */

+ 0x4E0D, /* 0xA4A3 */

+ 0x4E2D, /* 0xA4A4 */

+ 0x4E30, /* 0xA4A5 */

+ 0x4E39, /* 0xA4A6 */

+ 0x4E4B, /* 0xA4A7 */

+ 0x5C39, /* 0xA4A8 */

+ 0x4E88, /* 0xA4A9 */

+ 0x4E91, /* 0xA4AA */

+ 0x4E95, /* 0xA4AB */

+ 0x4E92, /* 0xA4AC */

+ 0x4E94, /* 0xA4AD */

+ 0x4EA2, /* 0xA4AE */

+ 0x4EC1, /* 0xA4AF */

+ 0x4EC0, /* 0xA4B0 */

+ 0x4EC3, /* 0xA4B1 */

+ 0x4EC6, /* 0xA4B2 */

+ 0x4EC7, /* 0xA4B3 */

+ 0x4ECD, /* 0xA4B4 */

+ 0x4ECA, /* 0xA4B5 */

+ 0x4ECB, /* 0xA4B6 */

+ 0x4EC4, /* 0xA4B7 */

+ 0x5143, /* 0xA4B8 */

+ 0x5141, /* 0xA4B9 */

+ 0x5167, /* 0xA4BA */

+ 0x516D, /* 0xA4BB */

+ 0x516E, /* 0xA4BC */

+ 0x516C, /* 0xA4BD */

+ 0x5197, /* 0xA4BE */

+ 0x51F6, /* 0xA4BF */

+ 0x5206, /* 0xA4C0 */

+ 0x5207, /* 0xA4C1 */

+ 0x5208, /* 0xA4C2 */

+ 0x52FB, /* 0xA4C3 */

+ 0x52FE, /* 0xA4C4 */

+ 0x52FF, /* 0xA4C5 */

+ 0x5316, /* 0xA4C6 */

+ 0x5339, /* 0xA4C7 */

+ 0x5348, /* 0xA4C8 */

+ 0x5347, /* 0xA4C9 */

+ 0x5345, /* 0xA4CA */

+ 0x535E, /* 0xA4CB */

+ 0x5384, /* 0xA4CC */

+ 0x53CB, /* 0xA4CD */

+ 0x53CA, /* 0xA4CE */

+ 0x53CD, /* 0xA4CF */

+ 0x58EC, /* 0xA4D0 */

+ 0x5929, /* 0xA4D1 */

+ 0x592B, /* 0xA4D2 */

+ 0x592A, /* 0xA4D3 */

+ 0x592D, /* 0xA4D4 */

+ 0x5B54, /* 0xA4D5 */

+ 0x5C11, /* 0xA4D6 */

+ 0x5C24, /* 0xA4D7 */

+ 0x5C3A, /* 0xA4D8 */

+ 0x5C6F, /* 0xA4D9 */

+ 0x5DF4, /* 0xA4DA */

+ 0x5E7B, /* 0xA4DB */

+ 0x5EFF, /* 0xA4DC */

+ 0x5F14, /* 0xA4DD */

+ 0x5F15, /* 0xA4DE */

+ 0x5FC3, /* 0xA4DF */

+ 0x6208, /* 0xA4E0 */

+ 0x6236, /* 0xA4E1 */

+ 0x624B, /* 0xA4E2 */

+ 0x624E, /* 0xA4E3 */

+ 0x652F, /* 0xA4E4 */

+ 0x6587, /* 0xA4E5 */

+ 0x6597, /* 0xA4E6 */

+ 0x65A4, /* 0xA4E7 */

+ 0x65B9, /* 0xA4E8 */

+ 0x65E5, /* 0xA4E9 */

+ 0x66F0, /* 0xA4EA */

+ 0x6708, /* 0xA4EB */

+ 0x6728, /* 0xA4EC */

+ 0x6B20, /* 0xA4ED */

+ 0x6B62, /* 0xA4EE */

+ 0x6B79, /* 0xA4EF */

+ 0x6BCB, /* 0xA4F0 */

+ 0x6BD4, /* 0xA4F1 */

+ 0x6BDB, /* 0xA4F2 */

+ 0x6C0F, /* 0xA4F3 */

+ 0x6C34, /* 0xA4F4 */

+ 0x706B, /* 0xA4F5 */

+ 0x722A, /* 0xA4F6 */

+ 0x7236, /* 0xA4F7 */

+ 0x723B, /* 0xA4F8 */

+ 0x7247, /* 0xA4F9 */

+ 0x7259, /* 0xA4FA */

+ 0x725B, /* 0xA4FB */

+ 0x72AC, /* 0xA4FC */

+ 0x738B, /* 0xA4FD */

+ 0x4E19, /* 0xA4FE */

+ 0x4E16, /* 0xA540 */

+ 0x4E15, /* 0xA541 */

+ 0x4E14, /* 0xA542 */

+ 0x4E18, /* 0xA543 */

+ 0x4E3B, /* 0xA544 */