/* gdkanji.c (Kanji code converter)                            */

/*                 written by Masahito Yamaga (ma@yama-ga.com) */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "gd.h"

#include "gdhelpers.h"

#include "gd_errors.h"

#ifdef HAVE_ERRNO_H

#include <errno.h>

#endif

#include <stdarg.h>

#if defined(HAVE_ICONV_H)

#include <iconv.h>

#endif

#ifndef HAVE_ICONV_T_DEF

typedef void *iconv_t;

#endif

#ifndef HAVE_ICONV

#define ICONV_CONST /**/

iconv_t iconv_open (const char *, const char *);

size_t iconv (iconv_t, ICONV_CONST char **, size_t *, char **, size_t *);

int iconv_close (iconv_t);

iconv_t

iconv_open (const char *tocode, const char *fromcode)

{

	(void)tocode;

	(void)fromcode;

	return (iconv_t) (-1);

}

size_t

iconv (iconv_t cd, ICONV_CONST char **inbuf, size_t * inbytesleft,

       char **outbuf, size_t * outbytesleft)

{

	(void)cd;

	(void)inbuf;

	(void)inbytesleft;

	(void)outbuf;

	(void)outbytesleft;

	return 0;

}

int

iconv_close (iconv_t cd)

{

	(void)cd;

	return 0;

}

#endif /* !HAVE_ICONV */

#define LIBNAME "any2eucjp()"

#if defined(__MSC__) || defined(__BORLANDC__) || defined(__TURBOC__) || defined(_Windows) || defined(MSDOS)

#ifndef SJISPRE

#define SJISPRE 1

#endif

#endif

#ifdef TRUE

#undef TRUE

#endif

#ifdef FALSE

#undef FALSE

#endif

#define TRUE  1

#define FALSE 0

#define NEW 1

#define OLD 2

#define ESCI 3

#define NEC 4

#define EUC 5

#define SJIS 6

#define EUCORSJIS 7

#define ASCII 8

#define NEWJISSTR "JIS7"

#define OLDJISSTR "jis"

#define EUCSTR    "eucJP"

#define SJISSTR   "SJIS"

#define ESC 27

#define SS2 142

/* DetectKanjiCode() derived from DetectCodeType() by Ken Lunde. */

static int

DetectKanjiCode (unsigned char *str)

{

	static int whatcode = ASCII;

	int oldcode = ASCII;

	int c, i;

	char *lang = NULL;

	c = '\1';

	i = 0;

	if (whatcode != EUCORSJIS && whatcode != ASCII) {

		oldcode = whatcode;

		whatcode = ASCII;

	}

	while ((whatcode == EUCORSJIS || whatcode == ASCII) && c != '\0') {

		if ((c = str[i++]) != '\0') {

			if (c == ESC) {

				c = str[i++];

				if (c == '$') {

					c = str[i++];

					if (c == 'B')

						whatcode = NEW;

					else if (c == '@')

						whatcode = OLD;

				} else if (c == '(') {

					c = str[i++];

					if (c == 'I')

						whatcode = ESCI;

				} else if (c == 'K')

					whatcode = NEC;

			} else if ((c >= 129 && c <= 141) || (c >= 143 && c <= 159))

				whatcode = SJIS;

			else if (c == SS2) {

				c = str[i++];

				if ((c >= 64 && c <= 126) || (c >= 128 && c <= 160)

				        || (c >= 224 && c <= 252))

					whatcode = SJIS;

				else if (c >= 161 && c <= 223)

					whatcode = EUCORSJIS;

			} else if (c >= 161 && c <= 223) {

				c = str[i++];

				if (c >= 240 && c <= 254)

					whatcode = EUC;

				else if (c >= 161 && c <= 223)

					whatcode = EUCORSJIS;

				else if (c >= 224 && c <= 239) {

					whatcode = EUCORSJIS;

					while (c >= 64 && c != '\0' && whatcode == EUCORSJIS) {

						if (c >= 129) {

							if (c <= 141 || (c >= 143 && c <= 159))

								whatcode = SJIS;

							else if (c >= 253 && c <= 254)

								whatcode = EUC;

						}

						c = str[i++];

					}

				} else if (c <= 159)

					whatcode = SJIS;

			} else if (c >= 240 && c <= 254)

				whatcode = EUC;

			else if (c >= 224 && c <= 239) {

				c = str[i++];

				if ((c >= 64 && c <= 126) || (c >= 128 && c <= 160))

					whatcode = SJIS;

				else if (c >= 253 && c <= 254)

					whatcode = EUC;

				else if (c >= 161 && c <= 252)

					whatcode = EUCORSJIS;

			}

		}

	}

#ifdef DEBUG

	if (whatcode == ASCII)

		gd_error_ex(GD_DEBUG, "Kanji code not included.");

	else if (whatcode == EUCORSJIS)

		gd_error_ex(GD_DEBUG, "Kanji code not detected.");

	else

		gd_error_ex(GD_DEBUG, "Kanji code detected at %d byte.", i);

#endif

	if (whatcode == EUCORSJIS && oldcode != ASCII)

		whatcode = oldcode;

	if (whatcode == EUCORSJIS) {

		if (getenv ("LC_ALL"))

			lang = getenv ("LC_ALL");

		else if (getenv ("LC_CTYPE"))

			lang = getenv ("LC_CTYPE");

		else if (getenv ("LANG"))

			lang = getenv ("LANG");

		if (lang) {

			if (strcmp (lang, "ja_JP.SJIS") == 0 ||

#ifdef hpux

			        strcmp (lang, "japanese") == 0 ||

#endif

			        strcmp (lang, "ja_JP.mscode") == 0 ||

			        strcmp (lang, "ja_JP.PCK") == 0)

				whatcode = SJIS;

			else if (strncmp (lang, "ja", 2) == 0)

#ifdef SJISPRE

				whatcode = SJIS;

#else

				whatcode = EUC;

#endif

		}

	}

	if (whatcode == EUCORSJIS)

#ifdef SJISPRE

		whatcode = SJIS;

#else

		whatcode = EUC;

#endif

	return whatcode;

}

