]> git.ipfire.org Git - thirdparty/glibc.git/blobdiff - iconvdata/euc-tw.c
Update copyright notices with scripts/update-copyrights
[thirdparty/glibc.git] / iconvdata / euc-tw.c
index a508c848ef183d342789779a67267c77674bc819..58ad6f1f8bf25b7667a58d51ed31f17af835cd94 100644 (file)
@@ -1,23 +1,23 @@
 /* Mapping tables for EUC-TW handling.
-   Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc.
+   Copyright (C) 1998-2014 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Ulrich Drepper <drepper@cygnus.com>, 1998.
 
    The GNU C Library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Library General Public License as
-   published by the Free Software Foundation; either version 2 of the
-   License, or (at your option) any later version.
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
 
    The GNU C Library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Library General Public License for more details.
+   Lesser General Public License for more details.
 
-   You should have received a copy of the GNU Library General Public
-   License along with the GNU C Library; see the file COPYING.LIB.  If not,
-   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <http://www.gnu.org/licenses/>.  */
 
+#include <dlfcn.h>
 #include <stdint.h>
 #include <cns11643l1.h>
 #include <cns11643.h>
     else if ((ch <= 0xa0 || ch > 0xfe) && ch != 0x8e)                        \
       {                                                                              \
        /* This is illegal.  */                                               \
-       result = __GCONV_ILLEGAL_INPUT;                                       \
-       break;                                                                \
+       STANDARD_FROM_LOOP_ERR_HANDLER (1);                                   \
       }                                                                              \
     else                                                                     \
       {                                                                              \
-       /* Two or more byte character.  First test whether the next           \
-          character is also available.  */                                   \
+       /* Two or more byte character.  First test whether the next byte      \
+          is also available.  */                                             \
        uint32_t ch2;                                                         \
                                                                              \
-       if (NEED_LENGTH_TEST && inptr + (ch == 0x8e ? 3 : 1) >= inend)        \
+       if (inptr + 1 >= inend)                                               \
          {                                                                   \
-           /* The second character is not available.  Store the              \
-              intermediate result.  */                                       \
+           /* The second byte is not available.  Store the intermediate      \
+              result.  */                                                    \
            result = __GCONV_INCOMPLETE_INPUT;                                \
            break;                                                            \
          }                                                                   \
                                                                              \
-       ch2 = *inptr;                                                         \
+       ch2 = *(inptr + 1);                                                   \
                                                                              \
        /* All second bytes of a multibyte character must be >= 0xa1. */      \
        if (ch2 < 0xa1 || ch2 == 0xff)                                        \
-         {                                                                   \
-           /* This is an illegal character.  */                              \
-           result = __GCONV_ILLEGAL_INPUT;                                   \
-           break;                                                            \
-         }                                                                   \
+         STANDARD_FROM_LOOP_ERR_HANDLER (1);                                 \
                                                                              \
        if (ch == 0x8e)                                                       \
          {                                                                   \
            /* This is code set 2: CNS 11643, planes 1 to 16.  */             \
-           const char *endp = inptr + 1;                                     \
+           const unsigned char *endp = inptr + 1;                            \
                                                                              \
-           ch = cns11643_to_ucs4 (&endp,                                     \
-                                  NEED_LENGTH_TEST ? inend - inptr - 1 : 3,  \
-                                  0x80);                                     \
-           /* Please note that we need not test for the missing input        \
-              characters here anymore.  */                                   \
-           if (ch == __UNKNOWN_10646_CHAR)                                   \
+           ch = cns11643_to_ucs4 (&endp, inend - inptr - 1, 0x80);           \
+                                                                             \
+           if (ch == 0)                                                      \
              {                                                               \
-               /* Illegal input.  */                                         \
-               result = __GCONV_ILLEGAL_INPUT;                               \
+               /* The third or fourth byte is not available.  Store          \
+                  the intermediate result.  */                               \
+               result = __GCONV_INCOMPLETE_INPUT;                            \
                break;                                                        \
              }                                                               \
                                                                              \
+           if (ch == __UNKNOWN_10646_CHAR)                                   \
+             /* Illegal input.  */                                           \
+             STANDARD_FROM_LOOP_ERR_HANDLER (1);                             \
+                                                                             \
            inptr += 4;                                                       \
          }                                                                   \
        else                                                                  \
            /* This is code set 1: CNS 11643, plane 1.  */                    \
            const unsigned char *endp = inptr;                                \
                                                                              \
-           ch = cns11643l1_to_ucs4 (&endp,                                   \
-                                    NEED_LENGTH_TEST ? inend - inptr : 2,    \
-                                    0x80);                                   \
+           ch = cns11643l1_to_ucs4 (&endp, inend - inptr, 0x80);             \
            /* Please note that we need not test for the missing input        \
               characters here anymore.  */                                   \
            if (ch == __UNKNOWN_10646_CHAR)                                   \
-             {                                                               \
-               /* Illegal input.  */                                         \
-               result = __GCONV_ILLEGAL_INPUT;                               \
-               break;                                                        \
-             }                                                               \
+             /* Illegal input.  */                                           \
+             STANDARD_FROM_LOOP_ERR_HANDLER (2);                             \
                                                                              \
            inptr += 2;                                                       \
          }                                                                   \
     put32 (outptr, ch);                                                              \
     outptr += 4;                                                             \
   }
