lc/gb18030/lcGB18030.c

/*
 * Copyright © 1996, 2015, Oracle and/or its affiliates. All rights reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice (including the next
 * paragraph) shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <stdio.h>
#include "Xlibint.h"
#include "XlcGeneric.h"

/*
 * codesets will derived from XLC_XLOCALE and codesets[0] is
 * gb18030.2000-1 in XLC_XLOCALE
 */
#define CS0     codesets[2] /* Codeset 0 - 7-bit ASCII  */
#define CS1     codesets[0] /* Codeset 1 - gb18030.2000-0   */
#define CS2     codesets[1] /* Codeset 2 - gb18030.2000-1   */

#define ascii       (codeset->cs_num == 0)
#define gb18030     (codeset->cs_num == 2)

#define ASCII_CODESET   0
#define GBK2K_CODESET1  1
#define GBK2K_CODESET2  2
#define MAX_CODESETS    3

#define ISASCII(ch) ((unsigned char)(ch) <= 0x7F)

#define GR      0x80    /* Begins right-side (non-ascii) region. */
#define GL      0x7f    /* Ends left-side (ascii) region.        */

#define isleftside(c)   (((c) & GR) ? 0 : 1)
#define isrightside(c)  (! isleftside(c))

typedef unsigned char   Uchar;
typedef unsigned long   Ulong;
typedef unsigned int    Uint;

#define BIT8OFF(c)  ((c) & GL)
#define BIT8ON(c)   ((c) | GR)

#define ESC         0x1b

typedef struct _CT_DATA
{
    char *charset;
    char *encode_string;
} CT_DATA;

static CT_DATA default_ct_data[] =
{
    {"ASCII",  "\033(B" },
    {"GB2312",  "\033$(A" },
    {"GB18030-0",  "\033%/2??SUN-GB18030-0" },
    {"GB18030-1",  "\033%/2??SUN-GB18030-1" }
};

static int num_ct_data = sizeof(default_ct_data)/sizeof(CT_DATA);

static char *
get_CT_encode_string(const char *charset)
{
    if (charset) {
    int  i;

    for (i=0; i < num_ct_data; ++i)
        if (strncmp(charset,
            default_ct_data[i].charset,
            strlen(charset)) == 0)
        return default_ct_data[i].encode_string;
    }

   return NULL;
}

typedef enum {t_ASCII, t_GB2312, t_GB18030_0, t_GB18030_1, t_NONE} CharSet_Type;

static  CharSet_Type
get_charset_with_encode_string(const char *s)
{
    if (s) {
    int i;

    for (i=0; i < num_ct_data; ++i)
        if (strncmp(s, default_ct_data[i].encode_string,
            strlen(default_ct_data[i].encode_string)) == 0)
            return i;
     }

    return t_NONE;
}

static void
twobyte_to_fourbyte(unsigned char *in_buf, unsigned char *out_buf)
{
    int tmp;

    tmp=(in_buf[0] << 8) + in_buf[1];

    out_buf[3] = 0x30 + tmp%10; tmp/=10;
    out_buf[2] = 0x81 + tmp%126; tmp/=126;
    out_buf[1] = 0x30 + tmp%10; tmp/=10;
    out_buf[0] = 0x81 + tmp;
}

static void
fourbyte_to_twobyte(unsigned char *in_buf, unsigned char *out_buf)
{
    int tmp;

    tmp = 12600 * (in_buf[0] - 0x81) + 1260 * (in_buf[1] - 0x30) +
    10 * (in_buf[2] - 0x81) + (in_buf[3] - 0x30);
    out_buf[0] = (tmp & 0xff00) >> 8;
    out_buf[1] = tmp & 0xff;
}

/*
 * In GB2312 range or not
 */
static int
isgb(unsigned char *s)
{
    /* consider the first byte */
    if (s[0] >= 0xA1 && s[0] <= 0xFE && s[1] >= 0xA1 &&
        s[1] <= 0xFE) {
    return True;
    }else{
    return False;
    }
}

/*
 * In GB18030 2 bytes range or not
 */
static int
isgb18030_2(unsigned char *s)
{
    /* consider the first byte */
    if (s[0] >= 0x81 && s[0] <= 0xfe &&
        ((s[1] >= 0x40 && s[1] <= 0x7e) ||
         (s[1] >= 0x80 && s[1] <= 0xfe)))
    return True;
    else
    return False;
}

/*
 * In GB18030 4 bytes range or not
 */