/* SJIStoJIS() is sjis2jis() by Ken Lunde. */

static void

SJIStoJIS (int *p1, int *p2)

{

	register unsigned char c1 = *p1;

	register unsigned char c2 = *p2;

	register int adjust = c2 < 159;

	register int rowOffset = c1 < 160 ? 112 : 176;

	register int cellOffset = adjust ? (31 + (c2 > 127)) : 126;

	*p1 = ((c1 - rowOffset) << 1) - adjust;

	*p2 -= cellOffset;

}

/* han2zen() was derived from han2zen() written by Ken Lunde. */

#define IS_DAKU(c) ((c >= 182 && c <= 196) || (c >= 202 && c <= 206) || (c == 179))

#define IS_HANDAKU(c) (c >= 202 && c <= 206)

static void

han2zen (int *p1, int *p2)

{

	int c = *p1;

	int daku = FALSE;

	int handaku = FALSE;

	int mtable[][2] = {

		{129, 66},

		{129, 117},

		{129, 118},

		{129, 65},

		{129, 69},

		{131, 146},

		{131, 64},

		{131, 66},

		{131, 68},

		{131, 70},

		{131, 72},

		{131, 131},

		{131, 133},

		{131, 135},

		{131, 98},

		{129, 91},

		{131, 65},

		{131, 67},

		{131, 69},

		{131, 71},

		{131, 73},

		{131, 74},

		{131, 76},

		{131, 78},

		{131, 80},

		{131, 82},

		{131, 84},

		{131, 86},

		{131, 88},

		{131, 90},

		{131, 92},

		{131, 94},

		{131, 96},

		{131, 99},

		{131, 101},

		{131, 103},

		{131, 105},

		{131, 106},

		{131, 107},

		{131, 108},

		{131, 109},

		{131, 110},

		{131, 113},

		{131, 116},

		{131, 119},

		{131, 122},

		{131, 125},

		{131, 126},

		{131, 128},

		{131, 129},

		{131, 130},

		{131, 132},

		{131, 134},

		{131, 136},

		{131, 137},

		{131, 138},

		{131, 139},

		{131, 140},

		{131, 141},

		{131, 143},

		{131, 147},

		{129, 74},

		{129, 75}

	};

	if (*p2 == 222 && IS_DAKU (*p1))

		daku = TRUE;		/* Daku-ten */

	else if (*p2 == 223 && IS_HANDAKU (*p1))

		handaku = TRUE;		/* Han-daku-ten */

	*p1 = mtable[c - 161][0];

	*p2 = mtable[c - 161][1];

	if (daku) {

		if ((*p2 >= 74 && *p2 <= 103) || (*p2 >= 110 && *p2 <= 122))

			(*p2)++;

		else if (*p2 == 131 || *p2 == 69)

			*p2 = 148;

	} else if (handaku && *p2 >= 110 && *p2 <= 122)

		(*p2) += 2;

}

