/*
 * 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 AND PERMISSION NOTICE
 *
 * Copyright (c) 1991-2005 Unicode, Inc. All rights reserved. Distributed
 * under the Terms of Use in http://www.unicode.org/copyright.html.
 *
 * This file has been modified by Sun Microsystems, Inc.
 */
/*
 * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */


#include        <sys/types.h>

#if     defined(JFP_ICONV_FROMCODE_UTF32BE)||defined(JFP_ICONV_FROMCODE_UTF32LE)
#define JFP_ICONV_FROMCODE_UTF32
#endif

#if     defined(JFP_ICONV_FROMCODE_UTF16BE)||defined(JFP_ICONV_FROMCODE_UTF16LE)
#define JFP_ICONV_FROMCODE_UTF16
#endif

#if     defined(JFP_ICONV_FROMCODE_UCS2BE)||defined(JFP_ICONV_FROMCODE_UCS2LE)
#define JFP_ICONV_FROMCODE_UCS2
#endif

#if     defined(JFP_ICONV_TOCODE_UTF32BE)||defined(JFP_ICONV_TOCODE_UTF32LE)
#define JFP_ICONV_TOCODE_UTF32
#endif

#if     defined(JFP_ICONV_TOCODE_UTF16BE)||defined(JFP_ICONV_TOCODE_UTF16LE)
#define JFP_ICONV_TOCODE_UTF16
#endif

#if     defined(JFP_ICONV_TOCODE_UCS2BE)||defined(JFP_ICONV_TOCODE_UCS2LE)
#define JFP_ICONV_TOCODE_UCS2
#endif


#define BOM     0xfeff
#define BSBOM16 0xfffe
#define BSBOM32 0xfffe0000
#define REPLACE 0xfffd
#define IFHISUR(x)      ((0xd800 <= (x)) && ((x) <= 0xdbff))
#define IFLOSUR(x)      ((0xdc00 <= (x)) && ((x) <= 0xdfff))

typedef struct {
        boolean_t         bom_written;
        boolean_t         little_endian;
} ucs_state_t;


#if     defined(JFP_ICONV_FROMCODE_UTF32)

static size_t                           /* return #bytes read, or -1 */
read_unicode(
        unsigned int    *p,             /* point variable to store UTF-32 */
        unsigned char   **pip,          /* point pointer to input buf */
        size_t          *pileft,        /* point #bytes left in input buf */
        ucs_state_t     *state)         /* BOM state and endian */
{
        unsigned char   *ip = *pip;
        size_t          ileft = *pileft;
        size_t          rv = (size_t)0; /* return value */
        unsigned char   ic1, ic2, ic3, ic4;     /* bytes read */
        unsigned int    u32;            /* resulted UTF-32 */

        NGET(ic1, "UTF32-1");
        NGET(ic2, "UTF32-2");
        NGET(ic3, "UTF32-3");
        NGET(ic4, "UTF32-4");

        if (state->bom_written == B_FALSE) {
                u32 = 0U;
                u32 |= (unsigned int)ic1 << 24;
                u32 |= (unsigned int)ic2 << 16;
                u32 |= (unsigned int)ic3 << 8;
                u32 |= (unsigned int)ic4 << 0;
                if (u32 == BOM) {
                        state->bom_written = B_TRUE;
                        state->little_endian = B_FALSE;
                        *p = BOM;
                        rv = (size_t)0;
                        goto ret;
                } else if (u32 == BSBOM32) {
                        state->bom_written = B_TRUE;
                        state->little_endian = B_TRUE;
                        *p = BOM;
                        rv = (size_t)0;
                        goto ret;
                } else {
                        state->bom_written = B_TRUE;
                }
        }

        if (state->little_endian == B_TRUE) {
                u32 = 0U;
                u32 |= (unsigned int)ic1 << 0;
                u32 |= (unsigned int)ic2 << 8;
                u32 |= (unsigned int)ic3 << 16;
                u32 |= (unsigned int)ic4 << 24;
        } else {
                u32 = 0U;
                u32 |= (unsigned int)ic1 << 24;
                u32 |= (unsigned int)ic2 << 16;
                u32 |= (unsigned int)ic3 << 8;
                u32 |= (unsigned int)ic4 << 0;
        }

        if (u32 == BSBOM32) {
                RETERROR(EILSEQ, "byte-swapped BOM detected")
        }

        if ((u32 == 0xfffe) || (u32 == 0xffff) || (u32 > 0x10ffff)
                        || IFHISUR(u32) || IFLOSUR(u32)) {
                RETERROR(EILSEQ, "illegal in UTF-32")
        }

        *p = u32;
        rv = *pileft - ileft;

ret:
        if (rv != (size_t)-1) {
                /* update *pip and *pileft only on successful return */
                *pip = ip;
                *pileft = ileft;
        }

        return (rv);
}