static int isgb18030_4(unsigned char *s)
{
    /* consider the first byte */
    if (s[0] >= 0x81 && s[0] <= 0xfe && s[1] >= 0x30 && s[1] <= 0x39 &&
        s[2] >= 0x81 && s[2] <= 0xfe && s[3] >= 0x30 && s[3] <= 0x39)
        return True;
    else
    return False;
}

/*
 * multibyte -> charset: codesets[0], codesets[1], codeset[2]
 */
static int
gb18030_mbtocs(
    XlcConv conv,
    XPointer *from,
    int *from_left,
    XPointer *to,
    int *to_left,
    XPointer *args,
    int num_args)
{
    unsigned char *src = (unsigned char *)*from;
    unsigned char *dst = (unsigned char *)*to;
    int     unconv_num = 0;
    int     char_size = 0;
    XLCd    lcd = (XLCd)conv->state;
    CodeSet *codesets = XLC_GENERIC(lcd, codeset_list);
    int     codeset_num = XLC_GENERIC(lcd, codeset_num);
    XlcCharSet  charset = NULL;

    if (isgb18030_2(src)) {
    if (GBK2K_CODESET1 >= codeset_num)
        return -1;
    charset = *CS1->charset_list;
    char_size = charset->char_size;

    if (*from_left >= 2 && *to_left >= char_size) {
            *dst++ = *src++;
        *dst++ = *src++;
    } else {
        return -1;
    }

        *from_left -= char_size;
        *to_left -= char_size;
    } else if (isgb18030_4(src)) {
    unsigned char iconv_buf[6];

    if (GBK2K_CODESET2 >= codeset_num)
        return -1;

    charset = *CS2->charset_list;
    char_size = charset->char_size;
        fourbyte_to_twobyte(src, iconv_buf);
    if (*from_left >= 4 && *to_left >= char_size) {
            *dst++ = iconv_buf[0];
        *dst++ = iconv_buf[1];
        src += 4;
    } else {
        return -1;
    }

        *from_left -= 4;
        *to_left -= char_size;
    } else if (ISASCII(*src)) {
    if (ASCII_CODESET >= codeset_num)
        return -1;
    charset = *CS0->charset_list;
    char_size = charset->char_size;

    if (*from_left >= char_size && *to_left >= char_size)
        *dst++ = *src++;
    else
        return -1;

        *from_left -= char_size;
        *to_left -= char_size;
    } else {        /* unknown */
    unconv_num++;
    src++;
        *from_left -= 1;
    }

    *to = (XPointer)dst;
    *from = (XPointer)src;

    if (num_args > 0)
    *((XlcCharSet *) args[0]) = charset;

    return unconv_num;
}

static int
gb18030_mbstocs(
    XlcConv conv,
    XPointer *from,
    int *from_left,
    XPointer *to,
    int *to_left,
    XPointer *args,
    int num_args)
{
    unsigned char *src = (unsigned char *)*from;
    unsigned char *dst = (unsigned char *)*to;
    int     char_size = 0;
    int     unconv_num = 0;
    int     flag = 0;
    XLCd    lcd = (XLCd)conv->state;
    CodeSet *codesets = XLC_GENERIC(lcd, codeset_list);
    int     codeset_num = XLC_GENERIC(lcd, codeset_num);
    XlcCharSet  charset = NULL;

    for (;;) {
    if (isgb18030_2(src)) {
        if (flag == 0)
        flag = 1;
        if (flag == 3 || flag == 2 )
        break;
        if (GBK2K_CODESET1 >= codeset_num)
        return -1;

        charset = *CS1->charset_list;
        char_size = charset->char_size;

        if (*from_left >= char_size && *to_left >= char_size) {
        *dst++ = *src++;
        *dst++ = *src++;
        *to_left -= char_size;
        *from_left -= char_size;
        }else {
        return -1;
        }
    } else if (isgb18030_4(src)) {
        unsigned char iconv_buf[6];

        if (flag == 0)
        flag = 2;
        if (flag == 3 || flag == 1)
        break;
        if (GBK2K_CODESET2 >= codeset_num)
        return -1;

        charset = *CS2->charset_list;
        char_size = charset->char_size;
        fourbyte_to_twobyte(src, iconv_buf);

        if (*from_left >= 4 && *to_left >= char_size) {
        *dst++ = iconv_buf[0];
        *dst++ = iconv_buf[1];
        src += 4;
        *to_left -= char_size;
        *from_left -= 4;
        } else {
        return -1;
        }
    } else if (ISASCII(*src)) {
        if  (flag == 0)
        flag = 3;
        if (flag == 1 || flag ==2 )
        break;
        if (ASCII_CODESET >= codeset_num)
        return -1;

        charset = *CS0->charset_list;
        char_size = charset->char_size;
        if (*from_left >= char_size && *to_left >= char_size) {
        *dst++ = *src++;
        *to_left -= char_size;
        *from_left -= char_size;
        } else {
        break;
        }
    } else{         /* unknown */
        unconv_num++;
        src++;
        *from_left -= 1;
    }

    if (*from_left <= 0)
        break;
    }

    *from = (XPointer)src;
    *to = (XPointer)dst;

    if (num_args > 0)
    *((XlcCharSet *) args[0]) = charset;

    return unconv_num;
}

