/*
 * 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 2007 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */


#include <stdlib.h>
#include <errno.h>
#include <euc.h>

#include "japanese.h"
#include "jfp_iconv_unicode.h"

#define JFP_U2E_ICONV_X0213
#include "jfp_ucs2_to_euc16.h"

#define DEF_SINGLE      '?'

#define INVL    0xff

static const unsigned char rowtosj1_x0213_p1[] = {
     /*          1     2     3     4     5     6     7 */
        INVL, 0x81, 0x81, 0x82, 0x82, 0x83, 0x83, 0x84,
     /*    8     9    10    11    12    13    14    15 */
        0x84, 0x85, 0x85, 0x86, 0x86, 0x87, 0x87, 0x88,
     /*   16    17    18    19    20    21    22    23 */
        0x88, 0x89, 0x89, 0x8a, 0x8a, 0x8b, 0x8b, 0x8c,
     /*   24    25    26    27    28    29    30    31 */
        0x8c, 0x8d, 0x8d, 0x8e, 0x8e, 0x8f, 0x8f, 0x90,
     /*   32    33    34    35    36    37    38    39 */
        0x90, 0x91, 0x91, 0x92, 0x92, 0x93, 0x93, 0x94,
     /*   40    41    42    43    44    45    46    47 */
        0x94, 0x95, 0x95, 0x96, 0x96, 0x97, 0x97, 0x98,
     /*   48    49    50    51    52    53    54    55 */
        0x98, 0x99, 0x99, 0x9a, 0x9a, 0x9b, 0x9b, 0x9c,
     /*   56    57    58    59    60    61    62    63 */
        0x9c, 0x9d, 0x9d, 0x9e, 0x9e, 0x9f, 0x9f, 0xe0,
     /*   64    65    66    67    68    69    70    71 */
        0xe0, 0xe1, 0xe1, 0xe2, 0xe2, 0xe3, 0xe3, 0xe4,
     /*   72    73    74    75    76    77    78    79 */
        0xe4, 0xe5, 0xe5, 0xe6, 0xe6, 0xe7, 0xe7, 0xe8,
     /*   80    81    82    83    84    85    86    87 */
        0xe8, 0xe9, 0xe9, 0xea, 0xea, 0xeb, 0xeb, 0xec,
     /*   88    89    90    91    92    93    94       */
        0xec, 0xed, 0xed, 0xee, 0xee, 0xef, 0xef
};

static const unsigned char rowtosj1_x0213_p2[] = {
     /*          1     2     3     4     5     6     7 */
        INVL, 0xf0, INVL, 0xf1, 0xf1, 0xf2, INVL, INVL,
     /*    8     9    10    11    12    13    14    15 */
        0xf0, INVL, INVL, INVL, 0xf2, 0xf3, 0xf3, 0xf4,
     /*   16    17    18    19    20    21    22    23 */
        INVL, INVL, INVL, INVL, INVL, INVL, INVL, INVL,
     /*   24    25    26    27    28    29    30    31 */
        INVL, INVL, INVL, INVL, INVL, INVL, INVL, INVL,
     /*   32    33    34    35    36    37    38    39 */
        INVL, INVL, INVL, INVL, INVL, INVL, INVL, INVL,
     /*   40    41    42    43    44    45    46    47 */
        INVL, INVL, INVL, INVL, INVL, INVL, INVL, INVL,
     /*   48    49    50    51    52    53    54    55 */
        INVL, INVL, INVL, INVL, INVL, INVL, INVL, INVL,
     /*   56    57    58    59    60    61    62    63 */
        INVL, INVL, INVL, INVL, INVL, INVL, INVL, INVL,
     /*   64    65    66    67    68    69    70    71 */
        INVL, INVL, INVL, INVL, INVL, INVL, INVL, INVL,
     /*   72    73    74    75    76    77    78    79 */
        INVL, INVL, INVL, INVL, INVL, INVL, 0xf4, 0xf5,
     /*   80    81    82    83    84    85    86    87 */
        0xf5, 0xf6, 0xf6, 0xf7, 0xf7, 0xf8, 0xf8, 0xf9,
     /*   88    89    90    91    92    93    94       */
        0xf9, 0xfa, 0xfa, 0xfb, 0xfb, 0xfc, 0xfc
};

static unsigned char e16tosj_x0213(
        unsigned short  e16,
        unsigned char   *pc2)
{
        unsigned char   c1;
        unsigned char   r, c;

        /* range check (if valid for plane 1 or 2) for e16
           has been done by the caller side */

        r = (e16 >> 8) - 0xa0;

        if ((e16 & 0x8080) == 0x8080) { /* Plane 1 */
                c1 = rowtosj1_x0213_p1[r];
        } else { /* Plane 2 */
                c1 = rowtosj1_x0213_p2[r];
        }

        c = (e16 & 0x7f) - 0x20;

        if ((r % 2) == 1) { /* odd row */
                *pc2 = (c - 1) + 0x40;
                if (*pc2 >= 0x7f) {
                        (*pc2)++;
                }
        } else { /* even row */
                *pc2 = (c - 1) + 0x9f;
        }

        return (c1);
}

void *
_icv_open(void)
{
        return (_icv_open_unicode((size_t)0));
}

void
_icv_close(void *cd)
{
        _icv_close_unicode(cd);
        return;
}

size_t
_icv_iconv(void *cd, char **inbuf, size_t *inbytesleft,
                                char **outbuf, size_t *outbytesleft)
{
        unsigned int    u32;            /* UTF-32 */
        unsigned short  e16;            /* 16-bit EUC */
        unsigned char   ic1, ic2;
        size_t          rv = (size_t)0;

        unsigned char   *ip;
        size_t          ileft;
        char            *op;
        size_t          oleft;

        /*
         * If inbuf and/or *inbuf are NULL, reset conversion descriptor
         * and put escape sequence if needed.
         */
        if ((inbuf == NULL) || (*inbuf == NULL)) {
                _icv_reset_unicode(cd);
                return ((size_t)0);
        }

        ip = (unsigned char *)*inbuf;
        ileft = *inbytesleft;
        op = *outbuf;
        oleft = *outbytesleft;

        while (ileft != 0) {
                GETU(&u32)

                e16 = _jfp_u32_to_euc16(u32);

                switch (e16 & 0x8080) {
                case 0x0000:    /* ASCII */
                        ic1 = (unsigned char)e16;
                        NPUT(ic1, "ASCII");
                        break;
                case 0x8080:    /* PLANE1 */
                        ic1 = e16tosj_x0213(e16, &ic2);
                        NPUT(ic1, "PLANE1-1");
                        NPUT(ic2, "PLANE1-2");
                        break;
                case 0x0080:    /* KANA */
                        ic1 = (unsigned char)e16;
                        NPUT(ic1, "KANA");
                        break;
                case 0x8000:    /* CS3 */
                        ic1 = e16tosj_x0213(e16, &ic2);
                        NPUT(ic1, "PLANE2-1");
                        NPUT(ic2, "PLANE2-2");
                        break;
                }

next:
                /*
                 * One character successfully converted so update
                 * values outside of this function's stack.
                 */
                *inbuf = (char *)ip;
                *inbytesleft = ileft;
                *outbuf = op;
                *outbytesleft = oleft;
        }

ret:

        DEBUGPRINTERROR

        /*
         * Return value for successful return is not defined by XPG
         * so return same as *inbytesleft as existing codes do.
         */
        return ((rv == (size_t)-1) ? rv : *inbytesleft);
}