cpython/Modules/cjkcodecs/_codecs_iso2022.c

/*
 * _codecs_iso2022.c: Codecs collection for ISO-2022 encodings.
 *
 * Written by Hye-Shik Chang <perky@FreeBSD.org>
 * $CJKCodecs: _codecs_iso2022.c,v 1.22 2004/08/19 17:08:13 perky Exp $
 */

#define USING_IMPORTED_MAPS
#define USING_BINARY_PAIR_SEARCH
#define EXTERN_JISX0213_PAIR
#define EMULATE_JISX0213_2000_ENCODE_INVALID MAP_UNMAPPABLE
#define EMULATE_JISX0213_2000_DECODE_INVALID MAP_UNMAPPABLE

#include "cjkcodecs.h"
#include "alg_jisx0201.h"
#include "emu_jisx0213_2000.h"
#include "mappings_jisx0213_pair.h"

/* STATE

   state->c[0-3]

	00000000
	||^^^^^|
	|+-----+----  G0-3 Character Set
	+-----------  Is G0-3 double byte?

   state->c[4]

	00000000
	      ||
	      |+----  Locked-Shift?
	      +-----  ESC Throughout
*/

#define ESC			0x1B
#define SO			0x0E
#define SI			0x0F
#define LF			0x0A

#define MAX_ESCSEQLEN		16

#define CHARSET_ISO8859_1	'A'
#define CHARSET_ASCII		'B'
#define CHARSET_ISO8859_7	'F'
#define CHARSET_JISX0201_K	'I'
#define CHARSET_JISX0201_R	'J'

#define CHARSET_GB2312		('A'|CHARSET_DBCS)
#define CHARSET_JISX0208	('B'|CHARSET_DBCS)
#define CHARSET_KSX1001		('C'|CHARSET_DBCS)
#define CHARSET_JISX0212	('D'|CHARSET_DBCS)
#define CHARSET_GB2312_8565	('E'|CHARSET_DBCS)
#define CHARSET_CNS11643_1	('G'|CHARSET_DBCS)
#define CHARSET_CNS11643_2	('H'|CHARSET_DBCS)
#define CHARSET_JISX0213_2000_1	('O'|CHARSET_DBCS)
#define CHARSET_JISX0213_2	('P'|CHARSET_DBCS)
#define CHARSET_JISX0213_2004_1	('Q'|CHARSET_DBCS)
#define CHARSET_JISX0208_O	('@'|CHARSET_DBCS)

#define CHARSET_DBCS		0x80
#define ESCMARK(mark)		((mark) & 0x7f)

#define IS_ESCEND(c)	(((c) >= 'A' && (c) <= 'Z') || (c) == '@')
#define IS_ISO2022ESC(c2) \
		((c2) == '(' || (c2) == ')' || (c2) == '$' || \
		 (c2) == '.' || (c2) == '&')
	/* this is not a complete list of ISO-2022 escape sequence headers.
	 * but, it's enough to implement CJK instances of iso-2022. */

#define MAP_UNMAPPABLE		0xFFFF
#define MAP_MULTIPLE_AVAIL	0xFFFE /* for JIS X 0213 */

#define F_SHIFTED		0x01
#define F_ESCTHROUGHOUT		0x02

#define STATE_SETG(dn, v)	((state)->c[dn]) = (v);
#define STATE_GETG(dn)		((state)->c[dn])

#define STATE_G0		STATE_GETG(0)
#define STATE_G1		STATE_GETG(1)
#define STATE_G2		STATE_GETG(2)
#define STATE_G3		STATE_GETG(3)
#define STATE_SETG0(v)		STATE_SETG(0, v)
#define STATE_SETG1(v)		STATE_SETG(1, v)
#define STATE_SETG2(v)		STATE_SETG(2, v)
#define STATE_SETG3(v)		STATE_SETG(3, v)

#define STATE_SETFLAG(f)	((state)->c[4]) |= (f);
#define STATE_GETFLAG(f)	((state)->c[4] & (f))
#define STATE_CLEARFLAG(f)	((state)->c[4]) &= ~(f);
#define STATE_CLEARFLAGS()	((state)->c[4]) = 0;

#define ISO2022_CONFIG		((const struct iso2022_config *)config)
#define CONFIG_ISSET(flag)	(ISO2022_CONFIG->flags & (flag))
#define CONFIG_DESIGNATIONS	(ISO2022_CONFIG->designations)

/* iso2022_config.flags */
#define NO_SHIFT		0x01
#define USE_G2			0x02
#define USE_JISX0208_EXT	0x04

/*-*- internal data structures -*-*/

typedef int (*iso2022_init_func)(void);
typedef ucs4_t (*iso2022_decode_func)(const unsigned char *data);
typedef DBCHAR (*iso2022_encode_func)(const ucs4_t *data, int *length);