+#define LOOP_NEED_FLAGS
+#define ONEBYTE_BODY \
+  {                                                                          \
+    if (c < 0x80)                                                            \
+      return c;                                                                      \
+    else                                                                     \
+      return WEOF;                                                           \
+  }
 #include <iconv/loop.c>
 
 
       *outptr++ = ch;                                                        \
     else                                                                     \
       {                                                                              \
-       /* Try the JIS character sets.  */                                    \
+       /* Try the CNS 11643 planes.  */                                      \
        size_t found;                                                         \
                                                                              \
-       found = ucs4_to_cns11643l1 (ch, outptr,                               \
-                                   NEED_LENGTH_TEST ? outend - outptr : 2);  \
-       if (NEED_LENGTH_TEST && found == 0)                                   \
+       found = ucs4_to_cns11643l1 (ch, outptr, outend - outptr);             \
+       if (__builtin_expect (found, 1) == 0)                                 \
          {                                                                   \
            /* We ran out of space.  */                                       \
-           result = __GCONV_INCOMPLETE_INPUT;                                \
+           result = __GCONV_FULL_OUTPUT;                                     \
            break;                                                            \
          }                                                                   \
-       if (found != __UNKNOWN_10646_CHAR)                                    \
+       if (__builtin_expect (found, 1) != __UNKNOWN_10646_CHAR)              \
          {                                                                   \
            /* It's a CNS 11643, plane 1 character, adjust it for EUC-TW.  */ \
            *outptr++ += 0x80;                                                \
          {                                                                   \
            /* No CNS 11643, plane 1 character.  */                           \
                                                                              \
-           found = ucs4_to_cns11643 (ch, outptr + 1,                         \
-                                     (NEED_LENGTH_TEST                       \
-                                      ? outend - outptr - 1 : 3));           \
-           if (NEED_LENGTH_TEST && found == 0)                               \
+           found = ucs4_to_cns11643 (ch, outptr + 1, outend - outptr - 1);   \
+           if (__builtin_expect (found, 1) == 0)                             \
              {                                                               \
                /* We ran out of space.  */                                   \
-               result = __GCONV_INCOMPLETE_INPUT;                            \
+               result = __GCONV_FULL_OUTPUT;                                 \
                break;                                                        \
              }                                                               \
-           if (found == __UNKNOWN_10646_CHAR)                                \
+           if (__builtin_expect (found, 0) == __UNKNOWN_10646_CHAR)          \
              {                                                               \
-               /* No legal input.  */                                        \
-               result = __GCONV_ILLEGAL_INPUT;                               \
-               break;                                                        \
+               UNICODE_TAG_HANDLER (ch, 4);                                  \
+                                                                             \
+               /* Illegal character.  */                                     \
+               STANDARD_TO_LOOP_ERR_HANDLER (4);                             \
              }                                                               \
                                                                              \
            /* It's a CNS 11643 character, adjust it for EUC-TW.  */          \
                                                                              \
     inptr += 4;                                                                      \
   }
+#define LOOP_NEED_FLAGS
 #include <iconv/loop.c>