1: /* Mapping tables for EUC-CN handling.
    2:    Copyright (C) 1998, 1999, 2000-2002 Free Software Foundation, Inc.
    3:    This file is part of the GNU C Library.
    4:    Contributed by Ulrich Drepper <drepper@cygnus.com>, 1998.
    5: 
    6:    The GNU C Library is free software; you can redistribute it and/or
    7:    modify it under the terms of the GNU Lesser General Public
    8:    License as published by the Free Software Foundation; either
    9:    version 2.1 of the License, or (at your option) any later version.
   10: 
   11:    The GNU C Library is distributed in the hope that it will be useful,
   12:    but WITHOUT ANY WARRANTY; without even the implied warranty of
   13:    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   14:    Lesser General Public License for more details.
   15: 
   16:    You should have received a copy of the GNU Lesser General Public
   17:    License along with the GNU C Library; if not, write to the Free
   18:    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   19:    02111-1307 USA.  */
   20: 
   21: #include <dlfcn.h>
   22: #include <gb2312.h>
   23: #include <stdint.h>
   24: 
   25: /* Definitions used in the body of the `gconv' function.  */
   26: #define CHARSET_NAME            "EUC-CN//"
   27: #define FROM_LOOP               from_euc_cn
   28: #define TO_LOOP                 to_euc_cn
   29: #define DEFINE_INIT             1
   30: #define DEFINE_FINI             1
   31: #define MIN_NEEDED_FROM         1
   32: #define MAX_NEEDED_FROM         2
   33: #define MIN_NEEDED_TO           4
   34: 
   35: 
   36: /* First define the conversion function from EUC-CN to UCS4.  */
   37: #define MIN_NEEDED_INPUT        MIN_NEEDED_FROM
   38: #define MAX_NEEDED_INPUT        MAX_NEEDED_FROM
   39: #define MIN_NEEDED_OUTPUT       MIN_NEEDED_TO
   40: #define LOOPFCT                 FROM_LOOP
   41: #define BODY \
   42:   {                                                                           \
   43:     uint32_t ch = *inptr;                                                     \
   44:                                                                               \
   45:     if (ch <= 0x7f)                                                           \
   46:       ++inptr;                                                                \
   47:     else                                                                      \
   48:       if ((__builtin_expect (ch <= 0xa0, 0) && ch != 0x8e && ch != 0x8f)      \
   49:           || __builtin_expect (ch > 0xfe, 0))                                \
   50:         {                                                                    \
   51:           /* This is illegal.  */                                            \
   52:           STANDARD_FROM_LOOP_ERR_HANDLER (1);                                \
   53:         }                                                                    \
   54:       else                                                                    \
   55:         {                                                                    \
   56:           /* Two or more byte character.  First test whether the             \
   57:              next byte is also available.  */                                \
   58:           const unsigned char *endp;                                         \
   59:                                                                               \
   60:           if (__builtin_expect (inptr + 1 >= inend, 0))                              \
   61:             {                                                                \
   62:               /* The second character is not available.  Store               \
   63:                  the intermediate result.  */                               \
   64:               result = __GCONV_INCOMPLETE_INPUT;                             \
   65:               break;                                                         \
   66:             }                                                                \
   67:                                                                               \
   68:           ch = inptr[1];                                                     \
   69:                                                                               \
   70:           /* All second bytes of a multibyte character must be >= 0xa1. */    \
   71:           if (__builtin_expect (ch < 0xa1, 0))                               \
   72:             STANDARD_FROM_LOOP_ERR_HANDLER (1);                                      \
   73:                                                                               \
   74:           /* This is code set 1: GB 2312-80.  */                             \
   75:           endp = inptr;                                                              \
   76:                                                                               \
   77:           ch = gb2312_to_ucs4 (&endp, 2, 0x80);                                      \
   78:           if (__builtin_expect (ch == __UNKNOWN_10646_CHAR, 0))                      \
   79:             {                                                                \
   80:               /* This is an illegal character.  */                           \
   81:               STANDARD_FROM_LOOP_ERR_HANDLER (2);                            \
   82:             }                                                                \
   83:                                                                               \
   84:           inptr += 2;                                                        \
   85:         }                                                                    \
   86:                                                                               \
   87:     put32 (outptr, ch);                                                       \
   88:     outptr += 4;                                                              \
   89:   }
   90: #define LOOP_NEED_FLAGS
   91: #define ONEBYTE_BODY \
   92:   {                                                                           \
   93:     if (c < 0x80)                                                             \
   94:       return c;                                                               \
   95:     else                                                                      \
   96:       return WEOF;                                                            \
   97:   }
   98: #include <iconv/loop.c>
   99: 
  100: 
  101: /* Next, define the other direction.  */
  102: #define MIN_NEEDED_INPUT        MIN_NEEDED_TO
  103: #define MIN_NEEDED_OUTPUT       MIN_NEEDED_FROM
  104: #define MAX_NEEDED_OUTPUT       MAX_NEEDED_FROM
  105: #define LOOPFCT                 TO_LOOP
  106: #define BODY \
  107:   {                                                                           \
  108:     uint32_t ch = get32 (inptr);                                              \
  109:                                                                               \
  110:     if (ch <= L'\x7f')                                                        \
  111:       /* It's plain ASCII.  */                                                \
  112:       *outptr++ = (unsigned char) ch;                                         \
  113:     else                                                                      \
  114:       {                                                                       \
  115:         size_t found;                                                        \
  116:                                                                               \
  117:         found = ucs4_to_gb2312 (ch, outptr, outend - outptr);                \
  118:         if (__builtin_expect (found, 1) != 0)                                \
  119:           {                                                                  \
  120:             if (__builtin_expect (found, 0) == __UNKNOWN_10646_CHAR)         \
  121:               {                                                                      \
  122:                 UNICODE_TAG_HANDLER (ch, 4);                                \
  123:                                                                               \
  124:                 /* Illegal character.  */                                   \
  125:                 STANDARD_TO_LOOP_ERR_HANDLER (4);                           \
  126:               }                                                                      \
  127:                                                                               \
  128:             /* It's a GB 2312 character, adjust it for EUC-CN.  */           \
  129:             *outptr++ += 0x80;                                               \
  130:             *outptr++ += 0x80;                                               \
  131:           }                                                                  \
  132:         else                                                                 \
  133:           {                                                                  \
  134:             /* We ran out of space.  */                                              \
  135:             result = __GCONV_FULL_OUTPUT;                                    \
  136:             break;                                                           \
  137:           }                                                                  \
  138:       }                                                                       \
  139:     inptr += 4;                                                               \
  140:   }
  141: #define LOOP_NEED_FLAGS
  142: #include <iconv/loop.c>
  143: 
  144: 
  145: /* Now define the toplevel functions.  */
  146: #include <iconv/skeleton.c>