static int
gb18030_wcstocs(
    XlcConv conv,
    XPointer *from,
    int *from_left,
    XPointer *to,
    int *to_left,
    XPointer *args,
    int num_args)
{
    unsigned char *dst = (unsigned char *)*to;
    wchar_t *src = (wchar_t *)*from;
    int     char_size = 0;
    int     unconv_num = 0;
    int     flag = 0;
    XLCd    lcd = (XLCd)conv->state;
    XlcCharSet  charset = NULL;
    CodeSet *codesets = XLC_GENERIC(lcd, codeset_list);
    int     codeset_num = XLC_GENERIC(lcd, codeset_num);

    charset = (XlcCharSet)args[0];

    for (;;) {
    wchar_t wch = *src;
    char tmp[32];

    wctomb(tmp, wch);

    if (isgb18030_2((unsigned char*)tmp)) {
        if (flag == 0)
        flag = 1;
        if (flag == 2 || flag == 3)
        break;
        if (GBK2K_CODESET1 >= codeset_num)
        return -1;

        charset = *CS1->charset_list;
        char_size = charset->char_size;

        if (*from_left > 0 && *to_left >= char_size) {
        *dst++ = tmp[0];
        *dst++ = tmp[1];
        *to_left -= char_size;
        } else {
        return -1;
        }
    } else if (isgb18030_4((unsigned char*)tmp)) {
        unsigned char iconv_buf[6];

        if (flag == 0)
        flag = 2;
        if (flag == 1 || flag == 3)
        break;
        if (GBK2K_CODESET2 >= codeset_num)
        return -1;

        charset = *CS2->charset_list;
        char_size = charset->char_size;
        fourbyte_to_twobyte((unsigned char*)tmp, iconv_buf);

        if (*from_left > 0 && *to_left >= char_size) {
        *dst++ = iconv_buf[0];
        *dst++ = iconv_buf[1];
        *to_left -= char_size;
        } else {
        return -1;
        }
    } else if (ISASCII(tmp[0])) {
        if (flag == 0)
        flag = 3;
        if (flag == 1 || flag == 2)
        break;
        if (ASCII_CODESET >= codeset_num)
        return -1;

        charset = *CS0->charset_list;
        char_size = charset->char_size;
        if (*from_left > 0 && *to_left >= char_size) {
        *dst++ = tmp[0];
        *to_left -= char_size;
        } else {
        return -1;
        }
    } else {    /* unknown */
        unconv_num++;
    }

    src++;      /* advance one wchar_t */
    (*from_left)--;
    if (*from_left <= 0)
        break;
    }

    *from = (XPointer)src;
    *to = (XPointer)dst;

    if (num_args > 0)
    *((XlcCharSet *)args[0]) = charset;

    return unconv_num;
}

static CodeSet
get_code_set_from_charset(
    XLCd lcd,
    XlcCharSet charset)
{
    CodeSet *codeset = XLC_GENERIC(lcd, codeset_list);
    XlcCharSet  *charset_list;
    int     codeset_num, num_charsets;

    codeset_num = XLC_GENERIC(lcd, codeset_num);

    for (; codeset_num-- > 0; codeset++) {
    num_charsets = (*codeset)->num_charsets;
    charset_list = (*codeset)->charset_list;

    for (; num_charsets-- > 0; charset_list++)
        if (*charset_list == charset)
        return *codeset;
    }

    return (CodeSet)NULL;
}

