Annotation of embedaddon/libiconv/lib/loop_unicode.h, revision 1.1.1.1
1.1 misho 1: /*
2: * Copyright (C) 1999-2003, 2005-2006, 2008 Free Software Foundation, Inc.
3: * This file is part of the GNU LIBICONV Library.
4: *
5: * The GNU LIBICONV Library is free software; you can redistribute it
6: * and/or modify it under the terms of the GNU Library General Public
7: * License as published by the Free Software Foundation; either version 2
8: * of the License, or (at your option) any later version.
9: *
10: * The GNU LIBICONV Library is distributed in the hope that it will be
11: * useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
12: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13: * Library General Public License for more details.
14: *
15: * You should have received a copy of the GNU Library General Public
16: * License along with the GNU LIBICONV Library; see the file COPYING.LIB.
17: * If not, write to the Free Software Foundation, Inc., 51 Franklin Street,
18: * Fifth Floor, Boston, MA 02110-1301, USA.
19: */
20:
21: /* This file defines the conversion loop via Unicode as a pivot encoding. */
22:
23: /* Attempt to transliterate wc. Return code as in xxx_wctomb. */
24: static int unicode_transliterate (conv_t cd, ucs4_t wc,
25: unsigned char* outptr, size_t outleft)
26: {
27: if (cd->oflags & HAVE_HANGUL_JAMO) {
28: /* Decompose Hangul into Jamo. Use double-width Jamo (contained
29: in all Korean encodings and ISO-2022-JP-2), not half-width Jamo
30: (contained in Unicode only). */
31: ucs4_t buf[3];
32: int ret = johab_hangul_decompose(cd,buf,wc);
33: if (ret != RET_ILUNI) {
34: /* we know 1 <= ret <= 3 */
35: state_t backup_state = cd->ostate;
36: unsigned char* backup_outptr = outptr;
37: size_t backup_outleft = outleft;
38: int i, sub_outcount;
39: for (i = 0; i < ret; i++) {
40: if (outleft == 0) {
41: sub_outcount = RET_TOOSMALL;
42: goto johab_hangul_failed;
43: }
44: sub_outcount = cd->ofuncs.xxx_wctomb(cd,outptr,buf[i],outleft);
45: if (sub_outcount <= RET_ILUNI)
46: goto johab_hangul_failed;
47: if (!(sub_outcount <= outleft)) abort();
48: outptr += sub_outcount; outleft -= sub_outcount;
49: }
50: return outptr-backup_outptr;
51: johab_hangul_failed:
52: cd->ostate = backup_state;
53: outptr = backup_outptr;
54: outleft = backup_outleft;
55: if (sub_outcount != RET_ILUNI)
56: return RET_TOOSMALL;
57: }
58: }
59: {
60: /* Try to use a variant, but postfix it with
61: U+303E IDEOGRAPHIC VARIATION INDICATOR
62: (cf. Ken Lunde's "CJKV information processing", p. 188). */
63: int indx = -1;
64: if (wc == 0x3006)
65: indx = 0;
66: else if (wc == 0x30f6)
67: indx = 1;
68: else if (wc >= 0x4e00 && wc < 0xa000)
69: indx = cjk_variants_indx[wc-0x4e00];
70: if (indx >= 0) {
71: for (;; indx++) {
72: ucs4_t buf[2];
73: unsigned short variant = cjk_variants[indx];
74: unsigned short last = variant & 0x8000;
75: variant &= 0x7fff;
76: variant += 0x3000;
77: buf[0] = variant; buf[1] = 0x303e;
78: {
79: state_t backup_state = cd->ostate;
80: unsigned char* backup_outptr = outptr;
81: size_t backup_outleft = outleft;
82: int i, sub_outcount;
83: for (i = 0; i < 2; i++) {
84: if (outleft == 0) {
85: sub_outcount = RET_TOOSMALL;
86: goto variant_failed;
87: }
88: sub_outcount = cd->ofuncs.xxx_wctomb(cd,outptr,buf[i],outleft);
89: if (sub_outcount <= RET_ILUNI)
90: goto variant_failed;
91: if (!(sub_outcount <= outleft)) abort();
92: outptr += sub_outcount; outleft -= sub_outcount;
93: }
94: return outptr-backup_outptr;
95: variant_failed:
96: cd->ostate = backup_state;
97: outptr = backup_outptr;
98: outleft = backup_outleft;
99: if (sub_outcount != RET_ILUNI)
100: return RET_TOOSMALL;
101: }
102: if (last)
103: break;
104: }
105: }
106: }
107: if (wc >= 0x2018 && wc <= 0x201a) {
108: /* Special case for quotation marks 0x2018, 0x2019, 0x201a */
109: ucs4_t substitute =
110: (cd->oflags & HAVE_QUOTATION_MARKS
111: ? (wc == 0x201a ? 0x2018 : wc)
112: : (cd->oflags & HAVE_ACCENTS
113: ? (wc==0x2019 ? 0x00b4 : 0x0060) /* use accents */
114: : 0x0027 /* use apostrophe */
115: ) );
116: int outcount = cd->ofuncs.xxx_wctomb(cd,outptr,substitute,outleft);
117: if (outcount != RET_ILUNI)
118: return outcount;
119: }
120: {
121: /* Use the transliteration table. */
122: int indx = translit_index(wc);
123: if (indx >= 0) {
124: const unsigned int * cp = &translit_data[indx];
125: unsigned int num = *cp++;
126: state_t backup_state = cd->ostate;
127: unsigned char* backup_outptr = outptr;
128: size_t backup_outleft = outleft;
129: unsigned int i;
130: int sub_outcount;
131: for (i = 0; i < num; i++) {
132: if (outleft == 0) {
133: sub_outcount = RET_TOOSMALL;
134: goto translit_failed;
135: }
136: sub_outcount = cd->ofuncs.xxx_wctomb(cd,outptr,cp[i],outleft);
137: if (sub_outcount == RET_ILUNI)
138: /* Recursive transliteration. */
139: sub_outcount = unicode_transliterate(cd,cp[i],outptr,outleft);
140: if (sub_outcount <= RET_ILUNI)
141: goto translit_failed;
142: if (!(sub_outcount <= outleft)) abort();
143: outptr += sub_outcount; outleft -= sub_outcount;
144: }
145: return outptr-backup_outptr;
146: translit_failed:
147: cd->ostate = backup_state;
148: outptr = backup_outptr;
149: outleft = backup_outleft;
150: if (sub_outcount != RET_ILUNI)
151: return RET_TOOSMALL;
152: }
153: }
154: return RET_ILUNI;
155: }
156:
157: #ifndef LIBICONV_PLUG
158:
159: struct uc_to_mb_fallback_locals {
160: unsigned char* l_outbuf;
161: size_t l_outbytesleft;
162: int l_errno;
163: };
164:
165: static void uc_to_mb_write_replacement (const char *buf, size_t buflen,
166: void* callback_arg)
167: {
168: struct uc_to_mb_fallback_locals * plocals =
169: (struct uc_to_mb_fallback_locals *) callback_arg;
170: /* Do nothing if already encountered an error in a previous call. */
171: if (plocals->l_errno == 0) {
172: /* Attempt to copy the passed buffer to the output buffer. */
173: if (plocals->l_outbytesleft < buflen)
174: plocals->l_errno = E2BIG;
175: else {
176: memcpy(plocals->l_outbuf, buf, buflen);
177: plocals->l_outbuf += buflen;
178: plocals->l_outbytesleft -= buflen;
179: }
180: }
181: }
182:
183: struct mb_to_uc_fallback_locals {
184: conv_t l_cd;
185: unsigned char* l_outbuf;
186: size_t l_outbytesleft;
187: int l_errno;
188: };
189:
190: static void mb_to_uc_write_replacement (const unsigned int *buf, size_t buflen,
191: void* callback_arg)
192: {
193: struct mb_to_uc_fallback_locals * plocals =
194: (struct mb_to_uc_fallback_locals *) callback_arg;
195: /* Do nothing if already encountered an error in a previous call. */
196: if (plocals->l_errno == 0) {
197: /* Attempt to convert the passed buffer to the target encoding. */
198: conv_t cd = plocals->l_cd;
199: unsigned char* outptr = plocals->l_outbuf;
200: size_t outleft = plocals->l_outbytesleft;
201: for (; buflen > 0; buf++, buflen--) {
202: ucs4_t wc = *buf;
203: int outcount;
204: if (outleft == 0) {
205: plocals->l_errno = E2BIG;
206: break;
207: }
208: outcount = cd->ofuncs.xxx_wctomb(cd,outptr,wc,outleft);
209: if (outcount != RET_ILUNI)
210: goto outcount_ok;
211: /* Handle Unicode tag characters (range U+E0000..U+E007F). */
212: if ((wc >> 7) == (0xe0000 >> 7))
213: goto outcount_zero;
214: /* Try transliteration. */
215: if (cd->transliterate) {
216: outcount = unicode_transliterate(cd,wc,outptr,outleft);
217: if (outcount != RET_ILUNI)
218: goto outcount_ok;
219: }
220: if (cd->discard_ilseq) {
221: outcount = 0;
222: goto outcount_ok;
223: }
224: #ifndef LIBICONV_PLUG
225: else if (cd->fallbacks.uc_to_mb_fallback != NULL) {
226: struct uc_to_mb_fallback_locals locals;
227: locals.l_outbuf = outptr;
228: locals.l_outbytesleft = outleft;
229: locals.l_errno = 0;
230: cd->fallbacks.uc_to_mb_fallback(wc,
231: uc_to_mb_write_replacement,
232: &locals,
233: cd->fallbacks.data);
234: if (locals.l_errno != 0) {
235: plocals->l_errno = locals.l_errno;
236: break;
237: }
238: outptr = locals.l_outbuf;
239: outleft = locals.l_outbytesleft;
240: outcount = 0;
241: goto outcount_ok;
242: }
243: #endif
244: outcount = cd->ofuncs.xxx_wctomb(cd,outptr,0xFFFD,outleft);
245: if (outcount != RET_ILUNI)
246: goto outcount_ok;
247: plocals->l_errno = EILSEQ;
248: break;
249: outcount_ok:
250: if (outcount < 0) {
251: plocals->l_errno = E2BIG;
252: break;
253: }
254: #ifndef LIBICONV_PLUG
255: if (cd->hooks.uc_hook)
256: (*cd->hooks.uc_hook)(wc, cd->hooks.data);
257: #endif
258: if (!(outcount <= outleft)) abort();
259: outptr += outcount; outleft -= outcount;
260: outcount_zero: ;
261: }
262: plocals->l_outbuf = outptr;
263: plocals->l_outbytesleft = outleft;
264: }
265: }
266:
267: #endif /* !LIBICONV_PLUG */
268:
269: static size_t unicode_loop_convert (iconv_t icd,
270: const char* * inbuf, size_t *inbytesleft,
271: char* * outbuf, size_t *outbytesleft)
272: {
273: conv_t cd = (conv_t) icd;
274: size_t result = 0;
275: const unsigned char* inptr = (const unsigned char*) *inbuf;
276: size_t inleft = *inbytesleft;
277: unsigned char* outptr = (unsigned char*) *outbuf;
278: size_t outleft = *outbytesleft;
279: while (inleft > 0) {
280: state_t last_istate = cd->istate;
281: ucs4_t wc;
282: int incount;
283: int outcount;
284: incount = cd->ifuncs.xxx_mbtowc(cd,&wc,inptr,inleft);
285: if (incount < 0) {
286: if ((unsigned int)(-1-incount) % 2 == (unsigned int)(-1-RET_ILSEQ) % 2) {
287: /* Case 1: invalid input, possibly after a shift sequence */
288: incount = DECODE_SHIFT_ILSEQ(incount);
289: if (cd->discard_ilseq) {
290: switch (cd->iindex) {
291: case ei_ucs4: case ei_ucs4be: case ei_ucs4le:
292: case ei_utf32: case ei_utf32be: case ei_utf32le:
293: case ei_ucs4internal: case ei_ucs4swapped:
294: incount += 4; break;
295: case ei_ucs2: case ei_ucs2be: case ei_ucs2le:
296: case ei_utf16: case ei_utf16be: case ei_utf16le:
297: case ei_ucs2internal: case ei_ucs2swapped:
298: incount += 2; break;
299: default:
300: incount += 1; break;
301: }
302: goto outcount_zero;
303: }
304: #ifndef LIBICONV_PLUG
305: else if (cd->fallbacks.mb_to_uc_fallback != NULL) {
306: unsigned int incount2;
307: struct mb_to_uc_fallback_locals locals;
308: switch (cd->iindex) {
309: case ei_ucs4: case ei_ucs4be: case ei_ucs4le:
310: case ei_utf32: case ei_utf32be: case ei_utf32le:
311: case ei_ucs4internal: case ei_ucs4swapped:
312: incount2 = 4; break;
313: case ei_ucs2: case ei_ucs2be: case ei_ucs2le:
314: case ei_utf16: case ei_utf16be: case ei_utf16le:
315: case ei_ucs2internal: case ei_ucs2swapped:
316: incount2 = 2; break;
317: default:
318: incount2 = 1; break;
319: }
320: locals.l_cd = cd;
321: locals.l_outbuf = outptr;
322: locals.l_outbytesleft = outleft;
323: locals.l_errno = 0;
324: cd->fallbacks.mb_to_uc_fallback((const char*)inptr+incount, incount2,
325: mb_to_uc_write_replacement,
326: &locals,
327: cd->fallbacks.data);
328: if (locals.l_errno != 0) {
329: inptr += incount; inleft -= incount;
330: errno = locals.l_errno;
331: result = -1;
332: break;
333: }
334: incount += incount2;
335: outptr = locals.l_outbuf;
336: outleft = locals.l_outbytesleft;
337: result += 1;
338: goto outcount_zero;
339: }
340: #endif
341: inptr += incount; inleft -= incount;
342: errno = EILSEQ;
343: result = -1;
344: break;
345: }
346: if (incount == RET_TOOFEW(0)) {
347: /* Case 2: not enough bytes available to detect anything */
348: errno = EINVAL;
349: result = -1;
350: break;
351: }
352: /* Case 3: k bytes read, but only a shift sequence */
353: incount = DECODE_TOOFEW(incount);
354: } else {
355: /* Case 4: k bytes read, making up a wide character */
356: if (outleft == 0) {
357: cd->istate = last_istate;
358: errno = E2BIG;
359: result = -1;
360: break;
361: }
362: outcount = cd->ofuncs.xxx_wctomb(cd,outptr,wc,outleft);
363: if (outcount != RET_ILUNI)
364: goto outcount_ok;
365: /* Handle Unicode tag characters (range U+E0000..U+E007F). */
366: if ((wc >> 7) == (0xe0000 >> 7))
367: goto outcount_zero;
368: /* Try transliteration. */
369: result++;
370: if (cd->transliterate) {
371: outcount = unicode_transliterate(cd,wc,outptr,outleft);
372: if (outcount != RET_ILUNI)
373: goto outcount_ok;
374: }
375: if (cd->discard_ilseq) {
376: outcount = 0;
377: goto outcount_ok;
378: }
379: #ifndef LIBICONV_PLUG
380: else if (cd->fallbacks.uc_to_mb_fallback != NULL) {
381: struct uc_to_mb_fallback_locals locals;
382: locals.l_outbuf = outptr;
383: locals.l_outbytesleft = outleft;
384: locals.l_errno = 0;
385: cd->fallbacks.uc_to_mb_fallback(wc,
386: uc_to_mb_write_replacement,
387: &locals,
388: cd->fallbacks.data);
389: if (locals.l_errno != 0) {
390: cd->istate = last_istate;
391: errno = locals.l_errno;
392: return -1;
393: }
394: outptr = locals.l_outbuf;
395: outleft = locals.l_outbytesleft;
396: outcount = 0;
397: goto outcount_ok;
398: }
399: #endif
400: outcount = cd->ofuncs.xxx_wctomb(cd,outptr,0xFFFD,outleft);
401: if (outcount != RET_ILUNI)
402: goto outcount_ok;
403: cd->istate = last_istate;
404: errno = EILSEQ;
405: result = -1;
406: break;
407: outcount_ok:
408: if (outcount < 0) {
409: cd->istate = last_istate;
410: errno = E2BIG;
411: result = -1;
412: break;
413: }
414: #ifndef LIBICONV_PLUG
415: if (cd->hooks.uc_hook)
416: (*cd->hooks.uc_hook)(wc, cd->hooks.data);
417: #endif
418: if (!(outcount <= outleft)) abort();
419: outptr += outcount; outleft -= outcount;
420: }
421: outcount_zero:
422: if (!(incount <= inleft)) abort();
423: inptr += incount; inleft -= incount;
424: }
425: *inbuf = (const char*) inptr;
426: *inbytesleft = inleft;
427: *outbuf = (char*) outptr;
428: *outbytesleft = outleft;
429: return result;
430: }
431:
432: static size_t unicode_loop_reset (iconv_t icd,
433: char* * outbuf, size_t *outbytesleft)
434: {
435: conv_t cd = (conv_t) icd;
436: if (outbuf == NULL || *outbuf == NULL) {
437: /* Reset the states. */
438: memset(&cd->istate,'\0',sizeof(state_t));
439: memset(&cd->ostate,'\0',sizeof(state_t));
440: return 0;
441: } else {
442: size_t result = 0;
443: if (cd->ifuncs.xxx_flushwc) {
444: state_t last_istate = cd->istate;
445: ucs4_t wc;
446: if (cd->ifuncs.xxx_flushwc(cd, &wc)) {
447: unsigned char* outptr = (unsigned char*) *outbuf;
448: size_t outleft = *outbytesleft;
449: int outcount = cd->ofuncs.xxx_wctomb(cd,outptr,wc,outleft);
450: if (outcount != RET_ILUNI)
451: goto outcount_ok;
452: /* Handle Unicode tag characters (range U+E0000..U+E007F). */
453: if ((wc >> 7) == (0xe0000 >> 7))
454: goto outcount_zero;
455: /* Try transliteration. */
456: result++;
457: if (cd->transliterate) {
458: outcount = unicode_transliterate(cd,wc,outptr,outleft);
459: if (outcount != RET_ILUNI)
460: goto outcount_ok;
461: }
462: if (cd->discard_ilseq) {
463: outcount = 0;
464: goto outcount_ok;
465: }
466: #ifndef LIBICONV_PLUG
467: else if (cd->fallbacks.uc_to_mb_fallback != NULL) {
468: struct uc_to_mb_fallback_locals locals;
469: locals.l_outbuf = outptr;
470: locals.l_outbytesleft = outleft;
471: locals.l_errno = 0;
472: cd->fallbacks.uc_to_mb_fallback(wc,
473: uc_to_mb_write_replacement,
474: &locals,
475: cd->fallbacks.data);
476: if (locals.l_errno != 0) {
477: cd->istate = last_istate;
478: errno = locals.l_errno;
479: return -1;
480: }
481: outptr = locals.l_outbuf;
482: outleft = locals.l_outbytesleft;
483: outcount = 0;
484: goto outcount_ok;
485: }
486: #endif
487: outcount = cd->ofuncs.xxx_wctomb(cd,outptr,0xFFFD,outleft);
488: if (outcount != RET_ILUNI)
489: goto outcount_ok;
490: cd->istate = last_istate;
491: errno = EILSEQ;
492: return -1;
493: outcount_ok:
494: if (outcount < 0) {
495: cd->istate = last_istate;
496: errno = E2BIG;
497: return -1;
498: }
499: #ifndef LIBICONV_PLUG
500: if (cd->hooks.uc_hook)
501: (*cd->hooks.uc_hook)(wc, cd->hooks.data);
502: #endif
503: if (!(outcount <= outleft)) abort();
504: outptr += outcount;
505: outleft -= outcount;
506: outcount_zero:
507: *outbuf = (char*) outptr;
508: *outbytesleft = outleft;
509: }
510: }
511: if (cd->ofuncs.xxx_reset) {
512: unsigned char* outptr = (unsigned char*) *outbuf;
513: size_t outleft = *outbytesleft;
514: int outcount = cd->ofuncs.xxx_reset(cd,outptr,outleft);
515: if (outcount < 0) {
516: errno = E2BIG;
517: return -1;
518: }
519: if (!(outcount <= outleft)) abort();
520: *outbuf = (char*) (outptr + outcount);
521: *outbytesleft = outleft - outcount;
522: }
523: memset(&cd->istate,'\0',sizeof(state_t));
524: memset(&cd->ostate,'\0',sizeof(state_t));
525: return result;
526: }
527: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to loop_unicode.h CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libiconv / lib