![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to mbfilter.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / mbstring / libmbfl / mbfl|
Return to mbfilter.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / mbstring / libmbfl / mbfl |
1.1 misho 1: /*
2: * charset=UTF-8
3: * vim600: encoding=utf-8
4: */
5:
6: /*
7: * "streamable kanji code filter and converter"
8: *
9: * Copyright (c) 1998,1999,2000,2001 HappySize, Inc. All rights reserved.
10: *
11: * This software is released under the GNU Lesser General Public License.
12: * (Version 2.1, February 1999)
13: * Please read the following detail of the licence (in japanese).
14: *
15: * ◆使用許諾条件◆
16: *
17: * このソフトウェアは株式会社ハッピーサイズによって開発されました。株式会社ハッ
18: * ピーサイズは、著作権法および万国著作権条約の定めにより、このソフトウェアに関
19: * するすべての権利を留保する権利を持ち、ここに行使します。株式会社ハッピーサイ
20: * ズは以下に明記した条件に従って、このソフトウェアを使用する排他的ではない権利
21: * をお客様に許諾します。何人たりとも、以下の条件に反してこのソフトウェアを使用
22: * することはできません。
23: *
24: * このソフトウェアを「GNU Lesser General Public License (Version 2.1, February
25: * 1999)」に示された条件で使用することを、全ての方に許諾します。「GNU Lesser
26: * General Public License」を満たさない使用には、株式会社ハッピーサイズから書面
27: * による許諾を得る必要があります。
28: *
29: * 「GNU Lesser General Public License」の全文は以下のウェブページから取得でき
30: * ます。「GNU Lesser General Public License」とは、これまでLibrary General
31: * Public Licenseと呼ばれていたものです。
32: * http://www.gnu.org/ --- GNUウェブサイト
33: * http://www.gnu.org/copyleft/lesser.html --- ライセンス文面
34: * このライセンスの内容がわからない方、守れない方には使用を許諾しません。
35: *
36: * しかしながら、当社とGNUプロジェクトとの特定の関係を示唆または主張するもので
37: * はありません。
38: *
39: * ◆保証内容◆
40: *
41: * このソフトウェアは、期待された動作・機能・性能を持つことを目標として設計され
42: * 開発されていますが、これを保証するものではありません。このソフトウェアは「こ
43: * のまま」の状態で提供されており、たとえばこのソフトウェアの有用性ないし特定の
44: * 目的に合致することといった、何らかの保証内容が、明示されたり暗黙に示されてい
45: * る場合であっても、その保証は無効です。このソフトウェアを使用した結果ないし使
46: * 用しなかった結果によって、直接あるいは間接に受けた身体的な傷害、財産上の損害
47: * 、データの損失あるいはその他の全ての損害については、その損害の可能性が使用者
48: * 、当社あるいは第三者によって警告されていた場合であっても、当社はその損害の賠
49: * 償および補填を行いません。この規定は他の全ての、書面上または書面に無い保証・
50: * 契約・規定に優先します。
51: *
52: * ◆著作権者の連絡先および使用条件についての問い合わせ先◆
53: *
54: * 〒102-0073
55: * 東京都千代田区九段北1-13-5日本地所第一ビル4F
56: * 株式会社ハッピーサイズ
57: * Phone: 03-3512-3655, Fax: 03-3512-3656
58: * Email: sales@happysize.co.jp
59: * Web: http://happysize.com/
60: *
61: * ◆著者◆
62: *
63: * 金本 茂 <sgk@happysize.co.jp>
64: *
65: * ◆履歴◆
66: *
67: * 1998/11/10 sgk implementation in C++
68: * 1999/4/25 sgk Cで書きなおし。
69: * 1999/4/26 sgk 入力フィルタを実装。漢字コードを推定しながらフィルタを追加。
70: * 1999/6/?? Unicodeサポート。
71: * 1999/6/22 sgk ライセンスをLGPLに変更。
72: *
73: */
74:
75: /*
76: * Unicode support
77: *
78: * Portions copyright (c) 1999,2000,2001 by the PHP3 internationalization team.
79: * All rights reserved.
80: *
81: */
82:
83:
84: #ifdef HAVE_CONFIG_H
85: #include "config.h"
86: #endif
87:
88: #include <stddef.h>
89:
90: #ifdef HAVE_STRING_H
91: #include <string.h>
92: #endif
93:
94: #ifdef HAVE_STRINGS_H
95: #include <strings.h>
96: #endif
97:
98: #ifdef HAVE_STDDEF_H
99: #include <stddef.h>
100: #endif
101:
102: #include "mbfilter.h"
103: #include "mbfl_filter_output.h"
104: #include "mbfilter_pass.h"
105: #include "filters/mbfilter_tl_jisx0201_jisx0208.h"
106:
107: #include "eaw_table.h"
108:
109: /* hex character table "0123456789ABCDEF" */
110: static char mbfl_hexchar_table[] = {
111: 0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x41,0x42,0x43,0x44,0x45,0x46
112: };
113:
114:
115:
116: /*
117: * encoding filter
118: */
119: #define CK(statement) do { if ((statement) < 0) return (-1); } while (0)
120:
121:
122: /*
123: * buffering converter
124: */
125: mbfl_buffer_converter *
126: mbfl_buffer_converter_new(
127: enum mbfl_no_encoding from,
128: enum mbfl_no_encoding to,
129: int buf_initsz)
130: {
131: mbfl_buffer_converter *convd;
132:
133: /* allocate */
134: convd = (mbfl_buffer_converter*)mbfl_malloc(sizeof (mbfl_buffer_converter));
135: if (convd == NULL) {
136: return NULL;
137: }
138:
139: /* initialize */
140: convd->from = mbfl_no2encoding(from);
141: convd->to = mbfl_no2encoding(to);
142: if (convd->from == NULL) {
143: convd->from = &mbfl_encoding_pass;
144: }
145: if (convd->to == NULL) {
146: convd->to = &mbfl_encoding_pass;
147: }
148:
149: /* create convert filter */
150: convd->filter1 = NULL;
151: convd->filter2 = NULL;
152: if (mbfl_convert_filter_get_vtbl(convd->from->no_encoding, convd->to->no_encoding) != NULL) {
153: convd->filter1 = mbfl_convert_filter_new(convd->from->no_encoding, convd->to->no_encoding, mbfl_memory_device_output, NULL, &convd->device);
154: } else {
155: convd->filter2 = mbfl_convert_filter_new(mbfl_no_encoding_wchar, convd->to->no_encoding, mbfl_memory_device_output, NULL, &convd->device);
156: if (convd->filter2 != NULL) {
157: convd->filter1 = mbfl_convert_filter_new(convd->from->no_encoding,
158: mbfl_no_encoding_wchar,
159: (int (*)(int, void*))convd->filter2->filter_function,
160: (int (*)(void*))convd->filter2->filter_flush,
161: convd->filter2);
162: if (convd->filter1 == NULL) {
163: mbfl_convert_filter_delete(convd->filter2);
164: }
165: }
166: }
167: if (convd->filter1 == NULL) {
168: return NULL;
169: }
170:
171: mbfl_memory_device_init(&convd->device, buf_initsz, buf_initsz/4);
172:
173: return convd;
174: }
175:
176: void
177: mbfl_buffer_converter_delete(mbfl_buffer_converter *convd)
178: {
179: if (convd != NULL) {
180: if (convd->filter1) {
181: mbfl_convert_filter_delete(convd->filter1);
182: }
183: if (convd->filter2) {
184: mbfl_convert_filter_delete(convd->filter2);
185: }
186: mbfl_memory_device_clear(&convd->device);
187: mbfl_free((void*)convd);
188: }
189: }
190:
191: void
192: mbfl_buffer_converter_reset(mbfl_buffer_converter *convd)
193: {
194: mbfl_memory_device_reset(&convd->device);
195: }
196:
197: int
198: mbfl_buffer_converter_illegal_mode(mbfl_buffer_converter *convd, int mode)
199: {
200: if (convd != NULL) {
201: if (convd->filter2 != NULL) {
202: convd->filter2->illegal_mode = mode;
203: } else if (convd->filter1 != NULL) {
204: convd->filter1->illegal_mode = mode;
205: } else {
206: return 0;
207: }
208: }
209:
210: return 1;
211: }
212:
213: int
214: mbfl_buffer_converter_illegal_substchar(mbfl_buffer_converter *convd, int substchar)
215: {
216: if (convd != NULL) {
217: if (convd->filter2 != NULL) {
218: convd->filter2->illegal_substchar = substchar;
219: } else if (convd->filter1 != NULL) {
220: convd->filter1->illegal_substchar = substchar;
221: } else {
222: return 0;
223: }
224: }
225:
226: return 1;
227: }
228:
229: int
230: mbfl_buffer_converter_strncat(mbfl_buffer_converter *convd, const unsigned char *p, int n)
231: {
232: mbfl_convert_filter *filter;
233: int (*filter_function)(int c, mbfl_convert_filter *filter);
234:
235: if (convd != NULL && p != NULL) {
236: filter = convd->filter1;
237: if (filter != NULL) {
238: filter_function = filter->filter_function;
239: while (n > 0) {
240: if ((*filter_function)(*p++, filter) < 0) {
241: break;
242: }
243: n--;
244: }
245: }
246: }
247:
248: return n;
249: }
250:
251: int
252: mbfl_buffer_converter_feed(mbfl_buffer_converter *convd, mbfl_string *string)
253: {
254: int n;
255: unsigned char *p;
256: mbfl_convert_filter *filter;
257: int (*filter_function)(int c, mbfl_convert_filter *filter);
258:
259: if (convd == NULL || string == NULL) {
260: return -1;
261: }
262: mbfl_memory_device_realloc(&convd->device, convd->device.pos + string->len, string->len/4);
263: /* feed data */
264: n = string->len;
265: p = string->val;
266: filter = convd->filter1;
267: if (filter != NULL) {
268: filter_function = filter->filter_function;
269: while (n > 0) {
270: if ((*filter_function)(*p++, filter) < 0) {
271: return -1;
272: }
273: n--;
274: }
275: }
276:
277: return 0;
278: }
279:
280: int
281: mbfl_buffer_converter_flush(mbfl_buffer_converter *convd)
282: {
283: if (convd == NULL) {
284: return -1;
285: }
286:
287: if (convd->filter1 != NULL) {
288: mbfl_convert_filter_flush(convd->filter1);
289: }
290: if (convd->filter2 != NULL) {
291: mbfl_convert_filter_flush(convd->filter2);
292: }
293:
294: return 0;
295: }
296:
297: mbfl_string *
298: mbfl_buffer_converter_getbuffer(mbfl_buffer_converter *convd, mbfl_string *result)
299: {
300: if (convd != NULL && result != NULL && convd->device.buffer != NULL) {
301: result->no_encoding = convd->to->no_encoding;
302: result->val = convd->device.buffer;
303: result->len = convd->device.pos;
304: } else {
305: result = NULL;
306: }
307:
308: return result;
309: }
310:
311: mbfl_string *
312: mbfl_buffer_converter_result(mbfl_buffer_converter *convd, mbfl_string *result)
313: {
314: if (convd == NULL || result == NULL) {
315: return NULL;
316: }
317: result->no_encoding = convd->to->no_encoding;
318: return mbfl_memory_device_result(&convd->device, result);
319: }
320:
321: mbfl_string *
322: mbfl_buffer_converter_feed_result(mbfl_buffer_converter *convd, mbfl_string *string,
323: mbfl_string *result)
324: {
325: if (convd == NULL || string == NULL || result == NULL) {
326: return NULL;
327: }
328: mbfl_buffer_converter_feed(convd, string);
329: if (convd->filter1 != NULL) {
330: mbfl_convert_filter_flush(convd->filter1);
331: }
332: if (convd->filter2 != NULL) {
333: mbfl_convert_filter_flush(convd->filter2);
334: }
335: result->no_encoding = convd->to->no_encoding;
336: return mbfl_memory_device_result(&convd->device, result);
337: }
338:
339: int mbfl_buffer_illegalchars(mbfl_buffer_converter *convd)
340: {
341: int num_illegalchars = 0;
342:
343: if (convd == NULL) {
344: return 0;
345: }
346:
347: if (convd->filter1 != NULL) {
348: num_illegalchars += convd->filter1->num_illegalchar;
349: }
350:
351: if (convd->filter2 != NULL) {
352: num_illegalchars += convd->filter2->num_illegalchar;
353: }
354:
355: return (num_illegalchars);
356: }
357:
358: /*
359: * encoding detector
360: */
361: mbfl_encoding_detector *
362: mbfl_encoding_detector_new(enum mbfl_no_encoding *elist, int elistsz, int strict)
363: {
364: mbfl_encoding_detector *identd;
365:
366: int i, num;
367: mbfl_identify_filter *filter;
368:
369: if (elist == NULL || elistsz <= 0) {
370: return NULL;
371: }
372:
373: /* allocate */
374: identd = (mbfl_encoding_detector*)mbfl_malloc(sizeof(mbfl_encoding_detector));
375: if (identd == NULL) {
376: return NULL;
377: }
378: identd->filter_list = (mbfl_identify_filter **)mbfl_calloc(elistsz, sizeof(mbfl_identify_filter *));
379: if (identd->filter_list == NULL) {
380: mbfl_free(identd);
381: return NULL;
382: }
383:
384: /* create filters */
385: i = 0;
386: num = 0;
387: while (i < elistsz) {
388: filter = mbfl_identify_filter_new(elist[i]);
389: if (filter != NULL) {
390: identd->filter_list[num] = filter;
391: num++;
392: }
393: i++;
394: }
395: identd->filter_list_size = num;
396:
397: /* set strict flag */
398: identd->strict = strict;
399:
400: return identd;
401: }
402:
403: void
404: mbfl_encoding_detector_delete(mbfl_encoding_detector *identd)
405: {
406: int i;
407:
408: if (identd != NULL) {
409: if (identd->filter_list != NULL) {
410: i = identd->filter_list_size;
411: while (i > 0) {
412: i--;
413: mbfl_identify_filter_delete(identd->filter_list[i]);
414: }
415: mbfl_free((void *)identd->filter_list);
416: }
417: mbfl_free((void *)identd);
418: }
419: }
420:
421: int
422: mbfl_encoding_detector_feed(mbfl_encoding_detector *identd, mbfl_string *string)
423: {
424: int i, n, num, bad, res;
425: unsigned char *p;
426: mbfl_identify_filter *filter;
427:
428: res = 0;
429: /* feed data */
430: if (identd != NULL && string != NULL && string->val != NULL) {
431: num = identd->filter_list_size;
432: n = string->len;
433: p = string->val;
434: bad = 0;
435: while (n > 0) {
436: for (i = 0; i < num; i++) {
437: filter = identd->filter_list[i];
438: if (!filter->flag) {
439: (*filter->filter_function)(*p, filter);
440: if (filter->flag) {
441: bad++;
442: }
443: }
444: }
445: if ((num - 1) <= bad) {
446: res = 1;
447: break;
448: }
449: p++;
450: n--;
451: }
452: }
453:
454: return res;
455: }
456:
457: enum mbfl_no_encoding mbfl_encoding_detector_judge(mbfl_encoding_detector *identd)
458: {
459: mbfl_identify_filter *filter;
460: enum mbfl_no_encoding encoding;
461: int n;
462:
463: /* judge */
464: encoding = mbfl_no_encoding_invalid;
465: if (identd != NULL) {
466: n = identd->filter_list_size - 1;
467: while (n >= 0) {
468: filter = identd->filter_list[n];
469: if (!filter->flag) {
470: if (!identd->strict || !filter->status) {
471: encoding = filter->encoding->no_encoding;
472: }
473: }
474: n--;
475: }
476:
477: /* fallback judge */
478: if (encoding == mbfl_no_encoding_invalid) {
479: n = identd->filter_list_size - 1;
480: while (n >= 0) {
481: filter = identd->filter_list[n];
482: if (!filter->flag) {
483: encoding = filter->encoding->no_encoding;
484: }
485: n--;
486: }
487: }
488: }
489:
490: return encoding;
491: }
492:
493:
494: /*
495: * encoding converter
496: */
497: mbfl_string *
498: mbfl_convert_encoding(
499: mbfl_string *string,
500: mbfl_string *result,
501: enum mbfl_no_encoding toenc)
502: {
503: int n;
504: unsigned char *p;
505: const mbfl_encoding *encoding;
506: mbfl_memory_device device;
507: mbfl_convert_filter *filter1;
508: mbfl_convert_filter *filter2;
509:
510: /* initialize */
511: encoding = mbfl_no2encoding(toenc);
512: if (encoding == NULL || string == NULL || result == NULL) {
513: return NULL;
514: }
515:
516: filter1 = NULL;
517: filter2 = NULL;
518: if (mbfl_convert_filter_get_vtbl(string->no_encoding, toenc) != NULL) {
519: filter1 = mbfl_convert_filter_new(string->no_encoding, toenc, mbfl_memory_device_output, 0, &device);
520: } else {
521: filter2 = mbfl_convert_filter_new(mbfl_no_encoding_wchar, toenc, mbfl_memory_device_output, 0, &device);
522: if (filter2 != NULL) {
523: filter1 = mbfl_convert_filter_new(string->no_encoding, mbfl_no_encoding_wchar, (int (*)(int, void*))filter2->filter_function, NULL, filter2);
524: if (filter1 == NULL) {
525: mbfl_convert_filter_delete(filter2);
526: }
527: }
528: }
529: if (filter1 == NULL) {
530: return NULL;
531: }
532:
533: if (filter2 != NULL) {
534: filter2->illegal_mode = MBFL_OUTPUTFILTER_ILLEGAL_MODE_CHAR;
535: filter2->illegal_substchar = 0x3f; /* '?' */
536: }
537:
538: mbfl_memory_device_init(&device, string->len, (string->len >> 2) + 8);
539:
540: /* feed data */
541: n = string->len;
542: p = string->val;
543: if (p != NULL) {
544: while (n > 0) {
545: if ((*filter1->filter_function)(*p++, filter1) < 0) {
546: break;
547: }
548: n--;
549: }
550: }
551:
552: mbfl_convert_filter_flush(filter1);
553: mbfl_convert_filter_delete(filter1);
554: if (filter2 != NULL) {
555: mbfl_convert_filter_flush(filter2);
556: mbfl_convert_filter_delete(filter2);
557: }
558:
559: return mbfl_memory_device_result(&device, result);
560: }
561:
562:
563: /*
564: * identify encoding
565: */
566: const mbfl_encoding *
567: mbfl_identify_encoding(mbfl_string *string, enum mbfl_no_encoding *elist, int elistsz, int strict)
568: {
569: int i, n, num, bad;
570: unsigned char *p;
571: mbfl_identify_filter *flist, *filter;
572: const mbfl_encoding *encoding;
573:
574: /* flist is an array of mbfl_identify_filter instances */
575: flist = (mbfl_identify_filter *)mbfl_calloc(elistsz, sizeof(mbfl_identify_filter));
576: if (flist == NULL) {
577: return NULL;
578: }
579:
580: num = 0;
581: if (elist != NULL) {
582: for (i = 0; i < elistsz; i++) {
583: if (!mbfl_identify_filter_init(&flist[num], elist[i])) {
584: num++;
585: }
586: }
587: }
588:
589: /* feed data */
590: n = string->len;
591: p = string->val;
592:
593: if (p != NULL) {
594: bad = 0;
595: while (n > 0) {
596: for (i = 0; i < num; i++) {
597: filter = &flist[i];
598: if (!filter->flag) {
599: (*filter->filter_function)(*p, filter);
600: if (filter->flag) {
601: bad++;
602: }
603: }
604: }
605: if ((num - 1) <= bad && !strict) {
606: break;
607: }
608: p++;
609: n--;
610: }
611: }
612:
613: /* judge */
614: encoding = NULL;
615:
616: for (i = 0; i < num; i++) {
617: filter = &flist[i];
618: if (!filter->flag) {
619: if (strict && filter->status) {
620: continue;
621: }
622: encoding = filter->encoding;
623: break;
624: }
625: }
626:
627: /* fall-back judge */
628: if (!encoding) {
629: for (i = 0; i < num; i++) {
630: filter = &flist[i];
631: if (!filter->flag && (!strict || !filter->status)) {
632: encoding = filter->encoding;
633: break;
634: }
635: }
636: }
637:
638: /* cleanup */
639: /* dtors should be called in reverse order */
640: i = num; while (--i >= 0) {
641: mbfl_identify_filter_cleanup(&flist[i]);
642: }
643:
644: mbfl_free((void *)flist);
645:
646: return encoding;
647: }
648:
649: const char*
650: mbfl_identify_encoding_name(mbfl_string *string, enum mbfl_no_encoding *elist, int elistsz, int strict)
651: {
652: const mbfl_encoding *encoding;
653:
654: encoding = mbfl_identify_encoding(string, elist, elistsz, strict);
655: if (encoding != NULL &&
656: encoding->no_encoding > mbfl_no_encoding_charset_min &&
657: encoding->no_encoding < mbfl_no_encoding_charset_max) {
658: return encoding->name;
659: } else {
660: return NULL;
661: }
662: }
663:
664: enum mbfl_no_encoding
665: mbfl_identify_encoding_no(mbfl_string *string, enum mbfl_no_encoding *elist, int elistsz, int strict)
666: {
667: const mbfl_encoding *encoding;
668:
669: encoding = mbfl_identify_encoding(string, elist, elistsz, strict);
670: if (encoding != NULL &&
671: encoding->no_encoding > mbfl_no_encoding_charset_min &&
672: encoding->no_encoding < mbfl_no_encoding_charset_max) {
673: return encoding->no_encoding;
674: } else {
675: return mbfl_no_encoding_invalid;
676: }
677: }
678:
679:
680: /*
681: * strlen
682: */
683: static int
684: filter_count_output(int c, void *data)
685: {
686: (*(int *)data)++;
687: return c;
688: }
689:
690: int
691: mbfl_strlen(mbfl_string *string)
692: {
693: int len, n, m, k;
694: unsigned char *p;
695: const unsigned char *mbtab;
696: const mbfl_encoding *encoding;
697:
698: encoding = mbfl_no2encoding(string->no_encoding);
699: if (encoding == NULL || string == NULL) {
700: return -1;
701: }
702:
703: len = 0;
704: if (encoding->flag & MBFL_ENCTYPE_SBCS) {
705: len = string->len;
706: } else if (encoding->flag & (MBFL_ENCTYPE_WCS2BE | MBFL_ENCTYPE_WCS2LE)) {
707: len = string->len/2;
708: } else if (encoding->flag & (MBFL_ENCTYPE_WCS4BE | MBFL_ENCTYPE_WCS4LE)) {
709: len = string->len/4;
710: } else if (encoding->mblen_table != NULL) {
711: mbtab = encoding->mblen_table;
712: n = 0;
713: p = string->val;
714: k = string->len;
715: /* count */
716: if (p != NULL) {
717: while (n < k) {
718: m = mbtab[*p];
719: n += m;
720: p += m;
721: len++;
722: };
723: }
724: } else {
725: /* wchar filter */
726: mbfl_convert_filter *filter = mbfl_convert_filter_new(
727: string->no_encoding,
728: mbfl_no_encoding_wchar,
729: filter_count_output, 0, &len);
730: if (filter == NULL) {
731: return -1;
732: }
733: /* count */
734: n = string->len;
735: p = string->val;
736: if (p != NULL) {
737: while (n > 0) {
738: (*filter->filter_function)(*p++, filter);
739: n--;
740: }
741: }
742: mbfl_convert_filter_delete(filter);
743: }
744:
745: return len;
746: }
747:
748:
749: /*
750: * strpos
751: */
752: struct collector_strpos_data {
753: mbfl_convert_filter *next_filter;
754: mbfl_wchar_device needle;
755: int needle_len;
756: int start;
757: int output;
758: int found_pos;
759: int needle_pos;
760: int matched_pos;
761: };
762:
763: static int
764: collector_strpos(int c, void* data)
765: {
766: int *p, *h, *m, n;
767: struct collector_strpos_data *pc = (struct collector_strpos_data*)data;
768:
769: if (pc->output >= pc->start) {
770: if (c == (int)pc->needle.buffer[pc->needle_pos]) {
771: if (pc->needle_pos == 0) {
772: pc->found_pos = pc->output; /* found position */
773: }
774: pc->needle_pos++; /* needle pointer */
775: if (pc->needle_pos >= pc->needle_len) {
776: pc->matched_pos = pc->found_pos; /* matched position */
777: pc->needle_pos--;
778: goto retry;
779: }
780: } else if (pc->needle_pos != 0) {
781: retry:
782: h = (int *)pc->needle.buffer;
783: h++;
784: for (;;) {
785: pc->found_pos++;
786: p = h;
787: m = (int *)pc->needle.buffer;
788: n = pc->needle_pos - 1;
789: while (n > 0 && *p == *m) {
790: n--;
791: p++;
792: m++;
793: }
794: if (n <= 0) {
795: if (*m != c) {
796: pc->needle_pos = 0;
797: }
798: break;
799: } else {
800: h++;
801: pc->needle_pos--;
802: }
803: }
804: }
805: }
806:
807: pc->output++;
808: return c;
809: }
810:
811: /*
812: * oddlen
813: */
814: int
815: mbfl_oddlen(mbfl_string *string)
816: {
817: int len, n, m, k;
818: unsigned char *p;
819: const unsigned char *mbtab;
820: const mbfl_encoding *encoding;
821:
822:
823: if (string == NULL) {
824: return -1;
825: }
826: encoding = mbfl_no2encoding(string->no_encoding);
827: if (encoding == NULL) {
828: return -1;
829: }
830:
831: len = 0;
832: if (encoding->flag & MBFL_ENCTYPE_SBCS) {
833: return 0;
834: } else if (encoding->flag & (MBFL_ENCTYPE_WCS2BE | MBFL_ENCTYPE_WCS2LE)) {
835: return len % 2;
836: } else if (encoding->flag & (MBFL_ENCTYPE_WCS4BE | MBFL_ENCTYPE_WCS4LE)) {
837: return len % 4;
838: } else if (encoding->mblen_table != NULL) {
839: mbtab = encoding->mblen_table;
840: n = 0;
841: p = string->val;
842: k = string->len;
843: /* count */
844: if (p != NULL) {
845: while (n < k) {
846: m = mbtab[*p];
847: n += m;
848: p += m;
849: };
850: }
851: return n-k;
852: } else {
853: /* how can i do ? */
854: return 0;
855: }
856: /* NOT REACHED */
857: }
858:
859: int
860: mbfl_strpos(
861: mbfl_string *haystack,
862: mbfl_string *needle,
863: int offset,
864: int reverse)
865: {
866: int result;
867: mbfl_string _haystack_u8, _needle_u8;
868: const mbfl_string *haystack_u8, *needle_u8;
869: const unsigned char *u8_tbl;
870:
871: if (haystack == NULL || haystack->val == NULL || needle == NULL || needle->val == NULL) {
872: return -8;
873: }
874:
875: {
876: const mbfl_encoding *u8_enc;
877: u8_enc = mbfl_no2encoding(mbfl_no_encoding_utf8);
878: if (u8_enc == NULL || u8_enc->mblen_table == NULL) {
879: return -8;
880: }
881: u8_tbl = u8_enc->mblen_table;
882: }
883:
884: if (haystack->no_encoding != mbfl_no_encoding_utf8) {
885: mbfl_string_init(&_haystack_u8);
886: haystack_u8 = mbfl_convert_encoding(haystack, &_haystack_u8, mbfl_no_encoding_utf8);
887: if (haystack_u8 == NULL) {
888: result = -4;
889: goto out;
890: }
891: } else {
892: haystack_u8 = haystack;
893: }
894:
895: if (needle->no_encoding != mbfl_no_encoding_utf8) {
896: mbfl_string_init(&_needle_u8);
897: needle_u8 = mbfl_convert_encoding(needle, &_needle_u8, mbfl_no_encoding_utf8);
898: if (needle_u8 == NULL) {
899: result = -4;
900: goto out;
901: }
902: } else {
903: needle_u8 = needle;
904: }
905:
906: if (needle_u8->len < 1) {
907: result = -8;
908: goto out;
909: }
910:
911: result = -1;
912: if (haystack_u8->len < needle_u8->len) {
913: goto out;
914: }
915:
916: if (!reverse) {
917: unsigned int jtbl[1 << (sizeof(unsigned char) * 8)];
918: unsigned int needle_u8_len = needle_u8->len;
919: unsigned int i;
920: const unsigned char *p, *q, *e;
921: const unsigned char *haystack_u8_val = haystack_u8->val,
922: *needle_u8_val = needle_u8->val;
923: for (i = 0; i < sizeof(jtbl) / sizeof(*jtbl); ++i) {
924: jtbl[i] = needle_u8_len + 1;
925: }
926: for (i = 0; i < needle_u8_len - 1; ++i) {
927: jtbl[needle_u8_val[i]] = needle_u8_len - i;
928: }
929: e = haystack_u8_val + haystack_u8->len;
930: p = haystack_u8_val;
931: while (--offset >= 0) {
932: if (p >= e) {
933: result = -16;
934: goto out;
935: }
936: p += u8_tbl[*p];
937: }
938: p += needle_u8_len;
939: if (p > e) {
940: goto out;
941: }
942: while (p <= e) {
943: const unsigned char *pv = p;
944: q = needle_u8_val + needle_u8_len;
945: for (;;) {
946: if (q == needle_u8_val) {
947: result = 0;
948: while (p > haystack_u8_val) {
949: unsigned char c = *--p;
950: if (c < 0x80) {
951: ++result;
952: } else if ((c & 0xc0) != 0x80) {
953: ++result;
954: }
955: }
956: goto out;
957: }
958: if (*--q != *--p) {
959: break;
960: }
961: }
962: p += jtbl[*p];
963: if (p <= pv) {
964: p = pv + 1;
965: }
966: }
967: } else {
968: unsigned int jtbl[1 << (sizeof(unsigned char) * 8)];
969: unsigned int needle_u8_len = needle_u8->len, needle_len = 0;
970: unsigned int i;
971: const unsigned char *p, *e, *q, *qe;
972: const unsigned char *haystack_u8_val = haystack_u8->val,
973: *needle_u8_val = needle_u8->val;
974: for (i = 0; i < sizeof(jtbl) / sizeof(*jtbl); ++i) {
975: jtbl[i] = needle_u8_len;
976: }
977: for (i = needle_u8_len - 1; i > 0; --i) {
978: unsigned char c = needle_u8_val[i];
979: jtbl[c] = i;
980: if (c < 0x80) {
981: ++needle_len;
982: } else if ((c & 0xc0) != 0x80) {
983: ++needle_len;
984: }
985: }
986: {
987: unsigned char c = needle_u8_val[0];
988: if (c < 0x80) {
989: ++needle_len;
990: } else if ((c & 0xc0) != 0x80) {
991: ++needle_len;
992: }
993: }
994: e = haystack_u8_val;
995: p = e + haystack_u8->len;
996: qe = needle_u8_val + needle_u8_len;
997: if (offset < 0) {
998: if (-offset > needle_len) {
999: offset += needle_len;
1000: while (offset < 0) {
1001: unsigned char c;
1002: if (p <= e) {
1003: result = -16;
1004: goto out;
1005: }
1006: c = *(--p);
1007: if (c < 0x80) {
1008: ++offset;
1009: } else if ((c & 0xc0) != 0x80) {
1010: ++offset;
1011: }
1012: }
1013: }
1014: } else {
1015: const unsigned char *ee = haystack_u8_val + haystack_u8->len;
1016: while (--offset >= 0) {
1017: if (e >= ee) {
1018: result = -16;
1019: goto out;
1020: }
1021: e += u8_tbl[*e];
1022: }
1023: }
1024: if (p < e + needle_u8_len) {
1025: goto out;
1026: }
1027: p -= needle_u8_len;
1028: while (p >= e) {
1029: const unsigned char *pv = p;
1030: q = needle_u8_val;
1031: for (;;) {
1032: if (q == qe) {
1033: result = 0;
1034: p -= needle_u8_len;
1035: while (p > haystack_u8_val) {
1036: unsigned char c = *--p;
1037: if (c < 0x80) {
1038: ++result;
1039: } else if ((c & 0xc0) != 0x80) {
1040: ++result;
1041: }
1042: }
1043: goto out;
1044: }
1045: if (*q != *p) {
1046: break;
1047: }
1048: ++p, ++q;
1049: }
1050: p -= jtbl[*p];
1051: if (p >= pv) {
1052: p = pv - 1;
1053: }
1054: }
1055: }
1056: out:
1057: if (haystack_u8 == &_haystack_u8) {
1058: mbfl_string_clear(&_haystack_u8);
1059: }
1060: if (needle_u8 == &_needle_u8) {
1061: mbfl_string_clear(&_needle_u8);
1062: }
1063: return result;
1064: }
1065:
1066: /*
1067: * substr_count
1068: */
1069:
1070: int
1071: mbfl_substr_count(
1072: mbfl_string *haystack,
1073: mbfl_string *needle
1074: )
1075: {
1076: int n, result = 0;
1077: unsigned char *p;
1078: mbfl_convert_filter *filter;
1079: struct collector_strpos_data pc;
1080:
1081: if (haystack == NULL || needle == NULL) {
1082: return -8;
1083: }
1084: /* needle is converted into wchar */
1085: mbfl_wchar_device_init(&pc.needle);
1086: filter = mbfl_convert_filter_new(
1087: needle->no_encoding,
1088: mbfl_no_encoding_wchar,
1089: mbfl_wchar_device_output, 0, &pc.needle);
1090: if (filter == NULL) {
1091: return -4;
1092: }
1093: p = needle->val;
1094: n = needle->len;
1095: if (p != NULL) {
1096: while (n > 0) {
1097: if ((*filter->filter_function)(*p++, filter) < 0) {
1098: break;
1099: }
1100: n--;
1101: }
1102: }
1103: mbfl_convert_filter_flush(filter);
1104: mbfl_convert_filter_delete(filter);
1105: pc.needle_len = pc.needle.pos;
1106: if (pc.needle.buffer == NULL) {
1107: return -4;
1108: }
1109: if (pc.needle_len <= 0) {
1110: mbfl_wchar_device_clear(&pc.needle);
1111: return -2;
1112: }
1113: /* initialize filter and collector data */
1114: filter = mbfl_convert_filter_new(
1115: haystack->no_encoding,
1116: mbfl_no_encoding_wchar,
1117: collector_strpos, 0, &pc);
1118: if (filter == NULL) {
1119: mbfl_wchar_device_clear(&pc.needle);
1120: return -4;
1121: }
1122: pc.start = 0;
1123: pc.output = 0;
1124: pc.needle_pos = 0;
1125: pc.found_pos = 0;
1126: pc.matched_pos = -1;
1127:
1128: /* feed data */
1129: p = haystack->val;
1130: n = haystack->len;
1131: if (p != NULL) {
1132: while (n > 0) {
1133: if ((*filter->filter_function)(*p++, filter) < 0) {
1134: pc.matched_pos = -4;
1135: break;
1136: }
1137: if (pc.matched_pos >= 0) {
1138: ++result;
1139: pc.matched_pos = -1;
1140: pc.needle_pos = 0;
1141: }
1142: n--;
1143: }
1144: }
1145: mbfl_convert_filter_flush(filter);
1146: mbfl_convert_filter_delete(filter);
1147: mbfl_wchar_device_clear(&pc.needle);
1148:
1149: return result;
1150: }
1151:
1152: /*
1153: * substr
1154: */
1155: struct collector_substr_data {
1156: mbfl_convert_filter *next_filter;
1157: int start;
1158: int stop;
1159: int output;
1160: };
1161:
1162: static int
1163: collector_substr(int c, void* data)
1164: {
1165: struct collector_substr_data *pc = (struct collector_substr_data*)data;
1166:
1167: if (pc->output >= pc->stop) {
1168: return -1;
1169: }
1170:
1171: if (pc->output >= pc->start) {
1172: (*pc->next_filter->filter_function)(c, pc->next_filter);
1173: }
1174:
1175: pc->output++;
1176:
1177: return c;
1178: }
1179:
1180: mbfl_string *
1181: mbfl_substr(
1182: mbfl_string *string,
1183: mbfl_string *result,
1184: int from,
1185: int length)
1186: {
1187: const mbfl_encoding *encoding;
1188: int n, m, k, len, start, end;
1189: unsigned char *p, *w;
1190: const unsigned char *mbtab;
1191:
1192: encoding = mbfl_no2encoding(string->no_encoding);
1193: if (encoding == NULL || string == NULL || result == NULL) {
1194: return NULL;
1195: }
1196: mbfl_string_init(result);
1197: result->no_language = string->no_language;
1198: result->no_encoding = string->no_encoding;
1199:
1200: if ((encoding->flag & (MBFL_ENCTYPE_SBCS | MBFL_ENCTYPE_WCS2BE | MBFL_ENCTYPE_WCS2LE | MBFL_ENCTYPE_WCS4BE | MBFL_ENCTYPE_WCS4LE)) ||
1201: encoding->mblen_table != NULL) {
1202: len = string->len;
1203: start = from;
1204: end = from + length;
1205: if (encoding->flag & (MBFL_ENCTYPE_WCS2BE | MBFL_ENCTYPE_WCS2LE)) {
1206: start *= 2;
1207: end = start + length*2;
1208: } else if (encoding->flag & (MBFL_ENCTYPE_WCS4BE | MBFL_ENCTYPE_WCS4LE)) {
1209: start *= 4;
1210: end = start + length*4;
1211: } else if (encoding->mblen_table != NULL) {
1212: mbtab = encoding->mblen_table;
1213: start = 0;
1214: end = 0;
1215: n = 0;
1216: k = 0;
1217: p = string->val;
1218: if (p != NULL) {
1219: /* search start position */
1220: while (k <= from) {
1221: start = n;
1222: if (n >= len) {
1223: break;
1224: }
1225: m = mbtab[*p];
1226: n += m;
1227: p += m;
1228: k++;
1229: }
1230: /* detect end position */
1231: k = 0;
1232: end = start;
1233: while (k < length) {
1234: end = n;
1235: if (n >= len) {
1236: break;
1237: }
1238: m = mbtab[*p];
1239: n += m;
1240: p += m;
1241: k++;
1242: }
1243: }
1244: }
1245:
1246: if (start > len) {
1247: start = len;
1248: }
1249: if (start < 0) {
1250: start = 0;
1251: }
1252: if (end > len) {
1253: end = len;
1254: }
1255: if (end < 0) {
1256: end = 0;
1257: }
1258: if (start > end) {
1259: start = end;
1260: }
1261:
1262: /* allocate memory and copy */
1263: n = end - start;
1264: result->len = 0;
1265: result->val = w = (unsigned char*)mbfl_malloc((n + 8)*sizeof(unsigned char));
1266: if (w != NULL) {
1267: p = string->val;
1268: if (p != NULL) {
1269: p += start;
1270: result->len = n;
1271: while (n > 0) {
1272: *w++ = *p++;
1273: n--;
1274: }
1275: }
1276: *w++ = '\0';
1277: *w++ = '\0';
1278: *w++ = '\0';
1279: *w = '\0';
1280: } else {
1281: result = NULL;
1282: }
1283: } else {
1284: mbfl_memory_device device;
1285: struct collector_substr_data pc;
1286: mbfl_convert_filter *decoder;
1287: mbfl_convert_filter *encoder;
1288:
1289: mbfl_memory_device_init(&device, length + 1, 0);
1290: mbfl_string_init(result);
1291: result->no_language = string->no_language;
1292: result->no_encoding = string->no_encoding;
1293: /* output code filter */
1294: decoder = mbfl_convert_filter_new(
1295: mbfl_no_encoding_wchar,
1296: string->no_encoding,
1297: mbfl_memory_device_output, 0, &device);
1298: /* wchar filter */
1299: encoder = mbfl_convert_filter_new(
1300: string->no_encoding,
1301: mbfl_no_encoding_wchar,
1302: collector_substr, 0, &pc);
1303: if (decoder == NULL || encoder == NULL) {
1304: mbfl_convert_filter_delete(encoder);
1305: mbfl_convert_filter_delete(decoder);
1306: return NULL;
1307: }
1308: pc.next_filter = decoder;
1309: pc.start = from;
1310: pc.stop = from + length;
1311: pc.output = 0;
1312:
1313: /* feed data */
1314: p = string->val;
1315: n = string->len;
1316: if (p != NULL) {
1317: while (n > 0) {
1318: if ((*encoder->filter_function)(*p++, encoder) < 0) {
1319: break;
1320: }
1321: n--;
1322: }
1323: }
1324:
1325: mbfl_convert_filter_flush(encoder);
1326: mbfl_convert_filter_flush(decoder);
1327: result = mbfl_memory_device_result(&device, result);
1328: mbfl_convert_filter_delete(encoder);
1329: mbfl_convert_filter_delete(decoder);
1330: }
1331:
1332: return result;
1333: }
1334:
1335: /*
1336: * strcut
1337: */
1338: mbfl_string *
1339: mbfl_strcut(
1340: mbfl_string *string,
1341: mbfl_string *result,
1342: int from,
1343: int length)
1344: {
1345: const mbfl_encoding *encoding;
1346: mbfl_memory_device device;
1347:
1348: /* validate the parameters */
1349: if (string == NULL || string->val == NULL || result == NULL) {
1350: return NULL;
1351: }
1352:
1353: if (from < 0 || length < 0) {
1354: return NULL;
1355: }
1356:
1357: if (from >= string->len) {
1358: from = string->len;
1359: }
1360:
1361: encoding = mbfl_no2encoding(string->no_encoding);
1362: if (encoding == NULL) {
1363: return NULL;
1364: }
1365:
1366: mbfl_string_init(result);
1367: result->no_language = string->no_language;
1368: result->no_encoding = string->no_encoding;
1369:
1370: if ((encoding->flag & (MBFL_ENCTYPE_SBCS
1371: | MBFL_ENCTYPE_WCS2BE
1372: | MBFL_ENCTYPE_WCS2LE
1373: | MBFL_ENCTYPE_WCS4BE
1374: | MBFL_ENCTYPE_WCS4LE))
1375: || encoding->mblen_table != NULL) {
1376: const unsigned char *start = NULL;
1377: const unsigned char *end = NULL;
1378: unsigned char *w;
1379: unsigned int sz;
1380:
1381: if (encoding->flag & (MBFL_ENCTYPE_WCS2BE | MBFL_ENCTYPE_WCS2LE)) {
1382: from &= -2;
1383:
1384: if (from + length >= string->len) {
1385: length = string->len - from;
1386: }
1387:
1388: start = string->val + from;
1389: end = start + (length & -2);
1390: } else if (encoding->flag & (MBFL_ENCTYPE_WCS4BE | MBFL_ENCTYPE_WCS4LE)) {
1391: from &= -4;
1392:
1393: if (from + length >= string->len) {
1394: length = string->len - from;
1395: }
1396:
1397: start = string->val + from;
1398: end = start + (length & -4);
1399: } else if ((encoding->flag & MBFL_ENCTYPE_SBCS)) {
1400: if (from + length >= string->len) {
1401: length = string->len - from;
1402: }
1403:
1404: start = string->val + from;
1405: end = start + length;
1406: } else if (encoding->mblen_table != NULL) {
1407: const unsigned char *mbtab = encoding->mblen_table;
1408: const unsigned char *p, *q;
1409: int m;
1410:
1411: /* search start position */
1412: for (m = 0, p = string->val, q = p + from;
1413: p < q; p += (m = mbtab[*p]));
1414:
1415: if (p > q) {
1416: p -= m;
1417: }
1418:
1419: start = p;
1420:
1421: /* search end position */
1422: if ((start - string->val) + length >= (int)string->len) {
1423: end = string->val + string->len;
1424: } else {
1425: for (q = p + length; p < q; p += (m = mbtab[*p]));
1426:
1427: if (p > q) {
1428: p -= m;
1429: }
1430: end = p;
1431: }
1432: } else {
1433: /* never reached */
1434: return NULL;
1435: }
1436:
1437: /* allocate memory and copy string */
1438: sz = end - start;
1439: if ((w = (unsigned char*)mbfl_calloc(sz + 8,
1440: sizeof(unsigned char))) == NULL) {
1441: return NULL;
1442: }
1443:
1444: memcpy(w, start, sz);
1445: w[sz] = '\0';
1446: w[sz + 1] = '\0';
1447: w[sz + 2] = '\0';
1448: w[sz + 3] = '\0';
1449:
1450: result->val = w;
1451: result->len = sz;
1452: } else {
1453: mbfl_convert_filter *encoder = NULL;
1454: mbfl_convert_filter *decoder = NULL;
1455: const unsigned char *p, *q, *r;
1456: struct {
1457: mbfl_convert_filter encoder;
1458: mbfl_convert_filter decoder;
1459: const unsigned char *p;
1460: int pos;
1461: } bk, _bk;
1462:
1463: /* output code filter */
1464: if (!(decoder = mbfl_convert_filter_new(
1465: mbfl_no_encoding_wchar,
1466: string->no_encoding,
1467: mbfl_memory_device_output, 0, &device))) {
1468: return NULL;
1469: }
1470:
1471: /* wchar filter */
1472: if (!(encoder = mbfl_convert_filter_new(
1473: string->no_encoding,
1474: mbfl_no_encoding_wchar,
1475: mbfl_filter_output_null,
1476: NULL, NULL))) {
1477: mbfl_convert_filter_delete(decoder);
1478: return NULL;
1479: }
1480:
1481: mbfl_memory_device_init(&device, length + 8, 0);
1482:
1483: p = string->val;
1484:
1485: /* search start position */
1486: for (q = string->val + from; p < q; p++) {
1487: (*encoder->filter_function)(*p, encoder);
1488: }
1489:
1490: /* switch the drain direction */
1491: encoder->output_function = (int(*)(int,void *))decoder->filter_function;
1492: encoder->flush_function = (int(*)(void *))decoder->filter_flush;
1493: encoder->data = decoder;
1494:
1495: q = string->val + string->len;
1496:
1497: /* save the encoder, decoder state and the pointer */
1498: mbfl_convert_filter_copy(decoder, &_bk.decoder);
1499: mbfl_convert_filter_copy(encoder, &_bk.encoder);
1500: _bk.p = p;
1501: _bk.pos = device.pos;
1502:
1503: if (length > q - p) {
1504: length = q - p;
1505: }
1506:
1507: if (length >= 20) {
1508: /* output a little shorter than "length" */
1509: /* XXX: the constant "20" was determined purely on the heuristics. */
1510: for (r = p + length - 20; p < r; p++) {
1511: (*encoder->filter_function)(*p, encoder);
1512: }
1513:
1514: /* if the offset of the resulting string exceeds the length,
1515: * then restore the state */
1516: if (device.pos > length) {
1517: p = _bk.p;
1518: device.pos = _bk.pos;
1519: decoder->filter_dtor(decoder);
1520: encoder->filter_dtor(encoder);
1521: mbfl_convert_filter_copy(&_bk.decoder, decoder);
1522: mbfl_convert_filter_copy(&_bk.encoder, encoder);
1523: bk = _bk;
1524: } else {
1525: /* save the encoder, decoder state and the pointer */
1526: mbfl_convert_filter_copy(decoder, &bk.decoder);
1527: mbfl_convert_filter_copy(encoder, &bk.encoder);
1528: bk.p = p;
1529: bk.pos = device.pos;
1530:
1531: /* flush the stream */
1532: (*encoder->filter_flush)(encoder);
1533:
1534: /* if the offset of the resulting string exceeds the length,
1535: * then restore the state */
1536: if (device.pos > length) {
1537: bk.decoder.filter_dtor(&bk.decoder);
1538: bk.encoder.filter_dtor(&bk.encoder);
1539:
1540: p = _bk.p;
1541: device.pos = _bk.pos;
1542: decoder->filter_dtor(decoder);
1543: encoder->filter_dtor(encoder);
1544: mbfl_convert_filter_copy(&_bk.decoder, decoder);
1545: mbfl_convert_filter_copy(&_bk.encoder, encoder);
1546: bk = _bk;
1547: } else {
1548: _bk.decoder.filter_dtor(&_bk.decoder);
1549: _bk.encoder.filter_dtor(&_bk.encoder);
1550:
1551: p = bk.p;
1552: device.pos = bk.pos;
1553: decoder->filter_dtor(decoder);
1554: encoder->filter_dtor(encoder);
1555: mbfl_convert_filter_copy(&bk.decoder, decoder);
1556: mbfl_convert_filter_copy(&bk.encoder, encoder);
1557: }
1558: }
1559: } else {
1560: bk = _bk;
1561: }
1562:
1563: /* detect end position */
1564: while (p < q) {
1565: (*encoder->filter_function)(*p, encoder);
1566:
1567: if (device.pos > length) {
1568: /* restore filter */
1569: p = bk.p;
1570: device.pos = bk.pos;
1571: decoder->filter_dtor(decoder);
1572: encoder->filter_dtor(encoder);
1573: mbfl_convert_filter_copy(&bk.decoder, decoder);
1574: mbfl_convert_filter_copy(&bk.encoder, encoder);
1575: break;
1576: }
1577:
1578: p++;
1579:
1580: /* backup current state */
1581: mbfl_convert_filter_copy(decoder, &_bk.decoder);
1582: mbfl_convert_filter_copy(encoder, &_bk.encoder);
1583: _bk.pos = device.pos;
1584: _bk.p = p;
1585:
1586: (*encoder->filter_flush)(encoder);
1587:
1588: if (device.pos > length) {
1589: _bk.decoder.filter_dtor(&_bk.decoder);
1590: _bk.encoder.filter_dtor(&_bk.encoder);
1591:
1592: /* restore filter */
1593: p = bk.p;
1594: device.pos = bk.pos;
1595: decoder->filter_dtor(decoder);
1596: encoder->filter_dtor(encoder);
1597: mbfl_convert_filter_copy(&bk.decoder, decoder);
1598: mbfl_convert_filter_copy(&bk.encoder, encoder);
1599: break;
1600: }
1601:
1602: bk.decoder.filter_dtor(&bk.decoder);
1603: bk.encoder.filter_dtor(&bk.encoder);
1604:
1605: p = _bk.p;
1606: device.pos = _bk.pos;
1607: decoder->filter_dtor(decoder);
1608: encoder->filter_dtor(encoder);
1609: mbfl_convert_filter_copy(&_bk.decoder, decoder);
1610: mbfl_convert_filter_copy(&_bk.encoder, encoder);
1611:
1612: bk = _bk;
1613: }
1614:
1615: (*encoder->filter_flush)(encoder);
1616:
1617: bk.decoder.filter_dtor(&bk.decoder);
1618: bk.encoder.filter_dtor(&bk.encoder);
1619:
1620: result = mbfl_memory_device_result(&device, result);
1621:
1622: mbfl_convert_filter_delete(encoder);
1623: mbfl_convert_filter_delete(decoder);
1624: }
1625:
1626: return result;
1627: }
1628:
1629:
1630: /*
1631: * strwidth
1632: */
1633: static int is_fullwidth(int c)
1634: {
1635: int i;
1636:
1637: if (c < mbfl_eaw_table[0].begin) {
1638: return 0;
1639: }
1640:
1641: for (i = 0; i < sizeof(mbfl_eaw_table) / sizeof(mbfl_eaw_table[0]); i++) {
1642: if (mbfl_eaw_table[i].begin <= c && c <= mbfl_eaw_table[i].end) {
1643: return 1;
1644: }
1645: }
1646:
1647: return 0;
1648: }
1649:
1650: static int
1651: filter_count_width(int c, void* data)
1652: {
1653: (*(int *)data) += (is_fullwidth(c) ? 2: 1);
1654: return c;
1655: }
1656:
1657: int
1658: mbfl_strwidth(mbfl_string *string)
1659: {
1660: int len, n;
1661: unsigned char *p;
1662: mbfl_convert_filter *filter;
1663:
1664: len = 0;
1665: if (string->len > 0 && string->val != NULL) {
1666: /* wchar filter */
1667: filter = mbfl_convert_filter_new(
1668: string->no_encoding,
1669: mbfl_no_encoding_wchar,
1670: filter_count_width, 0, &len);
1671: if (filter == NULL) {
1672: mbfl_convert_filter_delete(filter);
1673: return -1;
1674: }
1675:
1676: /* feed data */
1677: p = string->val;
1678: n = string->len;
1679: while (n > 0) {
1680: (*filter->filter_function)(*p++, filter);
1681: n--;
1682: }
1683:
1684: mbfl_convert_filter_flush(filter);
1685: mbfl_convert_filter_delete(filter);
1686: }
1687:
1688: return len;
1689: }
1690:
1691:
1692: /*
1693: * strimwidth
1694: */
1695: struct collector_strimwidth_data {
1696: mbfl_convert_filter *decoder;
1697: mbfl_convert_filter *decoder_backup;
1698: mbfl_memory_device device;
1699: int from;
1700: int width;
1701: int outwidth;
1702: int outchar;
1703: int status;
1704: int endpos;
1705: };
1706:
1707: static int
1708: collector_strimwidth(int c, void* data)
1709: {
1710: struct collector_strimwidth_data *pc = (struct collector_strimwidth_data*)data;
1711:
1712: switch (pc->status) {
1713: case 10:
1714: (*pc->decoder->filter_function)(c, pc->decoder);
1715: break;
1716: default:
1717: if (pc->outchar >= pc->from) {
1718: pc->outwidth += (is_fullwidth(c) ? 2: 1);
1719:
1720: if (pc->outwidth > pc->width) {
1721: if (pc->status == 0) {
1722: pc->endpos = pc->device.pos;
1723: mbfl_convert_filter_copy(pc->decoder, pc->decoder_backup);
1724: }
1725: pc->status++;
1726: (*pc->decoder->filter_function)(c, pc->decoder);
1727: c = -1;
1728: } else {
1729: (*pc->decoder->filter_function)(c, pc->decoder);
1730: }
1731: }
1732: pc->outchar++;
1733: break;
1734: }
1735:
1736: return c;
1737: }
1738:
1739: mbfl_string *
1740: mbfl_strimwidth(
1741: mbfl_string *string,
1742: mbfl_string *marker,
1743: mbfl_string *result,
1744: int from,
1745: int width)
1746: {
1747: struct collector_strimwidth_data pc;
1748: mbfl_convert_filter *encoder;
1749: int n, mkwidth;
1750: unsigned char *p;
1751:
1752: if (string == NULL || result == NULL) {
1753: return NULL;
1754: }
1755: mbfl_string_init(result);
1756: result->no_language = string->no_language;
1757: result->no_encoding = string->no_encoding;
1758: mbfl_memory_device_init(&pc.device, width, 0);
1759:
1760: /* output code filter */
1761: pc.decoder = mbfl_convert_filter_new(
1762: mbfl_no_encoding_wchar,
1763: string->no_encoding,
1764: mbfl_memory_device_output, 0, &pc.device);
1765: pc.decoder_backup = mbfl_convert_filter_new(
1766: mbfl_no_encoding_wchar,
1767: string->no_encoding,
1768: mbfl_memory_device_output, 0, &pc.device);
1769: /* wchar filter */
1770: encoder = mbfl_convert_filter_new(
1771: string->no_encoding,
1772: mbfl_no_encoding_wchar,
1773: collector_strimwidth, 0, &pc);
1774: if (pc.decoder == NULL || pc.decoder_backup == NULL || encoder == NULL) {
1775: mbfl_convert_filter_delete(encoder);
1776: mbfl_convert_filter_delete(pc.decoder);
1777: mbfl_convert_filter_delete(pc.decoder_backup);
1778: return NULL;
1779: }
1780: mkwidth = 0;
1781: if (marker) {
1782: mkwidth = mbfl_strwidth(marker);
1783: }
1784: pc.from = from;
1785: pc.width = width - mkwidth;
1786: pc.outwidth = 0;
1787: pc.outchar = 0;
1788: pc.status = 0;
1789: pc.endpos = 0;
1790:
1791: /* feed data */
1792: p = string->val;
1793: n = string->len;
1794: if (p != NULL) {
1795: while (n > 0) {
1796: n--;
1797: if ((*encoder->filter_function)(*p++, encoder) < 0) {
1798: break;
1799: }
1800: }
1801: mbfl_convert_filter_flush(encoder);
1802: if (pc.status != 0 && mkwidth > 0) {
1803: pc.width += mkwidth;
1804: while (n > 0) {
1805: if ((*encoder->filter_function)(*p++, encoder) < 0) {
1806: break;
1807: }
1808: n--;
1809: }
1810: mbfl_convert_filter_flush(encoder);
1811: if (pc.status != 1) {
1812: pc.status = 10;
1813: pc.device.pos = pc.endpos;
1814: mbfl_convert_filter_copy(pc.decoder_backup, pc.decoder);
1815: mbfl_convert_filter_reset(encoder, marker->no_encoding, mbfl_no_encoding_wchar);
1816: p = marker->val;
1817: n = marker->len;
1818: while (n > 0) {
1819: if ((*encoder->filter_function)(*p++, encoder) < 0) {
1820: break;
1821: }
1822: n--;
1823: }
1824: mbfl_convert_filter_flush(encoder);
1825: }
1826: } else if (pc.status != 0) {
1827: pc.device.pos = pc.endpos;
1828: mbfl_convert_filter_copy(pc.decoder_backup, pc.decoder);
1829: }
1830: mbfl_convert_filter_flush(pc.decoder);
1831: }
1832: result = mbfl_memory_device_result(&pc.device, result);
1833: mbfl_convert_filter_delete(encoder);
1834: mbfl_convert_filter_delete(pc.decoder);
1835: mbfl_convert_filter_delete(pc.decoder_backup);
1836:
1837: return result;
1838: }
1839:
1840: mbfl_string *
1841: mbfl_ja_jp_hantozen(
1842: mbfl_string *string,
1843: mbfl_string *result,
1844: int mode)
1845: {
1846: int n;
1847: unsigned char *p;
1848: const mbfl_encoding *encoding;
1849: mbfl_memory_device device;
1850: mbfl_convert_filter *decoder = NULL;
1851: mbfl_convert_filter *encoder = NULL;
1852: mbfl_convert_filter *tl_filter = NULL;
1853: mbfl_convert_filter *next_filter = NULL;
1854: mbfl_filt_tl_jisx0201_jisx0208_param *param = NULL;
1855:
1856: /* validate parameters */
1857: if (string == NULL || result == NULL) {
1858: return NULL;
1859: }
1860:
1861: encoding = mbfl_no2encoding(string->no_encoding);
1862: if (encoding == NULL) {
1863: return NULL;
1864: }
1865:
1866: mbfl_memory_device_init(&device, string->len, 0);
1867: mbfl_string_init(result);
1868:
1869: result->no_language = string->no_language;
1870: result->no_encoding = string->no_encoding;
1871:
1872: decoder = mbfl_convert_filter_new(
1873: mbfl_no_encoding_wchar,
1874: string->no_encoding,
1875: mbfl_memory_device_output, 0, &device);
1876: if (decoder == NULL) {
1877: goto out;
1878: }
1879: next_filter = decoder;
1880:
1881: param =
1882: (mbfl_filt_tl_jisx0201_jisx0208_param *)mbfl_malloc(sizeof(mbfl_filt_tl_jisx0201_jisx0208_param));
1883: if (param == NULL) {
1884: goto out;
1885: }
1886:
1887: param->mode = mode;
1888:
1889: tl_filter = mbfl_convert_filter_new2(
1890: &vtbl_tl_jisx0201_jisx0208,
1891: (int(*)(int, void*))next_filter->filter_function,
1892: (int(*)(void*))next_filter->filter_flush,
1893: next_filter);
1894: if (tl_filter == NULL) {
1895: mbfl_free(param);
1896: goto out;
1897: }
1898:
1899: tl_filter->opaque = param;
1900: next_filter = tl_filter;
1901:
1902: encoder = mbfl_convert_filter_new(
1903: string->no_encoding,
1904: mbfl_no_encoding_wchar,
1905: (int(*)(int, void*))next_filter->filter_function,
1906: (int(*)(void*))next_filter->filter_flush,
1907: next_filter);
1908: if (encoder == NULL) {
1909: goto out;
1910: }
1911:
1912: /* feed data */
1913: p = string->val;
1914: n = string->len;
1915: if (p != NULL) {
1916: while (n > 0) {
1917: if ((*encoder->filter_function)(*p++, encoder) < 0) {
1918: break;
1919: }
1920: n--;
1921: }
1922: }
1923:
1924: mbfl_convert_filter_flush(encoder);
1925: result = mbfl_memory_device_result(&device, result);
1926: out:
1927: if (tl_filter != NULL) {
1928: if (tl_filter->opaque != NULL) {
1929: mbfl_free(tl_filter->opaque);
1930: }
1931: mbfl_convert_filter_delete(tl_filter);
1932: }
1933:
1934: if (decoder != NULL) {
1935: mbfl_convert_filter_delete(decoder);
1936: }
1937:
1938: if (encoder != NULL) {
1939: mbfl_convert_filter_delete(encoder);
1940: }
1941:
1942: return result;
1943: }
1944:
1945:
1946: /*
1947: * MIME header encode
1948: */
1949: struct mime_header_encoder_data {
1950: mbfl_convert_filter *conv1_filter;
1951: mbfl_convert_filter *block_filter;
1952: mbfl_convert_filter *conv2_filter;
1953: mbfl_convert_filter *conv2_filter_backup;
1954: mbfl_convert_filter *encod_filter;
1955: mbfl_convert_filter *encod_filter_backup;
1956: mbfl_memory_device outdev;
1957: mbfl_memory_device tmpdev;
1958: int status1;
1959: int status2;
1960: int prevpos;
1961: int linehead;
1962: int firstindent;
1963: int encnamelen;
1964: int lwsplen;
1965: char encname[128];
1966: char lwsp[16];
1967: };
1968:
1969: static int
1970: mime_header_encoder_block_collector(int c, void *data)
1971: {
1972: int n;
1973: struct mime_header_encoder_data *pe = (struct mime_header_encoder_data *)data;
1974:
1975: switch (pe->status2) {
1976: case 1: /* encoded word */
1977: pe->prevpos = pe->outdev.pos;
1978: mbfl_convert_filter_copy(pe->conv2_filter, pe->conv2_filter_backup);
1979: mbfl_convert_filter_copy(pe->encod_filter, pe->encod_filter_backup);
1980: (*pe->conv2_filter->filter_function)(c, pe->conv2_filter);
1981: (*pe->conv2_filter->filter_flush)(pe->conv2_filter);
1982: (*pe->encod_filter->filter_flush)(pe->encod_filter);
1983: n = pe->outdev.pos - pe->linehead + pe->firstindent;
1984: pe->outdev.pos = pe->prevpos;
1985: mbfl_convert_filter_copy(pe->conv2_filter_backup, pe->conv2_filter);
1986: mbfl_convert_filter_copy(pe->encod_filter_backup, pe->encod_filter);
1987: if (n >= 74) {
1988: (*pe->conv2_filter->filter_flush)(pe->conv2_filter);
1989: (*pe->encod_filter->filter_flush)(pe->encod_filter);
1990: mbfl_memory_device_strncat(&pe->outdev, "\x3f\x3d", 2); /* ?= */
1991: mbfl_memory_device_strncat(&pe->outdev, pe->lwsp, pe->lwsplen);
1992: pe->linehead = pe->outdev.pos;
1993: pe->firstindent = 0;
1994: mbfl_memory_device_strncat(&pe->outdev, pe->encname, pe->encnamelen);
1995: c = (*pe->conv2_filter->filter_function)(c, pe->conv2_filter);
1996: } else {
1997: c = (*pe->conv2_filter->filter_function)(c, pe->conv2_filter);
1998: }
1999: break;
2000:
2001: default:
2002: mbfl_memory_device_strncat(&pe->outdev, pe->encname, pe->encnamelen);
2003: c = (*pe->conv2_filter->filter_function)(c, pe->conv2_filter);
2004: pe->status2 = 1;
2005: break;
2006: }
2007:
2008: return c;
2009: }
2010:
2011: static int
2012: mime_header_encoder_collector(int c, void *data)
2013: {
2014: static int qp_table[256] = {
2015: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x00 */
2016: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x00 */
2017: 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x20 */
2018: 0, 0, 0, 0, 0, 0, 0 ,0, 0, 0, 0, 0, 0, 1, 0, 1, /* 0x10 */
2019: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x40 */
2020: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, /* 0x50 */
2021: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x60 */
2022: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, /* 0x70 */
2023: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x80 */
2024: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x90 */
2025: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0xA0 */
2026: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0xB0 */
2027: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0xC0 */
2028: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0xD0 */
2029: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0xE0 */
2030: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 /* 0xF0 */
2031: };
2032:
2033: int n;
2034: struct mime_header_encoder_data *pe = (struct mime_header_encoder_data *)data;
2035:
2036: switch (pe->status1) {
2037: case 11: /* encoded word */
2038: (*pe->block_filter->filter_function)(c, pe->block_filter);
2039: break;
2040:
2041: default: /* ASCII */
2042: if (c <= 0x00ff && !qp_table[(c & 0xff)]) { /* ordinary characters */
2043: mbfl_memory_device_output(c, &pe->tmpdev);
2044: pe->status1 = 1;
2045: } else if (pe->status1 == 0 && c == 0x20) { /* repeat SPACE */
2046: mbfl_memory_device_output(c, &pe->tmpdev);
2047: } else {
2048: if (pe->tmpdev.pos < 74 && c == 0x20) {
2049: n = pe->outdev.pos - pe->linehead + pe->tmpdev.pos + pe->firstindent;
2050: if (n > 74) {
2051: mbfl_memory_device_strncat(&pe->outdev, pe->lwsp, pe->lwsplen); /* LWSP */
2052: pe->linehead = pe->outdev.pos;
2053: pe->firstindent = 0;
2054: } else if (pe->outdev.pos > 0) {
2055: mbfl_memory_device_output(0x20, &pe->outdev);
2056: }
2057: mbfl_memory_device_devcat(&pe->outdev, &pe->tmpdev);
2058: mbfl_memory_device_reset(&pe->tmpdev);
2059: pe->status1 = 0;
2060: } else {
2061: n = pe->outdev.pos - pe->linehead + pe->encnamelen + pe->firstindent;
2062: if (n > 60) {
2063: mbfl_memory_device_strncat(&pe->outdev, pe->lwsp, pe->lwsplen); /* LWSP */
2064: pe->linehead = pe->outdev.pos;
2065: pe->firstindent = 0;
2066: } else if (pe->outdev.pos > 0) {
2067: mbfl_memory_device_output(0x20, &pe->outdev);
2068: }
2069: mbfl_convert_filter_devcat(pe->block_filter, &pe->tmpdev);
2070: mbfl_memory_device_reset(&pe->tmpdev);
2071: (*pe->block_filter->filter_function)(c, pe->block_filter);
2072: pe->status1 = 11;
2073: }
2074: }
2075: break;
2076: }
2077:
2078: return c;
2079: }
2080:
2081: mbfl_string *
2082: mime_header_encoder_result(struct mime_header_encoder_data *pe, mbfl_string *result)
2083: {
2084: if (pe->status1 >= 10) {
2085: (*pe->conv2_filter->filter_flush)(pe->conv2_filter);
2086: (*pe->encod_filter->filter_flush)(pe->encod_filter);
2087: mbfl_memory_device_strncat(&pe->outdev, "\x3f\x3d", 2); /* ?= */
2088: } else if (pe->tmpdev.pos > 0) {
2089: if (pe->outdev.pos > 0) {
2090: if ((pe->outdev.pos - pe->linehead + pe->tmpdev.pos) > 74) {
2091: mbfl_memory_device_strncat(&pe->outdev, pe->lwsp, pe->lwsplen);
2092: } else {
2093: mbfl_memory_device_output(0x20, &pe->outdev);
2094: }
2095: }
2096: mbfl_memory_device_devcat(&pe->outdev, &pe->tmpdev);
2097: }
2098: mbfl_memory_device_reset(&pe->tmpdev);
2099: pe->prevpos = 0;
2100: pe->linehead = 0;
2101: pe->status1 = 0;
2102: pe->status2 = 0;
2103:
2104: return mbfl_memory_device_result(&pe->outdev, result);
2105: }
2106:
2107: struct mime_header_encoder_data*
2108: mime_header_encoder_new(
2109: enum mbfl_no_encoding incode,
2110: enum mbfl_no_encoding outcode,
2111: enum mbfl_no_encoding transenc)
2112: {
2113: int n;
2114: const char *s;
2115: const mbfl_encoding *outencoding;
2116: struct mime_header_encoder_data *pe;
2117:
2118: /* get output encoding and check MIME charset name */
2119: outencoding = mbfl_no2encoding(outcode);
2120: if (outencoding == NULL || outencoding->mime_name == NULL || outencoding->mime_name[0] == '\0') {
2121: return NULL;
2122: }
2123:
2124: pe = (struct mime_header_encoder_data*)mbfl_malloc(sizeof(struct mime_header_encoder_data));
2125: if (pe == NULL) {
2126: return NULL;
2127: }
2128:
2129: mbfl_memory_device_init(&pe->outdev, 0, 0);
2130: mbfl_memory_device_init(&pe->tmpdev, 0, 0);
2131: pe->prevpos = 0;
2132: pe->linehead = 0;
2133: pe->firstindent = 0;
2134: pe->status1 = 0;
2135: pe->status2 = 0;
2136:
2137: /* make the encoding description string exp. "=?ISO-2022-JP?B?" */
2138: n = 0;
2139: pe->encname[n++] = 0x3d;
2140: pe->encname[n++] = 0x3f;
2141: s = outencoding->mime_name;
2142: while (*s) {
2143: pe->encname[n++] = *s++;
2144: }
2145: pe->encname[n++] = 0x3f;
2146: if (transenc == mbfl_no_encoding_qprint) {
2147: pe->encname[n++] = 0x51;
2148: } else {
2149: pe->encname[n++] = 0x42;
2150: transenc = mbfl_no_encoding_base64;
2151: }
2152: pe->encname[n++] = 0x3f;
2153: pe->encname[n] = '\0';
2154: pe->encnamelen = n;
2155:
2156: n = 0;
2157: pe->lwsp[n++] = 0x0d;
2158: pe->lwsp[n++] = 0x0a;
2159: pe->lwsp[n++] = 0x20;
2160: pe->lwsp[n] = '\0';
2161: pe->lwsplen = n;
2162:
2163: /* transfer encode filter */
2164: pe->encod_filter = mbfl_convert_filter_new(outcode, transenc, mbfl_memory_device_output, 0, &(pe->outdev));
2165: pe->encod_filter_backup = mbfl_convert_filter_new(outcode, transenc, mbfl_memory_device_output, 0, &(pe->outdev));
2166:
2167: /* Output code filter */
2168: pe->conv2_filter = mbfl_convert_filter_new(mbfl_no_encoding_wchar, outcode, mbfl_filter_output_pipe, 0, pe->encod_filter);
2169: pe->conv2_filter_backup = mbfl_convert_filter_new(mbfl_no_encoding_wchar, outcode, mbfl_filter_output_pipe, 0, pe->encod_filter);
2170:
2171: /* encoded block filter */
2172: pe->block_filter = mbfl_convert_filter_new(mbfl_no_encoding_wchar, mbfl_no_encoding_wchar, mime_header_encoder_block_collector, 0, pe);
2173:
2174: /* Input code filter */
2175: pe->conv1_filter = mbfl_convert_filter_new(incode, mbfl_no_encoding_wchar, mime_header_encoder_collector, 0, pe);
2176:
2177: if (pe->encod_filter == NULL ||
2178: pe->encod_filter_backup == NULL ||
2179: pe->conv2_filter == NULL ||
2180: pe->conv2_filter_backup == NULL ||
2181: pe->conv1_filter == NULL) {
2182: mime_header_encoder_delete(pe);
2183: return NULL;
2184: }
2185:
2186: if (transenc == mbfl_no_encoding_qprint) {
2187: pe->encod_filter->status |= MBFL_QPRINT_STS_MIME_HEADER;
2188: pe->encod_filter_backup->status |= MBFL_QPRINT_STS_MIME_HEADER;
2189: } else {
2190: pe->encod_filter->status |= MBFL_BASE64_STS_MIME_HEADER;
2191: pe->encod_filter_backup->status |= MBFL_BASE64_STS_MIME_HEADER;
2192: }
2193:
2194: return pe;
2195: }
2196:
2197: void
2198: mime_header_encoder_delete(struct mime_header_encoder_data *pe)
2199: {
2200: if (pe) {
2201: mbfl_convert_filter_delete(pe->conv1_filter);
2202: mbfl_convert_filter_delete(pe->block_filter);
2203: mbfl_convert_filter_delete(pe->conv2_filter);
2204: mbfl_convert_filter_delete(pe->conv2_filter_backup);
2205: mbfl_convert_filter_delete(pe->encod_filter);
2206: mbfl_convert_filter_delete(pe->encod_filter_backup);
2207: mbfl_memory_device_clear(&pe->outdev);
2208: mbfl_memory_device_clear(&pe->tmpdev);
2209: mbfl_free((void*)pe);
2210: }
2211: }
2212:
2213: int
2214: mime_header_encoder_feed(int c, struct mime_header_encoder_data *pe)
2215: {
2216: return (*pe->conv1_filter->filter_function)(c, pe->conv1_filter);
2217: }
2218:
2219: mbfl_string *
2220: mbfl_mime_header_encode(
2221: mbfl_string *string,
2222: mbfl_string *result,
2223: enum mbfl_no_encoding outcode,
2224: enum mbfl_no_encoding encoding,
2225: const char *linefeed,
2226: int indent)
2227: {
2228: int n;
2229: unsigned char *p;
2230: struct mime_header_encoder_data *pe;
2231:
2232: mbfl_string_init(result);
2233: result->no_language = string->no_language;
2234: result->no_encoding = mbfl_no_encoding_ascii;
2235:
2236: pe = mime_header_encoder_new(string->no_encoding, outcode, encoding);
2237: if (pe == NULL) {
2238: return NULL;
2239: }
2240:
2241: if (linefeed != NULL) {
2242: n = 0;
2243: while (*linefeed && n < 8) {
2244: pe->lwsp[n++] = *linefeed++;
2245: }
2246: pe->lwsp[n++] = 0x20;
2247: pe->lwsp[n] = '\0';
2248: pe->lwsplen = n;
2249: }
2250: if (indent > 0 && indent < 74) {
2251: pe->firstindent = indent;
2252: }
2253:
2254: n = string->len;
2255: p = string->val;
2256: while (n > 0) {
2257: (*pe->conv1_filter->filter_function)(*p++, pe->conv1_filter);
2258: n--;
2259: }
2260:
2261: result = mime_header_encoder_result(pe, result);
2262: mime_header_encoder_delete(pe);
2263:
2264: return result;
2265: }
2266:
2267:
2268: /*
2269: * MIME header decode
2270: */
2271: struct mime_header_decoder_data {
2272: mbfl_convert_filter *deco_filter;
2273: mbfl_convert_filter *conv1_filter;
2274: mbfl_convert_filter *conv2_filter;
2275: mbfl_memory_device outdev;
2276: mbfl_memory_device tmpdev;
2277: int cspos;
2278: int status;
2279: enum mbfl_no_encoding encoding;
2280: enum mbfl_no_encoding incode;
2281: enum mbfl_no_encoding outcode;
2282: };
2283:
2284: static int
2285: mime_header_decoder_collector(int c, void* data)
2286: {
2287: const mbfl_encoding *encoding;
2288: struct mime_header_decoder_data *pd = (struct mime_header_decoder_data*)data;
2289:
2290: switch (pd->status) {
2291: case 1:
2292: if (c == 0x3f) { /* ? */
2293: mbfl_memory_device_output(c, &pd->tmpdev);
2294: pd->cspos = pd->tmpdev.pos;
2295: pd->status = 2;
2296: } else {
2297: mbfl_convert_filter_devcat(pd->conv1_filter, &pd->tmpdev);
2298: mbfl_memory_device_reset(&pd->tmpdev);
2299: if (c == 0x3d) { /* = */
2300: mbfl_memory_device_output(c, &pd->tmpdev);
2301: } else if (c == 0x0d || c == 0x0a) { /* CR or LF */
2302: pd->status = 9;
2303: } else {
2304: (*pd->conv1_filter->filter_function)(c, pd->conv1_filter);
2305: pd->status = 0;
2306: }
2307: }
2308: break;
2309: case 2: /* store charset string */
2310: if (c == 0x3f) { /* ? */
2311: /* identify charset */
2312: mbfl_memory_device_output('\0', &pd->tmpdev);
2313: encoding = mbfl_name2encoding((const char *)&pd->tmpdev.buffer[pd->cspos]);
2314: if (encoding != NULL) {
2315: pd->incode = encoding->no_encoding;
2316: pd->status = 3;
2317: }
2318: mbfl_memory_device_unput(&pd->tmpdev);
2319: mbfl_memory_device_output(c, &pd->tmpdev);
2320: } else {
2321: mbfl_memory_device_output(c, &pd->tmpdev);
2322: if (pd->tmpdev.pos > 100) { /* too long charset string */
2323: pd->status = 0;
2324: } else if (c == 0x0d || c == 0x0a) { /* CR or LF */
2325: mbfl_memory_device_unput(&pd->tmpdev);
2326: pd->status = 9;
2327: }
2328: if (pd->status != 2) {
2329: mbfl_convert_filter_devcat(pd->conv1_filter, &pd->tmpdev);
2330: mbfl_memory_device_reset(&pd->tmpdev);
2331: }
2332: }
2333: break;
2334: case 3: /* identify encoding */
2335: mbfl_memory_device_output(c, &pd->tmpdev);
2336: if (c == 0x42 || c == 0x62) { /* 'B' or 'b' */
2337: pd->encoding = mbfl_no_encoding_base64;
2338: pd->status = 4;
2339: } else if (c == 0x51 || c == 0x71) { /* 'Q' or 'q' */
2340: pd->encoding = mbfl_no_encoding_qprint;
2341: pd->status = 4;
2342: } else {
2343: if (c == 0x0d || c == 0x0a) { /* CR or LF */
2344: mbfl_memory_device_unput(&pd->tmpdev);
2345: pd->status = 9;
2346: } else {
2347: pd->status = 0;
2348: }
2349: mbfl_convert_filter_devcat(pd->conv1_filter, &pd->tmpdev);
2350: mbfl_memory_device_reset(&pd->tmpdev);
2351: }
2352: break;
2353: case 4: /* reset filter */
2354: mbfl_memory_device_output(c, &pd->tmpdev);
2355: if (c == 0x3f) { /* ? */
2356: /* charset convert filter */
2357: mbfl_convert_filter_reset(pd->conv1_filter, pd->incode, mbfl_no_encoding_wchar);
2358: /* decode filter */
2359: mbfl_convert_filter_reset(pd->deco_filter, pd->encoding, mbfl_no_encoding_8bit);
2360: pd->status = 5;
2361: } else {
2362: if (c == 0x0d || c == 0x0a) { /* CR or LF */
2363: mbfl_memory_device_unput(&pd->tmpdev);
2364: pd->status = 9;
2365: } else {
2366: pd->status = 0;
2367: }
2368: mbfl_convert_filter_devcat(pd->conv1_filter, &pd->tmpdev);
2369: }
2370: mbfl_memory_device_reset(&pd->tmpdev);
2371: break;
2372: case 5: /* encoded block */
2373: if (c == 0x3f) { /* ? */
2374: pd->status = 6;
2375: } else {
2376: (*pd->deco_filter->filter_function)(c, pd->deco_filter);
2377: }
2378: break;
2379: case 6: /* check end position */
2380: if (c == 0x3d) { /* = */
2381: /* flush and reset filter */
2382: (*pd->deco_filter->filter_flush)(pd->deco_filter);
2383: (*pd->conv1_filter->filter_flush)(pd->conv1_filter);
2384: mbfl_convert_filter_reset(pd->conv1_filter, mbfl_no_encoding_ascii, mbfl_no_encoding_wchar);
2385: pd->status = 7;
2386: } else {
2387: (*pd->deco_filter->filter_function)(0x3f, pd->deco_filter);
2388: if (c != 0x3f) { /* ? */
2389: (*pd->deco_filter->filter_function)(c, pd->deco_filter);
2390: pd->status = 5;
2391: }
2392: }
2393: break;
2394: case 7: /* after encoded block */
2395: if (c == 0x0d || c == 0x0a) { /* CR LF */
2396: pd->status = 8;
2397: } else {
2398: mbfl_memory_device_output(c, &pd->tmpdev);
2399: if (c == 0x3d) { /* = */
2400: pd->status = 1;
2401: } else if (c != 0x20 && c != 0x09) { /* not space */
2402: mbfl_convert_filter_devcat(pd->conv1_filter, &pd->tmpdev);
2403: mbfl_memory_device_reset(&pd->tmpdev);
2404: pd->status = 0;
2405: }
2406: }
2407: break;
2408: case 8: /* folding */
2409: case 9: /* folding */
2410: if (c != 0x0d && c != 0x0a && c != 0x20 && c != 0x09) {
2411: if (c == 0x3d) { /* = */
2412: if (pd->status == 8) {
2413: mbfl_memory_device_output(0x20, &pd->tmpdev); /* SPACE */
2414: } else {
2415: (*pd->conv1_filter->filter_function)(0x20, pd->conv1_filter);
2416: }
2417: mbfl_memory_device_output(c, &pd->tmpdev);
2418: pd->status = 1;
2419: } else {
2420: mbfl_memory_device_output(0x20, &pd->tmpdev);
2421: mbfl_memory_device_output(c, &pd->tmpdev);
2422: mbfl_convert_filter_devcat(pd->conv1_filter, &pd->tmpdev);
2423: mbfl_memory_device_reset(&pd->tmpdev);
2424: pd->status = 0;
2425: }
2426: }
2427: break;
2428: default: /* non encoded block */
2429: if (c == 0x0d || c == 0x0a) { /* CR LF */
2430: pd->status = 9;
2431: } else if (c == 0x3d) { /* = */
2432: mbfl_memory_device_output(c, &pd->tmpdev);
2433: pd->status = 1;
2434: } else {
2435: (*pd->conv1_filter->filter_function)(c, pd->conv1_filter);
2436: }
2437: break;
2438: }
2439:
2440: return c;
2441: }
2442:
2443: mbfl_string *
2444: mime_header_decoder_result(struct mime_header_decoder_data *pd, mbfl_string *result)
2445: {
2446: switch (pd->status) {
2447: case 1:
2448: case 2:
2449: case 3:
2450: case 4:
2451: case 7:
2452: case 8:
2453: case 9:
2454: mbfl_convert_filter_devcat(pd->conv1_filter, &pd->tmpdev);
2455: break;
2456: case 5:
2457: case 6:
2458: (*pd->deco_filter->filter_flush)(pd->deco_filter);
2459: (*pd->conv1_filter->filter_flush)(pd->conv1_filter);
2460: break;
2461: }
2462: (*pd->conv2_filter->filter_flush)(pd->conv2_filter);
2463: mbfl_memory_device_reset(&pd->tmpdev);
2464: pd->status = 0;
2465:
2466: return mbfl_memory_device_result(&pd->outdev, result);
2467: }
2468:
2469: struct mime_header_decoder_data*
2470: mime_header_decoder_new(enum mbfl_no_encoding outcode)
2471: {
2472: struct mime_header_decoder_data *pd;
2473:
2474: pd = (struct mime_header_decoder_data*)mbfl_malloc(sizeof(struct mime_header_decoder_data));
2475: if (pd == NULL) {
2476: return NULL;
2477: }
2478:
2479: mbfl_memory_device_init(&pd->outdev, 0, 0);
2480: mbfl_memory_device_init(&pd->tmpdev, 0, 0);
2481: pd->cspos = 0;
2482: pd->status = 0;
2483: pd->encoding = mbfl_no_encoding_pass;
2484: pd->incode = mbfl_no_encoding_ascii;
2485: pd->outcode = outcode;
2486: /* charset convert filter */
2487: pd->conv2_filter = mbfl_convert_filter_new(mbfl_no_encoding_wchar, pd->outcode, mbfl_memory_device_output, 0, &pd->outdev);
2488: pd->conv1_filter = mbfl_convert_filter_new(pd->incode, mbfl_no_encoding_wchar, mbfl_filter_output_pipe, 0, pd->conv2_filter);
2489: /* decode filter */
2490: pd->deco_filter = mbfl_convert_filter_new(pd->encoding, mbfl_no_encoding_8bit, mbfl_filter_output_pipe, 0, pd->conv1_filter);
2491:
2492: if (pd->conv1_filter == NULL || pd->conv2_filter == NULL || pd->deco_filter == NULL) {
2493: mime_header_decoder_delete(pd);
2494: return NULL;
2495: }
2496:
2497: return pd;
2498: }
2499:
2500: void
2501: mime_header_decoder_delete(struct mime_header_decoder_data *pd)
2502: {
2503: if (pd) {
2504: mbfl_convert_filter_delete(pd->conv2_filter);
2505: mbfl_convert_filter_delete(pd->conv1_filter);
2506: mbfl_convert_filter_delete(pd->deco_filter);
2507: mbfl_memory_device_clear(&pd->outdev);
2508: mbfl_memory_device_clear(&pd->tmpdev);
2509: mbfl_free((void*)pd);
2510: }
2511: }
2512:
2513: int
2514: mime_header_decoder_feed(int c, struct mime_header_decoder_data *pd)
2515: {
2516: return mime_header_decoder_collector(c, pd);
2517: }
2518:
2519: mbfl_string *
2520: mbfl_mime_header_decode(
2521: mbfl_string *string,
2522: mbfl_string *result,
2523: enum mbfl_no_encoding outcode)
2524: {
2525: int n;
2526: unsigned char *p;
2527: struct mime_header_decoder_data *pd;
2528:
2529: mbfl_string_init(result);
2530: result->no_language = string->no_language;
2531: result->no_encoding = outcode;
2532:
2533: pd = mime_header_decoder_new(outcode);
2534: if (pd == NULL) {
2535: return NULL;
2536: }
2537:
2538: /* feed data */
2539: n = string->len;
2540: p = string->val;
2541: while (n > 0) {
2542: mime_header_decoder_collector(*p++, pd);
2543: n--;
2544: }
2545:
2546: result = mime_header_decoder_result(pd, result);
2547: mime_header_decoder_delete(pd);
2548:
2549: return result;
2550: }
2551:
2552:
2553:
2554: /*
2555: * convert HTML numeric entity
2556: */
2557: struct collector_htmlnumericentity_data {
2558: mbfl_convert_filter *decoder;
2559: int status;
2560: int cache;
2561: int digit;
2562: int *convmap;
2563: int mapsize;
2564: };
2565:
2566: static int
2567: collector_encode_htmlnumericentity(int c, void *data)
2568: {
2569: struct collector_htmlnumericentity_data *pc = (struct collector_htmlnumericentity_data *)data;
2570: int f, n, s, r, d, size, *mapelm;
2571:
2572: size = pc->mapsize;
2573: f = 0;
2574: n = 0;
2575: while (n < size) {
2576: mapelm = &(pc->convmap[n*4]);
2577: if (c >= mapelm[0] && c <= mapelm[1]) {
2578: s = (c + mapelm[2]) & mapelm[3];
2579: if (s >= 0) {
2580: (*pc->decoder->filter_function)(0x26, pc->decoder); /* '&' */
2581: (*pc->decoder->filter_function)(0x23, pc->decoder); /* '#' */
2582: r = 100000000;
2583: s %= r;
2584: while (r > 0) {
2585: d = s/r;
2586: if (d || f) {
2587: f = 1;
2588: s %= r;
2589: (*pc->decoder->filter_function)(mbfl_hexchar_table[d], pc->decoder);
2590: }
2591: r /= 10;
2592: }
2593: if (!f) {
2594: f = 1;
2595: (*pc->decoder->filter_function)(mbfl_hexchar_table[0], pc->decoder);
2596: }
2597: (*pc->decoder->filter_function)(0x3b, pc->decoder); /* ';' */
2598: }
2599: }
2600: if (f) {
2601: break;
2602: }
2603: n++;
2604: }
2605: if (!f) {
2606: (*pc->decoder->filter_function)(c, pc->decoder);
2607: }
2608:
2609: return c;
2610: }
2611:
2612: static int
2613: collector_decode_htmlnumericentity(int c, void *data)
2614: {
2615: struct collector_htmlnumericentity_data *pc = (struct collector_htmlnumericentity_data *)data;
2616: int f, n, s, r, d, size, *mapelm;
2617:
2618: switch (pc->status) {
2619: case 1:
2620: if (c == 0x23) { /* '#' */
2621: pc->status = 2;
2622: } else {
2623: pc->status = 0;
2624: (*pc->decoder->filter_function)(0x26, pc->decoder); /* '&' */
2625: (*pc->decoder->filter_function)(c, pc->decoder);
2626: }
2627: break;
2628: case 2:
2629: if (c >= 0x30 && c <= 0x39) { /* '0' - '9' */
2630: pc->cache = c - 0x30;
2631: pc->status = 3;
2632: pc->digit = 1;
2633: } else {
2634: pc->status = 0;
2635: (*pc->decoder->filter_function)(0x26, pc->decoder); /* '&' */
2636: (*pc->decoder->filter_function)(0x23, pc->decoder); /* '#' */
2637: (*pc->decoder->filter_function)(c, pc->decoder);
2638: }
2639: break;
2640: case 3:
2641: s = 0;
2642: f = 0;
2643: if (c >= 0x30 && c <= 0x39) { /* '0' - '9' */
2644: if (pc->digit > 9) {
2645: pc->status = 0;
2646: s = pc->cache;
2647: f = 1;
2648: } else {
2649: s = pc->cache*10 + c - 0x30;
2650: pc->cache = s;
2651: pc->digit++;
2652: }
2653: } else {
2654: pc->status = 0;
2655: s = pc->cache;
2656: f = 1;
2657: n = 0;
2658: size = pc->mapsize;
2659: while (n < size) {
2660: mapelm = &(pc->convmap[n*4]);
2661: d = s - mapelm[2];
2662: if (d >= mapelm[0] && d <= mapelm[1]) {
2663: f = 0;
2664: (*pc->decoder->filter_function)(d, pc->decoder);
2665: if (c != 0x3b) { /* ';' */
2666: (*pc->decoder->filter_function)(c, pc->decoder);
2667: }
2668: break;
2669: }
2670: n++;
2671: }
2672: }
2673: if (f) {
2674: (*pc->decoder->filter_function)(0x26, pc->decoder); /* '&' */
2675: (*pc->decoder->filter_function)(0x23, pc->decoder); /* '#' */
2676: r = 1;
2677: n = pc->digit;
2678: while (n > 0) {
2679: r *= 10;
2680: n--;
2681: }
2682: s %= r;
2683: r /= 10;
2684: while (r > 0) {
2685: d = s/r;
2686: s %= r;
2687: r /= 10;
2688: (*pc->decoder->filter_function)(mbfl_hexchar_table[d], pc->decoder);
2689: }
2690: (*pc->decoder->filter_function)(c, pc->decoder);
2691: }
2692: break;
2693: default:
2694: if (c == 0x26) { /* '&' */
2695: pc->status = 1;
2696: } else {
2697: (*pc->decoder->filter_function)(c, pc->decoder);
2698: }
2699: break;
2700: }
2701:
2702: return c;
2703: }
2704:
2705: int mbfl_filt_decode_htmlnumericentity_flush(mbfl_convert_filter *filter)
2706: {
2707: struct collector_htmlnumericentity_data *pc = (struct collector_htmlnumericentity_data *)filter;
2708: int n, s, r, d;
2709:
2710: if (pc->status) {
2711: switch (pc->status) {
2712: case 1: /* '&' */
2713: (*pc->decoder->filter_function)(0x26, pc->decoder); /* '&' */
2714: break;
2715: case 2: /* '#' */
2716: (*pc->decoder->filter_function)(0x26, pc->decoder); /* '&' */
2717: (*pc->decoder->filter_function)(0x23, pc->decoder); /* '#' */
2718: break;
2719: case 3: /* '0'-'9' */
2720: (*pc->decoder->filter_function)(0x26, pc->decoder); /* '&' */
2721: (*pc->decoder->filter_function)(0x23, pc->decoder); /* '#' */
2722:
2723: s = pc->cache;
2724: r = 1;
2725: n = pc->digit;
2726: while (n > 0) {
2727: r *= 10;
2728: n--;
2729: }
2730: s %= r;
2731: r /= 10;
2732: while (r > 0) {
2733: d = s/r;
2734: s %= r;
2735: r /= 10;
2736: (*pc->decoder->filter_function)(mbfl_hexchar_table[d], pc->decoder);
2737: }
2738:
2739: break;
2740: default:
2741: break;
2742: }
2743: }
2744:
2745: pc->status = 0;
2746: pc->cache = 0;
2747: pc->digit = 0;
2748:
2749: return 0;
2750: }
2751:
2752: mbfl_string *
2753: mbfl_html_numeric_entity(
2754: mbfl_string *string,
2755: mbfl_string *result,
2756: int *convmap,
2757: int mapsize,
2758: int type)
2759: {
2760: struct collector_htmlnumericentity_data pc;
2761: mbfl_memory_device device;
2762: mbfl_convert_filter *encoder;
2763: int n;
2764: unsigned char *p;
2765:
2766: if (string == NULL || result == NULL) {
2767: return NULL;
2768: }
2769: mbfl_string_init(result);
2770: result->no_language = string->no_language;
2771: result->no_encoding = string->no_encoding;
2772: mbfl_memory_device_init(&device, string->len, 0);
2773:
2774: /* output code filter */
2775: pc.decoder = mbfl_convert_filter_new(
2776: mbfl_no_encoding_wchar,
2777: string->no_encoding,
2778: mbfl_memory_device_output, 0, &device);
2779: /* wchar filter */
2780: if (type == 0) {
2781: encoder = mbfl_convert_filter_new(
2782: string->no_encoding,
2783: mbfl_no_encoding_wchar,
2784: collector_encode_htmlnumericentity, 0, &pc);
2785: } else {
2786: encoder = mbfl_convert_filter_new(
2787: string->no_encoding,
2788: mbfl_no_encoding_wchar,
2789: collector_decode_htmlnumericentity,
2790: (int (*)(void*))mbfl_filt_decode_htmlnumericentity_flush, &pc);
2791: }
2792: if (pc.decoder == NULL || encoder == NULL) {
2793: mbfl_convert_filter_delete(encoder);
2794: mbfl_convert_filter_delete(pc.decoder);
2795: return NULL;
2796: }
2797: pc.status = 0;
2798: pc.cache = 0;
2799: pc.digit = 0;
2800: pc.convmap = convmap;
2801: pc.mapsize = mapsize;
2802:
2803: /* feed data */
2804: p = string->val;
2805: n = string->len;
2806: if (p != NULL) {
2807: while (n > 0) {
2808: if ((*encoder->filter_function)(*p++, encoder) < 0) {
2809: break;
2810: }
2811: n--;
2812: }
2813: }
2814: mbfl_convert_filter_flush(encoder);
2815: mbfl_convert_filter_flush(pc.decoder);
2816: result = mbfl_memory_device_result(&device, result);
2817: mbfl_convert_filter_delete(encoder);
2818: mbfl_convert_filter_delete(pc.decoder);
2819:
2820: return result;
2821: }
2822:
2823: /*
2824: * Local variables:
2825: * tab-width: 4
2826: * c-basic-offset: 4
2827: * End:
2828: */