static int
gb18030_cstombs(
    XlcConv conv,
    XPointer *from,
    int *from_left,
    XPointer *to,
    int *to_left,
    XPointer *args,
    int num_args)
{
    unsigned char *src = (unsigned char *)*from;
    unsigned char *dst = (unsigned char *)*to;
    int     char_size = 0;
    int     unconv_num = 0;
    XLCd    lcd = (XLCd)conv->state;
    XlcCharSet  charset = (XlcCharSet) args[0];
    CodeSet codeset;

    codeset = get_code_set_from_charset(lcd, charset);
    if (codeset == NULL)
    return -1;

    for (;;) {
    if (codeset->wc_encoding==0x5e84) {     /* GB18030-1 */
        char_size = 2;

        if (*from_left >= 2 && *to_left >= 4) {
        unsigned char iconv_buf[6];

        twobyte_to_fourbyte(src, iconv_buf);
        *dst++ = iconv_buf[0];
        *dst++ = iconv_buf[1];
        *dst++ = iconv_buf[2];
        *dst++ = iconv_buf[3];
        *to_left -= 4;
        } else {
        return -1;
        }
    } else if (isgb18030_2((unsigned char*)src)) {  /*2 bytes character*/
        char_size = 2;

        if (*from_left >= 2 && *to_left >= 2) {
        *dst++ = *src++;
        *dst++ = *src++;
        *to_left -= 2;
        } else {
        return -1;
        }
    } else if (ISASCII(*src)) {     /*ASCII character*/
        char_size = 1;

        if (*from_left >= 1 && *to_left >= 1) {
        *dst++ = *src++;
        *to_left -= 1;
        } else {
        return -1;
        }
    } else {            /* unknown */
        unconv_num++;
        src++;
        char_size = 1;
    }

    *from_left -= char_size;;
    if (*from_left <= 0)
        break;
    }

    *from = (XPointer)src;
    *to = (XPointer )dst;

    if (num_args > 0)
    *((XlcCharSet *) args[0]) = charset;

    return unconv_num;
}

static int
gb18030_cstowcs(
    XlcConv conv,
    XPointer *from,
    int *from_left,
    XPointer *to,
    int *to_left,
    XPointer *args,
    int num_args)
{
    XPointer    outbufptr, outbufptr_save;
    int     to_left_save = *to_left;
    wchar_t *pwc = (wchar_t *) *to;
    int     rtn, rtn_1;

    outbufptr = (XPointer) Xmalloc(*to_left * 4);
    outbufptr_save = outbufptr;

    rtn = gb18030_cstombs(conv, from, from_left,
        &outbufptr, to_left,
        args, num_args);
    *outbufptr='\0';

    rtn_1 = mbstowcs(pwc, outbufptr_save, (to_left_save - *to_left));

    Xfree(outbufptr_save);

    *to_left = to_left_save - rtn_1;
    *to = *to+ rtn_1 * sizeof(wchar_t);

    return rtn;
}


/*
 * In gb18030 locale, we only consider the following possibilities
 * all other ct formats are ignored, keep looping until end of buffer
 *  ASCII
 *  GB2312
 *  GB18030-0
 *  GB18030-1
 */
