path: root/usr/src/lib/iconv_modules/zh/common/zh_CN.iso2022-7%UTF-8.c

/*
 * 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 Sun Microsystems, Inc.
 * All rights reserved.
 */

#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <errno.h>
#ifdef DEBUG
#include <sys/fcntl.h>
#include <sys/stat.h>
#endif
#include <public_struc.h>
#include <gb2312_unicode.h>
#include <cns11643_unicode_CN.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 MBS */

#define SI	0x0f		/* shift in */
#define SO	0x0e		/* shift out */
#define ESC 0x1b		/* escape */
#define SS2	0x4e		/* SS2 shift out */
#define SS3 0x4f		/* SS3 shift out */
#define UTF8_NON_ID_CHAR1	0xEF	/* non-identified character */
#define UTF8_NON_ID_CHAR2	0xBF	/* non-identified character */
#define UTF8_NON_ID_CHAR3	0xBD	/* non-identified character */

typedef struct _icv_state {
	char	_buf[10];
	size_t	_bufcont;
	char	_keepc[4];	/* maximum # byte of CNS11643 code */
	short	_gstate;		/* state machine id */
	short	_istate;		/* state for shift in/out */
	int		_plane;		/* plane number for Chinese character */
	int		_last_plane;	/* last charactor's plane # */
	int 	_errno;		/* internal errno */
} _iconv_st;

enum _GSTATE    { G0, G1, G2, G3, G4, G5, G6, G7, G8, G9, \
				  G10,G11,G12,G13,G14,G15,G16,G17,G18,G19, \
				  G20,G21,G22,G23,G24,G25,G26,G27,G28,G29 };

enum _ISTATE	{ IN, OUT };


int iso_to_utf8(_iconv_st * st, char* buf, size_t buflen);
int binsearch(unsigned long x, table_t v[], int n);
int flush_buf(_iconv_st * st, char ** outbuf, size_t * outbytesleft);

int flush_buf(_iconv_st * st, char ** outbuf, size_t * outbytesleft) {

	if (!st->_bufcont)
		return 0;
	if (st->_bufcont > *outbytesleft) {
		st->_errno = E2BIG;
		return -1;
	}
	strncpy(st->_buf, *outbuf, st->_bufcont);
	(*outbuf)+=(st->_bufcont);
	(*outbytesleft)-=(st->_bufcont);
	st->_bufcont = 0;
	return st->_bufcont;
}

/*
 * 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->_gstate = G0;
	st->_istate = IN;
	st->_last_plane = st->_plane = -1;
	st->_errno = 0;
	st->_bufcont = 0;

	return ((void *) st);
}

/*
 * Close; called from iconv_close()
 */
void
_icv_close(_iconv_st *st)
{
	if (st == NULL)
		errno = EBADF;
	else
		free(st);
}

/*
 * Actual conversion; called from iconv()
 */