struct iso2022_designation {
	unsigned char mark;
	unsigned char plane;
	unsigned char width;
	iso2022_init_func initializer;
	iso2022_decode_func decoder;
	iso2022_encode_func encoder;
};

struct iso2022_config {
	int flags;
	const struct iso2022_designation *designations; /* non-ascii desigs */
};

/*-*- iso-2022 codec implementation -*-*/

CODEC_INIT(iso2022)
{
	const struct iso2022_designation *desig = CONFIG_DESIGNATIONS;
	for (desig = CONFIG_DESIGNATIONS; desig->mark; desig++)
		if (desig->initializer != NULL && desig->initializer() != 0)
			return -1;
	return 0;
}

ENCODER_INIT(iso2022)
{
	STATE_CLEARFLAGS()
	STATE_SETG0(CHARSET_ASCII)
	STATE_SETG1(CHARSET_ASCII)
	return 0;
}

ENCODER_RESET(iso2022)
{
	if (STATE_GETFLAG(F_SHIFTED)) {
		WRITE1(SI)
		NEXT_OUT(1)
		STATE_CLEARFLAG(F_SHIFTED)
	}
	if (STATE_G0 != CHARSET_ASCII) {
		WRITE3(ESC, '(', 'B')
		NEXT_OUT(3)
		STATE_SETG0(CHARSET_ASCII)
	}
	return 0;
}

ENCODER(iso2022)
{
	while (inleft > 0) {
		const struct iso2022_designation *dsg;
		DBCHAR encoded;
		ucs4_t c = **inbuf;
		int insize;

		if (c < 0x80) {
			if (STATE_G0 != CHARSET_ASCII) {
				WRITE3(ESC, '(', 'B')
				STATE_SETG0(CHARSET_ASCII)
				NEXT_OUT(3)
			}
			if (STATE_GETFLAG(F_SHIFTED)) {
				WRITE1(SI)
				STATE_CLEARFLAG(F_SHIFTED)
				NEXT_OUT(1)
			}
			WRITE1((unsigned char)c)
			NEXT(1, 1)
			continue;
		}

		DECODE_SURROGATE(c)
		insize = GET_INSIZE(c);

		encoded = MAP_UNMAPPABLE;
		for (dsg = CONFIG_DESIGNATIONS; dsg->mark; dsg++) {
			int length = 1;
			encoded = dsg->encoder(&c, &length);
			if (encoded == MAP_MULTIPLE_AVAIL) {
				/* this implementation won't work for pair
				 * of non-bmp characters. */
				if (inleft < 2) {
					if (!(flags & MBENC_FLUSH))
						return MBERR_TOOFEW;
					length = -1;
				}
				else
					length = 2;
#if Py_UNICODE_SIZE == 2
				if (length == 2) {
					ucs4_t u4in[2];
					u4in[0] = (ucs4_t)IN1;
					u4in[1] = (ucs4_t)IN2;
					encoded = dsg->encoder(u4in, &length);
				} else
					encoded = dsg->encoder(&c, &length);
#else
				encoded = dsg->encoder(*inbuf, &length);
#endif
				if (encoded != MAP_UNMAPPABLE) {
					insize = length;
					break;
				}
			}
			else if (encoded != MAP_UNMAPPABLE)
				break;
		}

		if (!dsg->mark)
			return 1;
		assert(dsg->width == 1 || dsg->width == 2);

		switch (dsg->plane) {
		case 0: /* G0 */
			if (STATE_GETFLAG(F_SHIFTED)) {
				WRITE1(SI)
				STATE_CLEARFLAG(F_SHIFTED)
				NEXT_OUT(1)
			}
			if (STATE_G0 != dsg->mark) {
				if (dsg->width == 1) {
					WRITE3(ESC, '(', ESCMARK(dsg->mark))
					STATE_SETG0(dsg->mark)
					NEXT_OUT(3)
				}
				else if (dsg->mark == CHARSET_JISX0208) {
					WRITE3(ESC, '$', ESCMARK(dsg->mark))
					STATE_SETG0(dsg->mark)
					NEXT_OUT(3)
				}
				else {
					WRITE4(ESC, '$', '(',
						ESCMARK(dsg->mark))
					STATE_SETG0(dsg->mark)
					NEXT_OUT(4)
				}
			}
			break;
		case 1: /* G1 */
			if (STATE_G1 != dsg->mark) {
				if (dsg->width == 1) {
					WRITE3(ESC, ')', ESCMARK(dsg->mark))
					STATE_SETG1(dsg->mark)
					NEXT_OUT(3)
				}
				else {
					WRITE4(ESC, '$', ')',
						ESCMARK(dsg->mark))
					STATE_SETG1(dsg->mark)
					NEXT_OUT(4)
				}
			}
			if (!STATE_GETFLAG(F_SHIFTED)) {
				WRITE1(SO)
				STATE_SETFLAG(F_SHIFTED)
				NEXT_OUT(1)
			}
			break;
		default: /* G2 and G3 is not supported: no encoding in
			  * CJKCodecs are using them yet */
			return MBERR_INTERNAL;
		}

		if (dsg->width == 1) {
			WRITE1((unsigned char)encoded)
			NEXT_OUT(1)
		}
		else {
			WRITE2(encoded >> 8, encoded & 0xff)
			NEXT_OUT(2)
		}
		NEXT_IN(insize)
	}

	return 0;
}

