/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright (c) 1995, by Sun Microsystems, Inc.
 * All rights reserved.
 */

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <libintl.h>

#define	MSB	0x80	/* most significant bit */
#define	MBYTE	0x8e	/* multi-byte (4 byte character) */
#define	PMASK	0xa0	/* plane number mask */
#define ONEBYTE	0xff	/* right most byte */
#define MSB_OFF	0x7f	/* mask off MSB */

#define SI      0x0f    /* shift in */
#define SO      0x0e    /* shift out */
#define ESC     0x1b    /* escape */

/* static const char plane_char[] = "0GH23456789:;<=>?"; */
static const char plane_char[] = "0GHIJKLMNOPQRSTUV";

#define GET_PLANEC(i)   (plane_char[i])

#define NON_ID_CHAR '_'	/* non-identified character */

typedef struct _icv_state {
	char	keepc[4];	/* maximum # byte of CNS11643 code */
	short	cstate;		/* state machine id (CNS) */
	short	istate;		/* state machine id (ISO) */
	int	_errno;		/* internal errno */
} _iconv_st;

enum _CSTATE	{ C0, C1, C2, C3, C4 };
enum _ISTATE    { IN, OUT };


static int get_plane_no_by_char(const char);
static int cns_to_iso(int, char[], char*, size_t);

static int get_plane_no_by_str(const char *);
struct _cv_state {
	int	plane_no;
	int	get_a_mbchar;
	int	more_bytes;
	int	first_byte;
	int	plane_changed;
	char	planec;
	char	*p;
	char	keepc[4];
};

/*
 * Open; called from iconv_open()
 */
void *
_icv_open()
{
	_iconv_st *st;

	if ((st = (_iconv_st *)malloc(sizeof(_iconv_st))) == NULL) {
		errno = ENOMEM;
		return ((void *) -1);
	}

	st->cstate = C0;
	st->istate = IN;
	st->_errno = 0;

#ifdef DEBUG
    fprintf(stderr, "==========     iconv(): CNS11643 --> ISO 2022-7     ==========\n");
#endif

	return ((void *) st);
}


/*
 * Close; called from iconv_close()
 */
void
_icv_close(_iconv_st *st)
{
	if (!st)
		errno = EBADF;
	else
		free(st);
}


/*
 * Actual conversion; called from iconv()
 */
/*=======================================================
 *
 *   State Machine for interpreting CNS 11643 code
 *
 *=======================================================
 *
 *               (ESC,SO)   plane 2 - 16
 *                1st C         2nd C       3rd C
 *    +------> C0 -----> C1 -----------> C2 -----> C3
 *    |  ascii |  plane 1 |                   4th C |
 *    ^        |  2nd C   v                         v
 *    |        |         C4 <------<--------<-------+
 *    |        v          | (SI)
 *    +----<---+-----<----v
 *
 *=======================================================*/
