LCOV - app.info - intl/uconv/ucvcn/nsISO2022CNToUnicode.cpp

LCOV - code coverage report
| Current view: | directory - intl/uconv/ucvcn - nsISO2022CNToUnicode.cpp (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 374 | 0 | 0.0 %
| Date: | 2012-07-07 | Functions: | 3 | 0 | 0.0 %

           1                 : /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
           2                 : /* ***** BEGIN LICENSE BLOCK *****
           3                 :  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
           4                 :  *
           5                 :  * The contents of this file are subject to the Mozilla Public License Version
           6                 :  * 1.1 (the "License"); you may not use this file except in compliance with
           7                 :  * the License. You may obtain a copy of the License at
           8                 :  * http://www.mozilla.org/MPL/
           9                 :  *
          10                 :  * Software distributed under the License is distributed on an "AS IS" basis,
          11                 :  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
          12                 :  * for the specific language governing rights and limitations under the
          13                 :  * License.
          14                 :  *
          15                 :  * The Original Code is mozilla.org code.
          16                 :  *
          17                 :  * The Initial Developer of the Original Code is
          18                 :  * Netscape Communications Corporation.
          19                 :  * Portions created by the Initial Developer are Copyright (C) 1998
          20                 :  * the Initial Developer. All Rights Reserved.
          21                 :  *
          22                 :  * Contributor(s):
          23                 :  *   Ervin Yan <ervin.yan@sun.com>
          24                 :  *
          25                 :  * Alternatively, the contents of this file may be used under the terms of
          26                 :  * either of the GNU General Public License Version 2 or later (the "GPL"),
          27                 :  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
          28                 :  * in which case the provisions of the GPL or the LGPL are applicable instead
          29                 :  * of those above. If you wish to allow use of your version of this file only
          30                 :  * under the terms of either the GPL or the LGPL, and not to allow others to
          31                 :  * use your version of this file under the terms of the MPL, indicate your
          32                 :  * decision by deleting the provisions above and replace them with the notice
          33                 :  * and other provisions required by the GPL or the LGPL. If you do not delete
          34                 :  * the provisions above, a recipient may use your version of this file under
          35                 :  * the terms of any one of the MPL, the GPL or the LGPL.
          36                 :  *
          37                 :  * ***** END LICENSE BLOCK ***** */
          38                 : #include "nsISO2022CNToUnicode.h"
          39                 : #include "nsUCSupport.h"
          40                 : #include "nsICharsetConverterManager.h"
          41                 : #include "nsIServiceManager.h"
          42                 :
          43                 : static NS_DEFINE_CID(kCharsetConverterManagerCID, NS_ICHARSETCONVERTERMANAGER_CID);
          44                 :
          45               0 : NS_IMETHODIMP nsISO2022CNToUnicode::GB2312_To_Unicode(unsigned char *aSrc, PRInt32 aSrcLength, PRUnichar * aDest, PRInt32 * aDestLength)
          46                 : {
          47                 :     nsresult rv;
          48                 :
          49               0 :     if(!mGB2312_Decoder) {
          50                 :        // creating a delegate converter (GB2312)
          51                 :        nsCOMPtr<nsICharsetConverterManager> ccm =
          52               0 :               do_GetService(kCharsetConverterManagerCID, &rv);
          53               0 :        if(NS_FAILED(rv))
          54               0 :           return NS_ERROR_UNEXPECTED;
          55                 :
          56               0 :        rv = ccm->GetUnicodeDecoderRaw("GB2312", getter_AddRefs(mGB2312_Decoder));
          57               0 :        if(NS_FAILED(rv))
          58               0 :           return NS_ERROR_UNEXPECTED;
          59                 :     }
          60                 :
          61               0 :     if(!mGB2312_Decoder) // failed creating a delegate converter
          62               0 :        return NS_ERROR_UNEXPECTED;
          63                 :
          64               0 :     rv = mGB2312_Decoder->Convert((const char *)aSrc, &aSrcLength, aDest, aDestLength);
          65               0 :     return rv;
          66                 : }
          67                 :
          68               0 : NS_IMETHODIMP nsISO2022CNToUnicode::EUCTW_To_Unicode(unsigned char *aSrc, PRInt32 aSrcLength, PRUnichar * aDest, PRInt32 * aDestLength)
          69                 : {
          70                 :     nsresult rv;
          71                 :
          72               0 :     if(!mEUCTW_Decoder) {
          73                 :        // creating a delegate converter (x-euc-tw)
          74                 :        nsCOMPtr<nsICharsetConverterManager> ccm =
          75               0 :               do_GetService(kCharsetConverterManagerCID, &rv);
          76               0 :        if(NS_FAILED(rv))
          77               0 :           return NS_ERROR_UNEXPECTED;
          78                 :
          79               0 :        rv = ccm->GetUnicodeDecoderRaw("x-euc-tw", getter_AddRefs(mEUCTW_Decoder));
          80               0 :        if(NS_FAILED(rv))
          81               0 :           return NS_ERROR_UNEXPECTED;
          82                 :     }
          83                 :
          84               0 :     if(!mEUCTW_Decoder) // failed creating a delegate converter
          85               0 :        return NS_ERROR_UNEXPECTED;
          86                 :
          87               0 :     rv = mEUCTW_Decoder->Convert((const char *)aSrc, &aSrcLength, aDest, aDestLength);
          88               0 :     return(rv);
          89                 : }
          90                 :
          91               0 : NS_IMETHODIMP nsISO2022CNToUnicode::Convert(const char * aSrc, PRInt32 * aSrcLen, PRUnichar * aDest, PRInt32 * aDestLen)
          92                 : {
          93               0 :   const unsigned char * srcEnd = (unsigned char *)aSrc + *aSrcLen;
          94               0 :   const unsigned char * src = (unsigned char *) aSrc;
          95               0 :   PRUnichar* destEnd = aDest + *aDestLen;
          96               0 :   PRUnichar* dest = aDest;
          97                 :   nsresult rv;
          98                 :   PRInt32 aLen;
          99                 :
         100               0 :   while ((src < srcEnd))
         101                 :   {
         102               0 :     switch (mState)
         103                 :     {
         104                 :       case eState_ASCII:
         105               0 :         if(ESC == *src) {
         106               0 :            mState = eState_ESC;
         107                 :         } else {
         108               0 :            if (CHECK_OVERRUN(dest, destEnd, 1))
         109               0 :               goto error1;
         110               0 :            *dest++ = (0x80 & *src) ? 0xFFFD : (PRUnichar) *src;
         111                 :
         112               0 :            mState = eState_ASCII;
         113                 :         }
         114               0 :         break;
         115                 :
         116                 :       case eState_ESC:    // ESC
         117               0 :         if('$' == *src) {
         118               0 :            mState = eState_ESC_24;
         119                 :         } else {
         120               0 :            if (CHECK_OVERRUN(dest, destEnd, 2))
         121               0 :               goto error1;
         122               0 :            *dest++ = (PRUnichar) ESC;
         123               0 :            *dest++ = (0x80 & *src) ? 0xFFFD : (PRUnichar) *src;
         124                 :
         125               0 :            mState = eState_ASCII;
         126                 :         }
         127               0 :         break;
         128                 :
         129                 :       case eState_ESC_24: // ESC $
         130               0 :         if(')' == *src) {
         131               0 :            mState = eState_ESC_24_29;
         132               0 :         } else if('*' == *src) {
         133               0 :            mState = eState_ESC_24_2A;
         134               0 :         } else if('+' == *src) {
         135               0 :            mState = eState_ESC_24_2B;
         136                 :         } else {
         137               0 :            if (CHECK_OVERRUN(dest, destEnd, 3))
         138               0 :               goto error1;
         139               0 :            *dest++ = (PRUnichar) ESC;
         140               0 :            *dest++ = (PRUnichar) '$';
         141               0 :            *dest++ = (0x80 & *src) ? 0xFFFD : (PRUnichar) *src;
         142                 :
         143               0 :            mState = eState_ASCII;
         144                 :         }
         145               0 :         break;
         146                 :
         147                 :       case eState_ESC_24_29: // ESC $ )
         148               0 :         if('A' == *src) {
         149               0 :            mState = eState_ESC_24_29_A;
         150               0 :         } else if('G' == *src) {
         151               0 :            mState = eState_ESC_24_29_G;
         152                 :         } else {
         153               0 :            if (CHECK_OVERRUN(dest, destEnd, 4))
         154               0 :               goto error1;
         155               0 :            *dest++ = (PRUnichar) ESC;
         156               0 :            *dest++ = (PRUnichar) '$';
         157               0 :            *dest++ = (PRUnichar) ')';
         158               0 :            *dest++ = (0x80 & *src) ? 0xFFFD : (PRUnichar) *src;
         159                 :
         160               0 :            mState = eState_ASCII;
         161                 :         }
         162               0 :         break;
         163                 :
         164                 :       case eState_ESC_24_29_A:  // ESC $ ) A
         165               0 :         if(SO == *src) {
         166               0 :            mState = eState_GB2312_1980;
         167               0 :            mRunLength = 0;
         168                 :         } else {
         169               0 :            if (CHECK_OVERRUN(dest, destEnd, 5))
         170               0 :               goto error1;
         171               0 :            *dest++ = (PRUnichar) ESC;
         172               0 :            *dest++ = (PRUnichar) '$';
         173               0 :            *dest++ = (PRUnichar) ')';
         174               0 :            *dest++ = (PRUnichar) 'A';
         175               0 :            *dest++ = (0x80 & *src) ? 0xFFFD : (PRUnichar) *src;
         176                 :
         177               0 :            mState = eState_ASCII;
         178                 :         }
         179               0 :         break;
         180                 :
         181                 :       case eState_GB2312_1980:   // ESC $ ) A SO
         182               0 :         if(SI == *src) { // Shift-In (SI)
         183               0 :            mState = eState_ESC_24_29_A_SO_SI;
         184               0 :            if (mRunLength == 0) {
         185               0 :               if (CHECK_OVERRUN(dest, destEnd, 1))
         186               0 :                  goto error1;
         187               0 :               *dest++ = 0xFFFD;
         188                 :            }
         189               0 :            mRunLength = 0;
         190               0 :         } else if(ESC == *src) {
         191               0 :            mState = eState_ESC;
         192                 :         } else {
         193               0 :            if(0x20 < *src && *src < 0x7f) {
         194               0 :               mData = *src;
         195               0 :               mState = eState_GB2312_1980_2ndbyte;
         196                 :            } else {
         197               0 :               if (CHECK_OVERRUN(dest, destEnd, 1))
         198               0 :                  goto error1;
         199               0 :               *dest++ = (0x80 & *src) ? 0xFFFD : (PRUnichar) *src;
         200                 :            }
         201                 :         }
         202               0 :         break;
         203                 :
         204                 :       case eState_GB2312_1980_2ndbyte:  // ESC $ ) A SO
         205               0 :         if(0x20 < *src && *src < 0x7f) {
         206                 :            unsigned char gb[2];
         207               0 :            PRInt32 gbLen = 2;
         208                 :
         209               0 :            gb[0] = mData | 0x80;
         210               0 :            gb[1] = *src | 0x80;
         211                 :
         212               0 :            aLen = destEnd - dest;
         213               0 :            rv = GB2312_To_Unicode(gb, gbLen, dest, &aLen);
         214               0 :            ++mRunLength;
         215               0 :            if(rv == NS_OK_UDEC_MOREOUTPUT) {
         216               0 :               goto error1;
         217               0 :            } else if(NS_FAILED(rv)) {
         218               0 :               goto error2;
         219                 :            }
         220                 :
         221               0 :            dest += aLen;
         222                 :         } else {
         223               0 :            if (CHECK_OVERRUN(dest, destEnd, 2))
         224               0 :               goto error1;
         225               0 :            *dest++ = (PRUnichar) mData;
         226               0 :            *dest++ = (0x80 & *src) ? 0xFFFD : (PRUnichar) *src;
         227                 :         }
         228               0 :         mState = eState_GB2312_1980;
         229               0 :         break;
         230                 :
         231                 :       case eState_ESC_24_29_A_SO_SI:  // ESC $ ) A SO SI
         232               0 :         if(SO == *src) {
         233               0 :            mState = eState_GB2312_1980;
         234               0 :            mRunLength = 0;
         235               0 :         } else if(ESC == *src) {
         236               0 :            mState = eState_ESC;
         237                 :         } else {
         238               0 :            if (CHECK_OVERRUN(dest, destEnd, 1))
         239               0 :               goto error1;
         240               0 :            *dest++ = (0x80 & *src) ? 0xFFFD : (PRUnichar) *src;
         241                 :
         242               0 :            mState = eState_ESC_24_29_A_SO_SI;
         243                 :         }
         244               0 :         break;
         245                 :
         246                 :       case eState_ESC_24_29_G:   // ESC $ ) G
         247               0 :         if(SO == *src) {
         248               0 :            mState = eState_CNS11643_1;
         249               0 :            mRunLength = 0;
         250                 :         } else {
         251               0 :            if (CHECK_OVERRUN(dest, destEnd, 5))
         252               0 :               goto error1;
         253               0 :            *dest++ = (PRUnichar) ESC;
         254               0 :            *dest++ = (PRUnichar) '$';
         255               0 :            *dest++ = (PRUnichar) ')';
         256               0 :            *dest++ = (PRUnichar) 'G';
         257               0 :            *dest++ = (0x80 & *src) ? 0xFFFD : (PRUnichar) *src;
         258                 :
         259               0 :            mState = eState_ASCII;
         260                 :         }
         261               0 :         break;
         262                 :
         263                 :       case eState_CNS11643_1:   // ESC $ ) G SO
         264               0 :         if(SI == *src) { // Shift-In (SI)
         265               0 :            mState = eState_ESC_24_29_G_SO_SI;
         266               0 :            if (mRunLength == 0) {
         267               0 :               if (CHECK_OVERRUN(dest, destEnd, 1))
         268               0 :                  goto error1;
         269               0 :               *dest++ = 0xFFFD;
         270                 :            }
         271               0 :            mRunLength = 0;
         272               0 :         } else if(ESC == *src) {
         273               0 :            mState = eState_ESC;
         274                 :         } else {
         275               0 :            if(0x20 < *src && *src < 0x7f) {
         276               0 :               mData = *src;
         277               0 :               mState = eState_CNS11643_1_2ndbyte;
         278                 :            } else {
         279               0 :               if (CHECK_OVERRUN(dest, destEnd, 1))
         280               0 :                  goto error1;
         281               0 :               *dest++ = (0x80 & *src) ? 0xFFFD : (PRUnichar) *src;
         282                 :            }
         283                 :         }
         284               0 :         break;
         285                 :
         286                 :       case eState_CNS11643_1_2ndbyte:  // ESC $ ) G SO
         287               0 :         if(0x20 < *src && *src < 0x7f) {
         288                 :            unsigned char cns[4];
         289               0 :            PRInt32 cnsLen = 2;
         290                 :
         291               0 :            cns[0] = mData | 0x80;
         292               0 :            cns[1] = *src | 0x80;
         293                 :
         294               0 :            aLen = destEnd - dest;
         295               0 :            rv = EUCTW_To_Unicode(cns, cnsLen, dest, &aLen);
         296               0 :            ++mRunLength;
         297               0 :            if(rv == NS_OK_UDEC_MOREOUTPUT) {
         298               0 :               goto error1;
         299               0 :            } else if(NS_FAILED(rv)) {
         300               0 :               goto error2;
         301                 :            }
         302                 :
         303               0 :            dest += aLen;
         304                 :         } else {
         305               0 :            if (CHECK_OVERRUN(dest, destEnd, 2))
         306               0 :               goto error1;
         307               0 :            *dest++ = (PRUnichar) mData;
         308               0 :            *dest++ = (0x80 & *src) ? 0xFFFD : (PRUnichar) *src;
         309                 :         }
         310               0 :         mState = eState_CNS11643_1;
         311               0 :         break;
         312                 :
         313                 :       case eState_ESC_24_29_G_SO_SI: // ESC $ ) G SO SI
         314               0 :         if(SO == *src) {
         315               0 :            mState = eState_CNS11643_1;
         316               0 :            mRunLength = 0;
         317               0 :         } else if(ESC == *src) {
         318               0 :            mState = eState_ESC;
         319                 :         } else {
         320               0 :            if (CHECK_OVERRUN(dest, destEnd, 1))
         321               0 :               goto error1;
         322               0 :            *dest++ = (0x80 & *src) ? 0xFFFD : (PRUnichar) *src;
         323                 :
         324               0 :            mState = eState_ESC_24_29_G_SO_SI;
         325                 :         }
         326               0 :         break;
         327                 :
         328                 :       case eState_ESC_24_2A: // ESC $ *
         329               0 :         if('H' == *src) {
         330               0 :            mState = eState_ESC_24_2A_H;
         331                 :         } else {
         332               0 :            if (CHECK_OVERRUN(dest, destEnd, 4))
         333               0 :               goto error1;
         334               0 :            *dest++ = (PRUnichar) ESC;
         335               0 :            *dest++ = (PRUnichar) '$';
         336               0 :            *dest++ = (PRUnichar) '*';
         337               0 :            *dest++ = (0x80 & *src) ? 0xFFFD : (PRUnichar) *src;
         338                 :
         339               0 :            mState = eState_ASCII;
         340                 :         }
         341               0 :         break;
         342                 :
         343                 :       case eState_ESC_24_2A_H:  // ESC $ * H
         344               0 :         if(ESC == *src) {
         345               0 :            mState = eState_ESC_24_2A_H_ESC;
         346                 :         } else {
         347               0 :            if (CHECK_OVERRUN(dest, destEnd, 5))
         348               0 :               goto error1;
         349               0 :            *dest++ = (PRUnichar) ESC;
         350               0 :            *dest++ = (PRUnichar) '$';
         351               0 :            *dest++ = (PRUnichar) '*';
         352               0 :            *dest++ = (PRUnichar) 'H';
         353               0 :            *dest++ = (0x80 & *src) ? 0xFFFD : (PRUnichar) *src;
         354                 :
         355               0 :            mState = eState_ASCII;
         356                 :         }
         357               0 :         break;
         358                 :
         359                 :       case eState_ESC_24_2A_H_ESC:  // ESC $ * H ESC
         360               0 :         if(SS2 == *src) {
         361               0 :            mState = eState_CNS11643_2;
         362               0 :            mRunLength = 0;
         363               0 :         } else if('$' == *src) {
         364               0 :            mState = eState_ESC_24;
         365                 :         } else {
         366               0 :            if (CHECK_OVERRUN(dest, destEnd, 6))
         367               0 :               goto error1;
         368               0 :            *dest++ = (PRUnichar) ESC;
         369               0 :            *dest++ = (PRUnichar) '$';
         370               0 :            *dest++ = (PRUnichar) '*';
         371               0 :            *dest++ = (PRUnichar) 'H';
         372               0 :            *dest++ = (PRUnichar) ESC;
         373               0 :            *dest++ = (0x80 & *src) ? 0xFFFD : (PRUnichar) *src;
         374                 :
         375               0 :            mState = eState_ASCII;
         376                 :         }
         377               0 :         break;
         378                 :
         379                 :       case eState_CNS11643_2:  // ESC $ * H ESC SS2
         380               0 :         if(SI == *src) { // Shift-In (SI)
         381               0 :            mState = eState_ESC_24_2A_H_ESC_SS2_SI;
         382               0 :            if (mRunLength == 0) {
         383               0 :               if (CHECK_OVERRUN(dest, destEnd, 1))
         384               0 :                  goto error1;
         385               0 :               *dest++ = 0xFFFD;
         386                 :            }
         387               0 :            mRunLength = 0;
         388               0 :         } else if(ESC == *src) {
         389               0 :            mState = eState_ESC_24_2A_H_ESC;
         390                 :         } else {
         391               0 :            if(0x20 < *src && *src < 0x7f) {
         392               0 :               mData = *src;
         393               0 :               mState = eState_CNS11643_2_2ndbyte;
         394                 :            } else {
         395               0 :               if (CHECK_OVERRUN(dest, destEnd, 1))
         396               0 :                  goto error1;
         397               0 :               *dest++ = (0x80 & *src) ? 0xFFFD : (PRUnichar) *src;
         398                 :            }
         399                 :         }
         400               0 :         break;
         401                 :
         402                 :       case eState_CNS11643_2_2ndbyte:   // ESC $ * H ESC SS2
         403               0 :         if(0x20 < *src && *src < 0x7f) {
         404                 :            unsigned char cns[4];
         405               0 :            PRInt32 cnsLen = 4;
         406                 :
         407               0 :            cns[0] = (unsigned char) MBYTE;
         408               0 :            cns[1] = (unsigned char) (PMASK + 2);
         409               0 :            cns[2] = mData | 0x80;
         410               0 :            cns[3] = *src | 0x80;
         411                 :
         412               0 :            aLen = destEnd - dest;
         413               0 :            rv = EUCTW_To_Unicode(cns, cnsLen, dest, &aLen);
         414               0 :            ++mRunLength;
         415               0 :            if(rv == NS_OK_UDEC_MOREOUTPUT) {
         416               0 :               goto error1;
         417               0 :            } else if(NS_FAILED(rv)) {
         418               0 :               goto error2;
         419                 :            }
         420                 :
         421               0 :            dest += aLen;
         422                 :         } else {
         423               0 :            if (CHECK_OVERRUN(dest, destEnd, 2))
         424               0 :               goto error1;
         425               0 :            *dest++ = (PRUnichar) mData;
         426               0 :            *dest++ = (0x80 & *src) ? 0xFFFD : (PRUnichar) *src;
         427                 :         }
         428               0 :         mState = eState_CNS11643_2;
         429               0 :         break;
         430                 :
         431                 :       case eState_ESC_24_2A_H_ESC_SS2_SI:  // ESC $ * H ESC SS2 SI
         432               0 :         if(ESC == *src) {
         433               0 :            mState = eState_ESC_24_2A_H_ESC_SS2_SI_ESC;
         434                 :         } else {
         435               0 :            if (CHECK_OVERRUN(dest, destEnd, 1))
         436               0 :               goto error1;
         437               0 :            *dest++ = (0x80 & *src) ? 0xFFFD : (PRUnichar) *src;
         438                 :
         439               0 :            mState = eState_ESC_24_2A_H_ESC_SS2_SI;
         440                 :         }
         441               0 :         break;
         442                 :
         443                 :       case eState_ESC_24_2A_H_ESC_SS2_SI_ESC:  // ESC $ * H ESC SS2 SI ESC
         444               0 :         if(SS2 == *src) {
         445               0 :            mState = eState_CNS11643_2;
         446               0 :            mRunLength = 0;
         447               0 :         } else if('$' == *src) {
         448               0 :            mState = eState_ESC_24;
         449                 :         } else {
         450               0 :            if (CHECK_OVERRUN(dest, destEnd, 1))
         451               0 :               goto error1;
         452               0 :            *dest++ = (0x80 & *src) ? 0xFFFD : (PRUnichar) *src;
         453                 :
         454               0 :            mState = eState_ESC_24_2A_H_ESC_SS2_SI;
         455                 :         }
         456               0 :         break;
         457                 :
         458                 :       case eState_ESC_24_2B: // ESC $ +
         459               0 :         if('I' <= *src && *src <= 'M') {
         460               0 :             mState = eState_ESC_24_2B_I;
         461               0 :             mPlaneID = *src - 'I' + 3;
         462                 :         } else {
         463               0 :            if (CHECK_OVERRUN(dest, destEnd, 4))
         464               0 :               goto error1;
         465               0 :            *dest++ = (PRUnichar) ESC;
         466               0 :            *dest++ = (PRUnichar) '$';
         467               0 :            *dest++ = (PRUnichar) '+';
         468               0 :            *dest++ = (0x80 & *src) ? 0xFFFD : (PRUnichar) *src;
         469                 :
         470               0 :            mState = eState_ASCII;
         471                 :         }
         472               0 :         break;
         473                 :
         474                 :       case eState_ESC_24_2B_I:  // ESC $ + I
         475               0 :         if(ESC == *src) {
         476               0 :            mState = eState_ESC_24_2B_I_ESC;
         477                 :         } else {
         478               0 :            if (CHECK_OVERRUN(dest, destEnd, 5))
         479               0 :               goto error1;
         480               0 :            *dest++ = (PRUnichar) ESC;
         481               0 :            *dest++ = (PRUnichar) '$';
         482               0 :            *dest++ = (PRUnichar) '+';
         483               0 :            *dest++ = (PRUnichar) 'I' + mPlaneID - 3;
         484               0 :            *dest++ = (0x80 & *src) ? 0xFFFD : (PRUnichar) *src;
         485                 :
         486               0 :            mState = eState_ASCII;
         487                 :         }
         488               0 :         break;
         489                 :
         490                 :       case eState_ESC_24_2B_I_ESC:  // ESC $ + I ESC
         491               0 :         if(SS3 == *src) {
         492               0 :            mState = eState_CNS11643_3;
         493               0 :            mRunLength = 0;
         494               0 :         } else if('$' == *src) {
         495               0 :            mState = eState_ESC_24;
         496                 :         } else {
         497               0 :            if (CHECK_OVERRUN(dest, destEnd, 6))
         498               0 :               goto error1;
         499               0 :            *dest++ = (PRUnichar) ESC;
         500               0 :            *dest++ = (PRUnichar) '$';
         501               0 :            *dest++ = (PRUnichar) '+';
         502               0 :            *dest++ = (PRUnichar) 'I' + mPlaneID - 3;
         503               0 :            *dest++ = (PRUnichar) ESC;
         504               0 :            *dest++ = (0x80 & *src) ? 0xFFFD : (PRUnichar) *src;
         505                 :
         506               0 :            mState = eState_ASCII;
         507                 :         }
         508               0 :         break;
         509                 :
         510                 :       case eState_CNS11643_3:   // ESC $ + I ESC SS3
         511               0 :         if(SI == *src) { // Shift-In (SI)
         512               0 :            mState = eState_ESC_24_2B_I_ESC_SS3_SI;
         513               0 :            if (mRunLength == 0) {
         514               0 :               if (CHECK_OVERRUN(dest, destEnd, 1))
         515               0 :                  goto error1;
         516               0 :               *dest++ = 0xFFFD;
         517                 :            }
         518               0 :            mRunLength = 0;
         519               0 :         } else if(ESC == *src) {
         520               0 :            mState = eState_ESC_24_2B_I_ESC;
         521                 :         } else {
         522               0 :            if(0x20 < *src && *src < 0x7f) {
         523               0 :               mData = *src;
         524               0 :               mState = eState_CNS11643_3_2ndbyte;
         525                 :            } else {
         526               0 :               if (CHECK_OVERRUN(dest, destEnd, 1))
         527               0 :                  goto error1;
         528               0 :               *dest++ = (0x80 & *src) ? 0xFFFD : (PRUnichar) *src;
         529                 :            }
         530                 :         }
         531                 :
         532               0 :         break;
         533                 :
         534                 :       case eState_CNS11643_3_2ndbyte:  // ESC $ + I ESC SS3
         535               0 :         if(0x20 < *src && *src < 0x7f) {
         536                 :            unsigned char cns[4];
         537               0 :            PRInt32 cnsLen = 4;
         538                 :
         539               0 :            cns[0] = (unsigned char) MBYTE;
         540               0 :            cns[1] = (unsigned char) (PMASK + mPlaneID);
         541               0 :            cns[2] = mData | 0x80;
         542               0 :            cns[3] = *src | 0x80;
         543                 :
         544               0 :            aLen = destEnd - dest;
         545               0 :            rv = EUCTW_To_Unicode(cns, cnsLen, dest, &aLen);
         546               0 :            ++mRunLength;
         547               0 :            if(rv == NS_OK_UDEC_MOREOUTPUT) {
         548               0 :               goto error1;
         549               0 :            } else if(NS_FAILED(rv)) {
         550               0 :               goto error2;
         551                 :            }
         552                 :
         553               0 :            dest += aLen;
         554                 :         } else {
         555               0 :            if (CHECK_OVERRUN(dest, destEnd, 2))
         556               0 :               goto error1;
         557               0 :            *dest++ = (PRUnichar) mData;
         558               0 :            *dest++ = (0x80 & *src) ? 0xFFFD : (PRUnichar) *src;
         559                 :         }
         560               0 :         mState = eState_CNS11643_3;
         561               0 :         break;
         562                 :
         563                 :       case eState_ESC_24_2B_I_ESC_SS3_SI:  // ESC $ + I ESC SS3 SI
         564               0 :         if(ESC == *src) {
         565               0 :            mState = eState_ESC_24_2B_I_ESC_SS3_SI_ESC;
         566                 :         } else {
         567               0 :            if (CHECK_OVERRUN(dest, destEnd, 1))
         568               0 :               goto error1;
         569               0 :            *dest++ = (0x80 & *src) ? 0xFFFD : (PRUnichar) *src;
         570                 :
         571               0 :            mState = eState_ESC_24_2B_I_ESC_SS3_SI;
         572                 :         }
         573               0 :         break;
         574                 :
         575                 :       case eState_ESC_24_2B_I_ESC_SS3_SI_ESC:  // ESC $ + I ESC SS3 SI ESC
         576               0 :         if(SS3 == *src) {
         577               0 :            mState = eState_CNS11643_3;
         578               0 :            mRunLength = 0;
         579               0 :         } else if('$' == *src) {
         580               0 :            mState = eState_ESC_24;
         581                 :         } else {
         582               0 :            if (CHECK_OVERRUN(dest, destEnd, 1))
         583               0 :               goto error1;
         584               0 :            *dest++ = (0x80 & *src) ? 0xFFFD : (PRUnichar) *src;
         585                 :
         586               0 :            mState = eState_ESC_24_2B_I_ESC_SS3_SI;
         587                 :         }
         588               0 :         break;
         589                 :
         590                 :       case eState_ERROR:
         591               0 :         NS_NOTREACHED("unhandled case");
         592               0 :         goto error2;
         593                 :
         594                 :     } // switch
         595               0 :     src++;
         596                 :   }
         597                 :
         598               0 :   *aDestLen = dest- aDest;
         599               0 :   return NS_OK;
         600                 :
         601                 : error1:
         602               0 :   *aDestLen = dest-aDest;
         603               0 :   *aSrcLen = src - (const unsigned char*)aSrc;
         604               0 :   return NS_OK_UDEC_MOREOUTPUT;
         605                 :
         606                 : error2:
         607               0 :   *aSrcLen = src - (const unsigned char*)aSrc;
         608               0 :   *aDestLen = dest-aDest;
         609               0 :   mState = eState_ASCII;
         610               0 :   return NS_ERROR_UNEXPECTED;
         611                 : }

Generated by: LCOV version 1.7