DECODER_INIT(iso2022)
{
	STATE_CLEARFLAGS()
	STATE_SETG0(CHARSET_ASCII)
	STATE_SETG1(CHARSET_ASCII)
	STATE_SETG2(CHARSET_ASCII)
	return 0;
}

DECODER_RESET(iso2022)
{
	STATE_SETG0(CHARSET_ASCII)
	STATE_CLEARFLAG(F_SHIFTED)
	return 0;
}

static int
iso2022processesc(const void *config, MultibyteCodec_State *state,
		  const unsigned char **inbuf, size_t *inleft)
{
	unsigned char charset, designation;
	size_t i, esclen;

	for (i = 1;i < MAX_ESCSEQLEN;i++) {
		if (i >= *inleft)
			return MBERR_TOOFEW;
		if (IS_ESCEND((*inbuf)[i])) {
			esclen = i + 1;
			break;
		}
		else if (CONFIG_ISSET(USE_JISX0208_EXT) && i+1 < *inleft &&
			 (*inbuf)[i] == '&' && (*inbuf)[i+1] == '@')
			i += 2;
	}

	if (i >= MAX_ESCSEQLEN)
		return 1; /* unterminated escape sequence */

	switch (esclen) {
	case 3:
		if (IN2 == '$') {
			charset = IN3 | CHARSET_DBCS;
			designation = 0;
		}
		else {
			charset = IN3;
			if (IN2 == '(') designation = 0;
			else if (IN2 == ')') designation = 1;
			else if (CONFIG_ISSET(USE_G2) && IN2 == '.')
				designation = 2;
			else return 3;
		}
		break;
	case 4:
		if (IN2 != '$')
			return 4;

		charset = IN4 | CHARSET_DBCS;
		if (IN3 == '(') designation = 0;
		else if (IN3 == ')') designation = 1;
		else return 4;
		break;
	case 6: /* designation with prefix */
		if (CONFIG_ISSET(USE_JISX0208_EXT) &&
		    (*inbuf)[3] == ESC && (*inbuf)[4] == '$' &&
		    (*inbuf)[5] == 'B') {
			charset = 'B' | CHARSET_DBCS;
			designation = 0;
		}
		else
			return 6;
		break;
	default:
		return esclen;
	}

	/* raise error when the charset is not designated for this encoding */
	if (charset != CHARSET_ASCII) {
		const struct iso2022_designation *dsg;

		for (dsg = CONFIG_DESIGNATIONS; dsg->mark; dsg++)
			if (dsg->mark == charset)
				break;
		if (!dsg->mark)
			return esclen;
	}

	STATE_SETG(designation, charset)
	*inleft -= esclen;
	(*inbuf) += esclen;
	return 0;
}

#define ISO8859_7_DECODE(c, assi)					\
	if ((c) < 0xa0) (assi) = (c);					\
	else if ((c) < 0xc0 && (0x288f3bc9L & (1L << ((c)-0xa0))))	\
		(assi) = (c);						\
	else if ((c) >= 0xb4 && (c) <= 0xfe && ((c) >= 0xd4 ||		\
		 (0xbffffd77L & (1L << ((c)-0xb4)))))			\
		(assi) = 0x02d0 + (c);					\
	else if ((c) == 0xa1) (assi) = 0x2018;				\
	else if ((c) == 0xa2) (assi) = 0x2019;				\
	else if ((c) == 0xaf) (assi) = 0x2015;

static int
iso2022processg2(const void *config, MultibyteCodec_State *state,
		 const unsigned char **inbuf, size_t *inleft,
		 Py_UNICODE **outbuf, size_t *outleft)
{
	/* not written to use encoder, decoder functions because only few
	 * encodings use G2 designations in CJKCodecs */
	if (STATE_G2 == CHARSET_ISO8859_1) {
		if (IN3 < 0x80)
			OUT1(IN3 + 0x80)
		else
			return 3;
	}
	else if (STATE_G2 == CHARSET_ISO8859_7) {
		ISO8859_7_DECODE(IN3 ^ 0x80, **outbuf)
		else return 3;
	}
	else if (STATE_G2 == CHARSET_ASCII) {
		if (IN3 & 0x80) return 3;
		else **outbuf = IN3;
	}
	else
		return MBERR_INTERNAL;

	(*inbuf) += 3;
	*inleft -= 3;
	(*outbuf) += 1;
	*outbuf -= 1;
	return 0;
}