#elif   defined(JFP_ICONV_FROMCODE_UTF16) || defined(JFP_ICONV_FROMCODE_UCS2)

static size_t                           /* return #bytes read, or -1 */
read_unicode(
        unsigned int    *p,             /* point variable to store UTF-32 */
        unsigned char   **pip,          /* point pointer to input buf */
        size_t          *pileft,        /* point #bytes left in input buf */
        ucs_state_t     *state)         /* BOM state and endian */
{
        unsigned char   *ip = *pip;
        size_t          ileft = *pileft;
        size_t          rv = (size_t)0; /* return value */
        unsigned char   ic1, ic2;       /* bytes read */
        unsigned int    u32;            /* resulted UTF-32 */
#ifndef JFP_ICONV_FROMCODE_UCS2
        unsigned int    losur;          /* low surrogate */
#endif

        NGET(ic1, "UTF16-1");   /* read 1st byte */
        NGET(ic2, "UTF16-2");   /* read 2nd byte */

        if (state->bom_written == B_FALSE) {
                u32 = 0U;
                u32 |= (unsigned int)ic1 << 8;
                u32 |= (unsigned int)ic2 << 0;
                if (u32 == BOM) {
                        state->bom_written = B_TRUE;
                        state->little_endian = B_FALSE;
                        *p = BOM;
                        rv = (size_t)0;
                        goto ret;
                } else if (u32 == BSBOM16) {
                        state->bom_written = B_TRUE;
                        state->little_endian = B_TRUE;
                        *p = BOM;
                        rv = (size_t)0;
                        goto ret;
                } else {
                        state->bom_written = B_TRUE;
                }
        }

        if (state->little_endian == B_TRUE) {
                u32 = (((unsigned int)ic2) << 8) | ic1;
        } else {
                u32 = (((unsigned int)ic1) << 8) | ic2;
        }

        if (u32 == BSBOM16) {
                RETERROR(EILSEQ, "byte-swapped BOM detected")
        }

        if ((u32 == 0xfffe) || (u32 == 0xffff) || (u32 > 0x10ffff)
                        || (IFLOSUR(u32))) {
                RETERROR(EILSEQ, "illegal in UTF16")
        }

        if (IFHISUR(u32)) {
#if     defined(JFP_ICONV_FROMCODE_UCS2)
                RETERROR(EILSEQ, "surrogate is illegal in UCS2")
#else   /* !defined(JFP_ICONV_FROMCODE_UCS2) */
                NGET(ic1, "LOSUR-1");
                NGET(ic2, "LOSUR-2");

                if (state->little_endian == B_TRUE) {
                        losur = (((unsigned int)ic2) << 8) | ic1;
                } else {
                        losur = (((unsigned int)ic1) << 8) | ic2;
                }

                if (IFLOSUR(losur)) {
                        u32 = ((u32 - 0xd800) * 0x400)
                                + (losur - 0xdc00) + 0x10000;
                } else {
                        RETERROR(EILSEQ, "low-surrogate expected")
                }
#endif  /* defined(JFP_ICONV_FROMCODE_UCS2) */
        }

        *p = u32;
        rv = *pileft - ileft;

ret:
        if (rv != (size_t)-1) {
                /* update *pip and *pileft only on successful return */
                *pip = ip;
                *pileft = ileft;
        }

        return (rv);
}

