blob: a2db1a3379d753eb0a56bf0454bff68917e73667 [file] [log] [blame]
/*
* 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 "cns11643_big5.h" /* CNS 11643 to Big-5 mapping table */
#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 MBS */
#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 */
int plane_no; /* plane number for Chinese character */
int _errno; /* internal errno */
} _iconv_st;
enum _CSTATE { C0, C1, C2, C3, C4, C5, C6, C7 };
static int get_plane_no_by_iso(const char);
static int iso_to_big5(int, char[], char*, size_t);
static int binsearch(unsigned long, table_t[], int);
/*
* 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->plane_no = 0;
st->_errno = 0;
#ifdef DEBUG
fprintf(stderr, "========== iconv(): ISO2022-7 --> Big-5 ==========\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 ISO 2022-7 code
*
*=========================================================================
*
* plane 2 - 16
* +---------->-------+
* plane ^ |
* ESC $ ) number SO | plane 1 v
* +-> C0 ----> C1 ---> C2 ---> C3 ------> C4 --> C5 -------> C6 C7
* | | ascii | ascii | ascii | ascii | SI | | | |
* +----------------------------+ <-----+------+ +------<---+------+
* ^ |
* | ascii v
* +---------<-------------<---------+
*
*=========================================================================*/
size_t
_icv_iconv(_iconv_st *st, char **inbuf, size_t *inbytesleft,
char **outbuf, size_t *outbytesleft)
{
int n;
if (st == NULL) {
errno = EBADF;
return ((size_t) -1);
}
if (inbuf == NULL || *inbuf == NULL) { /* Reset request. */
st->cstate = C0;
st->_errno = 0;
return ((size_t) 0);
}
#ifdef DEBUG
fprintf(stderr, "=== (Re-entry) iconv(): ISO 2022-7 --> Big-5 ===\n");
#endif
st->_errno = 0; /* reset internal errno */
errno = 0; /* reset external errno */
/* a state machine for interpreting ISO 2022-7 code */
while (*inbytesleft > 0 && *outbytesleft > 0) {
switch (st->cstate) {
case C0: /* assuming ASCII in the beginning */
if (**inbuf == ESC) {
st->cstate = C1;
} else { /* real ASCII */
**outbuf = **inbuf;
(*outbuf)++;
(*outbytesleft)--;
}
break;
case C1: /* got ESC, expecting $ */
if (**inbuf == '$') {
st->cstate = C2;
} else {
**outbuf = ESC;
(*outbuf)++;
(*outbytesleft)--;
st->cstate = C0;
st->_errno = 0;
continue; /* don't advance inbuf */
}
break;
case C2: /* got $, expecting ) */
if (**inbuf == ')') {
st->cstate = C3;
} else {
if (*outbytesleft < 2) {
st->_errno = errno = E2BIG;
return((size_t)-1);
}
**outbuf = ESC;
*(*outbuf+1) = '$';
(*outbuf) += 2;
(*outbytesleft) -= 2;
st->cstate = C0;
st->_errno = 0;
continue; /* don't advance inbuf */
}
break;
case C3: /* got ) expecting G,H,I,...,V */
st->plane_no = get_plane_no_by_iso(**inbuf);
if (st->plane_no > 0 ) { /* plane #1 - #16 */
st->cstate = C4;
} else {
if (*outbytesleft < 3) {
st->_errno = errno = E2BIG;
return((size_t)-1);
}
**outbuf = ESC;
*(*outbuf+1) = '$';
*(*outbuf+2) = ')';
(*outbuf) += 3;
(*outbytesleft) -= 3;
st->cstate = C0;
st->_errno = 0;
continue; /* don't advance inbuf */
}
break;
case C4: /* SI (Shift In) */
if (**inbuf == ESC) {
st->cstate = C1;
break;
}
if (**inbuf == SO) {
#ifdef DEBUG
fprintf(stderr, "<-------------- SO -------------->\n");
#endif
st->cstate = C5;
} else { /* ASCII */
**outbuf = **inbuf;
(*outbuf)++;
(*outbytesleft)--;
st->cstate = C0;
st->_errno = 0;
}
break;
case C5: /* SO (Shift Out) */
if (**inbuf == SI) {
#ifdef DEBUG
fprintf(stderr, ">-------------- SI --------------<\n");
#endif
st->cstate = C4;
} else { /* 1st Chinese character */
if (st->plane_no == 1) {
st->keepc[0] = (char) (**inbuf | MSB);
st->cstate = C6;
} else { /* 4-bypte code: plane #2 - #16 */
st->keepc[0] = (char) MBYTE;
st->keepc[1] = (char) (PMASK +
st->plane_no);
st->keepc[2] = (char) (**inbuf | MSB);
st->cstate = C7;
}
}
break;
case C6: /* plane #1: 2nd Chinese character */
st->keepc[1] = (char) (**inbuf | MSB);
st->keepc[2] = st->keepc[3] = '\0';
n = iso_to_big5(1, st->keepc, *outbuf, *outbytesleft);
if (n > 0) {
(*outbuf) += n;
(*outbytesleft) -= n;
} else {
st->_errno = errno;
return((size_t)-1);
}
st->cstate = C5;
break;
case C7: /* 4th Chinese character */
st->keepc[3] = (char) (**inbuf | MSB);
n = iso_to_big5(st->plane_no, st->keepc, *outbuf,
*outbytesleft);
if (n > 0) {
(*outbuf) += n;
(*outbytesleft) -= n;
} else {
st->_errno = errno;
return((size_t)-1);
}
st->cstate = C5;
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\tinbuf=%x\n",
st->_errno, st->cstate, **inbuf);
#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 ISO plane char; i.e. 'G' returns 1, 'H' returns 2, etc.
* Returns -1 on error conditions
*/
static int get_plane_no_by_iso(const char inbuf)
{
int ret;
unsigned char uc = (unsigned char) inbuf;
if (uc == '0') /* plane #0 */
return(0);
ret = uc - 'F';
switch (ret) {
case 1: /* 0x8EA1 - G */
case 2: /* 0x8EA2 - H */
case 3: /* 0x8EA3 - I */
case 4: /* 0x8EA4 - J */
case 5: /* 0x8EA5 - K */
case 6: /* 0x8EA6 - L */
case 7: /* 0x8EA7 - M */
case 8: /* 0x8EA8 - N */
case 9: /* 0x8EA9 - O */
case 10: /* 0x8EAA - P */
case 11: /* 0x8EAB - Q */
case 12: /* 0x8EAC - R */
case 13: /* 0x8EAD - S */
case 14: /* 0x8EAE - T */
case 15: /* 0x8EAF - U */
case 16: /* 0x8EB0 - V */
return (ret);
default:
return (-1);
}
}
/*
* ISO 2022-7 code --> Big-5 code
* Return: > 0 - converted with enough space in output buffer
* = 0 - no space in outbuf
*/
static int iso_to_big5(int plane_no, char keepc[], char *buf, size_t buflen)
{
char cns_str[3];
unsigned long cns_val; /* MSB mask off CNS 11643 value */
int unidx; /* binary search index */
unsigned long big5_val, val; /* Big-5 code */
#ifdef DEBUG
fprintf(stderr, "%s %d ", keepc, plane_no);
#endif
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
if (buflen < 2) {
errno = E2BIG;
return(0);
}
switch (plane_no) {
case 1:
unidx = binsearch(cns_val, cns_big5_tab1, MAX_CNS1_NUM);
if (unidx >= 0)
big5_val = cns_big5_tab1[unidx].value;
break;
case 2:
unidx = binsearch(cns_val, cns_big5_tab2, MAX_CNS2_NUM);
if (unidx >= 0)
big5_val = cns_big5_tab2[unidx].value;
break;
default:
unidx = -1; /* no mapping from CNS to Big-5 out of plane 1&2 */
break;
}
#ifdef DEBUG
fprintf(stderr, "unidx = %d, big5code = %x\t", unidx, big5_val);
#endif
if (unidx < 0) { /* no match from CNS to Big-5 */
*buf = *(buf+1) = NON_ID_CHAR;
} else {
val = big5_val & 0xffff;
*buf = (char) ((val & 0xff00) >> 8);
*(buf+1) = (char) (val & 0xff);
}
#ifdef DEBUG
fprintf(stderr, "\t->%x %x<-\n", *buf, *(buf+1));
#endif
return(2);
}
/* binsearch: find x in v[0] <= v[1] <= ... <= v[n-1] */
static int binsearch(unsigned long x, table_t v[], int n)
{
int low, high, mid;
low = 0;
high = n - 1;
while (low <= high) {
mid = (low + high) / 2;
if (x < v[mid].key)
high = mid - 1;
else if (x > v[mid].key)
low = mid + 1;
else /* found match */
return mid;
}
return (-1); /* no match */
}