DECODER(iso2022)
{
	const struct iso2022_designation *dsgcache = NULL;

	while (inleft > 0) {
		unsigned char c = IN1;
		int err;

		if (STATE_GETFLAG(F_ESCTHROUGHOUT)) {
			/* ESC throughout mode:
			 * for non-iso2022 escape sequences */
			WRITE1(c) /* assume as ISO-8859-1 */
			NEXT(1, 1)
			if (IS_ESCEND(c)) {
				STATE_CLEARFLAG(F_ESCTHROUGHOUT)
			}
			continue;
		}

		switch (c) {
		case ESC:
			REQUIRE_INBUF(2)
			if (IS_ISO2022ESC(IN2)) {
				err = iso2022processesc(config, state,
							inbuf, &inleft);
				if (err != 0)
					return err;
			}
			else if (CONFIG_ISSET(USE_G2) && IN2 == 'N') {/* SS2 */
				REQUIRE_INBUF(3)
				err = iso2022processg2(config, state,
					inbuf, &inleft, outbuf, &outleft);
				if (err != 0)
					return err;
			}
			else {
				WRITE1(ESC)
				STATE_SETFLAG(F_ESCTHROUGHOUT)
				NEXT(1, 1)
			}
			break;
		case SI:
			if (CONFIG_ISSET(NO_SHIFT))
				goto bypass;
			STATE_CLEARFLAG(F_SHIFTED)
			NEXT_IN(1)
			break;
		case SO:
			if (CONFIG_ISSET(NO_SHIFT))
				goto bypass;
			STATE_SETFLAG(F_SHIFTED)
			NEXT_IN(1)
			break;
		case LF:
			STATE_CLEARFLAG(F_SHIFTED)
			WRITE1(LF)
			NEXT(1, 1)
			break;
		default:
			if (c < 0x20) /* C0 */
				goto bypass;
			else if (c >= 0x80)
				return 1;
			else {
				const struct iso2022_designation *dsg;
				unsigned char charset;
				ucs4_t decoded;

				if (STATE_GETFLAG(F_SHIFTED))
					charset = STATE_G1;
				else
					charset = STATE_G0;

				if (charset == CHARSET_ASCII) {
bypass:					WRITE1(c)
					NEXT(1, 1)
					break;
				}

				if (dsgcache != NULL &&
				    dsgcache->mark == charset)
					dsg = dsgcache;
				else {
					for (dsg = CONFIG_DESIGNATIONS;
					     dsg->mark != charset
#ifdef Py_DEBUG
						&& dsg->mark != '\0'
#endif
					     ;dsg++)
						/* noop */;
					assert(dsg->mark != '\0');
					dsgcache = dsg;
				}

				REQUIRE_INBUF(dsg->width)
				decoded = dsg->decoder(*inbuf);
				if (decoded == MAP_UNMAPPABLE)
					return dsg->width;

				if (decoded < 0x10000) {
					WRITE1(decoded)
					NEXT_OUT(1)
				}
				else if (decoded < 0x30000) {
					WRITEUCS4(decoded)
				}
				else { /* JIS X 0213 pairs */
					WRITE2(decoded >> 16, decoded & 0xffff)
					NEXT_OUT(2)
				}
				NEXT_IN(dsg->width)
			}
			break;
		}
	}
	return 0;
}

/*-*- mapping table holders -*-*/

#define ENCMAP(enc) static const encode_map *enc##_encmap = NULL;
#define DECMAP(enc) static const decode_map *enc##_decmap = NULL;

/* kr */
ENCMAP(cp949)
DECMAP(ksx1001)

/* jp */
ENCMAP(jisxcommon)
DECMAP(jisx0208)
DECMAP(jisx0212)
ENCMAP(jisx0213_bmp)
DECMAP(jisx0213_1_bmp)
DECMAP(jisx0213_2_bmp)
ENCMAP(jisx0213_emp)
DECMAP(jisx0213_1_emp)
DECMAP(jisx0213_2_emp)

/* cn */
ENCMAP(gbcommon)
DECMAP(gb2312)

/* tw */

/*-*- mapping access functions -*-*/

static int
ksx1001_init(void)
{
	static int initialized = 0;

	if (!initialized && (
			IMPORT_MAP(kr, cp949, &cp949_encmap, NULL) ||
			IMPORT_MAP(kr, ksx1001, NULL, &ksx1001_decmap)))
		return -1;
	initialized = 1;
	return 0;
}

static ucs4_t
ksx1001_decoder(const unsigned char *data)
{
	ucs4_t u;
	TRYMAP_DEC(ksx1001, u, data[0], data[1])
		return u;
	else
		return MAP_UNMAPPABLE;
}

static DBCHAR
ksx1001_encoder(const ucs4_t *data, int *length)
{
	DBCHAR coded;
	assert(*length == 1);
	TRYMAP_ENC(cp949, coded, *data)
		if (!(coded & 0x8000))
			return coded;
	return MAP_UNMAPPABLE;
}

