LCOV - code coverage report
Current view: top level - src/backend/utils/mb/conversion_procs/euc_jp_and_sjis - euc_jp_and_sjis.c (source / functions) Hit Total Coverage
Test: PostgreSQL 12beta2 Lines: 115 319 36.1 %
Date: 2019-06-18 07:06:57 Functions: 19 19 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  *    EUC_JP, SJIS and MULE_INTERNAL
       4             :  *
       5             :  * Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
       6             :  * Portions Copyright (c) 1994, Regents of the University of California
       7             :  *
       8             :  * IDENTIFICATION
       9             :  *    src/backend/utils/mb/conversion_procs/euc_jp_and_sjis/euc_jp_and_sjis.c
      10             :  *
      11             :  *-------------------------------------------------------------------------
      12             :  */
      13             : 
      14             : #include "postgres.h"
      15             : #include "fmgr.h"
      16             : #include "mb/pg_wchar.h"
      17             : 
      18             : /*
      19             :  * SJIS alternative code.
      20             :  * this code is used if a mapping EUC -> SJIS is not defined.
      21             :  */
      22             : #define PGSJISALTCODE 0x81ac
      23             : #define PGEUCALTCODE 0xa2ae
      24             : 
      25             : /*
      26             :  * conversion table between SJIS UDC (IBM kanji) and EUC_JP
      27             :  */
      28             : #include "sjis.map"
      29             : 
      30           4 : PG_MODULE_MAGIC;
      31             : 
      32           4 : PG_FUNCTION_INFO_V1(euc_jp_to_sjis);
      33           4 : PG_FUNCTION_INFO_V1(sjis_to_euc_jp);
      34           4 : PG_FUNCTION_INFO_V1(euc_jp_to_mic);
      35           4 : PG_FUNCTION_INFO_V1(mic_to_euc_jp);
      36           4 : PG_FUNCTION_INFO_V1(sjis_to_mic);
      37           4 : PG_FUNCTION_INFO_V1(mic_to_sjis);
      38             : 
      39             : /* ----------
      40             :  * conv_proc(
      41             :  *      INTEGER,    -- source encoding id
      42             :  *      INTEGER,    -- destination encoding id
      43             :  *      CSTRING,    -- source string (null terminated C string)
      44             :  *      CSTRING,    -- destination string (null terminated C string)
      45             :  *      INTEGER     -- source string length
      46             :  * ) returns VOID;
      47             :  * ----------
      48             :  */
      49             : 
      50             : static void sjis2mic(const unsigned char *sjis, unsigned char *p, int len);
      51             : static void mic2sjis(const unsigned char *mic, unsigned char *p, int len);
      52             : static void euc_jp2mic(const unsigned char *euc, unsigned char *p, int len);
      53             : static void mic2euc_jp(const unsigned char *mic, unsigned char *p, int len);
      54             : static void euc_jp2sjis(const unsigned char *mic, unsigned char *p, int len);
      55             : static void sjis2euc_jp(const unsigned char *mic, unsigned char *p, int len);
      56             : 
      57             : Datum
      58           4 : euc_jp_to_sjis(PG_FUNCTION_ARGS)
      59             : {
      60           4 :     unsigned char *src = (unsigned char *) PG_GETARG_CSTRING(2);
      61           4 :     unsigned char *dest = (unsigned char *) PG_GETARG_CSTRING(3);
      62           4 :     int         len = PG_GETARG_INT32(4);
      63             : 
      64           4 :     CHECK_ENCODING_CONVERSION_ARGS(PG_EUC_JP, PG_SJIS);
      65             : 
      66           4 :     euc_jp2sjis(src, dest, len);
      67             : 
      68           4 :     PG_RETURN_VOID();
      69             : }
      70             : 
      71             : Datum
      72           4 : sjis_to_euc_jp(PG_FUNCTION_ARGS)
      73             : {
      74           4 :     unsigned char *src = (unsigned char *) PG_GETARG_CSTRING(2);
      75           4 :     unsigned char *dest = (unsigned char *) PG_GETARG_CSTRING(3);
      76           4 :     int         len = PG_GETARG_INT32(4);
      77             : 
      78           4 :     CHECK_ENCODING_CONVERSION_ARGS(PG_SJIS, PG_EUC_JP);
      79             : 
      80           4 :     sjis2euc_jp(src, dest, len);
      81             : 
      82           4 :     PG_RETURN_VOID();
      83             : }
      84             : 
      85             : Datum
      86           4 : euc_jp_to_mic(PG_FUNCTION_ARGS)
      87             : {
      88           4 :     unsigned char *src = (unsigned char *) PG_GETARG_CSTRING(2);
      89           4 :     unsigned char *dest = (unsigned char *) PG_GETARG_CSTRING(3);
      90           4 :     int         len = PG_GETARG_INT32(4);
      91             : 
      92           4 :     CHECK_ENCODING_CONVERSION_ARGS(PG_EUC_JP, PG_MULE_INTERNAL);
      93             : 
      94           4 :     euc_jp2mic(src, dest, len);
      95             : 
      96           4 :     PG_RETURN_VOID();
      97             : }
      98             : 
      99             : Datum
     100           4 : mic_to_euc_jp(PG_FUNCTION_ARGS)
     101             : {
     102           4 :     unsigned char *src = (unsigned char *) PG_GETARG_CSTRING(2);
     103           4 :     unsigned char *dest = (unsigned char *) PG_GETARG_CSTRING(3);
     104           4 :     int         len = PG_GETARG_INT32(4);
     105             : 
     106           4 :     CHECK_ENCODING_CONVERSION_ARGS(PG_MULE_INTERNAL, PG_EUC_JP);
     107             : 
     108           4 :     mic2euc_jp(src, dest, len);
     109             : 
     110           4 :     PG_RETURN_VOID();
     111             : }
     112             : 
     113             : Datum
     114           4 : sjis_to_mic(PG_FUNCTION_ARGS)
     115             : {
     116           4 :     unsigned char *src = (unsigned char *) PG_GETARG_CSTRING(2);
     117           4 :     unsigned char *dest = (unsigned char *) PG_GETARG_CSTRING(3);
     118           4 :     int         len = PG_GETARG_INT32(4);
     119             : 
     120           4 :     CHECK_ENCODING_CONVERSION_ARGS(PG_SJIS, PG_MULE_INTERNAL);
     121             : 
     122           4 :     sjis2mic(src, dest, len);
     123             : 
     124           4 :     PG_RETURN_VOID();
     125             : }
     126             : 
     127             : Datum
     128           4 : mic_to_sjis(PG_FUNCTION_ARGS)
     129             : {
     130           4 :     unsigned char *src = (unsigned char *) PG_GETARG_CSTRING(2);
     131           4 :     unsigned char *dest = (unsigned char *) PG_GETARG_CSTRING(3);
     132           4 :     int         len = PG_GETARG_INT32(4);
     133             : 
     134           4 :     CHECK_ENCODING_CONVERSION_ARGS(PG_MULE_INTERNAL, PG_SJIS);
     135             : 
     136           4 :     mic2sjis(src, dest, len);
     137             : 
     138           4 :     PG_RETURN_VOID();
     139             : }
     140             : 
     141             : /*
     142             :  * SJIS ---> MIC
     143             :  */
     144             : static void
     145           4 : sjis2mic(const unsigned char *sjis, unsigned char *p, int len)
     146             : {
     147             :     int         c1,
     148             :                 c2,
     149             :                 i,
     150             :                 k,
     151             :                 k2;
     152             : 
     153          20 :     while (len > 0)
     154             :     {
     155          12 :         c1 = *sjis;
     156          12 :         if (c1 >= 0xa1 && c1 <= 0xdf)
     157             :         {
     158             :             /* JIS X0201 (1 byte kana) */
     159           0 :             *p++ = LC_JISX0201K;
     160           0 :             *p++ = c1;
     161           0 :             sjis++;
     162           0 :             len--;
     163             :         }
     164          12 :         else if (IS_HIGHBIT_SET(c1))
     165             :         {
     166             :             /*
     167             :              * JIS X0208, X0212, user defined extended characters
     168             :              */
     169           0 :             if (len < 2 || !ISSJISHEAD(c1) || !ISSJISTAIL(sjis[1]))
     170           0 :                 report_invalid_encoding(PG_SJIS, (const char *) sjis, len);
     171           0 :             c2 = sjis[1];
     172           0 :             k = (c1 << 8) + c2;
     173           0 :             if (k >= 0xed40 && k < 0xf040)
     174             :             {
     175             :                 /* NEC selection IBM kanji */
     176           0 :                 for (i = 0;; i++)
     177             :                 {
     178           0 :                     k2 = ibmkanji[i].nec;
     179           0 :                     if (k2 == 0xffff)
     180           0 :                         break;
     181           0 :                     if (k2 == k)
     182             :                     {
     183           0 :                         k = ibmkanji[i].sjis;
     184           0 :                         c1 = (k >> 8) & 0xff;
     185           0 :                         c2 = k & 0xff;
     186             :                     }
     187             :                 }
     188             :             }
     189             : 
     190           0 :             if (k < 0xeb3f)
     191             :             {
     192             :                 /* JIS X0208 */
     193           0 :                 *p++ = LC_JISX0208;
     194           0 :                 *p++ = ((c1 & 0x3f) << 1) + 0x9f + (c2 > 0x9e);
     195           0 :                 *p++ = c2 + ((c2 > 0x9e) ? 2 : 0x60) + (c2 < 0x80);
     196             :             }
     197           0 :             else if ((k >= 0xeb40 && k < 0xf040) || (k >= 0xfc4c && k <= 0xfcfc))
     198             :             {
     199             :                 /* NEC selection IBM kanji - Other undecided justice */
     200           0 :                 *p++ = LC_JISX0208;
     201           0 :                 *p++ = PGEUCALTCODE >> 8;
     202           0 :                 *p++ = PGEUCALTCODE & 0xff;
     203             :             }
     204           0 :             else if (k >= 0xf040 && k < 0xf540)
     205             :             {
     206             :                 /*
     207             :                  * UDC1 mapping to X0208 85 ku - 94 ku JIS code 0x7521 -
     208             :                  * 0x7e7e EUC 0xf5a1 - 0xfefe
     209             :                  */
     210           0 :                 *p++ = LC_JISX0208;
     211           0 :                 c1 -= 0x6f;
     212           0 :                 *p++ = ((c1 & 0x3f) << 1) + 0xf3 + (c2 > 0x9e);
     213           0 :                 *p++ = c2 + ((c2 > 0x9e) ? 2 : 0x60) + (c2 < 0x80);
     214             :             }
     215           0 :             else if (k >= 0xf540 && k < 0xfa40)
     216             :             {
     217             :                 /*
     218             :                  * UDC2 mapping to X0212 85 ku - 94 ku JIS code 0x7521 -
     219             :                  * 0x7e7e EUC 0x8ff5a1 - 0x8ffefe
     220             :                  */
     221           0 :                 *p++ = LC_JISX0212;
     222           0 :                 c1 -= 0x74;
     223           0 :                 *p++ = ((c1 & 0x3f) << 1) + 0xf3 + (c2 > 0x9e);
     224           0 :                 *p++ = c2 + ((c2 > 0x9e) ? 2 : 0x60) + (c2 < 0x80);
     225             :             }
     226           0 :             else if (k >= 0xfa40)
     227             :             {
     228             :                 /*
     229             :                  * mapping IBM kanji to X0208 and X0212
     230             :                  */
     231           0 :                 for (i = 0;; i++)
     232             :                 {
     233           0 :                     k2 = ibmkanji[i].sjis;
     234           0 :                     if (k2 == 0xffff)
     235           0 :                         break;
     236           0 :                     if (k2 == k)
     237             :                     {
     238           0 :                         k = ibmkanji[i].euc;
     239           0 :                         if (k >= 0x8f0000)
     240             :                         {
     241           0 :                             *p++ = LC_JISX0212;
     242           0 :                             *p++ = 0x80 | ((k & 0xff00) >> 8);
     243           0 :                             *p++ = 0x80 | (k & 0xff);
     244             :                         }
     245             :                         else
     246             :                         {
     247           0 :                             *p++ = LC_JISX0208;
     248           0 :                             *p++ = 0x80 | (k >> 8);
     249           0 :                             *p++ = 0x80 | (k & 0xff);
     250             :                         }
     251             :                     }
     252             :                 }
     253             :             }
     254           0 :             sjis += 2;
     255           0 :             len -= 2;
     256             :         }
     257             :         else
     258             :         {                       /* should be ASCII */
     259          12 :             if (c1 == 0)
     260           0 :                 report_invalid_encoding(PG_SJIS, (const char *) sjis, len);
     261          12 :             *p++ = c1;
     262          12 :             sjis++;
     263          12 :             len--;
     264             :         }
     265             :     }
     266           4 :     *p = '\0';
     267           4 : }
     268             : 
     269             : /*
     270             :  * MIC ---> SJIS
     271             :  */
     272             : static void
     273           4 : mic2sjis(const unsigned char *mic, unsigned char *p, int len)
     274             : {
     275             :     int         c1,
     276             :                 c2,
     277             :                 k,
     278             :                 l;
     279             : 
     280          20 :     while (len > 0)
     281             :     {
     282          12 :         c1 = *mic;
     283          12 :         if (!IS_HIGHBIT_SET(c1))
     284             :         {
     285             :             /* ASCII */
     286          12 :             if (c1 == 0)
     287           0 :                 report_invalid_encoding(PG_MULE_INTERNAL,
     288             :                                         (const char *) mic, len);
     289          12 :             *p++ = c1;
     290          12 :             mic++;
     291          12 :             len--;
     292          12 :             continue;
     293             :         }
     294           0 :         l = pg_encoding_verifymb(PG_MULE_INTERNAL, (const char *) mic, len);
     295           0 :         if (l < 0)
     296           0 :             report_invalid_encoding(PG_MULE_INTERNAL,
     297             :                                     (const char *) mic, len);
     298           0 :         if (c1 == LC_JISX0201K)
     299           0 :             *p++ = mic[1];
     300           0 :         else if (c1 == LC_JISX0208)
     301             :         {
     302           0 :             c1 = mic[1];
     303           0 :             c2 = mic[2];
     304           0 :             k = (c1 << 8) | (c2 & 0xff);
     305           0 :             if (k >= 0xf5a1)
     306             :             {
     307             :                 /* UDC1 */
     308           0 :                 c1 -= 0x54;
     309           0 :                 *p++ = ((c1 - 0xa1) >> 1) + ((c1 < 0xdf) ? 0x81 : 0xc1) + 0x6f;
     310             :             }
     311             :             else
     312           0 :                 *p++ = ((c1 - 0xa1) >> 1) + ((c1 < 0xdf) ? 0x81 : 0xc1);
     313           0 :             *p++ = c2 - ((c1 & 1) ? ((c2 < 0xe0) ? 0x61 : 0x60) : 2);
     314             :         }
     315           0 :         else if (c1 == LC_JISX0212)
     316             :         {
     317             :             int         i,
     318             :                         k2;
     319             : 
     320           0 :             c1 = mic[1];
     321           0 :             c2 = mic[2];
     322           0 :             k = c1 << 8 | c2;
     323           0 :             if (k >= 0xf5a1)
     324             :             {
     325             :                 /* UDC2 */
     326           0 :                 c1 -= 0x54;
     327           0 :                 *p++ = ((c1 - 0xa1) >> 1) + ((c1 < 0xdf) ? 0x81 : 0xc1) + 0x74;
     328           0 :                 *p++ = c2 - ((c1 & 1) ? ((c2 < 0xe0) ? 0x61 : 0x60) : 2);
     329             :             }
     330             :             else
     331             :             {
     332             :                 /* IBM kanji */
     333           0 :                 for (i = 0;; i++)
     334             :                 {
     335           0 :                     k2 = ibmkanji[i].euc & 0xffff;
     336           0 :                     if (k2 == 0xffff)
     337             :                     {
     338           0 :                         *p++ = PGSJISALTCODE >> 8;
     339           0 :                         *p++ = PGSJISALTCODE & 0xff;
     340           0 :                         break;
     341             :                     }
     342           0 :                     if (k2 == k)
     343             :                     {
     344           0 :                         k = ibmkanji[i].sjis;
     345           0 :                         *p++ = k >> 8;
     346           0 :                         *p++ = k & 0xff;
     347           0 :                         break;
     348             :                     }
     349             :                 }
     350             :             }
     351             :         }
     352             :         else
     353           0 :             report_untranslatable_char(PG_MULE_INTERNAL, PG_SJIS,
     354             :                                        (const char *) mic, len);
     355           0 :         mic += l;
     356           0 :         len -= l;
     357             :     }
     358           4 :     *p = '\0';
     359           4 : }
     360             : 
     361             : /*
     362             :  * EUC_JP ---> MIC
     363             :  */
     364             : static void
     365           4 : euc_jp2mic(const unsigned char *euc, unsigned char *p, int len)
     366             : {
     367             :     int         c1;
     368             :     int         l;
     369             : 
     370          20 :     while (len > 0)
     371             :     {
     372          12 :         c1 = *euc;
     373          12 :         if (!IS_HIGHBIT_SET(c1))
     374             :         {
     375             :             /* ASCII */
     376          12 :             if (c1 == 0)
     377           0 :                 report_invalid_encoding(PG_EUC_JP,
     378             :                                         (const char *) euc, len);
     379          12 :             *p++ = c1;
     380          12 :             euc++;
     381          12 :             len--;
     382          12 :             continue;
     383             :         }
     384           0 :         l = pg_encoding_verifymb(PG_EUC_JP, (const char *) euc, len);
     385           0 :         if (l < 0)
     386           0 :             report_invalid_encoding(PG_EUC_JP,
     387             :                                     (const char *) euc, len);
     388           0 :         if (c1 == SS2)
     389             :         {                       /* 1 byte kana? */
     390           0 :             *p++ = LC_JISX0201K;
     391           0 :             *p++ = euc[1];
     392             :         }
     393           0 :         else if (c1 == SS3)
     394             :         {                       /* JIS X0212 kanji? */
     395           0 :             *p++ = LC_JISX0212;
     396           0 :             *p++ = euc[1];
     397           0 :             *p++ = euc[2];
     398             :         }
     399             :         else
     400             :         {                       /* kanji? */
     401           0 :             *p++ = LC_JISX0208;
     402           0 :             *p++ = c1;
     403           0 :             *p++ = euc[1];
     404             :         }
     405           0 :         euc += l;
     406           0 :         len -= l;
     407             :     }
     408           4 :     *p = '\0';
     409           4 : }
     410             : 
     411             : /*
     412             :  * MIC ---> EUC_JP
     413             :  */
     414             : static void
     415           4 : mic2euc_jp(const unsigned char *mic, unsigned char *p, int len)
     416             : {
     417             :     int         c1;
     418             :     int         l;
     419             : 
     420          20 :     while (len > 0)
     421             :     {
     422          12 :         c1 = *mic;
     423          12 :         if (!IS_HIGHBIT_SET(c1))
     424             :         {
     425             :             /* ASCII */
     426          12 :             if (c1 == 0)
     427           0 :                 report_invalid_encoding(PG_MULE_INTERNAL,
     428             :                                         (const char *) mic, len);
     429          12 :             *p++ = c1;
     430          12 :             mic++;
     431          12 :             len--;
     432          12 :             continue;
     433             :         }
     434           0 :         l = pg_encoding_verifymb(PG_MULE_INTERNAL, (const char *) mic, len);
     435           0 :         if (l < 0)
     436           0 :             report_invalid_encoding(PG_MULE_INTERNAL,
     437             :                                     (const char *) mic, len);
     438           0 :         if (c1 == LC_JISX0201K)
     439             :         {
     440           0 :             *p++ = SS2;
     441           0 :             *p++ = mic[1];
     442             :         }
     443           0 :         else if (c1 == LC_JISX0212)
     444             :         {
     445           0 :             *p++ = SS3;
     446           0 :             *p++ = mic[1];
     447           0 :             *p++ = mic[2];
     448             :         }
     449           0 :         else if (c1 == LC_JISX0208)
     450             :         {
     451           0 :             *p++ = mic[1];
     452           0 :             *p++ = mic[2];
     453             :         }
     454             :         else
     455           0 :             report_untranslatable_char(PG_MULE_INTERNAL, PG_EUC_JP,
     456             :                                        (const char *) mic, len);
     457           0 :         mic += l;
     458           0 :         len -= l;
     459             :     }
     460           4 :     *p = '\0';
     461           4 : }
     462             : 
     463             : /*
     464             :  * EUC_JP -> SJIS
     465             :  */
     466             : static void
     467           4 : euc_jp2sjis(const unsigned char *euc, unsigned char *p, int len)
     468             : {
     469             :     int         c1,
     470             :                 c2,
     471             :                 k;
     472             :     int         l;
     473             : 
     474          20 :     while (len > 0)
     475             :     {
     476          12 :         c1 = *euc;
     477          12 :         if (!IS_HIGHBIT_SET(c1))
     478             :         {
     479             :             /* ASCII */
     480          12 :             if (c1 == 0)
     481           0 :                 report_invalid_encoding(PG_EUC_JP,
     482             :                                         (const char *) euc, len);
     483          12 :             *p++ = c1;
     484          12 :             euc++;
     485          12 :             len--;
     486          12 :             continue;
     487             :         }
     488           0 :         l = pg_encoding_verifymb(PG_EUC_JP, (const char *) euc, len);
     489           0 :         if (l < 0)
     490           0 :             report_invalid_encoding(PG_EUC_JP,
     491             :                                     (const char *) euc, len);
     492           0 :         if (c1 == SS2)
     493             :         {
     494             :             /* hankaku kana? */
     495           0 :             *p++ = euc[1];
     496             :         }
     497           0 :         else if (c1 == SS3)
     498             :         {
     499             :             /* JIS X0212 kanji? */
     500           0 :             c1 = euc[1];
     501           0 :             c2 = euc[2];
     502           0 :             k = c1 << 8 | c2;
     503           0 :             if (k >= 0xf5a1)
     504             :             {
     505             :                 /* UDC2 */
     506           0 :                 c1 -= 0x54;
     507           0 :                 *p++ = ((c1 - 0xa1) >> 1) + ((c1 < 0xdf) ? 0x81 : 0xc1) + 0x74;
     508           0 :                 *p++ = c2 - ((c1 & 1) ? ((c2 < 0xe0) ? 0x61 : 0x60) : 2);
     509             :             }
     510             :             else
     511             :             {
     512             :                 int         i,
     513             :                             k2;
     514             : 
     515             :                 /* IBM kanji */
     516           0 :                 for (i = 0;; i++)
     517             :                 {
     518           0 :                     k2 = ibmkanji[i].euc & 0xffff;
     519           0 :                     if (k2 == 0xffff)
     520             :                     {
     521           0 :                         *p++ = PGSJISALTCODE >> 8;
     522           0 :                         *p++ = PGSJISALTCODE & 0xff;
     523           0 :                         break;
     524             :                     }
     525           0 :                     if (k2 == k)
     526             :                     {
     527           0 :                         k = ibmkanji[i].sjis;
     528           0 :                         *p++ = k >> 8;
     529           0 :                         *p++ = k & 0xff;
     530           0 :                         break;
     531             :                     }
     532             :                 }
     533             :             }
     534             :         }
     535             :         else
     536             :         {
     537             :             /* JIS X0208 kanji? */
     538           0 :             c2 = euc[1];
     539           0 :             k = (c1 << 8) | (c2 & 0xff);
     540           0 :             if (k >= 0xf5a1)
     541             :             {
     542             :                 /* UDC1 */
     543           0 :                 c1 -= 0x54;
     544           0 :                 *p++ = ((c1 - 0xa1) >> 1) + ((c1 < 0xdf) ? 0x81 : 0xc1) + 0x6f;
     545             :             }
     546             :             else
     547           0 :                 *p++ = ((c1 - 0xa1) >> 1) + ((c1 < 0xdf) ? 0x81 : 0xc1);
     548           0 :             *p++ = c2 - ((c1 & 1) ? ((c2 < 0xe0) ? 0x61 : 0x60) : 2);
     549             :         }
     550           0 :         euc += l;
     551           0 :         len -= l;
     552             :     }
     553           4 :     *p = '\0';
     554           4 : }
     555             : 
     556             : /*
     557             :  * SJIS ---> EUC_JP
     558             :  */
     559             : static void
     560           4 : sjis2euc_jp(const unsigned char *sjis, unsigned char *p, int len)
     561             : {
     562             :     int         c1,
     563             :                 c2,
     564             :                 i,
     565             :                 k,
     566             :                 k2;
     567             :     int         l;
     568             : 
     569          20 :     while (len > 0)
     570             :     {
     571          12 :         c1 = *sjis;
     572          12 :         if (!IS_HIGHBIT_SET(c1))
     573             :         {
     574             :             /* ASCII */
     575          12 :             if (c1 == 0)
     576           0 :                 report_invalid_encoding(PG_SJIS,
     577             :                                         (const char *) sjis, len);
     578          12 :             *p++ = c1;
     579          12 :             sjis++;
     580          12 :             len--;
     581          12 :             continue;
     582             :         }
     583           0 :         l = pg_encoding_verifymb(PG_SJIS, (const char *) sjis, len);
     584           0 :         if (l < 0)
     585           0 :             report_invalid_encoding(PG_SJIS,
     586             :                                     (const char *) sjis, len);
     587           0 :         if (c1 >= 0xa1 && c1 <= 0xdf)
     588             :         {
     589             :             /* JIS X0201 (1 byte kana) */
     590           0 :             *p++ = SS2;
     591           0 :             *p++ = c1;
     592             :         }
     593             :         else
     594             :         {
     595             :             /*
     596             :              * JIS X0208, X0212, user defined extended characters
     597             :              */
     598           0 :             c2 = sjis[1];
     599           0 :             k = (c1 << 8) + c2;
     600           0 :             if (k >= 0xed40 && k < 0xf040)
     601             :             {
     602             :                 /* NEC selection IBM kanji */
     603           0 :                 for (i = 0;; i++)
     604             :                 {
     605           0 :                     k2 = ibmkanji[i].nec;
     606           0 :                     if (k2 == 0xffff)
     607           0 :                         break;
     608           0 :                     if (k2 == k)
     609             :                     {
     610           0 :                         k = ibmkanji[i].sjis;
     611           0 :                         c1 = (k >> 8) & 0xff;
     612           0 :                         c2 = k & 0xff;
     613             :                     }
     614             :                 }
     615             :             }
     616             : 
     617           0 :             if (k < 0xeb3f)
     618             :             {
     619             :                 /* JIS X0208 */
     620           0 :                 *p++ = ((c1 & 0x3f) << 1) + 0x9f + (c2 > 0x9e);
     621           0 :                 *p++ = c2 + ((c2 > 0x9e) ? 2 : 0x60) + (c2 < 0x80);
     622             :             }
     623           0 :             else if ((k >= 0xeb40 && k < 0xf040) || (k >= 0xfc4c && k <= 0xfcfc))
     624             :             {
     625             :                 /* NEC selection IBM kanji - Other undecided justice */
     626           0 :                 *p++ = PGEUCALTCODE >> 8;
     627           0 :                 *p++ = PGEUCALTCODE & 0xff;
     628             :             }
     629           0 :             else if (k >= 0xf040 && k < 0xf540)
     630             :             {
     631             :                 /*
     632             :                  * UDC1 mapping to X0208 85 ku - 94 ku JIS code 0x7521 -
     633             :                  * 0x7e7e EUC 0xf5a1 - 0xfefe
     634             :                  */
     635           0 :                 c1 -= 0x6f;
     636           0 :                 *p++ = ((c1 & 0x3f) << 1) + 0xf3 + (c2 > 0x9e);
     637           0 :                 *p++ = c2 + ((c2 > 0x9e) ? 2 : 0x60) + (c2 < 0x80);
     638             :             }
     639           0 :             else if (k >= 0xf540 && k < 0xfa40)
     640             :             {
     641             :                 /*
     642             :                  * UDC2 mapping to X0212 85 ku - 94 ku JIS code 0x7521 -
     643             :                  * 0x7e7e EUC 0x8ff5a1 - 0x8ffefe
     644             :                  */
     645           0 :                 *p++ = SS3;
     646           0 :                 c1 -= 0x74;
     647           0 :                 *p++ = ((c1 & 0x3f) << 1) + 0xf3 + (c2 > 0x9e);
     648           0 :                 *p++ = c2 + ((c2 > 0x9e) ? 2 : 0x60) + (c2 < 0x80);
     649             :             }
     650           0 :             else if (k >= 0xfa40)
     651             :             {
     652             :                 /*
     653             :                  * mapping IBM kanji to X0208 and X0212
     654             :                  *
     655             :                  */
     656           0 :                 for (i = 0;; i++)
     657             :                 {
     658           0 :                     k2 = ibmkanji[i].sjis;
     659           0 :                     if (k2 == 0xffff)
     660           0 :                         break;
     661           0 :                     if (k2 == k)
     662             :                     {
     663           0 :                         k = ibmkanji[i].euc;
     664           0 :                         if (k >= 0x8f0000)
     665             :                         {
     666           0 :                             *p++ = SS3;
     667           0 :                             *p++ = 0x80 | ((k & 0xff00) >> 8);
     668           0 :                             *p++ = 0x80 | (k & 0xff);
     669             :                         }
     670             :                         else
     671             :                         {
     672           0 :                             *p++ = 0x80 | (k >> 8);
     673           0 :                             *p++ = 0x80 | (k & 0xff);
     674             :                         }
     675             :                     }
     676             :                 }
     677             :             }
     678             :         }
     679           0 :         sjis += l;
     680           0 :         len -= l;
     681             :     }
     682           4 :     *p = '\0';
     683           4 : }

Generated by: LCOV version 1.13