1
2 /* gdkanji.c (Kanji code converter) */
3 /* written by Masahito Yamaga (ma@yama-ga.com) */
4
5 #include <stdio.h>
6 #include <stdlib.h>
7 #include <string.h>
8 #include "gd.h"
9 #include "gdhelpers.h"
10
11 #include <stdarg.h>
12 #if defined(HAVE_ICONV_H) || defined(HAVE_ICONV)
13 #include <iconv.h>
14 #ifdef HAVE_ERRNO_H
15 #include <errno.h>
16 #endif
17 #endif
18
19 #if defined(HAVE_ICONV_H) && !defined(HAVE_ICONV)
20 #define HAVE_ICONV 1
21 #endif
22
23 #define LIBNAME "any2eucjp()"
24
25 #if defined(__MSC__) || defined(__BORLANDC__) || defined(__TURBOC__) || defined(_Windows) || defined(MSDOS)
26 #ifndef SJISPRE
27 #define SJISPRE 1
28 #endif
29 #endif
30
31 #ifdef TRUE
32 #undef TRUE
33 #endif
34 #ifdef FALSE
35 #undef FALSE
36 #endif
37
38 #define TRUE 1
39 #define FALSE 0
40
41 #define NEW 1
42 #define OLD 2
43 #define ESCI 3
44 #define NEC 4
45 #define EUC 5
46 #define SJIS 6
47 #define EUCORSJIS 7
48 #define ASCII 8
49
50 #define NEWJISSTR "JIS7"
51 #define OLDJISSTR "jis"
52 #define EUCSTR "eucJP"
53 #define SJISSTR "SJIS"
54
55 #define ESC 27
56 #define SS2 142
57
58 static void
debug(const char * format,...)59 debug (const char *format,...)
60 {
61 #ifdef DEBUG
62 va_list args;
63
64 va_start (args, format);
65 fprintf (stdout, "%s: ", LIBNAME);
66 vfprintf (stdout, format, args);
67 fprintf (stdout, "\n");
68 va_end (args);
69 #endif
70 }
71
72 static void
error(const char * format,...)73 error (const char *format,...)
74 {
75 va_list args;
76 char *tmp;
77
78 va_start(args, format);
79 vspprintf(&tmp, 0, format, args);
80 va_end(args);
81 php_error_docref(NULL, E_WARNING, "%s: %s", LIBNAME, tmp);
82 efree(tmp);
83 }
84
85 /* DetectKanjiCode() derived from DetectCodeType() by Ken Lunde. */
86
87 static int
DetectKanjiCode(unsigned char * str)88 DetectKanjiCode (unsigned char *str)
89 {
90 static int whatcode = ASCII;
91 int oldcode = ASCII;
92 int c, i;
93 char *lang = NULL;
94
95 c = '\1';
96 i = 0;
97
98 if (whatcode != EUCORSJIS && whatcode != ASCII)
99 {
100 oldcode = whatcode;
101 whatcode = ASCII;
102 }
103
104 while ((whatcode == EUCORSJIS || whatcode == ASCII) && c != '\0')
105 {
106 if ((c = str[i++]) != '\0')
107 {
108 if (c == ESC)
109 {
110 c = str[i++];
111 if (c == '$')
112 {
113 c = str[i++];
114 if (c == 'B')
115 whatcode = NEW;
116 else if (c == '@')
117 whatcode = OLD;
118 }
119 else if (c == '(')
120 {
121 c = str[i++];
122 if (c == 'I')
123 whatcode = ESCI;
124 }
125 else if (c == 'K')
126 whatcode = NEC;
127 }
128 else if ((c >= 129 && c <= 141) || (c >= 143 && c <= 159))
129 whatcode = SJIS;
130 else if (c == SS2)
131 {
132 c = str[i++];
133 if ((c >= 64 && c <= 126) || (c >= 128 && c <= 160) || (c >= 224 && c <= 252))
134 whatcode = SJIS;
135 else if (c >= 161 && c <= 223)
136 whatcode = EUCORSJIS;
137 }
138 else if (c >= 161 && c <= 223)
139 {
140 c = str[i++];
141 if (c >= 240 && c <= 254)
142 whatcode = EUC;
143 else if (c >= 161 && c <= 223)
144 whatcode = EUCORSJIS;
145 else if (c >= 224 && c <= 239)
146 {
147 whatcode = EUCORSJIS;
148 while (c >= 64 && c != '\0' && whatcode == EUCORSJIS)
149 {
150 if (c >= 129)
151 {
152 if (c <= 141 || (c >= 143 && c <= 159))
153 whatcode = SJIS;
154 else if (c >= 253 && c <= 254)
155 whatcode = EUC;
156 }
157 c = str[i++];
158 }
159 }
160 else if (c <= 159)
161 whatcode = SJIS;
162 }
163 else if (c >= 240 && c <= 254)
164 whatcode = EUC;
165 else if (c >= 224 && c <= 239)
166 {
167 c = str[i++];
168 if ((c >= 64 && c <= 126) || (c >= 128 && c <= 160))
169 whatcode = SJIS;
170 else if (c >= 253 && c <= 254)
171 whatcode = EUC;
172 else if (c >= 161 && c <= 252)
173 whatcode = EUCORSJIS;
174 }
175 }
176 }
177
178 #ifdef DEBUG
179 if (whatcode == ASCII)
180 debug ("Kanji code not included.");
181 else if (whatcode == EUCORSJIS)
182 debug ("Kanji code not detected.");
183 else
184 debug ("Kanji code detected at %d byte.", i);
185 #endif
186
187 if (whatcode == EUCORSJIS && oldcode != ASCII)
188 whatcode = oldcode;
189
190 if (whatcode == EUCORSJIS)
191 {
192 if (getenv ("LC_ALL"))
193 lang = getenv ("LC_ALL");
194 else if (getenv ("LC_CTYPE"))
195 lang = getenv ("LC_CTYPE");
196 else if (getenv ("LANG"))
197 lang = getenv ("LANG");
198
199 if (lang)
200 {
201 if (strcmp (lang, "ja_JP.SJIS") == 0 ||
202 #ifdef hpux
203 strcmp (lang, "japanese") == 0 ||
204 #endif
205 strcmp (lang, "ja_JP.mscode") == 0 ||
206 strcmp (lang, "ja_JP.PCK") == 0)
207 whatcode = SJIS;
208 else if (strncmp (lang, "ja", 2) == 0)
209 #ifdef SJISPRE
210 whatcode = SJIS;
211 #else
212 whatcode = EUC;
213 #endif
214 }
215 }
216
217 if (whatcode == EUCORSJIS)
218 #ifdef SJISPRE
219 whatcode = SJIS;
220 #else
221 whatcode = EUC;
222 #endif
223
224 return whatcode;
225 }
226
227 /* SJIStoJIS() is sjis2jis() by Ken Lunde. */
228
229 static void
SJIStoJIS(int * p1,int * p2)230 SJIStoJIS (int *p1, int *p2)
231 {
232 register unsigned char c1 = *p1;
233 register unsigned char c2 = *p2;
234 register int adjust = c2 < 159;
235 register int rowOffset = c1 < 160 ? 112 : 176;
236 register int cellOffset = adjust ? (31 + (c2 > 127)) : 126;
237
238 *p1 = ((c1 - rowOffset) << 1) - adjust;
239 *p2 -= cellOffset;
240 }
241
242 /* han2zen() was derived from han2zen() written by Ken Lunde. */
243
244 #define IS_DAKU(c) ((c >= 182 && c <= 196) || (c >= 202 && c <= 206) || (c == 179))
245 #define IS_HANDAKU(c) (c >= 202 && c <= 206)
246
247 static void
han2zen(int * p1,int * p2)248 han2zen (int *p1, int *p2)
249 {
250 int c = *p1;
251 int daku = FALSE;
252 int handaku = FALSE;
253 int mtable[][2] =
254 {
255 {129, 66},
256 {129, 117},
257 {129, 118},
258 {129, 65},
259 {129, 69},
260 {131, 146},
261 {131, 64},
262 {131, 66},
263 {131, 68},
264 {131, 70},
265 {131, 72},
266 {131, 131},
267 {131, 133},
268 {131, 135},
269 {131, 98},
270 {129, 91},
271 {131, 65},
272 {131, 67},
273 {131, 69},
274 {131, 71},
275 {131, 73},
276 {131, 74},
277 {131, 76},
278 {131, 78},
279 {131, 80},
280 {131, 82},
281 {131, 84},
282 {131, 86},
283 {131, 88},
284 {131, 90},
285 {131, 92},
286 {131, 94},
287 {131, 96},
288 {131, 99},
289 {131, 101},
290 {131, 103},
291 {131, 105},
292 {131, 106},
293 {131, 107},
294 {131, 108},
295 {131, 109},
296 {131, 110},
297 {131, 113},
298 {131, 116},
299 {131, 119},
300 {131, 122},
301 {131, 125},
302 {131, 126},
303 {131, 128},
304 {131, 129},
305 {131, 130},
306 {131, 132},
307 {131, 134},
308 {131, 136},
309 {131, 137},
310 {131, 138},
311 {131, 139},
312 {131, 140},
313 {131, 141},
314 {131, 143},
315 {131, 147},
316 {129, 74},
317 {129, 75}
318 };
319
320 if (*p2 == 222 && IS_DAKU (*p1))
321 daku = TRUE; /* Daku-ten */
322 else if (*p2 == 223 && IS_HANDAKU (*p1))
323 handaku = TRUE; /* Han-daku-ten */
324
325 *p1 = mtable[c - 161][0];
326 *p2 = mtable[c - 161][1];
327
328 if (daku)
329 {
330 if ((*p2 >= 74 && *p2 <= 103) || (*p2 >= 110 && *p2 <= 122))
331 (*p2)++;
332 else if (*p2 == 131 || *p2 == 69)
333 *p2 = 148;
334 }
335 else if (handaku && *p2 >= 110 && *p2 <= 122)
336 (*p2) += 2;
337 }
338
339 /* Recast strcpy to handle unsigned chars used below. */
340 #define ustrcpy(A,B) (strcpy((char*)(A),(const char*)(B)))
341
342 static void
do_convert(unsigned char * to,unsigned char * from,const char * code)343 do_convert (unsigned char *to, unsigned char *from, const char *code)
344 {
345 #ifdef HAVE_ICONV
346 iconv_t cd;
347 size_t from_len, to_len;
348
349 if ((cd = iconv_open (EUCSTR, code)) == (iconv_t) - 1)
350 {
351 error ("iconv_open() error");
352 #ifdef HAVE_ERRNO_H
353 if (errno == EINVAL)
354 error ("invalid code specification: \"%s\" or \"%s\"",
355 EUCSTR, code);
356 #endif
357 strcpy ((char *) to, (const char *) from);
358 return;
359 }
360
361 from_len = strlen ((const char *) from) + 1;
362 to_len = BUFSIZ;
363
364 if ((int) iconv(cd, (char **) &from, &from_len, (char **) &to, &to_len) == -1)
365 {
366 #ifdef HAVE_ERRNO_H
367 if (errno == EINVAL)
368 error ("invalid end of input string");
369 else if (errno == EILSEQ)
370 error ("invalid code in input string");
371 else if (errno == E2BIG)
372 error ("output buffer overflow at do_convert()");
373 else
374 #endif
375 error ("something happen");
376 strcpy ((char *) to, (const char *) from);
377 return;
378 }
379
380 if (iconv_close (cd) != 0)
381 {
382 error ("iconv_close() error");
383 }
384 #else
385 int p1, p2, i, j;
386 int jisx0208 = FALSE;
387 int hankaku = FALSE;
388
389 j = 0;
390 if (strcmp (code, NEWJISSTR) == 0 || strcmp (code, OLDJISSTR) == 0)
391 {
392 for (i = 0; from[i] != '\0' && j < BUFSIZ; i++)
393 {
394 if (from[i] == ESC)
395 {
396 i++;
397 if (from[i] == '$')
398 {
399 jisx0208 = TRUE;
400 hankaku = FALSE;
401 i++;
402 }
403 else if (from[i] == '(')
404 {
405 jisx0208 = FALSE;
406 i++;
407 if (from[i] == 'I') /* Hankaku Kana */
408 hankaku = TRUE;
409 else
410 hankaku = FALSE;
411 }
412 }
413 else
414 {
415 if (jisx0208)
416 to[j++] = from[i] + 128;
417 else if (hankaku)
418 {
419 to[j++] = SS2;
420 to[j++] = from[i] + 128;
421 }
422 else
423 to[j++] = from[i];
424 }
425 }
426 }
427 else if (strcmp (code, SJISSTR) == 0)
428 {
429 for (i = 0; from[i] != '\0' && j < BUFSIZ; i++)
430 {
431 p1 = from[i];
432 if (p1 < 127)
433 to[j++] = p1;
434 else if ((p1 >= 161) && (p1 <= 223))
435 { /* Hankaku Kana */
436 to[j++] = SS2;
437 to[j++] = p1;
438 }
439 else
440 {
441 p2 = from[++i];
442 SJIStoJIS (&p1, &p2);
443 to[j++] = p1 + 128;
444 to[j++] = p2 + 128;
445 }
446 }
447 }
448 else
449 {
450 error ("invalid code specification: \"%s\"", code);
451 return;
452 }
453
454 if (j >= BUFSIZ)
455 {
456 error ("output buffer overflow at do_convert()");
457 ustrcpy (to, from);
458 }
459 else
460 to[j] = '\0';
461 #endif /* HAVE_ICONV */
462 }
463
464 static int
do_check_and_conv(unsigned char * to,unsigned char * from)465 do_check_and_conv (unsigned char *to, unsigned char *from)
466 {
467 static unsigned char tmp[BUFSIZ];
468 int p1, p2, i, j;
469 int kanji = TRUE;
470
471 switch (DetectKanjiCode (from))
472 {
473 case NEW:
474 debug ("Kanji code is New JIS.");
475 do_convert (tmp, from, NEWJISSTR);
476 break;
477 case OLD:
478 debug ("Kanji code is Old JIS.");
479 do_convert (tmp, from, OLDJISSTR);
480 break;
481 case ESCI:
482 debug ("This string includes Hankaku-Kana (jisx0201) escape sequence [ESC] + ( + I.");
483 do_convert (tmp, from, NEWJISSTR);
484 break;
485 case NEC:
486 debug ("Kanji code is NEC Kanji.");
487 error ("cannot convert NEC Kanji.");
488 ustrcpy (tmp, from);
489 kanji = FALSE;
490 break;
491 case EUC:
492 debug ("Kanji code is EUC.");
493 ustrcpy (tmp, from);
494 break;
495 case SJIS:
496 debug ("Kanji code is SJIS.");
497 do_convert (tmp, from, SJISSTR);
498 break;
499 case EUCORSJIS:
500 debug ("Kanji code is EUC or SJIS.");
501 ustrcpy (tmp, from);
502 kanji = FALSE;
503 break;
504 case ASCII:
505 debug ("This is ASCII string.");
506 ustrcpy (tmp, from);
507 kanji = FALSE;
508 break;
509 default:
510 debug ("This string includes unknown code.");
511 ustrcpy (tmp, from);
512 kanji = FALSE;
513 break;
514 }
515
516 /* Hankaku Kana ---> Zenkaku Kana */
517 if (kanji)
518 {
519 j = 0;
520 for (i = 0; tmp[i] != '\0' && j < BUFSIZ; i++)
521 {
522 if (tmp[i] == SS2)
523 {
524 p1 = tmp[++i];
525 if (tmp[i + 1] == SS2)
526 {
527 p2 = tmp[i + 2];
528 if (p2 == 222 || p2 == 223)
529 i += 2;
530 else
531 p2 = 0;
532 }
533 else
534 p2 = 0;
535 han2zen (&p1, &p2);
536 SJIStoJIS (&p1, &p2);
537 to[j++] = p1 + 128;
538 to[j++] = p2 + 128;
539 }
540 else
541 to[j++] = tmp[i];
542 }
543
544 if (j >= BUFSIZ)
545 {
546 error ("output buffer overflow at Hankaku --> Zenkaku");
547 ustrcpy (to, tmp);
548 }
549 else
550 to[j] = '\0';
551 }
552 else
553 ustrcpy (to, tmp);
554
555 return kanji;
556 }
557
558 int
any2eucjp(unsigned char * dest,unsigned char * src,unsigned int dest_max)559 any2eucjp (unsigned char *dest, unsigned char *src, unsigned int dest_max)
560 {
561 static unsigned char tmp_dest[BUFSIZ];
562 int ret;
563
564 if (strlen ((const char *) src) >= BUFSIZ)
565 {
566 error ("input string too large");
567 return -1;
568 }
569 if (dest_max > BUFSIZ)
570 {
571 error ("invalid maximum size of destination\nit should be less than %d.", BUFSIZ);
572 return -1;
573 }
574 ret = do_check_and_conv (tmp_dest, src);
575 if (strlen ((const char *) tmp_dest) >= dest_max)
576 {
577 error ("output buffer overflow");
578 ustrcpy (dest, src);
579 return -1;
580 }
581 ustrcpy (dest, tmp_dest);
582 return ret;
583 }
584
585 #if 0
586 unsigned int
587 strwidth (unsigned char *s)
588 {
589 unsigned char *t;
590 unsigned int i;
591
592 t = (unsigned char *) gdMalloc (BUFSIZ);
593 any2eucjp (t, s, BUFSIZ);
594 i = strlen (t);
595 gdFree (t);
596 return i;
597 }
598
599 #ifdef DEBUG
600 int
601 main ()
602 {
603 unsigned char input[BUFSIZ];
604 unsigned char *output;
605 unsigned char *str;
606 int c, i = 0;
607
608 while ((c = fgetc (stdin)) != '\n' && i < BUFSIZ)
609 input[i++] = c;
610 input[i] = '\0';
611
612 printf ("input : %d bytes\n", strlen ((const char *) input));
613 printf ("output: %d bytes\n", strwidth (input));
614
615 output = (unsigned char *) gdMalloc (BUFSIZ);
616 any2eucjp (output, input, BUFSIZ);
617 str = output;
618 while (*str != '\0')
619 putchar (*(str++));
620 putchar ('\n');
621 gdFree (output);
622
623 return 0;
624 }
625 #endif
626 #endif
627