static int
jisx0208_init(void)
{
	static int initialized = 0;

	if (!initialized && (
			IMPORT_MAP(jp, jisxcommon, &jisxcommon_encmap, NULL) ||
			IMPORT_MAP(jp, jisx0208, NULL, &jisx0208_decmap)))
		return -1;
	initialized = 1;
	return 0;
}

static ucs4_t
jisx0208_decoder(const unsigned char *data)
{
	ucs4_t u;
	if (data[0] == 0x21 && data[1] == 0x40) /* F/W REVERSE SOLIDUS */
		return 0xff3c;
	else TRYMAP_DEC(jisx0208, u, data[0], data[1])
		return u;
	else
		return MAP_UNMAPPABLE;
}

static DBCHAR
jisx0208_encoder(const ucs4_t *data, int *length)
{
	DBCHAR coded;
	assert(*length == 1);
	if (*data == 0xff3c) /* F/W REVERSE SOLIDUS */
		return 0x2140;
	else TRYMAP_ENC(jisxcommon, coded, *data) {
		if (!(coded & 0x8000))
			return coded;
	}
	return MAP_UNMAPPABLE;
}

static int
jisx0212_init(void)
{
	static int initialized = 0;

	if (!initialized && (
			IMPORT_MAP(jp, jisxcommon, &jisxcommon_encmap, NULL) ||
			IMPORT_MAP(jp, jisx0212, NULL, &jisx0212_decmap)))
		return -1;
	initialized = 1;
	return 0;
}

static ucs4_t
jisx0212_decoder(const unsigned char *data)
{
	ucs4_t u;
	TRYMAP_DEC(jisx0212, u, data[0], data[1])
		return u;
	else
		return MAP_UNMAPPABLE;
}

static DBCHAR
jisx0212_encoder(const ucs4_t *data, int *length)
{
	DBCHAR coded;
	assert(*length == 1);
	TRYMAP_ENC(jisxcommon, coded, *data) {
		if (coded & 0x8000)
			return coded & 0x7fff;
	}
	return MAP_UNMAPPABLE;
}

static int
jisx0213_init(void)
{
	static int initialized = 0;

	if (!initialized && (
			jisx0208_init() ||
			IMPORT_MAP(jp, jisx0213_bmp,
				   &jisx0213_bmp_encmap, NULL) ||
			IMPORT_MAP(jp, jisx0213_1_bmp,
				   NULL, &jisx0213_1_bmp_decmap) ||
			IMPORT_MAP(jp, jisx0213_2_bmp,
				   NULL, &jisx0213_2_bmp_decmap) ||
			IMPORT_MAP(jp, jisx0213_emp,
				   &jisx0213_emp_encmap, NULL) ||
			IMPORT_MAP(jp, jisx0213_1_emp,
				   NULL, &jisx0213_1_emp_decmap) ||
			IMPORT_MAP(jp, jisx0213_2_emp,
				   NULL, &jisx0213_2_emp_decmap) ||
			IMPORT_MAP(jp, jisx0213_pair, &jisx0213_pair_encmap,
				   &jisx0213_pair_decmap)))
		return -1;
	initialized = 1;
	return 0;
}

#define config ((void *)2000)
static ucs4_t
jisx0213_2000_1_decoder(const unsigned char *data)
{
	ucs4_t u;
	EMULATE_JISX0213_2000_DECODE_PLANE1(u, data[0], data[1])
	else if (data[0] == 0x21 && data[1] == 0x40) /* F/W REVERSE SOLIDUS */
		return 0xff3c;
	else TRYMAP_DEC(jisx0208, u, data[0], data[1]);
	else TRYMAP_DEC(jisx0213_1_bmp, u, data[0], data[1]);
	else TRYMAP_DEC(jisx0213_1_emp, u, data[0], data[1])
		u |= 0x20000;
	else TRYMAP_DEC(jisx0213_pair, u, data[0], data[1]);
	else
		return MAP_UNMAPPABLE;
	return u;
}

static ucs4_t
jisx0213_2000_2_decoder(const unsigned char *data)
{
	ucs4_t u;
	EMULATE_JISX0213_2000_DECODE_PLANE2(u, data[0], data[1])
	TRYMAP_DEC(jisx0213_2_bmp, u, data[0], data[1]);
	else TRYMAP_DEC(jisx0213_2_emp, u, data[0], data[1])
		u |= 0x20000;
	else
		return MAP_UNMAPPABLE;
	return u;
}
#undef config

static ucs4_t
jisx0213_2004_1_decoder(const unsigned char *data)
{
	ucs4_t u;
	if (data[0] == 0x21 && data[1] == 0x40) /* F/W REVERSE SOLIDUS */
		return 0xff3c;
	else TRYMAP_DEC(jisx0208, u, data[0], data[1]);
	else TRYMAP_DEC(jisx0213_1_bmp, u, data[0], data[1]);
	else TRYMAP_DEC(jisx0213_1_emp, u, data[0], data[1])
		u |= 0x20000;
	else TRYMAP_DEC(jisx0213_pair, u, data[0], data[1]);
	else
		return MAP_UNMAPPABLE;
	return u;
}