#else   /* JFP_ICONV_FROMCODE_UTF8 (default) */

/*
 * The following vector shows remaining bytes in a UTF-8 character.
 * Index will be the first byte of the character.
 */
static const char remaining_bytes_tbl[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,
        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,

   /*  C0  C1  C2  C3  C4  C5  C6  C7  C8  C9  CA  CB  CC  CD  CE  CF  */
        0,  0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,

   /*  D0  D1  D2  D3  D4  D5  D6  D7  D8  D9  DA  DB  DC  DD  DE  DF  */
        1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,

   /*  E0  E1  E2  E3  E4  E5  E6  E7  E8  E9  EA  EB  EC  ED  EE  EF  */
        2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,

   /*  F0  F1  F2  F3  F4  F5  F6  F7  F8  F9  FA  FB  FC  FD  FE  FF  */
        3,  3,  3,  3,  3,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
};


/*
 * The following is a vector of bit-masks to get used bits in
 * the first byte of a UTF-8 character.  Index is remaining bytes at above of
 * the character.
 */
static const char masks_tbl[6] = { 0x00, 0x1f, 0x0f, 0x07, 0x03, 0x01 };


/*
 * The following two vectors are to provide valid minimum and
 * maximum values for the 2'nd byte of a multibyte UTF-8 character for
 * better illegal sequence checking. The index value must be the value of
 * the first byte of the UTF-8 character.
 */
static const unsigned char valid_min_2nd_byte[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,
        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,
     /*  C0    C1    C2    C3    C4    C5    C6    C7  */
        0,    0,    0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
     /*  C8    C9    CA    CB    CC    CD    CE    CF  */
        0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
     /*  D0    D1    D2    D3    D4    D5    D6    D7  */
        0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
     /*  D8    D9    DA    DB    DC    DD    DE    DF  */
        0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
     /*  E0    E1    E2    E3    E4    E5    E6    E7  */
        0xa0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
     /*  E8    E9    EA    EB    EC    ED    EE    EF  */
        0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
     /*  F0    F1    F2    F3    F4    F5    F6    F7  */
        0x90, 0x80, 0x80, 0x80, 0x80, 0,    0,    0,
        0,    0,    0,    0,    0,    0,    0,    0,
};

static const unsigned char valid_max_2nd_byte[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,
        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,
     /*  C0    C1    C2    C3    C4    C5    C6    C7  */
        0,    0,    0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf,
     /*  C8    C9    CA    CB    CC    CD    CE    CF  */
        0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf,
     /*  D0    D1    D2    D3    D4    D5    D6    D7  */
        0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf,
     /*  D8    D9    DA    DB    DC    DD    DE    DF  */
        0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf,
     /*  E0    E1    E2    E3    E4    E5    E6    E7  */
        0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf,
     /*  E8    E9    EA    EB    EC    ED    EE    EF  */
        0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0x9f, 0xbf, 0xbf,
     /*  F0    F1    F2    F3    F4    F5    F6    F7  */
        0xbf, 0xbf, 0xbf, 0xbf, 0x8f, 0,    0,    0,
        0,    0,    0,    0,    0,    0,    0,    0,
};

