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