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