static size_t
utf8_ucs(unsigned int *p, unsigned char **pip, size_t *pileft)
{
        unsigned int    l;      /* to be copied to *p on successful return */
        unsigned char   ic;     /* current byte */
        unsigned char   ic1;    /* 1st byte */
        unsigned char   *ip = *pip;     /* next byte to read */
        size_t          ileft = *pileft; /* number of bytes available */
        size_t          rv = (size_t)0; /* return value of this function */
        int             remaining_bytes;

        NGET(ic, "no bytes available"); /* read 1st byte */
        ic1 = ic;
        l = ic1; /* get bits from 1st byte to UCS value */

        if (ic1 < 0x80) {
                /* successfully converted */
                *p = l;
                rv = *pileft - ileft;
                goto ret;
        }

        remaining_bytes = remaining_bytes_tbl[ic1];

        if (remaining_bytes != 0) {
                l &= masks_tbl[remaining_bytes];

                for (; remaining_bytes > 0; remaining_bytes--) {
                        if (ic1 != 0U) {
                                NGET(ic, "2nd byte of UTF-8");
                                if ((ic < valid_min_2nd_byte[ic1]) ||
                                        (ic > valid_max_2nd_byte[ic1])) {
                                        RETERROR(EILSEQ, "2nd byte is invalid")
                                }
                                ic1 = 0U; /* 2nd byte check done */
                        } else {
                                NGET(ic, "3rd or later byte of UTF-8");
                                if ((ic < 0x80) || (ic > 0xbf)) {
                                RETERROR(EILSEQ, "3rd or later byte is invalid")
                                }
                        }
                        l = (l << 6) | (ic & 0x3f);
                }

                /* successfully converted */
                *p = l;
                rv = *pileft - ileft;
                goto ret;
        } else {
                RETERROR(EILSEQ, "1st byte is invalid")
        }

ret:
        if (rv != (size_t)-1) {
                /*
                 * update *pip and *pileft on successful return
                 */
                *pip = ip;
                *pileft = ileft;
        }

        return (rv);
}

/* for UTF-8 */
static size_t                           /* return #bytes read, or -1 */
read_unicode(
        unsigned int    *p,             /* point variable to store UTF-32 */
        unsigned char   **pip,          /* point pointer to input buf */
        size_t          *pileft,        /* point #bytes left in input buf */
        ucs_state_t     *state)         /* BOM state and endian - unused */
{
        return (utf8_ucs(p, pip, pileft));
}

#endif

#if     defined(JFP_ICONV_TOCODE_UTF32)

static size_t
write_unicode(
        unsigned int    u32,            /* UTF-32 to write */
        char            **pop,          /* point pointer to output buf */
        size_t          *poleft,        /* point #bytes left in output buf */
        ucs_state_t     *state,         /* BOM state and endian */
        const char      *msg)           /* debug message */
{
        char            *op = *pop;
        size_t          oleft = *poleft;
        size_t          rv = (size_t)0;         /* return value */
        unsigned char   ic1, ic2, ic3, ic4;     /* bytes to be written */

        if (state->bom_written == B_FALSE) {
                if (state->little_endian == B_TRUE) {
                        ic1 = (unsigned char)((BOM >> 0) & 0xff);
                        ic2 = (unsigned char)((BOM >> 8) & 0xff);
                        ic3 = (unsigned char)((BOM >> 16) & 0xff);
                        ic4 = (unsigned char)((BOM >> 24) & 0xff);
                } else {
                        ic1 = (unsigned char)((BOM >> 24) & 0xff);
                        ic2 = (unsigned char)((BOM >> 16) & 0xff);
                        ic3 = (unsigned char)((BOM >> 8) & 0xff);
                        ic4 = (unsigned char)((BOM >> 0) & 0xff);
                }
                rv += 4;
                NPUT(ic1, "BOM32-1")
                NPUT(ic2, "BOM32-2")
                NPUT(ic3, "BOM32-3")
                NPUT(ic4, "BOM32-4")
        }

        if (state->little_endian == B_TRUE) {
                ic1 = (unsigned char)((u32 >> 0) & 0xff);
                ic2 = (unsigned char)((u32 >> 8) & 0xff);
                ic3 = (unsigned char)((u32 >> 16) & 0xff);
                ic4 = (unsigned char)((u32 >> 24) & 0xff);
                rv += 4;
        } else {
                ic1 = (unsigned char)((u32 >> 24) & 0xff);
                ic2 = (unsigned char)((u32 >> 16) & 0xff);
                ic3 = (unsigned char)((u32 >> 8) & 0xff);
                ic4 = (unsigned char)((u32 >> 0) & 0xff);
                rv += 4;
        }

        NPUT(ic1, "UTF32-1")
        NPUT(ic2, "UTF32-2")
        NPUT(ic3, "UTF32-3")
        NPUT(ic4, "UTF32-4")

ret:
        if (rv != (size_t)-1) {
                /* update *pop and *poleft only on successful return */
                *pop = op;
                *poleft = oleft;
                if (state->bom_written == B_FALSE)
                        state->bom_written = B_TRUE;
        }

        return (rv);
}