size_t _icv_iconv(_iconv_st *st, \
					char **inbuf, size_t *inbytesleft, \
					char **outbuf, size_t *outbytesleft) {
	int		n;
	char	c;

	if (st == NULL) {
		errno = EBADF;
		return ((size_t) -1);
	}

	if (inbuf == NULL || *inbuf == NULL) { /* Reset request. */
		st->_errno = 0;
		return ((size_t) 0);
	}

	errno = st->_errno = 0;	/* reset internal and external errno */

	/* a state machine for interpreting ISO 2022-7 code */
	while (*inbytesleft > 0 && *outbytesleft > 0) {
		switch (st->_gstate) {
			case G0:		/* assuming ASCII in the beginning */
				if (**inbuf == ESC) {
					st->_gstate = G1;
					st->_buf[st->_bufcont++] = ESC;
				} else {	/* real ASCII */
					**outbuf = **inbuf;
					(*outbuf)++;
					(*outbytesleft)--;
				}
				break;
			case G1:		/* got ESC, expecting $ */
				if (**inbuf == '$') {
					st->_gstate = G2;
					st->_buf[st->_bufcont++] = '$';
				} else if (flush_buf(st, outbuf, outbytesleft) == -1) {
					errno = st->_errno;
					return (size_t)-1;
				} else {
					st->_gstate = G0;
					st->_errno = 0;
					st->_istate = IN;
					continue;	/* don't advance inbuf */
				}
				break;
			case G2:		/* got $, expecting ) * or + */
				if (**inbuf == ')') {
					st->_gstate = G3;
				} else if (**inbuf == '*') {
					st->_gstate = G12;
					st->_plane = 2;
				} else if (**inbuf == '+') {
					st->_gstate = G19;
				} else if (flush_buf(st, outbuf, outbytesleft) == -1) {
					errno = st->_errno;
					return (size_t)-1;
				} else {
					st->_gstate = G0;
					st->_errno = 0;
					st->_istate = IN;
					continue;	/* don't advance inbuf */
				}
				st->_buf[st->_bufcont++] = **inbuf;
				break;
			case G3:	/* got ) expecting A,G,H */
						/* H is for the bug of and zh_TW.BIG5 */
				if (**inbuf == 'A') {
					st->_plane = 0;
					st->_gstate = G4;
				} else if (**inbuf == 'G') {
					st->_plane = 1;
					st->_gstate = G8;
				} else if (**inbuf == 'H') {
					st->_plane = 2;
					st->_gstate = G8;
				} else if (flush_buf(st, outbuf, outbytesleft) == -1) {
					errno = st->_errno;
					return (size_t)-1;
				} else {
					st->_gstate = G0;
					st->_errno = 0;
					st->_istate = IN;
					continue;
				}
				st->_buf[st->_bufcont++] = **inbuf;
				break;
		case G4:	/* ESC $ ) A got, and SO is expected */
				if (**inbuf == SO) {
					st->_gstate = G5;
					st->_istate = OUT;
					st->_bufcont = 0;
					st->_last_plane = st->_plane;
				} else if (flush_buf(st, outbuf, outbytesleft) == -1) {
					errno = st->_errno;
					return (size_t)-1;
				} else {
					st->_gstate = G0;
					st->_errno = 0;
					st->_istate = IN;
					st->_plane = st->_last_plane;
					continue;
				}
				break;
		case G5:	/* SO (Shift Out) */
				if (**inbuf == SI) {
					st->_istate = IN;
				st->_gstate = G7;
					st->_last_plane = st->_plane;
				} else if (**inbuf == ESC) {
					st->_bufcont = 0;
					st->_gstate = G0;
					continue;
				} else {	/* Chinese Charactors */
					st->_keepc[0] = **inbuf;
					st->_gstate = G6;
				}
				break;
		case G6:	/* GB2312: 2nd Chinese character */
				st->_keepc[1] = **inbuf;
				n = iso_to_utf8(st, *outbuf, *outbytesleft);
				if (n > 0) {
					(*outbuf) += n;
					(*outbytesleft) -= n;
				} else {
					errno = st->_errno;
					return (size_t)-1;
				}
				st->_gstate = G5;
				break;
			case G7:	/* Shift in */
				if (**inbuf == SO) {
					st->_gstate = G5;
					st->_istate = OUT;
					st->_last_plane = st->_plane;
					st->_bufcont = 0;
				} else if (**inbuf == ESC) {
					st->_gstate = G0;
					continue;
				} else {
					**outbuf = **inbuf;
					(*outbuf)++;
					(*outbytesleft) --;
				}
				break;
		case G8:	/* BIG5: Chinese character */
				if (**inbuf == SO) {
					st->_istate = OUT;
					st->_gstate = G9;
					st->_bufcont = 0;
					st->_last_plane = st->_plane;
				} else if (flush_buf(st, outbuf, outbytesleft) == -1) {
					errno = st->_errno;
					return (size_t)-1;
				} else {
					st->_gstate = G0;
					st->_errno = 0;
					st->_plane = st->_last_plane;
					st->_istate = IN;
					continue;
				}
				break;
		case G9:
				if (**inbuf == SI) {
					st->_istate = IN;
					st->_gstate = G11;
					st->_last_plane = st->_plane;
				} else if (**inbuf == ESC) {
					if (flush_buf(st, outbuf, outbytesleft) == -1) {
						errno = st->_errno;
						return (size_t)-1;
					}
					st->_gstate = G0;
					continue;
				} else {	/* Chinese Charactor */
					st->_keepc[0] = **inbuf;
					st->_gstate = G10;
				}
				break;
			case G10:
				st->_keepc[1] = **inbuf;
				n = iso_to_utf8(st, *outbuf, *outbytesleft);
				if (n > 0) {
					(*outbuf) += n;
					(*outbytesleft) -= n;
				} else {
					errno = st->_errno;
					return (size_t)-1;
				}
				st->_gstate = G9;
				break;
			case G11:
				st->_bufcont = 0;
				if (**inbuf == SO) {
					st->_istate = OUT;
					st->_gstate = G9;
				} else if (**inbuf == ESC) {
					st->_gstate = G0;
					continue;
				} else {
					**outbuf = **inbuf;
					(*outbuf)++;
					(*outbytesleft)--;
				}
				break;
			case G12:
				if (**inbuf == 'H') {
					st->_buf[st->_bufcont++] = 'H';
					st->_gstate = G13;
				} else if (flush_buf(st, outbuf, outbytesleft) == -1) {
					errno = st->_errno;
					return (size_t)-1;
				} else {
					st->_istate = IN;
					st->_plane = st->_last_plane;
					st->_gstate = G0;
					continue;
				}
				break;
			case G13:
				if (**inbuf == ESC) {
					st->_buf[st->_bufcont++] = **inbuf;
					st->_gstate = G14;
				} else if (flush_buf(st, outbuf, outbytesleft) == -1) {
					errno = st->_errno;
					return (size_t)-1;
				} else {
					st->_gstate = G0;
					st->_istate = IN;
					st->_plane = st->_last_plane;
					continue;
				}
				break;
			case G14:
				if (**inbuf == SS2) {
					st->_istate = OUT;
					st->_gstate = G15;
					st->_bufcont = 0;
					st->_last_plane = st->_plane = 2;
				} else if (**inbuf == '$') {
					st->_bufcont --;
					if (flush_buf(st, outbuf, outbytesleft) == -1) {
						errno = st->_errno;
						return (size_t)-1;
					} else {
						st->_gstate = G1;
						st->_plane = st->_last_plane;
						st->_istate = IN;
						continue;
					}
				} else if (flush_buf(st, outbuf, outbytesleft) == -1) {
					errno = st->_errno;
					return (size_t)-1;
				} else {
					st->_gstate = G0;
					st->_istate = IN;
					st->_plane = st->_last_plane;
					continue;
				}
				break;
			case G15:
				if (**inbuf == SI) {
					st->_gstate = G16;
					st->_istate = IN;
					st->_last_plane = st->_plane;
				} else if (**inbuf == ESC) {
					st->_bufcont = 0;
					st->_gstate = G0;
					continue;
				} else {
					st->_keepc[0] = **inbuf;
					st->_gstate = G18;
				}
				break;
			case G16:
				if (**inbuf == ESC) {
					st->_gstate = G17;
					st->_buf[st->_bufcont++] = ESC;
				} else {
					**outbuf = **inbuf;
					(*outbuf) ++;
					(*outbytesleft) --;
					st->_bufcont = 0;
				}
				break;
			case G17:
				if (**inbuf == '$') {
					st->_gstate = G1;
					st->_buf[st->_bufcont++] = '$';
					continue;
				} else if (**inbuf == SS2) {
					st->_bufcont = 0;
					st->_gstate = G15;
					st->_istate = OUT;
				} else if (flush_buf(st, outbuf, outbytesleft) == -1) {
					errno = st->_errno;
					return (size_t)-1;
				} else {
					st->_gstate = G16;
					st->_istate = IN;
				}
				break;
			case G18:
				st->_keepc[1] = **inbuf;
				st->_gstate = G15;
				if ((n = iso_to_utf8(st, \
									*outbuf, \
									*outbytesleft)) > 0) {
					(*outbuf)+=n;
					(*outbytesleft)-=n;
				} else {
					errno = st->_errno;
					return (size_t)-1;
				}
				break;
			case G19:	/* Plane #: 3 - 16 */
				c = **inbuf;
				if				(c == 'I' || \
								c == 'J' || \
								c == 'K' || \
								c == 'L' || \
								c == 'M' || \
								c == 'N' || \
								c == 'O' || \
								c == 'P' || \
								c == 'Q' || \
								c == 'R' || \
								c == 'S' || \
								c == 'T' || \
								c == 'U' || \
								c == 'V') {
					st->_plane = c - 'I' + 3;
					st->_gstate = G20;
				} else if (flush_buf(st, outbuf, outbytesleft) == -1) {
					errno = st->_errno;
					return (size_t)-1;
				} else {
					st->_gstate = G0;
					st->_errno = 0;
					st->_istate = IN;
					st->_plane = st->_last_plane;
					continue;
				}
				st->_buf[st->_bufcont++] = c;
				break;
			case G20:
				if (**inbuf == ESC) {
					st->_buf[st->_bufcont++] = **inbuf;
					st->_gstate = G21;
				} else if (flush_buf(st, outbuf, outbytesleft) == -1) {
					errno = st->_errno;
					return (size_t)-1;
				} else {
					st->_gstate = G0;
					st->_istate = IN;
					st->_last_plane = st->_plane;
					continue;
				}
				break;
			case G21:
				if (**inbuf == SS3) {
					st->_istate = OUT;
					st->_gstate = G22;
					st->_bufcont = 0;
				} else if (**inbuf == '$') {
					st->_bufcont --;
					if (flush_buf(st, outbuf, outbytesleft) == -1) {
						errno = st->_errno;
						return (size_t)-1;
					} else {
						st->_istate = IN;
						st->_last_plane = st->_plane;
						st->_gstate = G1;
						continue;
					}
				} else if (flush_buf(st, outbuf, outbytesleft) == -1) {
					errno = st->_errno;
					return (size_t)-1;
				} else {
					st->_gstate = G0;
					st->_istate = IN;
					st->_last_plane = st->_plane;
					continue;
				}
				break;
			case G22:
				if (**inbuf == SI) {
					st->_istate = IN;
					st->_gstate = G24;
					st->_last_plane = st->_plane;
				} else {
					st->_keepc[0] = (char)MBYTE;
					st->_keepc[1] = (char)(PMASK + st->_plane);
					st->_keepc[2] = **inbuf;
					st->_gstate = G23;
				}
				break;
			case G23:
				st->_keepc[3] = **inbuf;
				if ((n = iso_to_utf8(st, \
									*outbuf, \
									*outbytesleft)) > 0) {
					(*outbuf)+=n;
					(*outbytesleft-=n);
				} else {
					errno = st->_errno;
					return (size_t)-1;
				}
				st->_gstate = G22;
				break;
			case G24:
				if (**inbuf == ESC) {
					st->_gstate = G25;
					st->_buf[st->_bufcont++] = ESC;
				} else {
					**outbuf = **inbuf;
					(*outbuf)++;
					(*outbytesleft)--;
					st->_bufcont = 0;
				}
				break;
			case G25:
				if (**inbuf == '$') {
					st->_gstate = G1;
					continue;
				} else if (**inbuf == SS3) {
					st->_gstate = G22;
					st->_bufcont = 0;
					st->_istate = OUT;
				} else if (flush_buf(st, outbuf, outbytesleft) == -1) {
					errno = st->_errno;
					return (size_t)-1;
				} else {
					st->_gstate = G24;
					st->_istate = IN;
				}
				break;
			default:			/* should never come here */
				st->_errno = errno = EILSEQ;
				st->_gstate = G0;	/* reset state */
				break;
		}	/* end of switch */

		(*inbuf)++;
		(*inbytesleft)--;

		if (st->_errno) {
			break;
		}
		if (errno)
			return((size_t)(-1));
	}

	if (*inbytesleft > 0 && *outbytesleft == 0) {
		errno = E2BIG;
		return((size_t)(-1));
	}
	return (size_t)((*inbytesleft));
}