size_t
_icv_iconv(_iconv_st *st, char **inbuf, size_t *inbytesleft,
				char **outbuf, size_t *outbytesleft)
{
	int plane_no = -1, n;
	/* pre_plane_no: need to be static when re-entry occurs on errno set */
	static int	pre_plane_no = -1;	/* previous plane number */

	if (st == NULL) {
		errno = EBADF;
		return ((size_t) -1);
	}

	if (inbuf == NULL || *inbuf == NULL) { /* Reset request. */
		if (st->cstate == C1) {
			if (outbytesleft && *outbytesleft >= 1
				&& outbuf && *outbuf) {
				**outbuf = SI;
				(*outbuf)++;
				(*outbytesleft)--;
			} else {
				errno = E2BIG;
				return((size_t) -1);
			}
		}
		st->cstate = C0;
		st->istate = IN;
		st->_errno = 0;
		return ((size_t) 0);
	}

#ifdef DEBUG
    fprintf(stderr, "=== (Re-entry)     iconv(): CNS11643 --> ISO 2022-7     ===\n");
    fprintf(stderr, "st->cstate=%d\tst->istate=%d\tst->_errno=%d\tplane_no=%d\n",
	st->cstate, st->istate, st->_errno, plane_no);
#endif
	st->_errno = 0;         /* reset internal errno */
	errno = 0;		/* reset external errno */

	/* a state machine for interpreting CNS 11643 code */
	while (*inbytesleft > 0 && *outbytesleft > 0) {
		switch (st->cstate) {
		case C0:		/* assuming ASCII in the beginning */
			if (**inbuf & MSB) {
				st->keepc[0] = (**inbuf);
				st->cstate = C1;
			} else {	/* real ASCII */
				if (st->istate == OUT) {
					st->cstate = C0;
					st->istate = IN;
					**outbuf = SI;
					(*outbuf)++;
					(*outbytesleft)--;
					if (*outbytesleft <= 0) {
						errno = E2BIG;
						return((size_t)-1);
					}
				}
				**outbuf = **inbuf;
				(*outbuf)++;
				(*outbytesleft)--;
			}
			break;
		case C1:		/* Chinese characters: 2nd byte */
			if ((st->keepc[0] & ONEBYTE) == MBYTE) { /* 4-byte (0x8e) */
				plane_no = get_plane_no_by_char(**inbuf);
				if (plane_no == -1) {	/* illegal plane */
					st->cstate = C0;
					st->istate = IN;
					st->_errno = errno = EILSEQ;
				} else {	/* 4-byte Chinese character */
					st->keepc[1] = (**inbuf);
					st->cstate = C2;
				}
			} else {	/* 2-byte Chinese character - plane #1 */
				if (**inbuf & MSB) {	/* plane #1 */
					st->cstate = C4;
					st->keepc[1] = (**inbuf);
					st->keepc[2] = st->keepc[3] = '\0';
					plane_no = 1;
					continue;       /* should not advance *inbuf */
				} else {	/* input char doesn't belong
						 * to the input code set
						 */
					st->cstate = C0;
					st->istate = IN;
					st->_errno = errno = EINVAL;
				}
			}
			break;
		case C2:	/* plane #2 - #16 (4 bytes): get 3nd byte */
			if (**inbuf & MSB) {	/* 3rd byte */
				st->keepc[2] = (**inbuf);
				st->cstate = C3;
			} else {
				st->_errno = errno = EINVAL;
				st->cstate = C0;
			}
			break;
		case C3:	/* plane #2 - #16 (4 bytes): get 4th byte */
			if (**inbuf & MSB) {	/* 4th byte */
				st->cstate = C4;
				st->keepc[3] = (**inbuf);
				continue;       /* should not advance *inbuf */
			} else {
				st->_errno = errno = EINVAL;
				st->cstate = C0;
			}
			break;
		case C4:	/* Convert code from CNS 11643 to ISO 2022-7 */
			if ((st->istate == IN) || (pre_plane_no != plane_no)) {
				/* change plane # in Chinese mode */
				if (st->istate == OUT) {
					**outbuf = SI;
					(*outbuf)++;
					(*outbytesleft)--;
#ifdef DEBUG
fprintf(stderr, "(plane #=%d\tpre_plane #=%d)\t", plane_no, pre_plane_no);
#endif
				}
				if (*outbytesleft < 4) {
					st->_errno = errno = E2BIG;
					return((size_t)-1);
				}
				pre_plane_no = plane_no;
				st->istate = OUT;	/* shift out */
				**outbuf = ESC;
				*(*outbuf+1) = '$';
				*(*outbuf+2) = ')';
				*(*outbuf+3) = GET_PLANEC(plane_no);
#ifdef DEBUG
fprintf(stderr, "ESC $ ) %c\n", *(*outbuf+3));
#endif
				(*outbuf) += 4;
				(*outbytesleft) -= 4;
				if (*outbytesleft <= 0) {
					st->_errno = errno = E2BIG;
					return((size_t)-1);
				}
				**outbuf = SO;
				(*outbuf)++;
				(*outbytesleft)--;
			}
			n = cns_to_iso(plane_no, st->keepc, *outbuf, *outbytesleft);
			if (n > 0) {
				(*outbuf) += n;
				(*outbytesleft) -= n;
			} else {
				st->_errno = errno;
				return((size_t)-1);
			}
			st->cstate = C0;
			break;
		default:			/* should never come here */
			st->_errno = errno = EILSEQ;
			st->cstate = C0;	/* reset state */
			break;
		}

		(*inbuf)++;
		(*inbytesleft)--;

		if (st->_errno) {
#ifdef DEBUG
    fprintf(stderr, "!!!!!\tst->_errno = %d\tst->cstate = %d\n",
		st->_errno, st->cstate);
#endif
			break;
		}
		if (errno)
			return((size_t)-1);
	}

	if (*inbytesleft > 0 && *outbytesleft == 0) {
		errno = E2BIG;
		return((size_t)-1);
	}
	return (*inbytesleft);
}