static int
gb18030_ctstombs(
    XlcConv conv,
    XPointer *from,
    int *from_left,
    XPointer *to,
    int *to_left,
    XPointer *args,
    int num_args)
{
    unsigned char *inbufptr = (unsigned char *)*from;
    unsigned char *outbufptr = (unsigned char *)*to;
    int unconv_num = 0;
    int i, j;
    int save_outbuf = True;
    CharSet_Type charset_type;

    /*
     * If outbufptr is NULL, doen't save output, but just counts
     * a length to hold the output.
     */
    if (outbufptr == NULL)
    save_outbuf = False;

    i = 0;
    j = 0;

    while (i < *from_left) {
    if (inbufptr[i] == ESC) {   /* got an escape */
        charset_type = get_charset_with_encode_string(
            (const char *)inbufptr + i);

        switch (charset_type) {
        case t_ASCII:
        i += strlen(default_ct_data[charset_type].encode_string);

        for (;;) {
            if (i >= *from_left) {  /* end of from buffer */
            goto FINISHED;
            }

            if ((inbufptr[i] == 0x0a || inbufptr[i] == 0x09 ||
             inbufptr[i] >= 0x20) && ISASCII(inbufptr[i])) {
            if (*to_left < 1) {     /* end of to buffer */
                goto FINISHED;
            }

            if (save_outbuf == True)
                outbufptr[j++] = inbufptr[i];

            (*to_left)--;
            ++i;
            } else {
            break;
            }
        }
        break;

        case t_GB2312:
        i += strlen(default_ct_data[charset_type].encode_string);

        for (;;) {
            unsigned char iconv_buf[3];

            if (i >= *from_left) {  /* end of from buffer */
            goto FINISHED;
            }

            iconv_buf[0] = (inbufptr[i] & 0x7f) | 0x80;
            iconv_buf[1] = (inbufptr[i + 1] & 0x7f) | 0x80;

            if (isgb(iconv_buf)) {
            if (*to_left < 2 || *from_left < 2) {
                goto FINISHED;
            }

            if (save_outbuf == True) {
                outbufptr[j++] = iconv_buf[0];
                outbufptr[j++] = iconv_buf[1];
            }

            *to_left -= 2;
            i = i + 2;
            } else {
            break;
            }
        }
        break;

        case t_GB18030_0:
        i += strlen(default_ct_data[charset_type].encode_string);

        for (;;) {
            if (i >= *from_left) {      /* end of from buffer */
            goto FINISHED;
            }

            if (isgb18030_2(inbufptr + i)) {
            if (*to_left < 2 || *from_left < 2) {
                goto FINISHED;
            }

            if (save_outbuf == True) {
                outbufptr[j++] = inbufptr[i];
                outbufptr[j++] = inbufptr[i + 1];
            }

            *to_left -= 2;
            i = i + 2;
            } else {
            break;
            }
        }
        break;

        case t_GB18030_1:           /* gb18030.2000-1 character */
        i += strlen(default_ct_data[charset_type].encode_string);

        for (;;) {
            if (i >= *from_left) {      /* end of from buffer */
            goto FINISHED;
            }

            if (isgb18030_4(inbufptr + i)) {
            if (*to_left < 4 || *from_left < 4) {
                goto FINISHED;
            }

            if (save_outbuf == True) {
                outbufptr[j++] = inbufptr[i] & 0xff;
                outbufptr[j++] = inbufptr[i+1] & 0xff;
                outbufptr[j++] = inbufptr[i+2] & 0xff;
                outbufptr[j++] = inbufptr[i+3] & 0xff;
            }

            *to_left -= 4;
            i = i + 4;
            } else {
            break;
            }
        }
        break;

        case t_NONE:
        i++;        /* encounter unknown escape sequence */
        unconv_num++;
        break;
        }
    } else if ((inbufptr[i] == 0x0a || inbufptr[i] == 0x09 ||
            inbufptr[i] >= 0x20) && ISASCII(inbufptr[i])) {
        /* Process default CT G0 ascii character */
        if (*to_left < 1) {
        goto FINISHED;
        }

        if (save_outbuf == True)
        outbufptr[j++] = inbufptr[i];

        i++;
        *to_left -= 1;
    } else {        /* unknown character */
        i++;
        unconv_num++;
    }
    }

FINISHED:
    *from = (XPointer)(inbufptr + i);
    *to = (XPointer)(outbufptr + j);
    if (i >= *from_left)
    *from_left = 0;
    else
    *from_left -= i;

    return (unconv_num);
}

static int
gb18030_ctstowcs(
    XlcConv conv,
    XPointer *from,
    int *from_left,
    XPointer *to,
    int *to_left,
    XPointer *args,
    int num_args)
{
    XPointer    outbufptr, outbufptr_end;
    int     to_left_save = *to_left;
    wchar_t     *pwc = (wchar_t *) *to;
    int     rtn, rtn_1;


    outbufptr = (XPointer) Xmalloc(*to_left * 4); /* 100 safty tolerence */
    outbufptr_end = outbufptr;

    rtn = gb18030_ctstombs(conv,
        from,
        from_left,
        &outbufptr_end,
        to_left,
        args,
        num_args);

    *outbufptr_end = '\0';

    rtn_1 = mbstowcs(pwc, outbufptr, (to_left_save - *to_left));

    Xfree(outbufptr);

    *to_left = to_left_save - rtn_1;
    *to = *to + rtn_1 * sizeof(wchar_t);

    return rtn;
}

/*
 * The mbs is GB18030 code, must be converted to euc code,
 * then pack to ct format.
 */