/*
 * ISO 2022-7 code --> UTF-8 code
 * Return: > 0 - converted with enough space in output buffer
 *         = 0 - no space in outbuf
 */
int iso_to_utf8(_iconv_st * st, char* buf, size_t buflen) {
	unsigned long iso_val;
	int unidx;
	unsigned long unicode;
	switch (st->_plane) {
		case 0:
			unidx = (((st->_keepc[0] & 0xff) - 0x21) * 94) + \
					(st->_keepc[1] & 0xff) - 0x21;
			if (unidx < 0 || unidx >= GBMAX) {
				st->_errno = EILSEQ;
				return (0);
			}
			unicode = Unicode[unidx];
			break;

		case 1:
			iso_val = ((st->_keepc[0] & MSB_OFF) << 8) + \
					(st->_keepc[1] & MSB_OFF);
			unidx = binsearch(iso_val, cns1_utf_tab, MAX_CNS1_NUM);
			if (unidx >= 0) {
				unicode = cns1_utf_tab[unidx].value;
				break;
			}
			st->_errno = EILSEQ;
			return (0);
		case 2:
			iso_val = ((st->_keepc[0] & MSB_OFF) << 8) + \
					(st->_keepc[1] & MSB_OFF);
			unidx = binsearch(iso_val, cns2_utf_tab, MAX_CNS2_NUM);
			if (unidx >= 0) {
				unicode = cns2_utf_tab[unidx].value;
				break;
			}
			st->_errno = EILSEQ;
			return (0);
		default:
			st->_errno = EILSEQ;
			return (0);
	}
	if (unidx >=0) {
		if (unicode > 0x0080 && unicode <= 0x07ff) {
			if (buflen < 2) {
				st->_errno = E2BIG;
				return (0);
			}
			*buf = (char)((unicode >> 6) & 0x1f) | 0xc0;
			*(buf+1) = (char)(unicode & 0x3f) | 0x80;
			return 2;
		}
		if (unicode > 0x0800 && unicode <= 0xffff) {
			if (buflen < 3) {
				st->_errno = E2BIG;
				return (0);
			}
			*buf = (char)((unicode >> 12) & 0xf) | 0xe0;
			*(buf+1) = (char)((unicode >>6) & 0x3f) | 0x80;
			*(buf+2) = (char)(unicode & 0x3f) | 0x80;
			return 3;
		}
	}
	if (buflen < 3) {
		st->_errno = E2BIG;
		return (0);
	}

	*buf = (char)UTF8_NON_ID_CHAR1;
	*(buf + 2) = (char)UTF8_NON_ID_CHAR2;
	*(buf + 2) = (char)UTF8_NON_ID_CHAR3;
	return (3);
}