/*
 * Get plane number by char; i.e. 0xa2 returns 2, 0xae returns 14, etc.
 * Returns -1 on error conditions
 */
static int get_plane_no_by_char(const char inbuf)
{
	int ret;
	unsigned char uc = (unsigned char) inbuf;

	ret = uc - PMASK;
	switch (ret) {
	case 1:		/* 0x8EA1 */
	case 2:		/* 0x8EA2 */
	case 3:		/* 0x8EA3 */
	case 4:		/* 0x8EA4 */
	case 5:		/* 0x8EA5 */
	case 6:		/* 0x8EA6 */
	case 7:		/* 0x8EA7 */
	case 12:	/* 0x8EAC */
	case 14:	/* 0x8EAE */
	case 15:	/* 0x8EAF */
	case 16:	/* 0x8EB0 */
		return (ret);
	default:
		return (-1);
	}
}


/*
 * CNS 11643 code --> ISO 2022-7
 * Return: > 0 - converted with enough space in output buffer
 *         = 0 - no space in outbuf
 */
static int cns_to_iso(int plane_no, char keepc[], char *buf, size_t buflen)
{
	char		cns_str[3];
	unsigned long	cns_val;	/* MSB mask off CNS 11643 value */

#ifdef DEBUG
    fprintf(stderr, "%s %d ", keepc, plane_no);
#endif
        if (buflen < 2) {
                errno = E2BIG;
                return(0);
        }

	if (plane_no == 1) {
		cns_str[0] = keepc[0] & MSB_OFF;
		cns_str[1] = keepc[1] & MSB_OFF;
	} else {
		cns_str[0] = keepc[2] & MSB_OFF;
		cns_str[1] = keepc[3] & MSB_OFF;
	}
	cns_val = (cns_str[0] << 8) + cns_str[1];
#ifdef DEBUG
    fprintf(stderr, "%x\t", cns_val);
#endif

	*buf = (cns_val & 0xff00) >> 8;
	*(buf+1) = cns_val & 0xff;

#ifdef DEBUG
    fprintf(stderr, "->%x %x<-\t->%c %c<-\n", *buf, *(buf+1), *buf, *(buf+1));
#endif
	return(2);
}
void *
_cv_open()
{
	struct _cv_state *st;

	if ((st = (struct _cv_state *)malloc(sizeof(struct _cv_state))) == NULL)
		return ((void *)-1);

	st->plane_no = 0;
	st->get_a_mbchar = 1;
	st->first_byte = 1;

	return (st);
}

void
_cv_close(struct _cv_state *st)
{
	free(st);
}


