?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
swi-prolog: update to 9.2.9
[oi-userland.git] / components / x11 / libX11 / srcs / modules / lc / gb18030 / lcGB18030.c
blob1292e10a649333672c816f8f4e42af712541f380
1 /*
2 * Copyright © 1996, 2015, Oracle and/or its affiliates. All rights reserved.
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
13 * Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21 * DEALINGS IN THE SOFTWARE.
22 */
23
24 #ifdef HAVE_CONFIG_H
25 #include <config.h>
26 #endif
27
28 #include <stdio.h>
29 #include "Xlibint.h"
30 #include "XlcGeneric.h"
31
32 /*
33 * codesets will derived from XLC_XLOCALE and codesets[0] is
34 * gb18030.2000-1 in XLC_XLOCALE
35 */
36 #define CS0 codesets[2] /* Codeset 0 - 7-bit ASCII */
37 #define CS1 codesets[0] /* Codeset 1 - gb18030.2000-0 */
38 #define CS2 codesets[1] /* Codeset 2 - gb18030.2000-1 */
39
40 #define ascii (codeset->cs_num == 0)
41 #define gb18030 (codeset->cs_num == 2)
42
43 #define ASCII_CODESET 0
44 #define GBK2K_CODESET1 1
45 #define GBK2K_CODESET2 2
46 #define MAX_CODESETS 3
47
48 #define ISASCII(ch) ((unsigned char)(ch) <= 0x7F)
49
50 #define GR 0x80 /* Begins right-side (non-ascii) region. */
51 #define GL 0x7f /* Ends left-side (ascii) region. */
52
53 #define isleftside(c) (((c) & GR) ? 0 : 1)
54 #define isrightside(c) (! isleftside(c))
55
56 typedef unsigned char Uchar;
57 typedef unsigned long Ulong;
58 typedef unsigned int Uint;
59
60 #define BIT8OFF(c) ((c) & GL)
61 #define BIT8ON(c) ((c) | GR)
62
63 #define ESC 0x1b
64
65 typedef struct _CT_DATA
66 {
67 char *charset;
68 char *encode_string;
69 } CT_DATA;
70
71 static CT_DATA default_ct_data[] =
72 {
73 {"ASCII", "\033(B" },
74 {"GB2312", "\033$(A" },
75 {"GB18030-0", "\033%/2??SUN-GB18030-0" },
76 {"GB18030-1", "\033%/2??SUN-GB18030-1" }
77 };
78
79 static int num_ct_data = sizeof(default_ct_data)/sizeof(CT_DATA);
80
81 static char *
82 get_CT_encode_string(const char *charset)
83 {
84 if (charset) {
85 int i;
86
87 for (i=0; i < num_ct_data; ++i)
88 if (strncmp(charset,
89 default_ct_data[i].charset,
90 strlen(charset)) == 0)
91 return default_ct_data[i].encode_string;
92 }
93
94 return NULL;
95 }
96
97 typedef enum {t_ASCII, t_GB2312, t_GB18030_0, t_GB18030_1, t_NONE} CharSet_Type;
98
99 static CharSet_Type
100 get_charset_with_encode_string(const char *s)
101 {
102 if (s) {
103 int i;
104
105 for (i=0; i < num_ct_data; ++i)
106 if (strncmp(s, default_ct_data[i].encode_string,
107 strlen(default_ct_data[i].encode_string)) == 0)
108 return i;
109 }
110
111 return t_NONE;
112 }
113
114 static void
115 twobyte_to_fourbyte(unsigned char *in_buf, unsigned char *out_buf)
116 {
117 int tmp;
118
119 tmp=(in_buf[0] << 8) + in_buf[1];
120
121 out_buf[3] = 0x30 + tmp%10; tmp/=10;
122 out_buf[2] = 0x81 + tmp%126; tmp/=126;
123 out_buf[1] = 0x30 + tmp%10; tmp/=10;
124 out_buf[0] = 0x81 + tmp;
125 }
126
127 static void
128 fourbyte_to_twobyte(unsigned char *in_buf, unsigned char *out_buf)
129 {
130 int tmp;
131
132 tmp = 12600 * (in_buf[0] - 0x81) + 1260 * (in_buf[1] - 0x30) +
133 10 * (in_buf[2] - 0x81) + (in_buf[3] - 0x30);
134 out_buf[0] = (tmp & 0xff00) >> 8;
135 out_buf[1] = tmp & 0xff;
136 }
137
138 /*
139 * In GB2312 range or not
140 */
141 static int
142 isgb(unsigned char *s)
143 {
144 /* consider the first byte */
145 if (s[0] >= 0xA1 && s[0] <= 0xFE && s[1] >= 0xA1 &&
146 s[1] <= 0xFE) {
147 return True;
148 }else{
149 return False;
150 }
151 }
152
153 /*
154 * In GB18030 2 bytes range or not
155 */
156 static int
157 isgb18030_2(unsigned char *s)
158 {
159 /* consider the first byte */
160 if (s[0] >= 0x81 && s[0] <= 0xfe &&
161 ((s[1] >= 0x40 && s[1] <= 0x7e) ||
162 (s[1] >= 0x80 && s[1] <= 0xfe)))
163 return True;
164 else
165 return False;
166 }
167
168 /*
169 * In GB18030 4 bytes range or not
170 */
171 static int isgb18030_4(unsigned char *s)
172 {
173 /* consider the first byte */
174 if (s[0] >= 0x81 && s[0] <= 0xfe && s[1] >= 0x30 && s[1] <= 0x39 &&
175 s[2] >= 0x81 && s[2] <= 0xfe && s[3] >= 0x30 && s[3] <= 0x39)
176 return True;
177 else
178 return False;
179 }
180
181 /*
182 * multibyte -> charset: codesets[0], codesets[1], codeset[2]
183 */
184 static int
185 gb18030_mbtocs(
186 XlcConv conv,
187 XPointer *from,
188 int *from_left,
189 XPointer *to,
190 int *to_left,
191 XPointer *args,
192 int num_args)
193 {
194 unsigned char *src = (unsigned char *)*from;
195 unsigned char *dst = (unsigned char *)*to;
196 int unconv_num = 0;
197 int char_size = 0;
198 XLCd lcd = (XLCd)conv->state;
199 CodeSet *codesets = XLC_GENERIC(lcd, codeset_list);
200 int codeset_num = XLC_GENERIC(lcd, codeset_num);
201 XlcCharSet charset = NULL;
202
203 if (isgb18030_2(src)) {
204 if (GBK2K_CODESET1 >= codeset_num)
205 return -1;
206 charset = *CS1->charset_list;
207 char_size = charset->char_size;
208
209 if (*from_left >= 2 && *to_left >= char_size) {
210 *dst++ = *src++;
211 *dst++ = *src++;
212 } else {
213 return -1;
214 }
215
216 *from_left -= char_size;
217 *to_left -= char_size;
218 } else if (isgb18030_4(src)) {
219 unsigned char iconv_buf[6];
220
221 if (GBK2K_CODESET2 >= codeset_num)
222 return -1;
223
224 charset = *CS2->charset_list;
225 char_size = charset->char_size;
226 fourbyte_to_twobyte(src, iconv_buf);
227 if (*from_left >= 4 && *to_left >= char_size) {
228 *dst++ = iconv_buf[0];
229 *dst++ = iconv_buf[1];
230 src += 4;
231 } else {
232 return -1;
233 }
234
235 *from_left -= 4;
236 *to_left -= char_size;
237 } else if (ISASCII(*src)) {
238 if (ASCII_CODESET >= codeset_num)
239 return -1;
240 charset = *CS0->charset_list;
241 char_size = charset->char_size;
242
243 if (*from_left >= char_size && *to_left >= char_size)
244 *dst++ = *src++;
245 else
246 return -1;
247
248 *from_left -= char_size;
249 *to_left -= char_size;
250 } else { /* unknown */
251 unconv_num++;
252 src++;
253 *from_left -= 1;
254 }
255
256 *to = (XPointer)dst;
257 *from = (XPointer)src;
258
259 if (num_args > 0)
260 *((XlcCharSet *) args[0]) = charset;
261
262 return unconv_num;
263 }
264
265 static int
266 gb18030_mbstocs(
267 XlcConv conv,
268 XPointer *from,
269 int *from_left,
270 XPointer *to,
271 int *to_left,
272 XPointer *args,
273 int num_args)
274 {
275 unsigned char *src = (unsigned char *)*from;
276 unsigned char *dst = (unsigned char *)*to;
277 int char_size = 0;
278 int unconv_num = 0;
279 int flag = 0;
280 XLCd lcd = (XLCd)conv->state;
281 CodeSet *codesets = XLC_GENERIC(lcd, codeset_list);
282 int codeset_num = XLC_GENERIC(lcd, codeset_num);
283 XlcCharSet charset = NULL;
284
285 for (;;) {
286 if (isgb18030_2(src)) {
287 if (flag == 0)
288 flag = 1;
289 if (flag == 3 || flag == 2 )
290 break;
291 if (GBK2K_CODESET1 >= codeset_num)
292 return -1;
293
294 charset = *CS1->charset_list;
295 char_size = charset->char_size;
296
297 if (*from_left >= char_size && *to_left >= char_size) {
298 *dst++ = *src++;
299 *dst++ = *src++;
300 *to_left -= char_size;
301 *from_left -= char_size;
302 }else {
303 return -1;
304 }
305 } else if (isgb18030_4(src)) {
306 unsigned char iconv_buf[6];
307
308 if (flag == 0)
309 flag = 2;
310 if (flag == 3 || flag == 1)
311 break;
312 if (GBK2K_CODESET2 >= codeset_num)
313 return -1;
314
315 charset = *CS2->charset_list;
316 char_size = charset->char_size;
317 fourbyte_to_twobyte(src, iconv_buf);
318
319 if (*from_left >= 4 && *to_left >= char_size) {
320 *dst++ = iconv_buf[0];
321 *dst++ = iconv_buf[1];
322 src += 4;
323 *to_left -= char_size;
324 *from_left -= 4;
325 } else {
326 return -1;
327 }
328 } else if (ISASCII(*src)) {
329 if (flag == 0)
330 flag = 3;
331 if (flag == 1 || flag ==2 )
332 break;
333 if (ASCII_CODESET >= codeset_num)
334 return -1;
335
336 charset = *CS0->charset_list;
337 char_size = charset->char_size;
338 if (*from_left >= char_size && *to_left >= char_size) {
339 *dst++ = *src++;
340 *to_left -= char_size;
341 *from_left -= char_size;
342 } else {
343 break;
344 }
345 } else{ /* unknown */
346 unconv_num++;
347 src++;
348 *from_left -= 1;
349 }
350
351 if (*from_left <= 0)
352 break;
353 }
354
355 *from = (XPointer)src;
356 *to = (XPointer)dst;
357
358 if (num_args > 0)
359 *((XlcCharSet *) args[0]) = charset;
360
361 return unconv_num;
362 }
363
364 static int
365 gb18030_wcstocs(
366 XlcConv conv,
367 XPointer *from,
368 int *from_left,
369 XPointer *to,
370 int *to_left,
371 XPointer *args,
372 int num_args)
373 {
374 unsigned char *dst = (unsigned char *)*to;
375 wchar_t *src = (wchar_t *)*from;
376 int char_size = 0;
377 int unconv_num = 0;
378 int flag = 0;
379 XLCd lcd = (XLCd)conv->state;
380 XlcCharSet charset = NULL;
381 CodeSet *codesets = XLC_GENERIC(lcd, codeset_list);
382 int codeset_num = XLC_GENERIC(lcd, codeset_num);
383
384 charset = (XlcCharSet)args[0];
385
386 for (;;) {
387 wchar_t wch = *src;
388 char tmp[32];
389
390 wctomb(tmp, wch);
391
392 if (isgb18030_2((unsigned char*)tmp)) {
393 if (flag == 0)
394 flag = 1;
395 if (flag == 2 || flag == 3)
396 break;
397 if (GBK2K_CODESET1 >= codeset_num)
398 return -1;
399
400 charset = *CS1->charset_list;
401 char_size = charset->char_size;
402
403 if (*from_left > 0 && *to_left >= char_size) {
404 *dst++ = tmp[0];
405 *dst++ = tmp[1];
406 *to_left -= char_size;
407 } else {
408 return -1;
409 }
410 } else if (isgb18030_4((unsigned char*)tmp)) {
411 unsigned char iconv_buf[6];
412
413 if (flag == 0)
414 flag = 2;
415 if (flag == 1 || flag == 3)
416 break;
417 if (GBK2K_CODESET2 >= codeset_num)
418 return -1;
419
420 charset = *CS2->charset_list;
421 char_size = charset->char_size;
422 fourbyte_to_twobyte((unsigned char*)tmp, iconv_buf);
423
424 if (*from_left > 0 && *to_left >= char_size) {
425 *dst++ = iconv_buf[0];
426 *dst++ = iconv_buf[1];
427 *to_left -= char_size;
428 } else {
429 return -1;
430 }
431 } else if (ISASCII(tmp[0])) {
432 if (flag == 0)
433 flag = 3;
434 if (flag == 1 || flag == 2)
435 break;
436 if (ASCII_CODESET >= codeset_num)
437 return -1;
438
439 charset = *CS0->charset_list;
440 char_size = charset->char_size;
441 if (*from_left > 0 && *to_left >= char_size) {
442 *dst++ = tmp[0];
443 *to_left -= char_size;
444 } else {
445 return -1;
446 }
447 } else { /* unknown */
448 unconv_num++;
449 }
450
451 src++; /* advance one wchar_t */
452 (*from_left)--;
453 if (*from_left <= 0)
454 break;
455 }
456
457 *from = (XPointer)src;
458 *to = (XPointer)dst;
459
460 if (num_args > 0)
461 *((XlcCharSet *)args[0]) = charset;
462
463 return unconv_num;
464 }
465
466 static CodeSet
467 get_code_set_from_charset(
468 XLCd lcd,
469 XlcCharSet charset)
470 {
471 CodeSet *codeset = XLC_GENERIC(lcd, codeset_list);
472 XlcCharSet *charset_list;
473 int codeset_num, num_charsets;
474
475 codeset_num = XLC_GENERIC(lcd, codeset_num);
476
477 for (; codeset_num-- > 0; codeset++) {
478 num_charsets = (*codeset)->num_charsets;
479 charset_list = (*codeset)->charset_list;
480
481 for (; num_charsets-- > 0; charset_list++)
482 if (*charset_list == charset)
483 return *codeset;
484 }
485
486 return (CodeSet)NULL;
487 }
488
489 static int
490 gb18030_cstombs(
491 XlcConv conv,
492 XPointer *from,
493 int *from_left,
494 XPointer *to,
495 int *to_left,
496 XPointer *args,
497 int num_args)
498 {
499 unsigned char *src = (unsigned char *)*from;
500 unsigned char *dst = (unsigned char *)*to;
501 int char_size = 0;
502 int unconv_num = 0;
503 XLCd lcd = (XLCd)conv->state;
504 XlcCharSet charset = (XlcCharSet) args[0];
505 CodeSet codeset;
506
507 codeset = get_code_set_from_charset(lcd, charset);
508 if (codeset == NULL)
509 return -1;
510
511 for (;;) {
512 if (codeset->wc_encoding==0x5e84) { /* GB18030-1 */
513 char_size = 2;
514
515 if (*from_left >= 2 && *to_left >= 4) {
516 unsigned char iconv_buf[6];
517
518 twobyte_to_fourbyte(src, iconv_buf);
519 *dst++ = iconv_buf[0];
520 *dst++ = iconv_buf[1];
521 *dst++ = iconv_buf[2];
522 *dst++ = iconv_buf[3];
523 *to_left -= 4;
524 } else {
525 return -1;
526 }
527 } else if (isgb18030_2((unsigned char*)src)) { /*2 bytes character*/
528 char_size = 2;
529
530 if (*from_left >= 2 && *to_left >= 2) {
531 *dst++ = *src++;
532 *dst++ = *src++;
533 *to_left -= 2;
534 } else {
535 return -1;
536 }
537 } else if (ISASCII(*src)) { /*ASCII character*/
538 char_size = 1;
539
540 if (*from_left >= 1 && *to_left >= 1) {
541 *dst++ = *src++;
542 *to_left -= 1;
543 } else {
544 return -1;
545 }
546 } else { /* unknown */
547 unconv_num++;
548 src++;
549 char_size = 1;
550 }
551
552 *from_left -= char_size;;
553 if (*from_left <= 0)
554 break;
555 }
556
557 *from = (XPointer)src;
558 *to = (XPointer )dst;
559
560 if (num_args > 0)
561 *((XlcCharSet *) args[0]) = charset;
562
563 return unconv_num;
564 }
565
566 static int
567 gb18030_cstowcs(
568 XlcConv conv,
569 XPointer *from,
570 int *from_left,
571 XPointer *to,
572 int *to_left,
573 XPointer *args,
574 int num_args)
575 {
576 XPointer outbufptr, outbufptr_save;
577 int to_left_save = *to_left;
578 wchar_t *pwc = (wchar_t *) *to;
579 int rtn, rtn_1;
580
581 outbufptr = (XPointer) Xmalloc(*to_left * 4);
582 outbufptr_save = outbufptr;
583
584 rtn = gb18030_cstombs(conv, from, from_left,
585 &outbufptr, to_left,
586 args, num_args);
587 *outbufptr='\0';
588
589 rtn_1 = mbstowcs(pwc, outbufptr_save, (to_left_save - *to_left));
590
591 Xfree(outbufptr_save);
592
593 *to_left = to_left_save - rtn_1;
594 *to = *to+ rtn_1 * sizeof(wchar_t);
595
596 return rtn;
597 }
598
599
600 /*
601 * In gb18030 locale, we only consider the following possibilities
602 * all other ct formats are ignored, keep looping until end of buffer
603 * ASCII
604 * GB2312
605 * GB18030-0
606 * GB18030-1
607 */
608 static int
609 gb18030_ctstombs(
610 XlcConv conv,
611 XPointer *from,
612 int *from_left,
613 XPointer *to,
614 int *to_left,
615 XPointer *args,
616 int num_args)
617 {
618 unsigned char *inbufptr = (unsigned char *)*from;
619 unsigned char *outbufptr = (unsigned char *)*to;
620 int unconv_num = 0;
621 int i, j;
622 int save_outbuf = True;
623 CharSet_Type charset_type;
624
625 /*
626 * If outbufptr is NULL, doen't save output, but just counts
627 * a length to hold the output.
628 */
629 if (outbufptr == NULL)
630 save_outbuf = False;
631
632 i = 0;
633 j = 0;
634
635 while (i < *from_left) {
636 if (inbufptr[i] == ESC) { /* got an escape */
637 charset_type = get_charset_with_encode_string(
638 (const char *)inbufptr + i);
639
640 switch (charset_type) {
641 case t_ASCII:
642 i += strlen(default_ct_data[charset_type].encode_string);
643
644 for (;;) {
645 if (i >= *from_left) { /* end of from buffer */
646 goto FINISHED;
647 }
648
649 if ((inbufptr[i] == 0x0a || inbufptr[i] == 0x09 ||
650 inbufptr[i] >= 0x20) && ISASCII(inbufptr[i])) {
651 if (*to_left < 1) { /* end of to buffer */
652 goto FINISHED;
653 }
654
655 if (save_outbuf == True)
656 outbufptr[j++] = inbufptr[i];
657
658 (*to_left)--;
659 ++i;
660 } else {
661 break;
662 }
663 }
664 break;
665
666 case t_GB2312:
667 i += strlen(default_ct_data[charset_type].encode_string);
668
669 for (;;) {
670 unsigned char iconv_buf[3];
671
672 if (i >= *from_left) { /* end of from buffer */
673 goto FINISHED;
674 }
675
676 iconv_buf[0] = (inbufptr[i] & 0x7f) | 0x80;
677 iconv_buf[1] = (inbufptr[i + 1] & 0x7f) | 0x80;
678
679 if (isgb(iconv_buf)) {
680 if (*to_left < 2 || *from_left < 2) {
681 goto FINISHED;
682 }
683
684 if (save_outbuf == True) {
685 outbufptr[j++] = iconv_buf[0];
686 outbufptr[j++] = iconv_buf[1];
687 }
688
689 *to_left -= 2;
690 i = i + 2;
691 } else {
692 break;
693 }
694 }
695 break;
696
697 case t_GB18030_0:
698 i += strlen(default_ct_data[charset_type].encode_string);
699
700 for (;;) {
701 if (i >= *from_left) { /* end of from buffer */
702 goto FINISHED;
703 }
704
705 if (isgb18030_2(inbufptr + i)) {
706 if (*to_left < 2 || *from_left < 2) {
707 goto FINISHED;
708 }
709
710 if (save_outbuf == True) {
711 outbufptr[j++] = inbufptr[i];
712 outbufptr[j++] = inbufptr[i + 1];
713 }
714
715 *to_left -= 2;
716 i = i + 2;
717 } else {
718 break;
719 }
720 }
721 break;
722
723 case t_GB18030_1: /* gb18030.2000-1 character */
724 i += strlen(default_ct_data[charset_type].encode_string);
725
726 for (;;) {
727 if (i >= *from_left) { /* end of from buffer */
728 goto FINISHED;
729 }
730
731 if (isgb18030_4(inbufptr + i)) {
732 if (*to_left < 4 || *from_left < 4) {
733 goto FINISHED;
734 }
735
736 if (save_outbuf == True) {
737 outbufptr[j++] = inbufptr[i] & 0xff;
738 outbufptr[j++] = inbufptr[i+1] & 0xff;
739 outbufptr[j++] = inbufptr[i+2] & 0xff;
740 outbufptr[j++] = inbufptr[i+3] & 0xff;
741 }
742
743 *to_left -= 4;
744 i = i + 4;
745 } else {
746 break;
747 }
748 }
749 break;
750
751 case t_NONE:
752 i++; /* encounter unknown escape sequence */
753 unconv_num++;
754 break;
755 }
756 } else if ((inbufptr[i] == 0x0a || inbufptr[i] == 0x09 ||
757 inbufptr[i] >= 0x20) && ISASCII(inbufptr[i])) {
758 /* Process default CT G0 ascii character */
759 if (*to_left < 1) {
760 goto FINISHED;
761 }
762
763 if (save_outbuf == True)
764 outbufptr[j++] = inbufptr[i];
765
766 i++;
767 *to_left -= 1;
768 } else { /* unknown character */
769 i++;
770 unconv_num++;
771 }
772 }
773
774 FINISHED:
775 *from = (XPointer)(inbufptr + i);
776 *to = (XPointer)(outbufptr + j);
777 if (i >= *from_left)
778 *from_left = 0;
779 else
780 *from_left -= i;
781
782 return (unconv_num);
783 }
784
785 static int
786 gb18030_ctstowcs(
787 XlcConv conv,
788 XPointer *from,
789 int *from_left,
790 XPointer *to,
791 int *to_left,
792 XPointer *args,
793 int num_args)
794 {
795 XPointer outbufptr, outbufptr_end;
796 int to_left_save = *to_left;
797 wchar_t *pwc = (wchar_t *) *to;
798 int rtn, rtn_1;
799
800
801 outbufptr = (XPointer) Xmalloc(*to_left * 4); /* 100 safty tolerence */
802 outbufptr_end = outbufptr;
803
804 rtn = gb18030_ctstombs(conv,
805 from,
806 from_left,
807 &outbufptr_end,
808 to_left,
809 args,
810 num_args);
811
812 *outbufptr_end = '\0';
813
814 rtn_1 = mbstowcs(pwc, outbufptr, (to_left_save - *to_left));
815
816 Xfree(outbufptr);
817
818 *to_left = to_left_save - rtn_1;
819 *to = *to + rtn_1 * sizeof(wchar_t);
820
821 return rtn;
822 }
823
824 /*
825 * The mbs is GB18030 code, must be converted to euc code,
826 * then pack to ct format.
827 */
828 static int
829 gb18030_mbstocts(
830 XlcConv conv,
831 XPointer *from,
832 int *from_left,
833 XPointer *to,
834 int *to_left,
835 XPointer *args,
836 int num_args)
837 {
838 unsigned char *inbufptr = (unsigned char *)*from;
839 unsigned char *outbufptr = (unsigned char *)*to;
840 int unconv_num = 0;
841 int flag = 0, j = 0, i = 0;
842 int encode_string_len;
843 char *encode_string;
844
845 while (i < *from_left && j < *to_left) {
846 if (isgb(&inbufptr[i])) { /* GB2312 character */
847 if (flag == 0 || flag != 2) {
848 encode_string = get_CT_encode_string("GB2312");
849 if (! encode_string )
850 return -1;
851
852 encode_string_len = strlen(encode_string);
853 if (j + encode_string_len + 2 >= *to_left)
854 break;
855
856 strncpy((char *)outbufptr+j, encode_string, encode_string_len);
857 j += encode_string_len;
858 flag = 2;
859 }
860
861 if (j + 2 >= *to_left)
862 break;
863
864 outbufptr[j++] = inbufptr[i++] & 0x7f;
865 outbufptr[j++] = inbufptr[i++] & 0x7f;
866 } else if (isgb18030_2(&inbufptr[i])) { /* 2 bytes GB 18030 */
867 if (flag == 0 || flag != 4) {
868 encode_string = get_CT_encode_string("GB18030-0");
869 if (! encode_string )
870 return -1;
871
872 encode_string_len = strlen(encode_string);
873 if (j + encode_string_len + 2 >= *to_left)
874 break;
875
876 strncpy((char *)outbufptr+j, encode_string, encode_string_len);
877 j += encode_string_len;
878 flag = 4;
879 }
880
881 if (j + 2 >= *to_left)
882 break;
883
884 outbufptr[j++] = inbufptr[i++] & 0xff;
885 outbufptr[j++] = inbufptr[i++] & 0xff;
886 } else if (isgb18030_4(&inbufptr[i])) { /* 4 bytes GB18030 */
887 if (flag == 0 || flag != 5) {
888 encode_string = get_CT_encode_string("GB18030-1");
889 if (!encode_string)
890 return -1;
891 encode_string_len = strlen(encode_string);
892
893 if (j + encode_string_len + 4 >= *to_left)
894 break;
895
896 strncpy((char *)outbufptr+j, encode_string, encode_string_len);
897 j += encode_string_len;
898 flag = 5;
899 }
900
901 if (j + 4 >= *to_left)
902 break;
903
904 outbufptr[j++] = inbufptr[i++];
905 outbufptr[j++] = inbufptr[i++];
906 outbufptr[j++] = inbufptr[i++];
907 outbufptr[j++] = inbufptr[i++];
908 } else if (ISASCII(inbufptr[i])) { /* ASCII */
909 if (flag == 0 || flag != 3) {
910 encode_string = get_CT_encode_string("ASCII");
911 if (!encode_string )
912 return -1;
913
914 encode_string_len = strlen(encode_string);
915 if (j + encode_string_len + 1 >= *to_left)
916 break;
917
918 strncpy((char *)outbufptr+j, encode_string, encode_string_len);
919 j += encode_string_len;
920 flag = 3;
921 }
922
923 if (j + 1 >= *to_left)
924 break;
925
926 outbufptr[j++] = inbufptr[i++];
927 } else{
928 i++; /* Skip this byte */
929 unconv_num++; /* Count this as an unconverted byte */
930 }
931 }
932
933 *from = (XPointer)&inbufptr[i];
934 *to = (XPointer)&outbufptr[j];
935 *from_left = *from_left - i;
936 *to_left = *to_left - j;
937
938 return unconv_num;
939 }
940
941 static int
942 gb18030_wcstocts(
943 XlcConv conv,
944 XPointer *from,
945 int *from_left,
946 XPointer *to,
947 int *to_left,
948 XPointer *args,
949 int num_args)
950 {
951
952 unsigned char inbufptr[10];
953 unsigned char *outbufptr = (unsigned char *)*to;
954 wchar_t *pwc = (wchar_t *)*from;
955 int unconv_num = 0;
956 int flag,j,i,k;
957 char *encode_string;
958 int encode_string_len;
959
960 i = k = j = 0;
961 flag = 0;
962
963 while (k < *from_left) {
964 if (wctomb((char *)inbufptr, pwc[k++]) == -1)
965 return (-1);
966
967 i=0;
968
969 if (isgb(&inbufptr[i])) { /* GB2312 */
970 if (flag == 0 || flag != 1) {
971 encode_string = get_CT_encode_string("GB2312");
972 if (! encode_string)
973 return (-1);
974
975 encode_string_len = strlen(encode_string);
976 if (j + encode_string_len + 2 >= *to_left)
977 break;
978
979 strncpy((char *)outbufptr+j, encode_string, encode_string_len);
980 j += encode_string_len;
981 flag = 1;
982 }
983
984 if (j + 2 >= *to_left)
985 break;
986
987 outbufptr[j++] = inbufptr[i++];
988 outbufptr[j++] = inbufptr[i++];
989 } else if (isgb18030_2(&inbufptr[i])) {
990 if (flag == 0 || flag != 2) {
991 encode_string = get_CT_encode_string("GB18030-0");
992 if (! encode_string)
993 return -1;
994
995 encode_string_len = strlen(encode_string);
996 if (j + encode_string_len + 2 >= *to_left)
997 break;
998
999 strncpy((char *)outbufptr+j, encode_string, encode_string_len);
1000 j += encode_string_len;
1001 flag = 2;
1002 }
1003
1004 if (j + 2 >= *to_left)
1005 break;
1006
1007 outbufptr[j++] = inbufptr[i++];
1008 outbufptr[j++] = inbufptr[i++];
1009 } else if (isgb18030_4(&inbufptr[i])) {
1010 if (flag == 0 || flag != 6) {
1011 encode_string = get_CT_encode_string("GB18030-1");
1012 if (! encode_string)
1013 return -1;
1014
1015 encode_string_len = strlen(encode_string);
1016 if (j + encode_string_len + 4 >= *to_left)
1017 break;
1018
1019 strncpy((char *)outbufptr+j, encode_string, encode_string_len);
1020 j += encode_string_len;
1021 flag = 6;
1022 }
1023
1024 if (j + 4 >= *to_left)
1025 break;
1026
1027 outbufptr[j++] = inbufptr[i++];
1028 outbufptr[j++] = inbufptr[i++];
1029 outbufptr[j++] = inbufptr[i++];
1030 outbufptr[j++] = inbufptr[i++];
1031 } else if (ISASCII(inbufptr[i])) {
1032 if (flag == 0 || flag != 3) {
1033 encode_string = get_CT_encode_string("ASCII");
1034 if (! encode_string)
1035 return -1;
1036
1037 encode_string_len = strlen(encode_string);
1038 if (j + encode_string_len + 1 >= *to_left)
1039 break;
1040
1041 strncpy((char *)outbufptr+j, encode_string, encode_string_len);
1042 j += encode_string_len;
1043
1044 flag = 3;
1045 }
1046
1047 outbufptr[j++] = inbufptr[i++];
1048 } else {
1049 unconv_num++;
1050 }
1051 }
1052
1053 *from = (XPointer)&pwc[k];
1054 *to = (XPointer)&outbufptr[j];
1055 *from_left = *from_left - k;
1056 *to_left = *to_left - j;
1057
1058 return unconv_num;
1059 }
1060
1061 static int
1062 gb18030_mbstowcs(
1063 XlcConv conv,
1064 XPointer *from,
1065 int *from_left,
1066 XPointer *to,
1067 int *to_left,
1068 XPointer *args,
1069 int num_args)
1070 {
1071 char *src = *((char **) from);
1072 wchar_t *dst = *((wchar_t **) to);
1073 int src_left = *from_left;
1074 int dst_left = *to_left;
1075 int mblen, unconv_num = 0;
1076
1077 while (src_left > 0 && dst_left > 0) {
1078 mblen = mbtowc(dst, src, src_left);
1079
1080 if (mblen > 0) {
1081 src += mblen;
1082 src_left -= mblen;
1083 dst++;
1084 dst_left--;
1085 } else {
1086 src++;
1087 src_left--;
1088 if (mblen < 0) {
1089 unconv_num++;
1090 } else {
1091 *dst++ = L'\0';
1092 dst_left--;
1093 }
1094 }
1095 }
1096
1097 *from = (XPointer) src;
1098 *to = (XPointer) dst;
1099 *from_left = src_left;
1100 *to_left = dst_left;
1101 return unconv_num;
1102 }
1103
1104 static int
1105 gb18030_wcstombs(
1106 XlcConv conv,
1107 XPointer *from,
1108 int *from_left,
1109 XPointer *to,
1110 int *to_left,
1111 XPointer *args,
1112 int num_args)
1113 {
1114 wchar_t *src = *((wchar_t **)from);
1115 char *dst = *((char **) to);
1116 char buf[MB_CUR_MAX];
1117 int src_left = *from_left;
1118 int dst_left = *to_left;
1119 int mblen, unconv_num = 0;
1120
1121 while (src_left > 0) {
1122 mblen = wctomb(buf, *src);
1123
1124 if (dst_left < mblen) {
1125 break;
1126 }
1127
1128 src++;
1129 src_left--;
1130
1131 if (mblen < 0) {
1132 unconv_num++;
1133 continue;
1134 }
1135
1136 dst_left -= mblen;
1137 for (int i = 0; i < mblen; i++) {
1138 *dst++ = buf[i];
1139 }
1140 }
1141
1142 *from = (XPointer) src;
1143 *to = (XPointer) dst;
1144 *from_left = src_left;
1145 *to_left = dst_left;
1146 return unconv_num;
1147 }
1148
1149
1150 static void
1151 close_converter(XlcConv conv)
1152 {
1153 Xfree((char *) conv);
1154 }
1155
1156 static XlcConv
1157 create_conv(
1158 XLCd lcd,
1159 XlcConvMethods methods)
1160 {
1161 XlcConv conv;
1162
1163 conv = (XlcConv) Xmalloc(sizeof(XlcConvRec));
1164 if (conv == NULL)
1165 return (XlcConv) NULL;
1166
1167 conv->methods = methods;
1168 conv->state = (XPointer) lcd;
1169 return conv;
1170 }
1171
1172
1173 enum { MBSTOCS, WCSTOCS, MBTOCS, CSTOMBS, CSTOWCS, MBSTOCTS, CTSTOMBS,
1174 CTSTOWCS, WCSTOCTS, MBSTOWCS, WCSTOMBS, STRTOMBS };
1175
1176 static XlcConvMethodsRec conv_methods[] = {
1177 {close_converter, gb18030_mbstocs, NULL },
1178 {close_converter, gb18030_wcstocs, NULL },
1179 {close_converter, gb18030_mbtocs, NULL },
1180 {close_converter, gb18030_cstombs, NULL },
1181 {close_converter, gb18030_cstowcs, NULL },
1182 {close_converter, gb18030_mbstocts, NULL },
1183 {close_converter, gb18030_ctstombs, NULL },
1184 {close_converter, gb18030_ctstowcs, NULL },
1185 {close_converter, gb18030_wcstocts, NULL },
1186 {close_converter, gb18030_mbstowcs, NULL },
1187 {close_converter, gb18030_wcstombs, NULL },
1188
1189 };
1190
1191
1192 static XlcConv
1193 open_mbstocs(
1194 XLCd from_lcd,
1195 const char *from_type,
1196 XLCd to_lcd,
1197 const char *to_type)
1198 {
1199 return create_conv(from_lcd, &conv_methods[MBSTOCS]);
1200 }
1201
1202 static XlcConv
1203 open_wcstocs(
1204 XLCd from_lcd,
1205 const char *from_type,
1206 XLCd to_lcd,
1207 const char *to_type)
1208 {
1209 return create_conv(from_lcd, &conv_methods[WCSTOCS]);
1210 }
1211
1212 static XlcConv
1213 open_mbtocs(
1214 XLCd from_lcd,
1215 const char *from_type,
1216 XLCd to_lcd,
1217 const char *to_type)
1218 {
1219 return create_conv(from_lcd, &conv_methods[MBTOCS]);
1220 }
1221
1222 static XlcConv
1223 open_cstombs(
1224 XLCd from_lcd,
1225 const char *from_type,
1226 XLCd to_lcd,
1227 const char *to_type)
1228 {
1229 return create_conv(from_lcd, &conv_methods[CSTOMBS]);
1230 }
1231
1232 static XlcConv
1233 open_cstowcs(
1234 XLCd from_lcd,
1235 const char *from_type,
1236 XLCd to_lcd,
1237 const char *to_type)
1238 {
1239 return create_conv(from_lcd, &conv_methods[CSTOWCS]);
1240 }
1241
1242 static XlcConv
1243 open_wcstocts(
1244 XLCd from_lcd,
1245 const char *from_type,
1246 XLCd to_lcd,
1247 const char *to_type)
1248 {
1249 return create_conv(from_lcd, &conv_methods[WCSTOCTS]);
1250 }
1251
1252 static XlcConv
1253 open_mbstocts(
1254 XLCd from_lcd,
1255 const char *from_type,
1256 XLCd to_lcd,
1257 const char *to_type)
1258 {
1259 return create_conv(from_lcd, &conv_methods[MBSTOCTS]);
1260 }
1261
1262 static XlcConv
1263 open_ctstombs(
1264 XLCd from_lcd,
1265 const char *from_type,
1266 XLCd to_lcd,
1267 const char *to_type)
1268 {
1269 return create_conv(from_lcd, &conv_methods[CTSTOMBS]);
1270 }
1271
1272 static XlcConv
1273 open_ctstowcs(
1274 XLCd from_lcd,
1275 const char *from_type,
1276 XLCd to_lcd,
1277 const char *to_type)
1278 {
1279 return create_conv(from_lcd, &conv_methods[CTSTOWCS]);
1280 }
1281
1282 static XlcConv
1283 open_mbstowcs(
1284 XLCd from_lcd,
1285 const char *from_type,
1286 XLCd to_lcd,
1287 const char *to_type)
1288 {
1289 return create_conv(from_lcd, &conv_methods[MBSTOWCS]);
1290 }
1291
1292 static XlcConv
1293 open_wcstombs(
1294 XLCd from_lcd,
1295 const char *from_type,
1296 XLCd to_lcd,
1297 const char *to_type)
1298 {
1299 return create_conv(from_lcd, &conv_methods[WCSTOMBS]);
1300 }
1301
1302 XLCd
1303 _XlcGb18030Loader(const char *name)
1304 {
1305 XLCd lcd;
1306
1307 lcd = _XlcCreateLC(name, _XlcGenericMethods);
1308 if (lcd == NULL)
1309 return lcd;
1310
1311 if ((_XlcNCompareISOLatin1(XLC_PUBLIC_PART(lcd)->codeset, "gb18030", 7))) {
1312 _XlcDestroyLC(lcd);
1313 return (XLCd) NULL;
1314 }
1315
1316 /* MB/WC <-> CS */
1317 _XlcSetConverter(lcd, XlcNMultiByte, lcd, XlcNCharSet, open_mbstocs);
1318 _XlcSetConverter(lcd, XlcNWideChar, lcd, XlcNCharSet, open_wcstocs);
1319 _XlcSetConverter(lcd, XlcNCharSet, lcd, XlcNMultiByte, open_cstombs);
1320 _XlcSetConverter(lcd, XlcNCharSet, lcd, XlcNWideChar, open_cstowcs);
1321
1322 _XlcSetConverter(lcd, XlcNMultiByte, lcd, XlcNChar, open_mbtocs);
1323
1324 /* MB/WC <-> CT */
1325 _XlcSetConverter(lcd, XlcNMultiByte, lcd, XlcNCompoundText, open_mbstocts);
1326 _XlcSetConverter(lcd, XlcNCompoundText, lcd, XlcNMultiByte, open_ctstombs);
1327 _XlcSetConverter(lcd, XlcNCompoundText, lcd, XlcNWideChar, open_ctstowcs);
1328 _XlcSetConverter(lcd, XlcNWideChar, lcd, XlcNCompoundText, open_wcstocts);
1329
1330 /* MB <-> WC */
1331 _XlcSetConverter(lcd, XlcNMultiByte, lcd, XlcNWideChar, open_mbstowcs);
1332 _XlcSetConverter(lcd, XlcNWideChar, lcd, XlcNMultiByte, open_wcstombs);
1333
1334
1335 _XlcAddUtf8Converters(lcd);
1336
1337 return lcd;
1338 }
1339