static int
gb18030_mbstocts(
    XlcConv conv,
    XPointer *from,
    int *from_left,
    XPointer *to,
    int *to_left,
    XPointer *args,
    int num_args)
{
    unsigned char *inbufptr = (unsigned char *)*from;
    unsigned char *outbufptr = (unsigned char *)*to;
    int     unconv_num = 0;
    int     flag = 0, j = 0, i = 0;
    int     encode_string_len;
    char    *encode_string;

    while (i < *from_left && j < *to_left)  {
    if (isgb(&inbufptr[i])) {   /* GB2312 character */
        if (flag == 0 || flag != 2) {
        encode_string = get_CT_encode_string("GB2312");
        if (! encode_string )
            return -1;

        encode_string_len = strlen(encode_string);
        if (j + encode_string_len + 2 >= *to_left)
            break;

        strncpy((char *)outbufptr+j, encode_string, encode_string_len);
        j += encode_string_len;
        flag = 2;
        }

        if (j + 2 >= *to_left)
        break;

        outbufptr[j++] = inbufptr[i++] & 0x7f;
        outbufptr[j++] = inbufptr[i++] & 0x7f;
    } else if (isgb18030_2(&inbufptr[i])) {     /* 2 bytes GB 18030 */
        if (flag == 0 || flag != 4) {
        encode_string = get_CT_encode_string("GB18030-0");
        if (! encode_string )
            return -1;

        encode_string_len = strlen(encode_string);
        if (j + encode_string_len + 2 >= *to_left)
            break;

        strncpy((char *)outbufptr+j, encode_string, encode_string_len);
        j += encode_string_len;
        flag = 4;
        }

        if (j + 2 >= *to_left)
        break;

        outbufptr[j++] = inbufptr[i++] & 0xff;
        outbufptr[j++] = inbufptr[i++] & 0xff;
    } else if (isgb18030_4(&inbufptr[i])) {     /* 4 bytes GB18030 */
        if (flag == 0 || flag != 5) {
        encode_string = get_CT_encode_string("GB18030-1");
        if (!encode_string)
            return -1;
        encode_string_len = strlen(encode_string);

        if (j + encode_string_len + 4 >= *to_left)
            break;

        strncpy((char *)outbufptr+j, encode_string, encode_string_len);
        j += encode_string_len;
        flag = 5;
        }

        if (j + 4 >= *to_left)
        break;

        outbufptr[j++] = inbufptr[i++];
        outbufptr[j++] = inbufptr[i++];
        outbufptr[j++] = inbufptr[i++];
        outbufptr[j++] = inbufptr[i++];
    } else if (ISASCII(inbufptr[i])) {  /* ASCII */
        if (flag == 0 || flag != 3) {
        encode_string = get_CT_encode_string("ASCII");
        if (!encode_string )
            return -1;

        encode_string_len = strlen(encode_string);
        if (j + encode_string_len + 1 >= *to_left)
            break;

        strncpy((char *)outbufptr+j, encode_string, encode_string_len);
        j += encode_string_len;
        flag = 3;
        }

        if (j + 1 >= *to_left)
        break;

        outbufptr[j++] = inbufptr[i++];
    } else{
        i++;        /* Skip this byte */
        unconv_num++;   /* Count this as an unconverted byte */
    }
    }

    *from = (XPointer)&inbufptr[i];
    *to = (XPointer)&outbufptr[j];
    *from_left = *from_left - i;
    *to_left = *to_left - j;

    return unconv_num;
}

static int
gb18030_wcstocts(
    XlcConv conv,
    XPointer *from,
    int *from_left,
    XPointer *to,
    int *to_left,
    XPointer *args,
    int num_args)
{

    unsigned char inbufptr[10];
    unsigned char *outbufptr = (unsigned char *)*to;
    wchar_t *pwc = (wchar_t *)*from;
    int     unconv_num = 0;
    int     flag,j,i,k;
    char    *encode_string;
    int     encode_string_len;

    i = k = j = 0;
    flag = 0;

    while (k < *from_left) {
    if (wctomb((char *)inbufptr, pwc[k++]) == -1)
        return (-1);

    i=0;

    if (isgb(&inbufptr[i])) {       /* GB2312 */
        if (flag == 0 || flag != 1) {
        encode_string = get_CT_encode_string("GB2312");
        if (! encode_string)
            return (-1);

        encode_string_len = strlen(encode_string);
        if (j + encode_string_len + 2 >= *to_left)
            break;

        strncpy((char *)outbufptr+j, encode_string, encode_string_len);
        j += encode_string_len;
        flag = 1;
        }

        if (j + 2 >= *to_left)
        break;

        outbufptr[j++] = inbufptr[i++];
        outbufptr[j++] = inbufptr[i++];
    } else if (isgb18030_2(&inbufptr[i])) {
        if (flag == 0 || flag != 2) {
        encode_string = get_CT_encode_string("GB18030-0");
        if (! encode_string)
            return -1;

        encode_string_len = strlen(encode_string);
        if (j + encode_string_len + 2 >= *to_left)
            break;

        strncpy((char *)outbufptr+j, encode_string, encode_string_len);
        j += encode_string_len;
        flag = 2;
        }

        if (j + 2 >= *to_left)
        break;

        outbufptr[j++] = inbufptr[i++];
        outbufptr[j++] = inbufptr[i++];
    } else if (isgb18030_4(&inbufptr[i])) {
        if (flag == 0 || flag != 6) {
        encode_string = get_CT_encode_string("GB18030-1");
        if (! encode_string)
            return -1;

        encode_string_len = strlen(encode_string);
        if (j + encode_string_len + 4 >= *to_left)
            break;

        strncpy((char *)outbufptr+j, encode_string, encode_string_len);
        j += encode_string_len;
        flag = 6;
        }

        if (j + 4 >= *to_left)
        break;

        outbufptr[j++] = inbufptr[i++];
        outbufptr[j++] = inbufptr[i++];
        outbufptr[j++] = inbufptr[i++];
        outbufptr[j++] = inbufptr[i++];
    } else if (ISASCII(inbufptr[i])) {
        if (flag == 0 || flag != 3) {
        encode_string = get_CT_encode_string("ASCII");
        if (! encode_string)
            return -1;

        encode_string_len = strlen(encode_string);
        if (j + encode_string_len + 1 >= *to_left)
            break;

        strncpy((char *)outbufptr+j, encode_string, encode_string_len);
        j += encode_string_len;

        flag = 3;
        }

        outbufptr[j++] = inbufptr[i++];
    } else {
        unconv_num++;
    }
    }

    *from = (XPointer)&pwc[k];
    *to = (XPointer)&outbufptr[j];
    *from_left = *from_left - k;
    *to_left = *to_left - j;

    return unconv_num;
}