static ucs4_t
jisx0213_2004_2_decoder(const unsigned char *data)
{
	ucs4_t u;
	TRYMAP_DEC(jisx0213_2_bmp, u, data[0], data[1]);
	else TRYMAP_DEC(jisx0213_2_emp, u, data[0], data[1])
		u |= 0x20000;
	else
		return MAP_UNMAPPABLE;
	return u;
}

static DBCHAR
jisx0213_encoder(const ucs4_t *data, int *length, void *config)
{
	DBCHAR coded;

	switch (*length) {
	case 1: /* first character */
		if (*data >= 0x10000) {
			if ((*data) >> 16 == 0x20000 >> 16) {
				EMULATE_JISX0213_2000_ENCODE_EMP(coded, *data)
				else TRYMAP_ENC(jisx0213_emp, coded,
						(*data) & 0xffff)
					return coded;
			}
			return MAP_UNMAPPABLE;
		}

		EMULATE_JISX0213_2000_ENCODE_BMP(coded, *data)
		else TRYMAP_ENC(jisx0213_bmp, coded, *data) {
			if (coded == MULTIC)
				return MAP_MULTIPLE_AVAIL;
		}
		else TRYMAP_ENC(jisxcommon, coded, *data) {
			if (coded & 0x8000)
				return MAP_UNMAPPABLE;
		}
		else
			return MAP_UNMAPPABLE;
		return coded;
	case 2: /* second character of unicode pair */
		coded = find_pairencmap((ucs2_t)data[0], (ucs2_t)data[1],
				jisx0213_pair_encmap, JISX0213_ENCPAIRS);
		if (coded == DBCINV) {
			*length = 1;
			coded = find_pairencmap((ucs2_t)data[0], 0,
				  jisx0213_pair_encmap, JISX0213_ENCPAIRS);
			if (coded == DBCINV)
				return MAP_UNMAPPABLE;
		}
		else
			return coded;
	case -1: /* flush unterminated */
		*length = 1;
		coded = find_pairencmap((ucs2_t)data[0], 0,
				jisx0213_pair_encmap, JISX0213_ENCPAIRS);
		if (coded == DBCINV)
			return MAP_UNMAPPABLE;
		else
			return coded;
	default:
		return MAP_UNMAPPABLE;
	}
}

static DBCHAR
jisx0213_2000_1_encoder(const ucs4_t *data, int *length)
{
	DBCHAR coded = jisx0213_encoder(data, length, (void *)2000);
	if (coded == MAP_UNMAPPABLE || coded == MAP_MULTIPLE_AVAIL)
		return coded;
	else if (coded & 0x8000)
		return MAP_UNMAPPABLE;
	else
		return coded;
}

static DBCHAR
jisx0213_2000_1_encoder_paironly(const ucs4_t *data, int *length)
{
	DBCHAR coded;
	int ilength = *length;

	coded = jisx0213_encoder(data, length, (void *)2000);
	switch (ilength) {
	case 1:
		if (coded == MAP_MULTIPLE_AVAIL)
			return MAP_MULTIPLE_AVAIL;
		else
			return MAP_UNMAPPABLE;
	case 2:
		if (*length != 2)
			return MAP_UNMAPPABLE;
		else
			return coded;
	default:
		return MAP_UNMAPPABLE;
	}
}

static DBCHAR
jisx0213_2000_2_encoder(const ucs4_t *data, int *length)
{
	DBCHAR coded = jisx0213_encoder(data, length, (void *)2000);
	if (coded == MAP_UNMAPPABLE || coded == MAP_MULTIPLE_AVAIL)
		return coded;
	else if (coded & 0x8000)
		return coded;
	else
		return MAP_UNMAPPABLE;
}

static DBCHAR
jisx0213_2004_1_encoder(const ucs4_t *data, int *length)
{
	DBCHAR coded = jisx0213_encoder(data, length, NULL);
	if (coded == MAP_UNMAPPABLE || coded == MAP_MULTIPLE_AVAIL)
		return coded;
	else if (coded & 0x8000)
		return MAP_UNMAPPABLE;
	else
		return coded;
}

static DBCHAR
jisx0213_2004_1_encoder_paironly(const ucs4_t *data, int *length)
{
	DBCHAR coded;
	int ilength = *length;

	coded = jisx0213_encoder(data, length, NULL);
	switch (ilength) {
	case 1:
		if (coded == MAP_MULTIPLE_AVAIL)
			return MAP_MULTIPLE_AVAIL;
		else
			return MAP_UNMAPPABLE;
	case 2:
		if (*length != 2)
			return MAP_UNMAPPABLE;
		else
			return coded;
	default:
		return MAP_UNMAPPABLE;
	}
}