size_t
_cv_enconv(struct _cv_state *st, char **cvinbuf, size_t *cvinbytesleft,
				char **cvoutbuf, size_t *cvoutbytesleft)
{
	char	*inbuf;
	char	*outbuf;
	size_t insize;
	size_t outsize;

	unsigned char	uc;
	int		i;

	if (cvinbuf == NULL || *cvinbuf == NULL) { /* Reset request. */
		if (cvoutbuf && *cvoutbuf != NULL &&
		*cvoutbytesleft > 0 && st->plane_no != 0) {
			**cvoutbuf = SI;
			(*cvoutbytesleft)--;
			(*cvoutbuf)++;
		}
		st->plane_no = 0;
		st->get_a_mbchar = 1;
		st->first_byte = 1;

		return (0);
	}


	inbuf = *cvinbuf;
	outbuf = *cvoutbuf;
	insize = *cvinbytesleft;
	outsize = *cvoutbytesleft;

	while ((int) insize > 0 && (int) outsize > 0) {

		if (st->get_a_mbchar) {
			if (st->plane_no == 0) { /* short cut */
				do {
					uc = *inbuf;
					if ((uc & MSB) == 0) {
						*outbuf++ = uc;
						outsize--;
						inbuf++;
						insize--;
					} else
						goto non_plane_0;
				} while ((int) insize > 0 && (int) outsize > 0);
				goto success;
			}

non_plane_0:
			if (st->first_byte) {
				st->first_byte = 0;
				st->keepc[0] = uc = *inbuf++;
				insize--;
				if (uc & MSB) {
					if (uc == 0x8e)
						st->more_bytes = 3;
					else
						st->more_bytes = 1;
					st->p = st->keepc + 1;
				} else
					st->more_bytes = 0;
			}
			while (st->more_bytes > 0 && (int) insize > 0) {
				*st->p++ = *inbuf++;
				st->more_bytes--;
				insize--;
			}
			if (st->more_bytes == 0)
				st->get_a_mbchar = 0;

		/* up to this point, st->keepc contains a complete mb char */

			i = get_plane_no_by_str(st->keepc);
			st->plane_changed = (st->plane_no != i);
			if (st->plane_changed) { /* generate SI */
				st->planec = GET_PLANEC(i);
				if (st->plane_no != 0) {
					*outbuf++ = SI;
					outsize--;
					st->plane_no = i;
					if ((int) outsize <= 0)
						goto success;
				} else
					st->plane_no = i;
			}
		}

		/*
		 * up to this point, st->keepc contains a complete mb char and
		 * we know the plane_no
		 */

		switch (st->plane_no) {
		case 0:
			*outbuf++ = st->keepc[0];
			outsize--;
			break;
		case 1:
			if (st->plane_changed) {
				if (outsize < 7)
					goto success;
				*outbuf++ = ESC;
				*outbuf++ = '$';
				*outbuf++ = ')';
				*outbuf++ = 'G';
				*outbuf++ = SO;
				*outbuf++ = st->keepc[0] & MSB_OFF;
				*outbuf++ = st->keepc[1] & MSB_OFF;
				outsize -= 7;
			} else { /* don't need the escape sequence */
				if (outsize < 2)
					goto success;
				*outbuf++ = st->keepc[0] & MSB_OFF;
				*outbuf++ = st->keepc[1] & MSB_OFF;
				outsize -= 2;
			}
			break;
		default:
			if (st->plane_changed) {
				if (outsize < 7)
					goto success;
				*outbuf++ = ESC;
				*outbuf++ = '$';
				*outbuf++ = ')';
				*outbuf++ = st->planec;
				*outbuf++ = SO;
				*outbuf++ = st->keepc[2] & MSB_OFF;
				*outbuf++ = st->keepc[3] & MSB_OFF;
				outsize -= 7;
			} else { /* don't need the escape sequence */
				if (outsize < 2)
					goto success;
				*outbuf++ = st->keepc[2] & MSB_OFF;
				*outbuf++ = st->keepc[3] & MSB_OFF;
				outsize -= 2;
			}
			break;
		}
		/*
		 * up to this point, a complete multibyte character has been
		 * converted and written to outbuf, so need to grab the next
		 * mb char from inbuf
		 */
		st->get_a_mbchar = 1;
		st->first_byte = 1;
	}

success:
	*cvinbytesleft = insize;
	*cvoutbytesleft = outsize;
	*cvinbuf = inbuf;
	*cvoutbuf = outbuf;

	return (insize);
}

static int get_plane_no_by_str(const char *inbuf) {
	unsigned char uc = (unsigned char) *inbuf;

	if (uc & MSB) {
		if (uc != 0x8e)
			return (1);
		uc = *(++inbuf);
		return (uc - 0xa0);
	} else
		return (0);
}