/* binsearch: find x in v[0] <= v[1] <= ... <= v[n-1] */
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 */
}

#ifdef DEBUG
main(int argc, char ** argv) {
	char *inbuf, *outbuf, *in_tmp, *out_tmp;
	size_t inbytesleft, outbytesleft;
	int fd;
	int i;
	struct stat s;
	_iconv_st * st;
	if (argc < 2) {
		fprintf(stderr, "Usage: %s input\n", argv[0]);
		exit(-1);
	}
	if ((fd = open(argv[1], O_RDONLY)) == -1) {
		perror("open");
		exit(-2);
	}
	if (fstat(fd, &s) == -1) {
		perror("stat");
		exit(-3);
	}
	inbytesleft = outbytesleft = s.st_size;
	in_tmp = inbuf = (char *)malloc(inbytesleft);
	out_tmp = outbuf = (char *)malloc(outbytesleft);
	if (!inbuf || !outbuf) {
		perror("malloc");
		exit(-1);
	}
	if (read(fd, inbuf, inbytesleft) != inbytesleft) {
		perror("read");
		exit(-4);
	}
	for (i = 0; i < inbytesleft; i++)
		fprintf(stderr, "%x\t", *(inbuf+i));
	fprintf(stderr, "\n");
	st = (_iconv_st *)_icv_open();
	if (st == (_iconv_st *) -1) {
		perror("_icv_open");
		exit(-1);
	}
	if (_icv_iconv(st, \
			&inbuf, &inbytesleft, \
			&outbuf, &outbytesleft) == -1) {
		perror("icv_iconv");
		fprintf(stderr, "\ninbytesleft = %d\n", inbytesleft);
		exit(-2);
	}
	if (write(1, out_tmp, s.st_size - outbytesleft) == -1) {
		perror("write");
		exit(-1);
	}
	free(in_tmp);
	free(out_tmp);
	close(fd);
	_icv_close(st);
}
#endif