#elif   defined(JFP_ICONV_TOCODE_UTF16) || defined(JFP_ICONV_TOCODE_UCS2)

static size_t
write_unicode(
        unsigned int    u32,            /* UTF-32 to write */
        char            **pop,          /* point pointer to output buf */
        size_t          *poleft,        /* point #bytes left in output buf */
        ucs_state_t     *state,         /* BOM state and endian */
        const char      *msg)           /* debug message */
{
        char            *op = *pop;
        size_t          oleft = *poleft;
        size_t          rv = (size_t)0; /* return value */
        unsigned char   ic1, ic2;       /* bytes to be written */
        unsigned int    losur = 0U;             /* Hi/Lo surrogates */

        if (state->bom_written == B_FALSE) {
                if (state->little_endian == B_TRUE) {
                        ic1 = (unsigned char)((BOM >> 0) & 0xff);
                        ic2 = (unsigned char)((BOM >> 8) & 0xff);
                } else {
                        ic1 = (unsigned char)((BOM >> 8) & 0xff);
                        ic2 = (unsigned char)((BOM >> 0) & 0xff);
                }
                rv += 2;
                NPUT(ic1, "BOM16-1")
                NPUT(ic2, "BOM16-2")
        }

        if (u32 > 0xffff) {
#if     defined(JFP_ICONV_TOCODE_UCS2)
                u32 = REPLACE;
#else   /* !defined(JFP_ICONV_TOCODE_UCS2) */
                losur = ((u32 - 0x10000) % 0x400) + 0xdc00;
                u32 = ((u32 - 0x10000) / 0x400) + 0xd800;
#endif  /* defined(JFP_ICONV_TOCODE_UCS2) */
        }

        if (state->little_endian == B_TRUE) {
                ic1 = (unsigned char)(u32 & 0xff);
                ic2 = (unsigned char)((u32 >> 8) & 0xff);
                rv += 2;
        } else {
                ic1 = (unsigned char)((u32 >> 8) & 0xff);
                ic2 = (unsigned char)(u32 & 0xff);
                rv += 2;
        }

        NPUT(ic1, "UTF16-1")
        NPUT(ic2, "UTF16-2")

        if (losur != 0U) {
                if (state->little_endian == B_TRUE) {
                        ic1 = (unsigned char)(losur & 0xff);
                        ic2 = (unsigned char)((losur >> 8) & 0xff);
                        rv += 2;
                } else {
                        ic1 = (unsigned char)((losur >> 8) & 0xff);
                        ic2 = (unsigned char)(losur & 0xff);
                        rv += 2;
                }

                NPUT(ic1, "LOSUR-1")
                NPUT(ic2, "LOSUR-2")
        }


ret:
        if (rv != (size_t)-1) {
                /* update *pop and *poleft only on successful return */
                *pop = op;
                *poleft = oleft;
                if (state->bom_written == B_FALSE)
                        state->bom_written = B_TRUE;
        }

        return (rv);
}

#else   /* JFP_ICONV_TOCODE_UTF8 (default) */