static DBCHAR
jisx0213_2004_2_encoder(const ucs4_t *data, int *length)
{
	DBCHAR coded = jisx0213_encoder(data, length, NULL);
	if (coded == MAP_UNMAPPABLE || coded == MAP_MULTIPLE_AVAIL)
		return coded;
	else if (coded & 0x8000)
		return coded;
	else
		return MAP_UNMAPPABLE;
}

static ucs4_t
jisx0201_r_decoder(const unsigned char *data)
{
	ucs4_t u;
	JISX0201_R_DECODE(*data, u)
	else return MAP_UNMAPPABLE;
	return u;
}

static DBCHAR
jisx0201_r_encoder(const ucs4_t *data, int *length)
{
	DBCHAR coded;
	JISX0201_R_ENCODE(*data, coded)
	else return MAP_UNMAPPABLE;
	return coded;
}

static ucs4_t
jisx0201_k_decoder(const unsigned char *data)
{
	ucs4_t u;
	JISX0201_K_DECODE(*data ^ 0x80, u)
	else return MAP_UNMAPPABLE;
	return u;
}

static DBCHAR
jisx0201_k_encoder(const ucs4_t *data, int *length)
{
	DBCHAR coded;
	JISX0201_K_ENCODE(*data, coded)
	else return MAP_UNMAPPABLE;
	return coded - 0x80;
}

static int
gb2312_init(void)
{
	static int initialized = 0;

	if (!initialized && (
			IMPORT_MAP(cn, gbcommon, &gbcommon_encmap, NULL) ||
			IMPORT_MAP(cn, gb2312, NULL, &gb2312_decmap)))
		return -1;
	initialized = 1;
	return 0;
}

static ucs4_t
gb2312_decoder(const unsigned char *data)
{
	ucs4_t u;
	TRYMAP_DEC(gb2312, u, data[0], data[1])
		return u;
	else
		return MAP_UNMAPPABLE;
}

static DBCHAR
gb2312_encoder(const ucs4_t *data, int *length)
{
	DBCHAR coded;
	assert(*length == 1);
	TRYMAP_ENC(gbcommon, coded, *data) {
		if (!(coded & 0x8000))
			return coded;
	}
	return MAP_UNMAPPABLE;
}


static ucs4_t
dummy_decoder(const unsigned char *data)
{
	return MAP_UNMAPPABLE;
}

static DBCHAR
dummy_encoder(const ucs4_t *data, int *length)
{
	return MAP_UNMAPPABLE;
}

/*-*- registry tables -*-*/

#define REGISTRY_KSX1001	{ CHARSET_KSX1001, 1, 2,		\
				  ksx1001_init,				\
				  ksx1001_decoder, ksx1001_encoder }
#define REGISTRY_JISX0201_R	{ CHARSET_JISX0201_R, 0, 1,		\
				  NULL,					\
				  jisx0201_r_decoder, jisx0201_r_encoder }
#define REGISTRY_JISX0201_K	{ CHARSET_JISX0201_K, 0, 1,		\
				  NULL,					\
				  jisx0201_k_decoder, jisx0201_k_encoder }
#define REGISTRY_JISX0208	{ CHARSET_JISX0208, 0, 2,		\
				  jisx0208_init,			\
				  jisx0208_decoder, jisx0208_encoder }
#define REGISTRY_JISX0208_O	{ CHARSET_JISX0208_O, 0, 2,		\
				  jisx0208_init,			\
				  jisx0208_decoder, jisx0208_encoder }
#define REGISTRY_JISX0212	{ CHARSET_JISX0212, 0, 2,		\
				  jisx0212_init,			\
				  jisx0212_decoder, jisx0212_encoder }
#define REGISTRY_JISX0213_2000_1 { CHARSET_JISX0213_2000_1, 0, 2,	\
				  jisx0213_init,			\
				  jisx0213_2000_1_decoder,		\
				  jisx0213_2000_1_encoder }
#define REGISTRY_JISX0213_2000_1_PAIRONLY { CHARSET_JISX0213_2000_1, 0, 2, \
				  jisx0213_init,			\
				  jisx0213_2000_1_decoder,		\
				  jisx0213_2000_1_encoder_paironly }
#define REGISTRY_JISX0213_2000_2 { CHARSET_JISX0213_2, 0, 2,		\
				  jisx0213_init,			\
				  jisx0213_2000_2_decoder,		\
				  jisx0213_2000_2_encoder }
#define REGISTRY_JISX0213_2004_1 { CHARSET_JISX0213_2004_1, 0, 2,	\
				  jisx0213_init,			\
				  jisx0213_2004_1_decoder,		\
				  jisx0213_2004_1_encoder }
