Debian Codegraph @

deps/libiconv/lib/loop_wchar.h

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