LCOV - code coverage report
Current view: top level - Modules/cjkcodecs - _codecs_jp.c (source / functions) Hit Total Coverage
Test: CPython 3.12 LCOV report [commit 5e6661bce9] Lines: 1 406 0.2 %
Date: 2023-03-20 08:15:36 Functions: 1 11 9.1 %
Branches: 0 854 0.0 %

           Branch data     Line data    Source code
       1                 :            : /*
       2                 :            :  * _codecs_jp.c: Codecs collection for Japanese encodings
       3                 :            :  *
       4                 :            :  * Written by Hye-Shik Chang <perky@FreeBSD.org>
       5                 :            :  */
       6                 :            : 
       7                 :            : #define USING_BINARY_PAIR_SEARCH
       8                 :            : #define EMPBASE 0x20000
       9                 :            : 
      10                 :            : #include "cjkcodecs.h"
      11                 :            : #include "mappings_jp.h"
      12                 :            : #include "mappings_jisx0213_pair.h"
      13                 :            : #include "alg_jisx0201.h"
      14                 :            : #include "emu_jisx0213_2000.h"
      15                 :            : 
      16                 :            : /*
      17                 :            :  * CP932 codec
      18                 :            :  */
      19                 :            : 
      20                 :          0 : ENCODER(cp932)
      21                 :            : {
      22         [ #  # ]:          0 :     while (*inpos < inlen) {
      23                 :          0 :         Py_UCS4 c = INCHAR1;
      24                 :            :         DBCHAR code;
      25                 :            :         unsigned char c1, c2;
      26                 :            : 
      27         [ #  # ]:          0 :         if (c <= 0x80) {
      28         [ #  # ]:          0 :             WRITEBYTE1((unsigned char)c);
      29                 :          0 :             NEXT(1, 1);
      30                 :          0 :             continue;
      31                 :            :         }
      32   [ #  #  #  # ]:          0 :         else if (c >= 0xff61 && c <= 0xff9f) {
      33         [ #  # ]:          0 :             WRITEBYTE1(c - 0xfec0);
      34                 :          0 :             NEXT(1, 1);
      35                 :          0 :             continue;
      36                 :            :         }
      37   [ #  #  #  # ]:          0 :         else if (c >= 0xf8f0 && c <= 0xf8f3) {
      38                 :            :             /* Windows compatibility */
      39         [ #  # ]:          0 :             REQUIRE_OUTBUF(1);
      40         [ #  # ]:          0 :             if (c == 0xf8f0)
      41                 :          0 :                 OUTBYTE1(0xa0);
      42                 :            :             else
      43                 :          0 :                 OUTBYTE1(c - 0xf8f1 + 0xfd);
      44                 :          0 :             NEXT(1, 1);
      45                 :          0 :             continue;
      46                 :            :         }
      47                 :            : 
      48         [ #  # ]:          0 :         if (c > 0xFFFF)
      49                 :          0 :             return 1;
      50         [ #  # ]:          0 :         REQUIRE_OUTBUF(2);
      51                 :            : 
      52   [ #  #  #  #  :          0 :         if (TRYMAP_ENC(cp932ext, code, c)) {
             #  #  #  # ]
      53                 :          0 :             OUTBYTE1(code >> 8);
      54                 :          0 :             OUTBYTE2(code & 0xff);
      55                 :            :         }
      56   [ #  #  #  #  :          0 :         else if (TRYMAP_ENC(jisxcommon, code, c)) {
             #  #  #  # ]
      57         [ #  # ]:          0 :             if (code & 0x8000) /* MSB set: JIS X 0212 */
      58                 :          0 :                 return 1;
      59                 :            : 
      60                 :            :             /* JIS X 0208 */
      61                 :          0 :             c1 = code >> 8;
      62                 :          0 :             c2 = code & 0xff;
      63         [ #  # ]:          0 :             c2 = (((c1 - 0x21) & 1) ? 0x5e : 0) + (c2 - 0x21);
      64                 :          0 :             c1 = (c1 - 0x21) >> 1;
      65         [ #  # ]:          0 :             OUTBYTE1(c1 < 0x1f ? c1 + 0x81 : c1 + 0xc1);
      66         [ #  # ]:          0 :             OUTBYTE2(c2 < 0x3f ? c2 + 0x40 : c2 + 0x41);
      67                 :            :         }
      68   [ #  #  #  # ]:          0 :         else if (c >= 0xe000 && c < 0xe758) {
      69                 :            :             /* User-defined area */
      70                 :          0 :             c1 = (Py_UCS4)(c - 0xe000) / 188;
      71                 :          0 :             c2 = (Py_UCS4)(c - 0xe000) % 188;
      72                 :          0 :             OUTBYTE1(c1 + 0xf0);
      73         [ #  # ]:          0 :             OUTBYTE2(c2 < 0x3f ? c2 + 0x40 : c2 + 0x41);
      74                 :            :         }
      75                 :            :         else
      76                 :          0 :             return 1;
      77                 :            : 
      78                 :          0 :         NEXT(1, 2);
      79                 :            :     }
      80                 :            : 
      81                 :          0 :     return 0;
      82                 :            : }
      83                 :            : 
      84                 :          0 : DECODER(cp932)
      85                 :            : {
      86         [ #  # ]:          0 :     while (inleft > 0) {
      87                 :          0 :         unsigned char c = INBYTE1, c2;
      88                 :            :         Py_UCS4 decoded;
      89                 :            : 
      90         [ #  # ]:          0 :         if (c <= 0x80) {
      91         [ #  # ]:          0 :             OUTCHAR(c);
      92                 :          0 :             NEXT_IN(1);
      93                 :          0 :             continue;
      94                 :            :         }
      95   [ #  #  #  # ]:          0 :         else if (c >= 0xa0 && c <= 0xdf) {
      96         [ #  # ]:          0 :             if (c == 0xa0)
      97         [ #  # ]:          0 :                 OUTCHAR(0xf8f0); /* half-width katakana */
      98                 :            :             else
      99         [ #  # ]:          0 :                 OUTCHAR(0xfec0 + c);
     100                 :          0 :             NEXT_IN(1);
     101                 :          0 :             continue;
     102                 :            :         }
     103         [ #  # ]:          0 :         else if (c >= 0xfd/* && c <= 0xff*/) {
     104                 :            :             /* Windows compatibility */
     105         [ #  # ]:          0 :             OUTCHAR(0xf8f1 - 0xfd + c);
     106                 :          0 :             NEXT_IN(1);
     107                 :          0 :             continue;
     108                 :            :         }
     109                 :            : 
     110         [ #  # ]:          0 :         REQUIRE_INBUF(2);
     111                 :          0 :         c2 = INBYTE2;
     112                 :            : 
     113   [ #  #  #  #  :          0 :         if (TRYMAP_DEC(cp932ext, decoded, c, c2))
             #  #  #  # ]
     114         [ #  # ]:          0 :             OUTCHAR(decoded);
     115   [ #  #  #  #  :          0 :         else if ((c >= 0x81 && c <= 0x9f) || (c >= 0xe0 && c <= 0xea)){
             #  #  #  # ]
     116   [ #  #  #  #  :          0 :             if (c2 < 0x40 || (c2 > 0x7e && c2 < 0x80) || c2 > 0xfc)
             #  #  #  # ]
     117                 :          0 :                 return 1;
     118                 :            : 
     119         [ #  # ]:          0 :             c = (c < 0xe0 ? c - 0x81 : c - 0xc1);
     120         [ #  # ]:          0 :             c2 = (c2 < 0x80 ? c2 - 0x40 : c2 - 0x41);
     121                 :          0 :             c = (2 * c + (c2 < 0x5e ? 0 : 1) + 0x21);
     122         [ #  # ]:          0 :             c2 = (c2 < 0x5e ? c2 : c2 - 0x5e) + 0x21;
     123                 :            : 
     124   [ #  #  #  #  :          0 :             if (TRYMAP_DEC(jisx0208, decoded, c, c2))
             #  #  #  # ]
     125         [ #  # ]:          0 :                 OUTCHAR(decoded);
     126                 :            :             else
     127                 :          0 :                 return 1;
     128                 :            :         }
     129   [ #  #  #  # ]:          0 :         else if (c >= 0xf0 && c <= 0xf9) {
     130   [ #  #  #  # ]:          0 :             if ((c2 >= 0x40 && c2 <= 0x7e) ||
     131   [ #  #  #  # ]:          0 :                 (c2 >= 0x80 && c2 <= 0xfc))
     132   [ #  #  #  # ]:          0 :                 OUTCHAR(0xe000 + 188 * (c - 0xf0) +
     133                 :            :                     (c2 < 0x80 ? c2 - 0x40 : c2 - 0x41));
     134                 :            :             else
     135                 :          0 :                 return 1;
     136                 :            :         }
     137                 :            :         else
     138                 :          0 :             return 1;
     139                 :            : 
     140                 :          0 :         NEXT_IN(2);
     141                 :            :     }
     142                 :            : 
     143                 :          0 :     return 0;
     144                 :            : }
     145                 :            : 
     146                 :            : 
     147                 :            : /*
     148                 :            :  * EUC-JIS-2004 codec
     149                 :            :  */
     150                 :            : 
     151                 :          0 : ENCODER(euc_jis_2004)
     152                 :            : {
     153         [ #  # ]:          0 :     while (*inpos < inlen) {
     154                 :          0 :         Py_UCS4 c = INCHAR1;
     155                 :            :         DBCHAR code;
     156                 :            :         Py_ssize_t insize;
     157                 :            : 
     158         [ #  # ]:          0 :         if (c < 0x80) {
     159         [ #  # ]:          0 :             WRITEBYTE1(c);
     160                 :          0 :             NEXT(1, 1);
     161                 :          0 :             continue;
     162                 :            :         }
     163                 :            : 
     164                 :          0 :         insize = 1;
     165                 :            : 
     166         [ #  # ]:          0 :         if (c <= 0xFFFF) {
     167   [ #  #  #  #  :          0 :             EMULATE_JISX0213_2000_ENCODE_BMP(code, c)
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
     168   [ #  #  #  #  :          0 :             else if (TRYMAP_ENC(jisx0213_bmp, code, c)) {
             #  #  #  # ]
     169         [ #  # ]:          0 :                 if (code == MULTIC) {
     170         [ #  # ]:          0 :                     if (inlen - *inpos < 2) {
     171         [ #  # ]:          0 :                         if (flags & MBENC_FLUSH) {
     172                 :          0 :                             code = find_pairencmap(
     173                 :          0 :                                 (ucs2_t)c, 0,
     174                 :            :                               jisx0213_pair_encmap,
     175                 :            :                                 JISX0213_ENCPAIRS);
     176         [ #  # ]:          0 :                             if (code == DBCINV)
     177                 :          0 :                                 return 1;
     178                 :            :                         }
     179                 :            :                         else
     180                 :          0 :                             return MBERR_TOOFEW;
     181                 :            :                     }
     182                 :            :                     else {
     183                 :          0 :                         Py_UCS4 c2 = INCHAR2;
     184                 :          0 :                         code = find_pairencmap(
     185                 :          0 :                             (ucs2_t)c, c2,
     186                 :            :                             jisx0213_pair_encmap,
     187                 :            :                             JISX0213_ENCPAIRS);
     188         [ #  # ]:          0 :                         if (code == DBCINV) {
     189                 :          0 :                             code = find_pairencmap(
     190                 :          0 :                                 (ucs2_t)c, 0,
     191                 :            :                               jisx0213_pair_encmap,
     192                 :            :                                 JISX0213_ENCPAIRS);
     193         [ #  # ]:          0 :                             if (code == DBCINV)
     194                 :          0 :                                 return 1;
     195                 :            :                         } else
     196                 :          0 :                             insize = 2;
     197                 :            :                     }
     198                 :            :                 }
     199                 :            :             }
     200   [ #  #  #  #  :          0 :             else if (TRYMAP_ENC(jisxcommon, code, c))
             #  #  #  # ]
     201                 :            :                 ;
     202   [ #  #  #  # ]:          0 :             else if (c >= 0xff61 && c <= 0xff9f) {
     203                 :            :                 /* JIS X 0201 half-width katakana */
     204         [ #  # ]:          0 :                 WRITEBYTE2(0x8e, c - 0xfec0);
     205                 :          0 :                 NEXT(1, 2);
     206                 :          0 :                 continue;
     207                 :            :             }
     208         [ #  # ]:          0 :             else if (c == 0xff3c)
     209                 :            :                 /* F/W REVERSE SOLIDUS (see NOTES) */
     210                 :          0 :                 code = 0x2140;
     211         [ #  # ]:          0 :             else if (c == 0xff5e)
     212                 :            :                 /* F/W TILDE (see NOTES) */
     213                 :          0 :                 code = 0x2232;
     214                 :            :             else
     215                 :          0 :                 return 1;
     216                 :            :         }
     217         [ #  # ]:          0 :         else if (c >> 16 == EMPBASE >> 16) {
     218   [ #  #  #  # ]:          0 :             EMULATE_JISX0213_2000_ENCODE_EMP(code, c)
     219   [ #  #  #  #  :          0 :             else if (TRYMAP_ENC(jisx0213_emp, code, c & 0xffff))
             #  #  #  # ]
     220                 :            :                 ;
     221                 :            :             else
     222                 :          0 :                 return insize;
     223                 :            :         }
     224                 :            :         else
     225                 :          0 :             return insize;
     226                 :            : 
     227         [ #  # ]:          0 :         if (code & 0x8000) {
     228                 :            :             /* Codeset 2 */
     229         [ #  # ]:          0 :             WRITEBYTE3(0x8f, code >> 8, (code & 0xFF) | 0x80);
     230                 :          0 :             NEXT(insize, 3);
     231                 :            :         } else {
     232                 :            :             /* Codeset 1 */
     233         [ #  # ]:          0 :             WRITEBYTE2((code >> 8) | 0x80, (code & 0xFF) | 0x80);
     234                 :          0 :             NEXT(insize, 2);
     235                 :            :         }
     236                 :            :     }
     237                 :            : 
     238                 :          0 :     return 0;
     239                 :            : }
     240                 :            : 
     241                 :          0 : DECODER(euc_jis_2004)
     242                 :            : {
     243         [ #  # ]:          0 :     while (inleft > 0) {
     244                 :          0 :         unsigned char c = INBYTE1;
     245                 :            :         Py_UCS4 code, decoded;
     246                 :            : 
     247         [ #  # ]:          0 :         if (c < 0x80) {
     248         [ #  # ]:          0 :             OUTCHAR(c);
     249                 :          0 :             NEXT_IN(1);
     250                 :          0 :             continue;
     251                 :            :         }
     252                 :            : 
     253         [ #  # ]:          0 :         if (c == 0x8e) {
     254                 :            :             /* JIS X 0201 half-width katakana */
     255                 :            :             unsigned char c2;
     256                 :            : 
     257         [ #  # ]:          0 :             REQUIRE_INBUF(2);
     258                 :          0 :             c2 = INBYTE2;
     259   [ #  #  #  # ]:          0 :             if (c2 >= 0xa1 && c2 <= 0xdf) {
     260         [ #  # ]:          0 :                 OUTCHAR(0xfec0 + c2);
     261                 :          0 :                 NEXT_IN(2);
     262                 :            :             }
     263                 :            :             else
     264                 :          0 :                 return 1;
     265                 :            :         }
     266         [ #  # ]:          0 :         else if (c == 0x8f) {
     267                 :            :             unsigned char c2, c3;
     268                 :            : 
     269         [ #  # ]:          0 :             REQUIRE_INBUF(3);
     270                 :          0 :             c2 = INBYTE2 ^ 0x80;
     271                 :          0 :             c3 = INBYTE3 ^ 0x80;
     272                 :            : 
     273                 :            :             /* JIS X 0213 Plane 2 or JIS X 0212 (see NOTES) */
     274   [ #  #  #  #  :          0 :             EMULATE_JISX0213_2000_DECODE_PLANE2(writer, c2, c3)
             #  #  #  # ]
     275   [ #  #  #  #  :          0 :             else if (TRYMAP_DEC(jisx0213_2_bmp, decoded, c2, c3))
             #  #  #  # ]
     276         [ #  # ]:          0 :                 OUTCHAR(decoded);
     277   [ #  #  #  #  :          0 :             else if (TRYMAP_DEC(jisx0213_2_emp, code, c2, c3)) {
             #  #  #  # ]
     278         [ #  # ]:          0 :                 OUTCHAR(EMPBASE | code);
     279                 :          0 :                 NEXT_IN(3);
     280                 :          0 :                 continue;
     281                 :            :             }
     282   [ #  #  #  #  :          0 :             else if (TRYMAP_DEC(jisx0212, decoded, c2, c3))
             #  #  #  # ]
     283         [ #  # ]:          0 :                 OUTCHAR(decoded);
     284                 :            :             else
     285                 :          0 :                 return 1;
     286                 :          0 :             NEXT_IN(3);
     287                 :            :         }
     288                 :            :         else {
     289                 :            :             unsigned char c2;
     290                 :            : 
     291         [ #  # ]:          0 :             REQUIRE_INBUF(2);
     292                 :          0 :             c ^= 0x80;
     293                 :          0 :             c2 = INBYTE2 ^ 0x80;
     294                 :            : 
     295                 :            :             /* JIS X 0213 Plane 1 */
     296   [ #  #  #  #  :          0 :             EMULATE_JISX0213_2000_DECODE_PLANE1(writer, c, c2)
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                #  #  # ]
     297   [ #  #  #  # ]:          0 :             else if (c == 0x21 && c2 == 0x40)
     298         [ #  # ]:          0 :                 OUTCHAR(0xff3c);
     299   [ #  #  #  # ]:          0 :             else if (c == 0x22 && c2 == 0x32)
     300         [ #  # ]:          0 :                 OUTCHAR(0xff5e);
     301   [ #  #  #  #  :          0 :             else if (TRYMAP_DEC(jisx0208, decoded, c, c2))
             #  #  #  # ]
     302         [ #  # ]:          0 :                 OUTCHAR(decoded);
     303   [ #  #  #  #  :          0 :             else if (TRYMAP_DEC(jisx0213_1_bmp, decoded, c, c2))
             #  #  #  # ]
     304         [ #  # ]:          0 :                 OUTCHAR(decoded);
     305   [ #  #  #  #  :          0 :             else if (TRYMAP_DEC(jisx0213_1_emp, code, c, c2)) {
             #  #  #  # ]
     306         [ #  # ]:          0 :                 OUTCHAR(EMPBASE | code);
     307                 :          0 :                 NEXT_IN(2);
     308                 :          0 :                 continue;
     309                 :            :             }
     310   [ #  #  #  #  :          0 :             else if (TRYMAP_DEC(jisx0213_pair, code, c, c2)) {
             #  #  #  # ]
     311   [ #  #  #  #  :          0 :                 OUTCHAR2(code >> 16, code & 0xffff);
                   #  # ]
     312                 :          0 :                 NEXT_IN(2);
     313                 :          0 :                 continue;
     314                 :            :             }
     315                 :            :             else
     316                 :          0 :                 return 1;
     317                 :          0 :             NEXT_IN(2);
     318                 :            :         }
     319                 :            :     }
     320                 :            : 
     321                 :          0 :     return 0;
     322                 :            : }
     323                 :            : 
     324                 :            : 
     325                 :            : /*
     326                 :            :  * EUC-JP codec
     327                 :            :  */
     328                 :            : 
     329                 :          0 : ENCODER(euc_jp)
     330                 :            : {
     331         [ #  # ]:          0 :     while (*inpos < inlen) {
     332                 :          0 :         Py_UCS4 c = INCHAR1;
     333                 :            :         DBCHAR code;
     334                 :            : 
     335         [ #  # ]:          0 :         if (c < 0x80) {
     336         [ #  # ]:          0 :             WRITEBYTE1((unsigned char)c);
     337                 :          0 :             NEXT(1, 1);
     338                 :          0 :             continue;
     339                 :            :         }
     340                 :            : 
     341         [ #  # ]:          0 :         if (c > 0xFFFF)
     342                 :          0 :             return 1;
     343                 :            : 
     344   [ #  #  #  #  :          0 :         if (TRYMAP_ENC(jisxcommon, code, c))
             #  #  #  # ]
     345                 :            :             ;
     346   [ #  #  #  # ]:          0 :         else if (c >= 0xff61 && c <= 0xff9f) {
     347                 :            :             /* JIS X 0201 half-width katakana */
     348         [ #  # ]:          0 :             WRITEBYTE2(0x8e, c - 0xfec0);
     349                 :          0 :             NEXT(1, 2);
     350                 :          0 :             continue;
     351                 :            :         }
     352                 :            : #ifndef STRICT_BUILD
     353         [ #  # ]:          0 :         else if (c == 0xff3c) /* FULL-WIDTH REVERSE SOLIDUS */
     354                 :          0 :             code = 0x2140;
     355         [ #  # ]:          0 :         else if (c == 0xa5) { /* YEN SIGN */
     356         [ #  # ]:          0 :             WRITEBYTE1(0x5c);
     357                 :          0 :             NEXT(1, 1);
     358                 :          0 :             continue;
     359         [ #  # ]:          0 :         } else if (c == 0x203e) { /* OVERLINE */
     360         [ #  # ]:          0 :             WRITEBYTE1(0x7e);
     361                 :          0 :             NEXT(1, 1);
     362                 :          0 :             continue;
     363                 :            :         }
     364                 :            : #endif
     365                 :            :         else
     366                 :          0 :             return 1;
     367                 :            : 
     368         [ #  # ]:          0 :         if (code & 0x8000) {
     369                 :            :             /* JIS X 0212 */
     370         [ #  # ]:          0 :             WRITEBYTE3(0x8f, code >> 8, (code & 0xFF) | 0x80);
     371                 :          0 :             NEXT(1, 3);
     372                 :            :         } else {
     373                 :            :             /* JIS X 0208 */
     374         [ #  # ]:          0 :             WRITEBYTE2((code >> 8) | 0x80, (code & 0xFF) | 0x80);
     375                 :          0 :             NEXT(1, 2);
     376                 :            :         }
     377                 :            :     }
     378                 :            : 
     379                 :          0 :     return 0;
     380                 :            : }
     381                 :            : 
     382                 :          0 : DECODER(euc_jp)
     383                 :            : {
     384         [ #  # ]:          0 :     while (inleft > 0) {
     385                 :          0 :         unsigned char c = INBYTE1;
     386                 :            :         Py_UCS4 decoded;
     387                 :            : 
     388         [ #  # ]:          0 :         if (c < 0x80) {
     389         [ #  # ]:          0 :             OUTCHAR(c);
     390                 :          0 :             NEXT_IN(1);
     391                 :          0 :             continue;
     392                 :            :         }
     393                 :            : 
     394         [ #  # ]:          0 :         if (c == 0x8e) {
     395                 :            :             /* JIS X 0201 half-width katakana */
     396                 :            :             unsigned char c2;
     397                 :            : 
     398         [ #  # ]:          0 :             REQUIRE_INBUF(2);
     399                 :          0 :             c2 = INBYTE2;
     400   [ #  #  #  # ]:          0 :             if (c2 >= 0xa1 && c2 <= 0xdf) {
     401         [ #  # ]:          0 :                 OUTCHAR(0xfec0 + c2);
     402                 :          0 :                 NEXT_IN(2);
     403                 :            :             }
     404                 :            :             else
     405                 :          0 :                 return 1;
     406                 :            :         }
     407         [ #  # ]:          0 :         else if (c == 0x8f) {
     408                 :            :             unsigned char c2, c3;
     409                 :            : 
     410         [ #  # ]:          0 :             REQUIRE_INBUF(3);
     411                 :          0 :             c2 = INBYTE2;
     412                 :          0 :             c3 = INBYTE3;
     413                 :            :             /* JIS X 0212 */
     414   [ #  #  #  #  :          0 :             if (TRYMAP_DEC(jisx0212, decoded, c2 ^ 0x80, c3 ^ 0x80)) {
             #  #  #  # ]
     415         [ #  # ]:          0 :                 OUTCHAR(decoded);
     416                 :          0 :                 NEXT_IN(3);
     417                 :            :             }
     418                 :            :             else
     419                 :          0 :                 return 1;
     420                 :            :         }
     421                 :            :         else {
     422                 :            :             unsigned char c2;
     423                 :            : 
     424         [ #  # ]:          0 :             REQUIRE_INBUF(2);
     425                 :          0 :             c2 = INBYTE2;
     426                 :            :             /* JIS X 0208 */
     427                 :            : #ifndef STRICT_BUILD
     428   [ #  #  #  # ]:          0 :             if (c == 0xa1 && c2 == 0xc0)
     429                 :            :                 /* FULL-WIDTH REVERSE SOLIDUS */
     430         [ #  # ]:          0 :                 OUTCHAR(0xff3c);
     431                 :            :             else
     432                 :            : #endif
     433   [ #  #  #  #  :          0 :             if (TRYMAP_DEC(jisx0208, decoded, c ^ 0x80, c2 ^ 0x80))
             #  #  #  # ]
     434         [ #  # ]:          0 :                 OUTCHAR(decoded);
     435                 :            :             else
     436                 :          0 :                 return 1;
     437                 :          0 :             NEXT_IN(2);
     438                 :            :         }
     439                 :            :     }
     440                 :            : 
     441                 :          0 :     return 0;
     442                 :            : }
     443                 :            : 
     444                 :            : 
     445                 :            : /*
     446                 :            :  * SHIFT_JIS codec
     447                 :            :  */
     448                 :            : 
     449                 :          0 : ENCODER(shift_jis)
     450                 :            : {
     451         [ #  # ]:          0 :     while (*inpos < inlen) {
     452                 :          0 :         Py_UCS4 c = INCHAR1;
     453                 :            :         DBCHAR code;
     454                 :            :         unsigned char c1, c2;
     455                 :            : 
     456                 :            : #ifdef STRICT_BUILD
     457                 :            :         JISX0201_R_ENCODE(c, code)
     458                 :            : #else
     459         [ #  # ]:          0 :         if (c < 0x80)
     460                 :          0 :             code = c;
     461         [ #  # ]:          0 :         else if (c == 0x00a5)
     462                 :          0 :             code = 0x5c; /* YEN SIGN */
     463         [ #  # ]:          0 :         else if (c == 0x203e)
     464                 :          0 :             code = 0x7e; /* OVERLINE */
     465                 :            : #endif
     466   [ #  #  #  # ]:          0 :         else JISX0201_K_ENCODE(c, code)
     467         [ #  # ]:          0 :         else if (c > 0xFFFF)
     468                 :          0 :             return 1;
     469                 :            :         else
     470                 :          0 :             code = NOCHAR;
     471                 :            : 
     472   [ #  #  #  #  :          0 :         if (code < 0x80 || (code >= 0xa1 && code <= 0xdf)) {
                   #  # ]
     473         [ #  # ]:          0 :             REQUIRE_OUTBUF(1);
     474                 :            : 
     475                 :          0 :             OUTBYTE1((unsigned char)code);
     476                 :          0 :             NEXT(1, 1);
     477                 :          0 :             continue;
     478                 :            :         }
     479                 :            : 
     480         [ #  # ]:          0 :         REQUIRE_OUTBUF(2);
     481                 :            : 
     482         [ #  # ]:          0 :         if (code == NOCHAR) {
     483   [ #  #  #  #  :          0 :             if (TRYMAP_ENC(jisxcommon, code, c))
             #  #  #  # ]
     484                 :            :                 ;
     485                 :            : #ifndef STRICT_BUILD
     486         [ #  # ]:          0 :             else if (c == 0xff3c)
     487                 :          0 :                 code = 0x2140; /* FULL-WIDTH REVERSE SOLIDUS */
     488                 :            : #endif
     489                 :            :             else
     490                 :          0 :                 return 1;
     491                 :            : 
     492         [ #  # ]:          0 :             if (code & 0x8000) /* MSB set: JIS X 0212 */
     493                 :          0 :                 return 1;
     494                 :            :         }
     495                 :            : 
     496                 :          0 :         c1 = code >> 8;
     497                 :          0 :         c2 = code & 0xff;
     498         [ #  # ]:          0 :         c2 = (((c1 - 0x21) & 1) ? 0x5e : 0) + (c2 - 0x21);
     499                 :          0 :         c1 = (c1 - 0x21) >> 1;
     500         [ #  # ]:          0 :         OUTBYTE1(c1 < 0x1f ? c1 + 0x81 : c1 + 0xc1);
     501         [ #  # ]:          0 :         OUTBYTE2(c2 < 0x3f ? c2 + 0x40 : c2 + 0x41);
     502                 :          0 :         NEXT(1, 2);
     503                 :            :     }
     504                 :            : 
     505                 :          0 :     return 0;
     506                 :            : }
     507                 :            : 
     508                 :          0 : DECODER(shift_jis)
     509                 :            : {
     510         [ #  # ]:          0 :     while (inleft > 0) {
     511                 :          0 :         unsigned char c = INBYTE1;
     512                 :            :         Py_UCS4 decoded;
     513                 :            : 
     514                 :            : #ifdef STRICT_BUILD
     515                 :            :         JISX0201_R_DECODE(c, writer)
     516                 :            : #else
     517         [ #  # ]:          0 :         if (c < 0x80)
     518         [ #  # ]:          0 :             OUTCHAR(c);
     519                 :            : #endif
     520   [ #  #  #  #  :          0 :         else JISX0201_K_DECODE(c, writer)
                   #  # ]
     521   [ #  #  #  #  :          0 :         else if ((c >= 0x81 && c <= 0x9f) || (c >= 0xe0 && c <= 0xea)){
             #  #  #  # ]
     522                 :            :             unsigned char c1, c2;
     523                 :            : 
     524         [ #  # ]:          0 :             REQUIRE_INBUF(2);
     525                 :          0 :             c2 = INBYTE2;
     526   [ #  #  #  #  :          0 :             if (c2 < 0x40 || (c2 > 0x7e && c2 < 0x80) || c2 > 0xfc)
             #  #  #  # ]
     527                 :          0 :                 return 1;
     528                 :            : 
     529         [ #  # ]:          0 :             c1 = (c < 0xe0 ? c - 0x81 : c - 0xc1);
     530         [ #  # ]:          0 :             c2 = (c2 < 0x80 ? c2 - 0x40 : c2 - 0x41);
     531                 :          0 :             c1 = (2 * c1 + (c2 < 0x5e ? 0 : 1) + 0x21);
     532         [ #  # ]:          0 :             c2 = (c2 < 0x5e ? c2 : c2 - 0x5e) + 0x21;
     533                 :            : 
     534                 :            : #ifndef STRICT_BUILD
     535   [ #  #  #  # ]:          0 :             if (c1 == 0x21 && c2 == 0x40) {
     536                 :            :                 /* FULL-WIDTH REVERSE SOLIDUS */
     537         [ #  # ]:          0 :                 OUTCHAR(0xff3c);
     538                 :          0 :                 NEXT_IN(2);
     539                 :          0 :                 continue;
     540                 :            :             }
     541                 :            : #endif
     542   [ #  #  #  #  :          0 :             if (TRYMAP_DEC(jisx0208, decoded, c1, c2)) {
             #  #  #  # ]
     543         [ #  # ]:          0 :                 OUTCHAR(decoded);
     544                 :          0 :                 NEXT_IN(2);
     545                 :          0 :                 continue;
     546                 :            :             }
     547                 :            :             else
     548                 :          0 :                 return 1;
     549                 :            :         }
     550                 :            :         else
     551                 :          0 :             return 1;
     552                 :            : 
     553                 :          0 :         NEXT_IN(1); /* JIS X 0201 */
     554                 :            :     }
     555                 :            : 
     556                 :          0 :     return 0;
     557                 :            : }
     558                 :            : 
     559                 :            : 
     560                 :            : /*
     561                 :            :  * SHIFT_JIS-2004 codec
     562                 :            :  */
     563                 :            : 
     564                 :          0 : ENCODER(shift_jis_2004)
     565                 :            : {
     566         [ #  # ]:          0 :     while (*inpos < inlen) {
     567                 :          0 :         Py_UCS4 c = INCHAR1;
     568                 :          0 :         DBCHAR code = NOCHAR;
     569                 :            :         int c1, c2;
     570                 :            :         Py_ssize_t insize;
     571                 :            : 
     572   [ #  #  #  #  :          0 :         JISX0201_ENCODE(c, code)
          #  #  #  #  #  
             #  #  #  #  
                      # ]
     573                 :            : 
     574   [ #  #  #  #  :          0 :         if (code < 0x80 || (code >= 0xa1 && code <= 0xdf)) {
                   #  # ]
     575         [ #  # ]:          0 :             WRITEBYTE1((unsigned char)code);
     576                 :          0 :             NEXT(1, 1);
     577                 :          0 :             continue;
     578                 :            :         }
     579                 :            : 
     580         [ #  # ]:          0 :         REQUIRE_OUTBUF(2);
     581                 :          0 :         insize = 1;
     582                 :            : 
     583         [ #  # ]:          0 :         if (code == NOCHAR) {
     584         [ #  # ]:          0 :             if (c <= 0xffff) {
     585   [ #  #  #  #  :          0 :                 EMULATE_JISX0213_2000_ENCODE_BMP(code, c)
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
     586   [ #  #  #  #  :          0 :                 else if (TRYMAP_ENC(jisx0213_bmp, code, c)) {
             #  #  #  # ]
     587         [ #  # ]:          0 :                     if (code == MULTIC) {
     588         [ #  # ]:          0 :                         if (inlen - *inpos < 2) {
     589         [ #  # ]:          0 :                             if (flags & MBENC_FLUSH) {
     590                 :          0 :                             code = find_pairencmap
     591                 :          0 :                                 ((ucs2_t)c, 0,
     592                 :            :                               jisx0213_pair_encmap,
     593                 :            :                                 JISX0213_ENCPAIRS);
     594         [ #  # ]:          0 :                             if (code == DBCINV)
     595                 :          0 :                                 return 1;
     596                 :            :                             }
     597                 :            :                             else
     598                 :          0 :                                 return MBERR_TOOFEW;
     599                 :            :                         }
     600                 :            :                         else {
     601                 :          0 :                             Py_UCS4 ch2 = INCHAR2;
     602                 :          0 :                             code = find_pairencmap(
     603                 :          0 :                                 (ucs2_t)c, ch2,
     604                 :            :                               jisx0213_pair_encmap,
     605                 :            :                                 JISX0213_ENCPAIRS);
     606         [ #  # ]:          0 :                             if (code == DBCINV) {
     607                 :          0 :                             code = find_pairencmap(
     608                 :          0 :                                 (ucs2_t)c, 0,
     609                 :            :                               jisx0213_pair_encmap,
     610                 :            :                                 JISX0213_ENCPAIRS);
     611         [ #  # ]:          0 :                             if (code == DBCINV)
     612                 :          0 :                                 return 1;
     613                 :            :                             }
     614                 :            :                             else
     615                 :          0 :                                 insize = 2;
     616                 :            :                         }
     617                 :            :                     }
     618                 :            :                 }
     619   [ #  #  #  #  :          0 :                 else if (TRYMAP_ENC(jisxcommon, code, c)) {
             #  #  #  # ]
     620                 :            :                     /* abandon JIS X 0212 codes */
     621         [ #  # ]:          0 :                     if (code & 0x8000)
     622                 :          0 :                         return 1;
     623                 :            :                 }
     624                 :            :                 else
     625                 :          0 :                     return 1;
     626                 :            :             }
     627         [ #  # ]:          0 :             else if (c >> 16 == EMPBASE >> 16) {
     628   [ #  #  #  # ]:          0 :                 EMULATE_JISX0213_2000_ENCODE_EMP(code, c)
     629   [ #  #  #  #  :          0 :                 else if (TRYMAP_ENC(jisx0213_emp, code, c&0xffff))
             #  #  #  # ]
     630                 :            :                     ;
     631                 :            :                 else
     632                 :          0 :                     return insize;
     633                 :            :             }
     634                 :            :             else
     635                 :          0 :                 return insize;
     636                 :            :         }
     637                 :            : 
     638                 :          0 :         c1 = code >> 8;
     639                 :          0 :         c2 = (code & 0xff) - 0x21;
     640                 :            : 
     641         [ #  # ]:          0 :         if (c1 & 0x80) {
     642                 :            :             /* Plane 2 */
     643         [ #  # ]:          0 :             if (c1 >= 0xee)
     644                 :          0 :                 c1 -= 0x87;
     645   [ #  #  #  # ]:          0 :             else if (c1 >= 0xac || c1 == 0xa8)
     646                 :          0 :                 c1 -= 0x49;
     647                 :            :             else
     648                 :          0 :                 c1 -= 0x43;
     649                 :            :         }
     650                 :            :         else {
     651                 :            :             /* Plane 1 */
     652                 :          0 :             c1 -= 0x21;
     653                 :            :         }
     654                 :            : 
     655         [ #  # ]:          0 :         if (c1 & 1)
     656                 :          0 :             c2 += 0x5e;
     657                 :          0 :         c1 >>= 1;
     658         [ #  # ]:          0 :         OUTBYTE1(c1 + (c1 < 0x1f ? 0x81 : 0xc1));
     659         [ #  # ]:          0 :         OUTBYTE2(c2 + (c2 < 0x3f ? 0x40 : 0x41));
     660                 :            : 
     661                 :          0 :         NEXT(insize, 2);
     662                 :            :     }
     663                 :            : 
     664                 :          0 :     return 0;
     665                 :            : }
     666                 :            : 
     667                 :          0 : DECODER(shift_jis_2004)
     668                 :            : {
     669         [ #  # ]:          0 :     while (inleft > 0) {
     670                 :          0 :         unsigned char c = INBYTE1;
     671                 :            : 
     672   [ #  #  #  #  :          0 :         JISX0201_DECODE(c, writer)
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
     673   [ #  #  #  #  :          0 :         else if ((c >= 0x81 && c <= 0x9f) || (c >= 0xe0 && c <= 0xfc)){
             #  #  #  # ]
     674                 :            :             unsigned char c1, c2;
     675                 :            :             Py_UCS4 code, decoded;
     676                 :            : 
     677         [ #  # ]:          0 :             REQUIRE_INBUF(2);
     678                 :          0 :             c2 = INBYTE2;
     679   [ #  #  #  #  :          0 :             if (c2 < 0x40 || (c2 > 0x7e && c2 < 0x80) || c2 > 0xfc)
             #  #  #  # ]
     680                 :          0 :                 return 1;
     681                 :            : 
     682         [ #  # ]:          0 :             c1 = (c < 0xe0 ? c - 0x81 : c - 0xc1);
     683         [ #  # ]:          0 :             c2 = (c2 < 0x80 ? c2 - 0x40 : c2 - 0x41);
     684                 :          0 :             c1 = (2 * c1 + (c2 < 0x5e ? 0 : 1));
     685         [ #  # ]:          0 :             c2 = (c2 < 0x5e ? c2 : c2 - 0x5e) + 0x21;
     686                 :            : 
     687         [ #  # ]:          0 :             if (c1 < 0x5e) { /* Plane 1 */
     688                 :          0 :                 c1 += 0x21;
     689   [ #  #  #  #  :          0 :                 EMULATE_JISX0213_2000_DECODE_PLANE1(writer,
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                #  #  # ]
     690                 :            :                                 c1, c2)
     691   [ #  #  #  #  :          0 :                 else if (TRYMAP_DEC(jisx0208, decoded, c1, c2))
             #  #  #  # ]
     692         [ #  # ]:          0 :                     OUTCHAR(decoded);
     693   [ #  #  #  #  :          0 :                 else if (TRYMAP_DEC(jisx0213_1_bmp, decoded, c1, c2))
             #  #  #  # ]
     694         [ #  # ]:          0 :                     OUTCHAR(decoded);
     695   [ #  #  #  #  :          0 :                 else if (TRYMAP_DEC(jisx0213_1_emp, code, c1, c2))
             #  #  #  # ]
     696         [ #  # ]:          0 :                     OUTCHAR(EMPBASE | code);
     697   [ #  #  #  #  :          0 :                 else if (TRYMAP_DEC(jisx0213_pair, code, c1, c2))
             #  #  #  # ]
     698   [ #  #  #  #  :          0 :                     OUTCHAR2(code >> 16, code & 0xffff);
                   #  # ]
     699                 :            :                 else
     700                 :          0 :                     return 1;
     701                 :          0 :                 NEXT_IN(2);
     702                 :            :             }
     703                 :            :             else { /* Plane 2 */
     704         [ #  # ]:          0 :                 if (c1 >= 0x67)
     705                 :          0 :                     c1 += 0x07;
     706   [ #  #  #  # ]:          0 :                 else if (c1 >= 0x63 || c1 == 0x5f)
     707                 :          0 :                     c1 -= 0x37;
     708                 :            :                 else
     709                 :          0 :                     c1 -= 0x3d;
     710                 :            : 
     711   [ #  #  #  #  :          0 :                 EMULATE_JISX0213_2000_DECODE_PLANE2(writer,
             #  #  #  # ]
     712                 :            :                                 c1, c2)
     713   [ #  #  #  #  :          0 :                 else if (TRYMAP_DEC(jisx0213_2_bmp, decoded, c1, c2))
             #  #  #  # ]
     714         [ #  # ]:          0 :                     OUTCHAR(decoded);
     715   [ #  #  #  #  :          0 :                 else if (TRYMAP_DEC(jisx0213_2_emp, code, c1, c2)) {
             #  #  #  # ]
     716         [ #  # ]:          0 :                     OUTCHAR(EMPBASE | code);
     717                 :          0 :                     NEXT_IN(2);
     718                 :          0 :                     continue;
     719                 :            :                 }
     720                 :            :                 else
     721                 :          0 :                     return 1;
     722                 :          0 :                 NEXT_IN(2);
     723                 :            :             }
     724                 :          0 :             continue;
     725                 :            :         }
     726                 :            :         else
     727                 :          0 :             return 1;
     728                 :            : 
     729                 :          0 :         NEXT_IN(1); /* JIS X 0201 */
     730                 :            :     }
     731                 :            : 
     732                 :          0 :     return 0;
     733                 :            : }
     734                 :            : 
     735                 :            : 
     736                 :            : BEGIN_MAPPINGS_LIST
     737                 :            :   MAPPING_DECONLY(jisx0208)
     738                 :            :   MAPPING_DECONLY(jisx0212)
     739                 :            :   MAPPING_ENCONLY(jisxcommon)
     740                 :            :   MAPPING_DECONLY(jisx0213_1_bmp)
     741                 :            :   MAPPING_DECONLY(jisx0213_2_bmp)
     742                 :            :   MAPPING_ENCONLY(jisx0213_bmp)
     743                 :            :   MAPPING_DECONLY(jisx0213_1_emp)
     744                 :            :   MAPPING_DECONLY(jisx0213_2_emp)
     745                 :            :   MAPPING_ENCONLY(jisx0213_emp)
     746                 :            :   MAPPING_ENCDEC(jisx0213_pair)
     747                 :            :   MAPPING_ENCDEC(cp932ext)
     748                 :            : END_MAPPINGS_LIST
     749                 :            : 
     750                 :            : BEGIN_CODECS_LIST
     751                 :            :   CODEC_STATELESS(shift_jis)
     752                 :            :   CODEC_STATELESS(cp932)
     753                 :            :   CODEC_STATELESS(euc_jp)
     754                 :            :   CODEC_STATELESS(shift_jis_2004)
     755                 :            :   CODEC_STATELESS(euc_jis_2004)
     756                 :            :   { "euc_jisx0213", (void *)2000, NULL, _STATELESS_METHODS(euc_jis_2004) },
     757                 :            :   { "shift_jisx0213", (void *)2000, NULL, _STATELESS_METHODS(shift_jis_2004) },
     758                 :            : END_CODECS_LIST
     759                 :            : 
     760                 :          1 : I_AM_A_MODULE_FOR(jp)

Generated by: LCOV version 1.14