#define REGISTRY_JISX0213_2004_1_PAIRONLY { CHARSET_JISX0213_2004_1, 0, 2, \
				  jisx0213_init,			\
				  jisx0213_2004_1_decoder,		\
				  jisx0213_2004_1_encoder_paironly }
#define REGISTRY_JISX0213_2004_2 { CHARSET_JISX0213_2, 0, 2,		\
				  jisx0213_init,			\
				  jisx0213_2004_2_decoder,		\
				  jisx0213_2004_2_encoder }
#define REGISTRY_GB2312		{ CHARSET_GB2312, 1, 2,			\
				  gb2312_init,				\
				  gb2312_decoder, gb2312_encoder }
#define REGISTRY_CNS11643_1	{ CHARSET_CNS11643_1, 1, 2,		\
				  cns11643_init,			\
				  cns11643_1_decoder, cns11643_1_encoder }
#define REGISTRY_CNS11643_2	{ CHARSET_CNS11643_2, 2, 2,		\
				  cns11643_init,			\
				  cns11643_2_decoder, cns11643_2_encoder }
#define REGISTRY_ISO8859_1	{ CHARSET_ISO8859_1, 2, 1,		\
				  NULL, dummy_decoder, dummy_encoder }
#define REGISTRY_ISO8859_7	{ CHARSET_ISO8859_7, 2, 1,		\
				  NULL, dummy_decoder, dummy_encoder }
#define REGISTRY_SENTINEL	{ 0, }
#define CONFIGDEF(var, attrs)						\
	static const struct iso2022_config iso2022_##var##_config = {	\
		attrs, iso2022_##var##_designations			\
	};

static const struct iso2022_designation iso2022_kr_designations[] = {
	REGISTRY_KSX1001, REGISTRY_SENTINEL
};
CONFIGDEF(kr, 0)

static const struct iso2022_designation iso2022_jp_designations[] = {
	REGISTRY_JISX0208, REGISTRY_JISX0201_R, REGISTRY_JISX0208_O,
	REGISTRY_SENTINEL
};
CONFIGDEF(jp, NO_SHIFT | USE_JISX0208_EXT)

static const struct iso2022_designation iso2022_jp_1_designations[] = {
	REGISTRY_JISX0208, REGISTRY_JISX0212, REGISTRY_JISX0201_R,
	REGISTRY_JISX0208_O, REGISTRY_SENTINEL
};
CONFIGDEF(jp_1, NO_SHIFT | USE_JISX0208_EXT)

static const struct iso2022_designation iso2022_jp_2_designations[] = {
	REGISTRY_JISX0208, REGISTRY_JISX0212, REGISTRY_KSX1001,
	REGISTRY_GB2312, REGISTRY_JISX0201_R, REGISTRY_JISX0208_O,
	REGISTRY_ISO8859_1, REGISTRY_ISO8859_7, REGISTRY_SENTINEL
};
CONFIGDEF(jp_2, NO_SHIFT | USE_G2 | USE_JISX0208_EXT)

static const struct iso2022_designation iso2022_jp_2004_designations[] = {
	REGISTRY_JISX0213_2004_1_PAIRONLY, REGISTRY_JISX0208,
	REGISTRY_JISX0213_2004_1, REGISTRY_JISX0213_2004_2, REGISTRY_SENTINEL
};
CONFIGDEF(jp_2004, NO_SHIFT | USE_JISX0208_EXT)

static const struct iso2022_designation iso2022_jp_3_designations[] = {
	REGISTRY_JISX0213_2000_1_PAIRONLY, REGISTRY_JISX0208,
	REGISTRY_JISX0213_2000_1, REGISTRY_JISX0213_2000_2, REGISTRY_SENTINEL
};
CONFIGDEF(jp_3, NO_SHIFT | USE_JISX0208_EXT)

static const struct iso2022_designation iso2022_jp_ext_designations[] = {
	REGISTRY_JISX0208, REGISTRY_JISX0212, REGISTRY_JISX0201_R,
	REGISTRY_JISX0201_K, REGISTRY_JISX0208_O, REGISTRY_SENTINEL
};
CONFIGDEF(jp_ext, NO_SHIFT | USE_JISX0208_EXT)


BEGIN_MAPPINGS_LIST
  /* no mapping table here */
END_MAPPINGS_LIST

#define ISO2022_CODEC(variation) {		\
	"iso2022_" #variation,			\
	&iso2022_##variation##_config,		\
	iso2022_codec_init,			\
	_STATEFUL_METHODS(iso2022)		\
},

BEGIN_CODECS_LIST
  ISO2022_CODEC(kr)
  ISO2022_CODEC(jp)
  ISO2022_CODEC(jp_1)
  ISO2022_CODEC(jp_2)
  ISO2022_CODEC(jp_2004)
  ISO2022_CODEC(jp_3)
  ISO2022_CODEC(jp_ext)
END_CODECS_LIST

I_AM_A_MODULE_FOR(iso2022)