/*
 * 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);
}