static int
gb18030_mbstowcs(
    XlcConv conv,
    XPointer *from,
    int *from_left,
    XPointer *to,
    int *to_left,
    XPointer *args,
    int num_args)
{
    char *src = *((char **) from);
    wchar_t *dst = *((wchar_t **) to);
    int src_left = *from_left;
    int dst_left = *to_left;
    int mblen, unconv_num = 0;

    while (src_left > 0 && dst_left > 0) {
        mblen = mbtowc(dst, src, src_left);

        if (mblen > 0) {
            src += mblen;
            src_left -= mblen;
            dst++;
            dst_left--;
        } else {
            src++;
            src_left--;
        if (mblen < 0) {
        unconv_num++;
        } else {
        *dst++ = L'\0';
                dst_left--;
        }
        }
    }

    *from = (XPointer) src;
    *to = (XPointer) dst;
    *from_left = src_left;
    *to_left = dst_left;
    return unconv_num;
}

static int
gb18030_wcstombs(
    XlcConv conv,
    XPointer *from,
    int *from_left,
    XPointer *to,
    int *to_left,
    XPointer *args,
    int num_args)
{
    wchar_t *src = *((wchar_t **)from);
    char *dst = *((char **) to);
    char buf[MB_CUR_MAX];
    int src_left = *from_left;
    int dst_left = *to_left;
    int mblen, unconv_num = 0;

    while (src_left > 0) {
        mblen = wctomb(buf, *src);

    if (dst_left < mblen) {
        break;
    }

        src++;
        src_left--;

    if (mblen < 0) {
        unconv_num++;
        continue;
    }

        dst_left -= mblen;
    for (int i = 0; i < mblen; i++) {
        *dst++ = buf[i];
    }
    }

    *from = (XPointer) src;
    *to = (XPointer) dst;
    *from_left = src_left;
    *to_left = dst_left;
    return unconv_num;
}


static void
close_converter(XlcConv conv)
{
    Xfree((char *) conv);
}

static XlcConv
create_conv(
    XLCd lcd,
    XlcConvMethods methods)
{
    XlcConv conv;

    conv = (XlcConv) Xmalloc(sizeof(XlcConvRec));
    if (conv == NULL)
    return (XlcConv) NULL;

    conv->methods = methods;
    conv->state = (XPointer) lcd;
    return conv;
}


enum { MBSTOCS, WCSTOCS, MBTOCS, CSTOMBS, CSTOWCS, MBSTOCTS, CTSTOMBS,
       CTSTOWCS, WCSTOCTS, MBSTOWCS, WCSTOMBS, STRTOMBS };

static XlcConvMethodsRec conv_methods[] = {
    {close_converter, gb18030_mbstocs,  NULL },
    {close_converter, gb18030_wcstocs,  NULL },
    {close_converter, gb18030_mbtocs,   NULL },
    {close_converter, gb18030_cstombs,  NULL },
    {close_converter, gb18030_cstowcs,  NULL },
    {close_converter, gb18030_mbstocts, NULL },
    {close_converter, gb18030_ctstombs, NULL },
    {close_converter, gb18030_ctstowcs, NULL },
    {close_converter, gb18030_wcstocts, NULL },
    {close_converter, gb18030_mbstowcs, NULL },
    {close_converter, gb18030_wcstombs, NULL },

};