static size_t
write_unicode(
        unsigned int    u32,            /* UTF-32 to write */
        char            **pop,          /* point pointer to output buf */
        size_t          *poleft,        /* point #bytes left in output buf */
        ucs_state_t     *state,         /* BOM state and endian - unused */
        const char      *msg)           /* debug message */
{
        char    *op = *pop;
        size_t  oleft = *poleft;
        size_t  rv = 0;                 /* return value */

        if (u32 <= 0x7f) {
                NPUT((unsigned char)(u32), msg);
                rv = 1;
        } else if (u32 <= 0x7ff) {
                NPUT((unsigned char)((((u32)>>6) & 0x1f) | 0xc0), msg);
                NPUT((unsigned char)((((u32)>>0) & 0x3f) | 0x80), msg);
                rv = 2;
        } else if ((u32 >= 0xd800) && (u32 <= 0xdfff)) {
                RETERROR(EILSEQ, "surrogate in UTF-8")
        } else if (u32 <= 0xffff) {
                NPUT((unsigned char)((((u32)>>12) & 0x0f) | 0xe0), msg);
                NPUT((unsigned char)((((u32)>>6) & 0x3f) | 0x80), msg);
                NPUT((unsigned char)((((u32)>>0) & 0x3f) | 0x80), msg);
                rv = 3;
        } else if (u32 <= 0x10ffff) {
                NPUT((unsigned char)((((u32)>>18) & 0x07) | 0xf0), msg);
                NPUT((unsigned char)((((u32)>>12) & 0x3f) | 0x80), msg);
                NPUT((unsigned char)((((u32)>>6) & 0x3f) | 0x80), msg);
                NPUT((unsigned char)((((u32)>>0) & 0x3f) | 0x80), msg);
                rv = 4;
        } else {
                RETERROR(EILSEQ, "beyond range of UTF-8")
        }

ret:
        if (rv != (size_t)-1) {
                /* update *pop and *poleft only on successful return */
                *pop = op;
                *poleft = oleft;
        }

        return (rv);
}

#endif

#define GETU(pu32) \
        switch (read_unicode(pu32, &ip, &ileft, (ucs_state_t *)cd)) { \
        case (size_t)-1: \
                /* errno has been set in read_unicode() */ \
                rv = (size_t)-1; \
                goto ret; \
        case (size_t)0: \
                /* character read was handled in the read_unicode() */ \
                /* no further evaluation needed in caller side */ \
                rv = (size_t)0; \
                goto next; \
        default: \
                break; \
        }


#define PUTU(u32, msg)  \
        if (write_unicode(u32, &op, &oleft, (ucs_state_t *)cd, msg) \
                        == (size_t)-1) { \
                rv = ((size_t)-1);\
                goto ret; \
        }

#include        <stdlib.h>

static void
_icv_reset_unicode(void *cd)
{
        ucs_state_t     *state = (ucs_state_t *)cd;

#if     defined(JFP_ICONV_FROMCODE_UTF32BE) || \
        defined(JFP_ICONV_TOCODE_UTF32BE) || \
        defined(JFP_ICONV_FROMCODE_UTF16BE) || \
        defined(JFP_ICONV_TOCODE_UTF16BE) || \
        defined(JFP_ICONV_FROMCODE_UCS2BE) || \
        defined(JFP_ICONV_TOCODE_UCS2BE)
        state->little_endian = B_FALSE;
        state->bom_written = B_TRUE;
#elif   defined(JFP_ICONV_FROMCODE_UTF32LE) || \
        defined(JFP_ICONV_TOCODE_UTF32LE) || \
        defined(JFP_ICONV_FROMCODE_UTF16LE) || \
        defined(JFP_ICONV_TOCODE_UTF16LE) || \
        defined(JFP_ICONV_FROMCODE_UCS2LE) || \
        defined(JFP_ICONV_TOCODE_UCS2LE)
        state->little_endian = B_TRUE;
        state->bom_written = B_TRUE;
#elif   defined(_LITTLE_ENDIAN)
        state->little_endian = B_TRUE;
        state->bom_written = B_FALSE;
#elif   defined(_BIG_ENDIAN)
        state->little_endian = B_FALSE;
        state->bom_written = B_FALSE;
#endif

        return;
}

static void *
_icv_open_unicode(size_t extsize)
{
        ucs_state_t     *cd;

        if ((cd = (ucs_state_t *)calloc(1,
                        sizeof (ucs_state_t) + extsize)) == NULL) {
                errno = ENOMEM;
                return ((void *)-1);
        }

        _icv_reset_unicode((void *)cd);

        return ((void *)cd);
}

static void
_icv_close_unicode(void *cd)
{
        if (cd == NULL) {
                errno = EBADF;
        } else {
                free(cd);
        }
        return;
}

static void *
_icv_get_ext(void *cd)
{
        return ((void *)((unsigned char *)cd + sizeof (ucs_state_t)));
}