1: /*
2: * Copyright (C) 2000-2002, 2005-2006, 2008-2009, 2011 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 three conversion loops:
22: - from wchar_t to anything else,
23: - from anything else to wchar_t,
24: - from wchar_t to wchar_t.
25: */
26:
27: #if HAVE_WCRTOMB || HAVE_MBRTOWC
28: /* Tru64 with Desktop Toolkit C has a bug: <stdio.h> must be included before
29: <wchar.h>.
30: BSD/OS 4.0.1 has a bug: <stddef.h>, <stdio.h> and <time.h> must be
31: included before <wchar.h>.
32: In some builds of uClibc, <wchar.h> is nonexistent and wchar_t is defined
33: by <stddef.h>. */
34: # include <stddef.h>
35: # include <stdio.h>
36: # include <time.h>
37: # include <wchar.h>
38: # define BUF_SIZE 64 /* assume MB_LEN_MAX <= 64 */
39: /* Some systems, like BeOS, have multibyte encodings but lack mbstate_t. */
40: extern size_t mbrtowc ();
41: # ifdef mbstate_t
42: # define mbrtowc(pwc, s, n, ps) (mbrtowc)(pwc, s, n, 0)
43: # define mbsinit(ps) 1
44: # endif
45: # ifndef mbsinit
46: # if !HAVE_MBSINIT
47: # define mbsinit(ps) 1
48: # endif
49: # endif
50: #endif
51:
52: /*
53: * The first two conversion loops have an extended conversion descriptor.
54: */
55: struct wchar_conv_struct {
56: struct conv_struct parent;
57: #if HAVE_WCRTOMB || HAVE_MBRTOWC
58: mbstate_t state;
59: #endif
60: };
61:
62:
63: #if HAVE_WCRTOMB
64:
65: /* From wchar_t to anything else. */
66:
67: #ifndef LIBICONV_PLUG
68:
69: #if 0
70:
71: struct wc_to_mb_fallback_locals {
72: struct wchar_conv_struct * l_wcd;
73: char* l_outbuf;
74: size_t l_outbytesleft;
75: int l_errno;
76: };
77:
78: /* A callback that writes a string given in the locale encoding. */
79: static void wc_to_mb_write_replacement (const char *buf, size_t buflen,
80: void* callback_arg)
81: {
82: struct wc_to_mb_fallback_locals * plocals =
83: (struct wc_to_mb_fallback_locals *) callback_arg;
84: /* Do nothing if already encountered an error in a previous call. */
85: if (plocals->l_errno == 0) {
86: /* Attempt to convert the passed buffer to the target encoding.
87: Here we don't support characters split across multiple calls. */
88: const char* bufptr = buf;
89: size_t bufleft = buflen;
90: size_t res = unicode_loop_convert(&plocals->l_wcd->parent,
91: &bufptr,&bufleft,
92: &plocals->l_outbuf,&plocals->l_outbytesleft);
93: if (res == (size_t)(-1)) {
94: if (errno == EILSEQ || errno == EINVAL)
95: /* Invalid buf contents. */
96: plocals->l_errno = EILSEQ;
97: else if (errno == E2BIG)
98: /* Output buffer too small. */
99: plocals->l_errno = E2BIG;
100: else
101: abort();
102: } else {
103: /* Successful conversion. */
104: if (bufleft > 0)
105: abort();
106: }
107: }
108: }
109:
110: #else
111:
112: struct wc_to_mb_fallback_locals {
113: char* l_outbuf;
114: size_t l_outbytesleft;
115: int l_errno;
116: };
117:
118: /* A callback that writes a string given in the target encoding. */
119: static void wc_to_mb_write_replacement (const char *buf, size_t buflen,
120: void* callback_arg)
121: {
122: struct wc_to_mb_fallback_locals * plocals =
123: (struct wc_to_mb_fallback_locals *) callback_arg;
124: /* Do nothing if already encountered an error in a previous call. */
125: if (plocals->l_errno == 0) {
126: /* Attempt to copy the passed buffer to the output buffer. */
127: if (plocals->l_outbytesleft < buflen)
128: plocals->l_errno = E2BIG;
129: else {
130: memcpy(plocals->l_outbuf, buf, buflen);
131: plocals->l_outbuf += buflen;
132: plocals->l_outbytesleft -= buflen;
133: }
134: }
135: }
136:
137: #endif
138:
139: #endif /* !LIBICONV_PLUG */
140:
141: static size_t wchar_from_loop_convert (iconv_t icd,
142: const char* * inbuf, size_t *inbytesleft,
143: char* * outbuf, size_t *outbytesleft)
144: {
145: struct wchar_conv_struct * wcd = (struct wchar_conv_struct *) icd;
146: size_t result = 0;
147: while (*inbytesleft >= sizeof(wchar_t)) {
148: const wchar_t * inptr = (const wchar_t *) *inbuf;
149: size_t inleft = *inbytesleft;
150: char buf[BUF_SIZE];
151: mbstate_t state = wcd->state;
152: size_t bufcount = 0;
153: while (inleft >= sizeof(wchar_t)) {
154: /* Convert one wchar_t to multibyte representation. */
155: size_t count = wcrtomb(buf+bufcount,*inptr,&state);
156: if (count == (size_t)(-1)) {
157: /* Invalid input. */
158: if (wcd->parent.discard_ilseq) {
159: count = 0;
160: }
161: #ifndef LIBICONV_PLUG
162: else if (wcd->parent.fallbacks.wc_to_mb_fallback != NULL) {
163: /* Drop the contents of buf[] accumulated so far, and instead
164: pass all queued wide characters to the fallback handler. */
165: struct wc_to_mb_fallback_locals locals;
166: const wchar_t * fallback_inptr;
167: #if 0
168: locals.l_wcd = wcd;
169: #endif
170: locals.l_outbuf = *outbuf;
171: locals.l_outbytesleft = *outbytesleft;
172: locals.l_errno = 0;
173: for (fallback_inptr = (const wchar_t *) *inbuf;
174: fallback_inptr <= inptr;
175: fallback_inptr++)
176: wcd->parent.fallbacks.wc_to_mb_fallback(*fallback_inptr,
177: wc_to_mb_write_replacement,
178: &locals,
179: wcd->parent.fallbacks.data);
180: if (locals.l_errno != 0) {
181: errno = locals.l_errno;
182: return -1;
183: }
184: wcd->state = state;
185: *inbuf = (const char *) (inptr + 1);
186: *inbytesleft = inleft - sizeof(wchar_t);
187: *outbuf = locals.l_outbuf;
188: *outbytesleft = locals.l_outbytesleft;
189: result += 1;
190: break;
191: }
192: #endif
193: else {
194: errno = EILSEQ;
195: return -1;
196: }
197: }
198: inptr++;
199: inleft -= sizeof(wchar_t);
200: bufcount += count;
201: if (count == 0) {
202: /* Continue, append next wchar_t. */
203: } else {
204: /* Attempt to convert the accumulated multibyte representations
205: to the target encoding. */
206: const char* bufptr = buf;
207: size_t bufleft = bufcount;
208: char* outptr = *outbuf;
209: size_t outleft = *outbytesleft;
210: size_t res = unicode_loop_convert(&wcd->parent,
211: &bufptr,&bufleft,
212: &outptr,&outleft);
213: if (res == (size_t)(-1)) {
214: if (errno == EILSEQ)
215: /* Invalid input. */
216: return -1;
217: else if (errno == E2BIG)
218: /* Output buffer too small. */
219: return -1;
220: else if (errno == EINVAL) {
221: /* Continue, append next wchar_t, but avoid buffer overrun. */
222: if (bufcount + MB_CUR_MAX > BUF_SIZE)
223: abort();
224: } else
225: abort();
226: } else {
227: /* Successful conversion. */
228: wcd->state = state;
229: *inbuf = (const char *) inptr;
230: *inbytesleft = inleft;
231: *outbuf = outptr;
232: *outbytesleft = outleft;
233: result += res;
234: break;
235: }
236: }
237: }
238: }
239: return result;
240: }
241:
242: static size_t wchar_from_loop_reset (iconv_t icd,
243: char* * outbuf, size_t *outbytesleft)
244: {
245: struct wchar_conv_struct * wcd = (struct wchar_conv_struct *) icd;
246: if (outbuf == NULL || *outbuf == NULL) {
247: /* Reset the states. */
248: memset(&wcd->state,'\0',sizeof(mbstate_t));
249: return unicode_loop_reset(&wcd->parent,NULL,NULL);
250: } else {
251: if (!mbsinit(&wcd->state)) {
252: mbstate_t state = wcd->state;
253: char buf[BUF_SIZE];
254: size_t bufcount = wcrtomb(buf,(wchar_t)0,&state);
255: if (bufcount == (size_t)(-1) || bufcount == 0 || buf[bufcount-1] != '\0')
256: abort();
257: else {
258: const char* bufptr = buf;
259: size_t bufleft = bufcount-1;
260: char* outptr = *outbuf;
261: size_t outleft = *outbytesleft;
262: size_t res = unicode_loop_convert(&wcd->parent,
263: &bufptr,&bufleft,
264: &outptr,&outleft);
265: if (res == (size_t)(-1)) {
266: if (errno == E2BIG)
267: return -1;
268: else
269: abort();
270: } else {
271: res = unicode_loop_reset(&wcd->parent,&outptr,&outleft);
272: if (res == (size_t)(-1))
273: return res;
274: else {
275: /* Successful. */
276: wcd->state = state;
277: *outbuf = outptr;
278: *outbytesleft = outleft;
279: return 0;
280: }
281: }
282: }
283: } else
284: return unicode_loop_reset(&wcd->parent,outbuf,outbytesleft);
285: }
286: }
287:
288: #endif
289:
290:
291: #if HAVE_MBRTOWC
292:
293: /* From anything else to wchar_t. */
294:
295: #ifndef LIBICONV_PLUG
296:
297: struct mb_to_wc_fallback_locals {
298: char* l_outbuf;
299: size_t l_outbytesleft;
300: int l_errno;
301: };
302:
303: static void mb_to_wc_write_replacement (const wchar_t *buf, size_t buflen,
304: void* callback_arg)
305: {
306: struct mb_to_wc_fallback_locals * plocals =
307: (struct mb_to_wc_fallback_locals *) callback_arg;
308: /* Do nothing if already encountered an error in a previous call. */
309: if (plocals->l_errno == 0) {
310: /* Attempt to copy the passed buffer to the output buffer. */
311: if (plocals->l_outbytesleft < sizeof(wchar_t)*buflen)
312: plocals->l_errno = E2BIG;
313: else {
314: for (; buflen > 0; buf++, buflen--) {
315: *(wchar_t*) plocals->l_outbuf = *buf;
316: plocals->l_outbuf += sizeof(wchar_t);
317: plocals->l_outbytesleft -= sizeof(wchar_t);
318: }
319: }
320: }
321: }
322:
323: #endif /* !LIBICONV_PLUG */
324:
325: static size_t wchar_to_loop_convert (iconv_t icd,
326: const char* * inbuf, size_t *inbytesleft,
327: char* * outbuf, size_t *outbytesleft)
328: {
329: struct wchar_conv_struct * wcd = (struct wchar_conv_struct *) icd;
330: size_t result = 0;
331: while (*inbytesleft > 0) {
332: size_t incount;
333: for (incount = 1; ; ) {
334: /* Here incount <= *inbytesleft. */
335: char buf[BUF_SIZE];
336: const char* inptr = *inbuf;
337: size_t inleft = incount;
338: char* bufptr = buf;
339: size_t bufleft = BUF_SIZE;
340: size_t res = unicode_loop_convert(&wcd->parent,
341: &inptr,&inleft,
342: &bufptr,&bufleft);
343: if (res == (size_t)(-1)) {
344: if (errno == EILSEQ)
345: /* Invalid input. */
346: return -1;
347: else if (errno == EINVAL) {
348: /* Incomplete input. Next try with one more input byte. */
349: } else
350: /* E2BIG shouldn't occur. */
351: abort();
352: } else {
353: /* Successful conversion. */
354: size_t bufcount = bufptr-buf; /* = BUF_SIZE-bufleft */
355: mbstate_t state = wcd->state;
356: wchar_t wc;
357: res = mbrtowc(&wc,buf,bufcount,&state);
358: if (res == (size_t)(-2)) {
359: /* Next try with one more input byte. */
360: } else {
361: if (res == (size_t)(-1)) {
362: /* Invalid input. */
363: if (wcd->parent.discard_ilseq) {
364: }
365: #ifndef LIBICONV_PLUG
366: else if (wcd->parent.fallbacks.mb_to_wc_fallback != NULL) {
367: /* Drop the contents of buf[] accumulated so far, and instead
368: pass all queued chars to the fallback handler. */
369: struct mb_to_wc_fallback_locals locals;
370: locals.l_outbuf = *outbuf;
371: locals.l_outbytesleft = *outbytesleft;
372: locals.l_errno = 0;
373: wcd->parent.fallbacks.mb_to_wc_fallback(*inbuf, incount,
374: mb_to_wc_write_replacement,
375: &locals,
376: wcd->parent.fallbacks.data);
377: if (locals.l_errno != 0) {
378: errno = locals.l_errno;
379: return -1;
380: }
381: /* Restoring the state is not needed because it is the initial
382: state anyway: For all known locale encodings, the multibyte
383: to wchar_t conversion doesn't have shift state, and we have
384: excluded partial accumulated characters. */
385: /* wcd->state = state; */
386: *inbuf += incount;
387: *inbytesleft -= incount;
388: *outbuf = locals.l_outbuf;
389: *outbytesleft = locals.l_outbytesleft;
390: result += 1;
391: break;
392: }
393: #endif
394: else
395: return -1;
396: } else {
397: if (*outbytesleft < sizeof(wchar_t)) {
398: errno = E2BIG;
399: return -1;
400: }
401: *(wchar_t*) *outbuf = wc;
402: /* Restoring the state is not needed because it is the initial
403: state anyway: For all known locale encodings, the multibyte
404: to wchar_t conversion doesn't have shift state, and we have
405: excluded partial accumulated characters. */
406: /* wcd->state = state; */
407: *outbuf += sizeof(wchar_t);
408: *outbytesleft -= sizeof(wchar_t);
409: }
410: *inbuf += incount;
411: *inbytesleft -= incount;
412: result += res;
413: break;
414: }
415: }
416: incount++;
417: if (incount > *inbytesleft) {
418: /* Incomplete input. */
419: errno = EINVAL;
420: return -1;
421: }
422: }
423: }
424: return result;
425: }
426:
427: static size_t wchar_to_loop_reset (iconv_t icd,
428: char* * outbuf, size_t *outbytesleft)
429: {
430: struct wchar_conv_struct * wcd = (struct wchar_conv_struct *) icd;
431: size_t res = unicode_loop_reset(&wcd->parent,outbuf,outbytesleft);
432: if (res == (size_t)(-1))
433: return res;
434: memset(&wcd->state,0,sizeof(mbstate_t));
435: return 0;
436: }
437:
438: #endif
439:
440:
441: /* From wchar_t to wchar_t. */
442:
443: static size_t wchar_id_loop_convert (iconv_t icd,
444: const char* * inbuf, size_t *inbytesleft,
445: char* * outbuf, size_t *outbytesleft)
446: {
447: struct conv_struct * cd = (struct conv_struct *) icd;
448: const wchar_t* inptr = (const wchar_t*) *inbuf;
449: size_t inleft = *inbytesleft / sizeof(wchar_t);
450: wchar_t* outptr = (wchar_t*) *outbuf;
451: size_t outleft = *outbytesleft / sizeof(wchar_t);
452: size_t count = (inleft <= outleft ? inleft : outleft);
453: if (count > 0) {
454: *inbytesleft -= count * sizeof(wchar_t);
455: *outbytesleft -= count * sizeof(wchar_t);
456: do {
457: wchar_t wc = *inptr++;
458: *outptr++ = wc;
459: #ifndef LIBICONV_PLUG
460: if (cd->hooks.wc_hook)
461: (*cd->hooks.wc_hook)(wc, cd->hooks.data);
462: #endif
463: } while (--count > 0);
464: *inbuf = (const char*) inptr;
465: *outbuf = (char*) outptr;
466: }
467: return 0;
468: }
469:
470: static size_t wchar_id_loop_reset (iconv_t icd,
471: char* * outbuf, size_t *outbytesleft)
472: {
473: return 0;
474: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to loop_wchar.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