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

LCOV - code coverage report
| Current view: | directory - intl/uconv/ucvcn - nsGBKConvUtil.cpp (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 51 | 38 | 74.5 %
| Date: | 2012-04-21 | Functions: | 3 | 3 | 100.0 %

           1                 : /* -*- Mode: C++; tab-width: 2; 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 Communicator client 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                 :  *
          24                 :  * Alternatively, the contents of this file may be used under the terms of
          25                 :  * either of the GNU General Public License Version 2 or later (the "GPL"),
          26                 :  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
          27                 :  * in which case the provisions of the GPL or the LGPL are applicable instead
          28                 :  * of those above. If you wish to allow use of your version of this file only
          29                 :  * under the terms of either the GPL or the LGPL, and not to allow others to
          30                 :  * use your version of this file under the terms of the MPL, indicate your
          31                 :  * decision by deleting the provisions above and replace them with the notice
          32                 :  * and other provisions required by the GPL or the LGPL. If you do not delete
          33                 :  * the provisions above, a recipient may use your version of this file under
          34                 :  * the terms of any one of the MPL, the GPL or the LGPL.
          35                 :  *
          36                 :  * ***** END LICENSE BLOCK ***** */
          37                 :
          38                 : #include "nsGBKConvUtil.h"
          39                 : #include "gbku.h"
          40                 : #include "nsCRT.h"
          41                 : #define MAX_GBK_LENGTH 24066 /* (0xfe-0x80)*(0xfe-0x3f) */
          42                 : //--------------------------------------------------------------------
          43                 : // nsGBKConvUtil
          44                 : //--------------------------------------------------------------------
          45                 :
          46                 : static bool gInitToGBKTable = false;
          47                 : static const PRUnichar gGBKToUnicodeTable[MAX_GBK_LENGTH] = {
          48                 : #include "cp936map.h"
          49                 : };
          50                 : static PRUint16 gUnicodeToGBKTable[0xA000-0x4e00];
          51                 :
          52             128 : bool nsGBKConvUtil::UnicodeToGBKChar(
          53                 :   PRUnichar aChar, bool aToGL, char*
          54                 :   aOutByte1, char* aOutByte2)
          55                 : {
          56             128 :   NS_ASSERTION(gInitToGBKTable, "gGBKToUnicodeTable is not init yet. need to call InitToGBKTable first");
          57             128 :   bool found=false;
          58             128 :   *aOutByte1 = *aOutByte2 = 0;
          59             128 :   if(UNICHAR_IN_RANGE(0xd800, aChar, 0xdfff))
          60                 :   {
          61                 :     // surrogate is not in here
          62               0 :     return false;
          63                 :   }
          64             128 :   if(UNICHAR_IN_RANGE(0x4e00, aChar, 0x9FFF))
          65                 :   {
          66             128 :     PRUint16 item = gUnicodeToGBKTable[aChar - 0x4e00];
          67             128 :     if(item != 0)
          68                 :     {
          69             128 :       *aOutByte1 = item >> 8;
          70             128 :       *aOutByte2 = item & 0x00FF;
          71             128 :       found = true;
          72                 :     } else {
          73               0 :       return false;
          74             128 :     }
          75                 :   } else {
          76                 :     // ugly linear search
          77               0 :     for( PRInt32 i = 0; i < MAX_GBK_LENGTH; i++ )
          78                 :     {
          79               0 :       if( aChar == gGBKToUnicodeTable[i])
          80                 :       {
          81               0 :         *aOutByte1 = (i /  0x00BF + 0x0081) ;
          82               0 :         *aOutByte2 = (i %  0x00BF + 0x0040) ;
          83               0 :         found = true;
          84               0 :         break;
          85                 :       }
          86                 :     }
          87                 :   }
          88             128 :   if(! found)
          89               0 :     return false;
          90                 :
          91             128 :   if(aToGL) {
          92                 :     // to GL, we only return if it is in the range
          93               2 :     if(UINT8_IN_RANGE(0xA1, *aOutByte1, 0xFE) &&
          94                 :        UINT8_IN_RANGE(0xA1, *aOutByte2, 0xFE))
          95                 :     {
          96                 :       // mask them to GL
          97               2 :       *aOutByte1 &= 0x7F;
          98               2 :       *aOutByte2 &= 0x7F;
          99                 :     } else {
         100                 :       // if it does not fit into 0xa1-0xfe 0xa1-0xfe range that mean
         101                 :       // it is not a GB2312 character, we cannot map to GL
         102               0 :       *aOutByte1 = 0x00;
         103               0 :       *aOutByte2 = 0x00;
         104               0 :       return false;
         105                 :     }
         106                 :   }
         107             128 :   return true;
         108                 : }
         109           40664 : PRUnichar nsGBKConvUtil::GBKCharToUnicode(char aByte1, char aByte2)
         110                 : {
         111           40664 :   NS_ASSERTION(UINT8_IN_RANGE(0x81,aByte1, 0xFE), "first byte out of range");
         112           40664 :   NS_ASSERTION(UINT8_IN_RANGE(0x40,aByte2, 0xFE), "second byte out of range");
         113                 :
         114           40664 :   PRUint8 i1 = (PRUint8)aByte1;
         115           40664 :   PRUint8 i2 = (PRUint8)aByte2;
         116           40664 :   PRUint16 idx = (i1 - 0x0081) * 0x00bf + i2 - 0x0040 ;
         117                 :
         118           40664 :   NS_ASSERTION(idx < MAX_GBK_LENGTH, "ARB");
         119                 :   // play it safe- add if statement here ot protect ARB
         120                 :   // probably not necessary
         121           40664 :   if(idx < MAX_GBK_LENGTH)
         122           40664 :     return gGBKToUnicodeTable[ idx ];
         123                 :   else
         124               0 :     return UCS2_NO_MAPPING;
         125                 : }
         126              18 : void nsGBKConvUtil::InitToGBKTable()
         127                 : {
         128              18 :   if ( gInitToGBKTable )
         129              10 :    return;
         130                 :
         131                 :   PRUnichar unicode;
         132                 :   PRUnichar i;
         133                 :   // zap it to zero first
         134               8 :   memset(gUnicodeToGBKTable,0, sizeof(gUnicodeToGBKTable));
         135                 :
         136          192536 :   for ( i=0; i<MAX_GBK_LENGTH; i++ )
         137                 :   {
         138          192528 :     unicode = gGBKToUnicodeTable[i];
         139                 :     // to reduce size of gUnicodeToGBKTable, we only do direct unicode to GB
         140                 :     // table mapping between unicode 0x4E00 and 0xA000. Others by searching
         141                 :     // gGBKToUnicodeTable. There is a trade off between memory usage and speed.
         142          192528 :     if(UNICHAR_IN_RANGE(0x4e00, unicode, 0x9fff))
         143                 :     {
         144          167216 :       unicode -= 0x4E00;
         145          167216 :       gUnicodeToGBKTable[unicode] =  (( i / 0x00BF + 0x0081) << 8) |
         146          167216 :                                     ( i % 0x00BF+ 0x0040);
         147                 :     }
         148                 :   }
         149               8 :   gInitToGBKTable = true;
         150                 : }

Generated by: LCOV version 1.7