/* 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