static XlcConv
open_mbstocs(
    XLCd from_lcd,
    const char *from_type,
    XLCd to_lcd,
    const char *to_type)
{
    return create_conv(from_lcd, &conv_methods[MBSTOCS]);
}

static XlcConv
open_wcstocs(
    XLCd from_lcd,
    const char *from_type,
    XLCd to_lcd,
    const char *to_type)
{
    return create_conv(from_lcd, &conv_methods[WCSTOCS]);
}

static XlcConv
open_mbtocs(
    XLCd from_lcd,
    const char *from_type,
    XLCd to_lcd,
    const char *to_type)
{
    return create_conv(from_lcd, &conv_methods[MBTOCS]);
}

static XlcConv
open_cstombs(
    XLCd from_lcd,
    const char *from_type,
    XLCd to_lcd,
    const char *to_type)
{
    return create_conv(from_lcd, &conv_methods[CSTOMBS]);
}

static XlcConv
open_cstowcs(
    XLCd from_lcd,
    const char *from_type,
    XLCd to_lcd,
    const char *to_type)
{
    return create_conv(from_lcd, &conv_methods[CSTOWCS]);
}

static XlcConv
open_wcstocts(
    XLCd from_lcd,
    const char *from_type,
    XLCd to_lcd,
    const char *to_type)
{
    return create_conv(from_lcd, &conv_methods[WCSTOCTS]);
}

static XlcConv
open_mbstocts(
    XLCd from_lcd,
    const char *from_type,
    XLCd to_lcd,
    const char *to_type)
{
    return create_conv(from_lcd, &conv_methods[MBSTOCTS]);
}

static XlcConv
open_ctstombs(
    XLCd from_lcd,
    const char *from_type,
    XLCd to_lcd,
    const char *to_type)
{
    return create_conv(from_lcd, &conv_methods[CTSTOMBS]);
}

static XlcConv
open_ctstowcs(
    XLCd from_lcd,
    const char *from_type,
    XLCd to_lcd,
    const char *to_type)
{
    return create_conv(from_lcd, &conv_methods[CTSTOWCS]);
}

static XlcConv
open_mbstowcs(
    XLCd from_lcd,
    const char *from_type,
    XLCd to_lcd,
    const char *to_type)
{
    return create_conv(from_lcd, &conv_methods[MBSTOWCS]);
}

static XlcConv
open_wcstombs(
    XLCd from_lcd,
    const char *from_type,
    XLCd to_lcd,
    const char *to_type)
{
    return create_conv(from_lcd, &conv_methods[WCSTOMBS]);
}

XLCd
_XlcGb18030Loader(const char *name)
{
    XLCd lcd;

    lcd = _XlcCreateLC(name, _XlcGenericMethods);
    if (lcd == NULL)
    return lcd;

    if ((_XlcNCompareISOLatin1(XLC_PUBLIC_PART(lcd)->codeset, "gb18030", 7))) {
    _XlcDestroyLC(lcd);
    return (XLCd) NULL;
    }

    /* MB/WC  <->  CS */
    _XlcSetConverter(lcd, XlcNMultiByte,  lcd, XlcNCharSet,   open_mbstocs);
    _XlcSetConverter(lcd, XlcNWideChar,   lcd, XlcNCharSet,   open_wcstocs);
    _XlcSetConverter(lcd, XlcNCharSet,    lcd, XlcNMultiByte, open_cstombs);
    _XlcSetConverter(lcd, XlcNCharSet,    lcd, XlcNWideChar,  open_cstowcs);

    _XlcSetConverter(lcd, XlcNMultiByte,  lcd, XlcNChar,      open_mbtocs);

    /* MB/WC  <->  CT */
    _XlcSetConverter(lcd, XlcNMultiByte, lcd, XlcNCompoundText, open_mbstocts);
    _XlcSetConverter(lcd, XlcNCompoundText, lcd, XlcNMultiByte, open_ctstombs);
    _XlcSetConverter(lcd, XlcNCompoundText, lcd, XlcNWideChar, open_ctstowcs);
    _XlcSetConverter(lcd, XlcNWideChar, lcd, XlcNCompoundText, open_wcstocts);

    /* MB <-> WC */
    _XlcSetConverter(lcd, XlcNMultiByte, lcd, XlcNWideChar,     open_mbstowcs);
    _XlcSetConverter(lcd, XlcNWideChar,  lcd, XlcNMultiByte,    open_wcstombs);


    _XlcAddUtf8Converters(lcd);

    return lcd;
}