release/src/router/libiconv/lib/loop_unicode.h

   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 }