/* Recast strcpy to handle unsigned chars used below. */

#define ustrcpy(A,B) (strcpy((char*)(A),(const char*)(B)))

#define ustrncpy(A,B, maxsize) (strncpy((char*)(A),(const char*)(B), maxsize))

static void

do_convert (unsigned char **to_p, unsigned char **from_p, const char *code)

{

	unsigned char *to = *to_p;

	unsigned char *from = *from_p;

#ifdef HAVE_ICONV

	iconv_t cd;

	size_t from_len, to_len;

	if ((cd = iconv_open (EUCSTR, code)) == (iconv_t) - 1) {

		gd_error ("iconv_open() error");

#ifdef HAVE_ERRNO_H

		if (errno == EINVAL)

			gd_error ("invalid code specification: \"%s\" or \"%s\"", EUCSTR, code);

#endif

		ustrcpy (to, from);

		return;

	}

	from_len = strlen ((const char *)from) + 1;

	to_len = BUFSIZ;

	if ((int) (iconv (cd, (char **)from_p, &from_len, (char **)to_p, &to_len))

	        == -1) {

#ifdef HAVE_ERRNO_H

		if (errno == EINVAL)

			gd_error ("invalid end of input string");

		else if (errno == EILSEQ)

			gd_error ("invalid code in input string");

		else if (errno == E2BIG)

			gd_error ("output buffer overflow at do_convert()");

		else

#endif

			gd_error ("something happen");

		ustrcpy (to, from);

		return;

	}

	if (iconv_close (cd) != 0) {

		gd_error ("iconv_close() error");

	}

#else

	int p1, p2, i, j;

	int jisx0208 = FALSE;

	int hankaku = FALSE;

	j = 0;

	if (strcmp (code, NEWJISSTR) == 0 || strcmp (code, OLDJISSTR) == 0) {

		for (i = 0; from[i] != '\0' && j < BUFSIZ; i++) {

			if (from[i] == ESC) {

				i++;

				if (from[i] == '$') {

					jisx0208 = TRUE;

					hankaku = FALSE;

					i++;

				} else if (from[i] == '(') {

					jisx0208 = FALSE;

					i++;

					if (from[i] == 'I')	/* Hankaku Kana */

						hankaku = TRUE;

					else

						hankaku = FALSE;

				}

			} else {

				if (jisx0208)

					to[j++] = from[i] + 128;

				else if (hankaku) {

					to[j++] = SS2;

					to[j++] = from[i] + 128;

				} else

					to[j++] = from[i];

			}

		}

	} else if (strcmp (code, SJISSTR) == 0) {

		for (i = 0; from[i] != '\0' && j < BUFSIZ; i++) {

			p1 = from[i];

			if (p1 < 127)

				to[j++] = p1;

			else if ((p1 >= 161) && (p1 <= 223)) {

				/* Hankaku Kana */

				to[j++] = SS2;

				to[j++] = p1;

			} else {

				p2 = from[++i];

				SJIStoJIS (&p1, &p2;;

				to[j++] = p1 + 128;

				to[j++] = p2 + 128;

			}

		}

	} else {

		gd_error ("invalid code specification: \"%s\"", code);

		return;

	}

	if (j >= BUFSIZ) {

		gd_error ("output buffer overflow at do_convert()");

		ustrcpy (to, from);

	} else

		to[j] = '\0';

#endif /* HAVE_ICONV */

}

static int

do_check_and_conv (unsigned char *to, unsigned char *from)

{

	static unsigned char tmp[BUFSIZ];

	unsigned char *tmp_p = &tmp[0];

	int p1, p2, i, j;

	int kanji = TRUE;

	int copy_string = FALSE;

	switch (DetectKanjiCode (from)) {

	case NEW:

		gd_error_ex(GD_DEBUG, "Kanji code is New JIS.");

		do_convert (&tmp_p, &from, NEWJISSTR);

		break;

	case OLD:

		gd_error_ex(GD_DEBUG, "Kanji code is Old JIS.");

		do_convert (&tmp_p, &from, OLDJISSTR);

		break;

	case ESCI:

		gd_error_ex(GD_DEBUG, "This string includes Hankaku-Kana (jisx0201) escape sequence [ESC] + ( + I.");

		do_convert (&tmp_p, &from, NEWJISSTR);

		break;

	case NEC:

		gd_error_ex(GD_DEBUG, "Kanji code is NEC Kanji.");

		gd_error("cannot convert NEC Kanji.");

		copy_string = TRUE;

		kanji = FALSE;

		break;

	case EUC:

		gd_error_ex(GD_DEBUG, "Kanji code is EUC.");

		copy_string = TRUE;

		break;

	case SJIS:

		gd_error_ex(GD_DEBUG, "Kanji code is SJIS.");

		do_convert (&tmp_p, &from, SJISSTR);

		break;

	case EUCORSJIS:

		gd_error_ex(GD_DEBUG, "Kanji code is EUC or SJIS.");

		copy_string = TRUE;

		kanji = FALSE;

		break;

	case ASCII:

		gd_error_ex(GD_DEBUG, "This is ASCII string.");

		copy_string = TRUE;

		kanji = FALSE;

		break;

	default:

		gd_error_ex(GD_DEBUG, "This string includes unknown code.");

		copy_string = TRUE;

		kanji = FALSE;

		break;

	}

	if (copy_string) {

		ustrncpy (tmp, from, BUFSIZ);

		tmp[BUFSIZ-1] = '\0';

	}

	/* Hankaku Kana ---> Zenkaku Kana */

	if (kanji) {

		j = 0;

		for (i = 0; tmp[i] != '\0' && j < BUFSIZ; i++) {

			if (tmp[i] == SS2) {

				p1 = tmp[++i];

				if (tmp[i + 1] == SS2) {

					p2 = tmp[i + 2];

					if (p2 == 222 || p2 == 223)

						i += 2;

					else

						p2 = 0;

				} else

					p2 = 0;

				han2zen (&p1, &p2;;

				SJIStoJIS (&p1, &p2;;

				to[j++] = p1 + 128;

				to[j++] = p2 + 128;

			} else

				to[j++] = tmp[i];

		}

		if (j >= BUFSIZ) {

			gd_error("output buffer overflow at Hankaku --> Zenkaku");

			ustrcpy (to, tmp);

		} else

			to[j] = '\0';

	} else

		ustrcpy (to, tmp);

	return kanji;

}

int

any2eucjp (unsigned char *dest, unsigned char *src, unsigned int dest_max)

{

	static unsigned char tmp_dest[BUFSIZ];

	int ret;

	if (strlen ((const char *) src) >= BUFSIZ) {

		gd_error("input string too large");

		return -1;

	}

	if (dest_max > BUFSIZ) {

		gd_error

		("invalid maximum size of destination\nit should be less than %d.",

		 BUFSIZ);

		return -1;

	}

	ret = do_check_and_conv (tmp_dest, src);

	if (strlen ((const char *) tmp_dest) >= dest_max) {

		gd_error("output buffer overflow");

		ustrcpy (dest, src);

		return -1;

	}

	ustrcpy (dest, tmp_dest);

	return ret;

}

#if 0

unsigned int

strwidth (unsigned char *s)

{

	unsigned char *t;

	unsigned int i;

	t = (unsigned char *) gdMalloc (BUFSIZ);

	any2eucjp (t, s, BUFSIZ);

	i = strlen (t);

	gdFree (t);

	return i;

}

#ifdef DEBUG

int

main ()

{

	unsigned char input[BUFSIZ];

	unsigned char *output;

	unsigned char *str;

	int c, i = 0;

	while ((c = fgetc (stdin)) != '\n' && i < BUFSIZ)

		input[i++] = c;

	input[i] = '\0';

	printf ("input : %d bytes\n", strlen ((const char *) input));

	printf ("output: %d bytes\n", strwidth (input));

	output = (unsigned char *) gdMalloc (BUFSIZ);

	any2eucjp (output, input, BUFSIZ);

	str = output;

	while (*str != '\0')

		putchar (*(str++));

	putchar ('\n');

	gdFree (output);

	return 0;

}

#endif

#endif