chnconv_dll.cpp

This software performs code conversion of Chinese characters, including GB2312/GBK and BIG5. It a

      // 暥帤嶲徠傪夝愅偡傞
      if ( pData->dwConversionMode & CONVMODE_INPUT_CODE_NUMBER ) {

         C = DecodeCharRef ( C, pData ) ;
         if ( C == EOF ) continue ;

         // 僄儔乕側傜僶僢僼傽傪栠偡
         if ( *GetStoredCharsA ( pData->CharRefBuffer ) ) {
            C = UnreadDecodeCharRefBuffer ( C, pData ) ;
            if ( pData->CharRefUnreadBuffer == STOREDCHARS_ERROR ) { pData->nError = CONV_ERROR_MEMORY ; goto CAUGHT_ERROR ; }
            if ( C == EOF ) continue ;
         }
      }


      // 惂屼暥帤丒夵峴側偳偼偦偺傑傑弌椡
      if ( isascii ( C ) && iscntrl ( C ) ) {
         StreamWrite ( C, pData->StreamOut ) ;
         continue ;
      }


      int cSaved = C ;

      if ( ( pData->nSrcCodePage & CP_DEFINE_CODEPAGE ) == CP_JAPANESE ) {
         if ( C != 0xEEF9 ) C = SjisNec2ibm ( C ) ;   // NEC->IBM
      }


      int cUnicode ;
      int cResult ;


      // 儐乕僓曄姺
      cResult = ConvertByUserDefinition ( C, & cUnicode, pData ) ;
      if ( cResult ) {
         Putc ( cResult, pData->StreamOut ) ;
         continue ;
      }
      if ( cUnicode && pData->dwConversionMode & CONVMODE_TXT_UNICODE_HTML ) {
         Putwc ( cUnicode, pData->StreamOut ) ;
         continue ;
      }


      // 曄姺偺儊僀儞
      cResult = ConvertChineseCharacter ( C, pData->dwConversionMode ) ;
      if ( ! ( pData->dwConversionMode & CONVMODE_CW_TXT_FANTIZI ) ) {
         switch ( pData->nSrcCodePage ) {
            case CP_JAPANESE_CW :   if ( C >= 0xF040 && C <= 0xF4FF ) { cResult = 0 ; } break ;
            case CP_JAPANESE_CWN :  if ( C >= 0xF090 && C <= 0xF4FF ) { cResult = 0 ; } break ;
         }
      }
      if ( cResult ) {
         Putc ( cResult, pData->StreamOut ) ;
         continue ;
      }


      // 奜帤
      if ( ( pData->nSrcCodePage & CP_DEFINE_CODEPAGE ) != CP_JAPANESE && ( pData->nDstCodePage & CP_DEFINE_CODEPAGE ) != CP_JAPANESE ) {
         cResult = UnicodeToGaiji ( GaijiToUnicode ( C, pData->nSrcCodePage & CP_DEFINE_CODEPAGE ), pData->nDstCodePage & CP_DEFINE_CODEPAGE ) ;
         if ( pData->nSrcCodePage == CP_CHINESE_SIMPLIFIED && C >= 0xFE50 && C <= 0xFEA0 ) cResult = 0 ;
         if ( pData->nDstCodePage == CP_CHINESE_SIMPLIFIED && cResult >= 0xFE50 && cResult <= 0xFEA0 ) cResult = 0 ;
      }
      if ( cResult ) {
         Putc ( cResult, pData->StreamOut ) ;
         continue ;
      }


      // 曄姺偱偒側偄傕偺傪 OS 宱桼偱 Unicode 偵捈愙曄姺
      if ( ! ( pData->dwConversionMode & CONVMODE_NO_USE_UNICODE ) ) {
         if ( ( pData->nSrcCodePage & CP_DEFINE_CODEPAGE ) != CP_JAPANESE && ( pData->nDstCodePage & CP_DEFINE_CODEPAGE ) != CP_JAPANESE ) {
            cUnicode = ConvertCharacterEx ( C, pData->nSrcCodePage, pData->nDstCodePage ) ;
            int cTmp = GetNonLinshiDaima ( cUnicode ) ;
            if ( cTmp ) cUnicode = cTmp ;
         }
      }
      if ( cUnicode && pData->dwConversionMode & CONVMODE_TXT_UNICODE_HTML ) {
         Putwc ( cUnicode, pData->StreamOut ) ;
         continue ;
      }


      // 暋悢偺暥帤偱弌椡
      if ( ! ( pData->dwConversionMode & CONVMODE_NO_MULTI_CHAR ) ) {
         char szBuffer [ 0x20 ] ;
         const char *szString = GetMultiCharString ( C, pData->nSrcCodePage, pData->nDstCodePage, szBuffer ) ;
         if ( szString ) {
            StreamWriteString ( szString, pData->StreamOut ) ;
            continue ;
         }
      }


      // 曄姺偱偒側偄暥帤偺弌椡
      PutUnmappableChar ( cSaved, pData ) ;
   }


   CAUGHT_ERROR :

   return pData->nError ;
}



// 暥帤嶲徠傪張棟偡傞
// 暥帤傪曉偡
// 撪晹偱張棟偟偨傜丄EOF 傪曉偡
int DecodeCharRef ( int C, CHNCONVDATA *pData ) {

   char *szBuffer = GetStoredCharsA ( pData->CharRefBuffer ) ;

   // 暥帤傪廂擺
   if ( C == '[' && ! *szBuffer ||
       *szBuffer == '[' && isascii ( C ) && ( isupper ( C ) || isxdigit ( C ) || C == ':' )
   ) {

      // 挿偡偓
      if ( strlen ( szBuffer ) >= 0x10 ) return C ;

      pData->CharRefBuffer = StoreCharsA ( C, pData->CharRefBuffer ) ;
      if ( pData->CharRefBuffer == STOREDCHARS_ERROR ) pData->nError = CONV_ERROR_MEMORY ;

      return EOF ;
   }

   // 悢抣傪夝庍
   if ( C == ']' && *szBuffer == '[' ) {

      szBuffer ++ ;

      // 僐乕僪儁乕僕柤傪擣幆
      for ( int nCount = 0 ; nCount < CODEPAGE_NAME_LIST_NELEM ; nCount ++ ) {

         int nCodePage = CodePageNameList [ nCount ].nCodePage ;
         const char *nCodeName = CodePageNameList [ nCount ].szCodeName ;

         if ( ! strheadcmp ( szBuffer, nCodeName ) && *( szBuffer + strlen ( nCodeName ) ) == ':' ) {
            char *szString ;
            int cResult = strtoul ( szBuffer + strlen ( nCodeName ) + 1, & szString, 0x10 ) ;
            if ( ! *szString ) {

               if ( nCodePage == pData->nDstCodePage ) {
                  ClearStoredCharsA ( pData->CharRefBuffer ) ;
                  Putc ( cResult, pData->StreamOut ) ;
                  return EOF ;
               }

               if ( nCodePage == pData->nSrcCodePage ) {
                  ClearStoredCharsA ( pData->CharRefBuffer ) ;
                  return cResult ;
               }

               if ( ( nCodePage & CP_DEFINE_CODEPAGE ) == CP_JAPANESE ) {
                  if ( cResult != 0xEEF9 ) cResult = SjisNec2ibm ( cResult ) ;   // NEC->IBM
               }

               CONVERTCHARACTER *ConvertChineseCharacter = GetConvertFunction ( nCodePage, pData->nDstCodePage, pData->dwConversionMode & CONVMODE_CW_TXT_FANTIZI ) ;
               if ( ConvertChineseCharacter && ( cResult = ConvertChineseCharacter ( cResult, pData->dwConversionMode ) ) ) {
                  ClearStoredCharsA ( pData->CharRefBuffer ) ;
                  Putc ( cResult, pData->StreamOut ) ;
                  return EOF ;
               }
            }
            break ;
         }
      }
   }

   return C ;
}



// 暥帤嶲徠偺僶僢僼傽傪撉傒栠偟丄師偵張棟偡傋偒暥帤傪曉偡
int UnreadDecodeCharRefBuffer ( int C, CHNCONVDATA *pData ) {

   int cStart = PopStoredCharsA ( pData->CharRefBuffer ) ;

   for ( int cTmp ; ( cTmp = PopStoredCharsA ( pData->CharRefBuffer ) ) != EOF ; ) {
      pData->CharRefUnreadBuffer = StoreCharsW ( cTmp, pData->CharRefUnreadBuffer ) ;
   }

   pData->CharRefUnreadBuffer = StoreCharsW ( C, pData->CharRefUnreadBuffer ) ;

   return cStart ;
}



////////////////////////////////////////////
//     TXT 擖椡儖乕僥傿儞偺壓惪偗娭悢     //
////////////////////////////////////////////



// 晄惓側僶僀僩楍側傜偽 EOF 傪曉偡
int Getc ( int C1, CHNCONVDATA *pData ) {

   STREAM *StreamIn = pData->StreamIn ;
   int nSrcCodePage = pData->nSrcCodePage & CP_DEFINE_CODEPAGE ;

   if ( ismbblead_cp ( C1, nSrcCodePage ) ) {

      int C2 ;
      if ( ( C2 = StreamRead ( StreamIn ) ) == EOF ) return EOF ;

      return ( C1 << 8 ) | C2 ;
   }

   return C1 ;
}



// 晄惓側僶僀僩楍側傜偽 EOF 傪曉偡
// 僄僗働乕僾偵傛傞儌乕僪曄峏偺傒側傜偽 GETC_ONLY_ESCAPE 傪曉偡
int GetcHz ( int C1, CHNCONVDATA *pData ) {

   STREAM *StreamIn = pData->StreamIn ;

   // HZ 偺張棟
   if ( pData->nEncodeMode == EM_ASCII ) {
      if ( C1 == '~' ) {
         int C2 ;
         if ( ( C2 = StreamRead ( StreamIn ) ) == EOF ) return EOF ;
         if ( C2 == 0x7B ) {
            pData->nEncodeMode = EM_LOCAL ;
            return GETC_ONLY_ESCAPE ;
         }
         if ( C2 == '\n' ) {
            return GETC_ONLY_ESCAPE ;
         }
         if ( C2 != '~' ) StreamUnread ( C2, StreamIn ) ;
      }
   }
   else {
      int C2 ;
      if ( ( C2 = StreamRead ( StreamIn ) ) == EOF ) return EOF ;
      if ( C1 == '~' && C2 == 0x7D ) {
         pData->nEncodeMode = EM_ASCII ;
         return GETC_ONLY_ESCAPE ;
      }
      if ( C1 >= 0x21 && C1 <= 0x7D && C2 >= 0x21 && C2 <= 0x7E ) {
         return ( ( C1 << 8 ) | C2 ) | 0x8080 ;
      }
      // caught illegal
      if ( C1 == 0x20 || C2 == 0x20 ) C1 = 0x20 ;
      else                            StreamUnread ( C2, StreamIn ) ;
   }

   if ( ismbblead_gb ( C1 ) ) {
      int C2 ;
      if ( ( C2 = StreamRead ( StreamIn ) ) == EOF ) return EOF ;
      return ( C1 << 8 ) | C2 ;
   }

   return C1 ;
}



int Putc ( int C, STREAM *StreamOut ) {
   if ( C >= 0x100 ) StreamWrite ( ( C >> 8 ) & 0xFF, StreamOut ) ;
   StreamWrite ( C & 0xFF, StreamOut ) ;
   return 0 ;
}



int Putwc ( int cUnicode, STREAM *StreamOut ) {
   StreamWriteFormat ( StreamOut, "&#x%04X;", cUnicode ) ;
   return 0 ;
}



int PutUnmappableChar ( int C, CHNCONVDATA *pData ) {

   if ( pData->dwConversionMode & CONVMODE_OUTPUT_CODE_NUMBER ) {
      StreamWriteFormat ( pData->StreamOut, "[%s:%04X]", GetCodeName ( pData->nSrcCodePage ), C ) ;
   }
   else {
      if ( C >= 0x100 && ! ( pData->dwConversionMode & CONVMODE_ONE_QUESTION_MARK ) ) Putc ( '?', pData->StreamOut ) ;
      Putc ( '?', pData->StreamOut ) ;
   }

   return 0 ;
}



////////////////////////////////////////////
//           RTF 曄姺儖乕僥傿儞           //
////////////////////////////////////////////



#define FIELD_DETECT 0


int InitRtfFontName ( const char **pDstFont, const char **pDstGothicFont, CHNCONVDATA *pData ) ;
int WriteFontName ( int nFontNumber, const char *szFontName, int nCodePage, int IsGothic, STREAM *StreamOut ) ;
int WriteLangInfo ( int nLang, int nLangFe, int nLangFeNp, STREAM *StreamOut ) ;
int WriteAltFontName ( const char *szFontName, int nCodePage, STREAM *StreamOut ) ;
char *EncodeHexaDecimal ( const char *szSrc, char *szDst, int nCodePage ) ;
const char *GetFirstKeyword ( const char *szString ) ;
const char *GetLastKeyword ( const char *szString ) ;
const char *GetEnglishFontName ( int nCharset, const char *szLocalizedName, int *pCharset ) ;
const char *GetLocalizedFontName ( int nCharset, const char *szEnglishName, int *pCharset ) ;
int FontNameToPseudoCodePage ( int nCodePage, const char *szFontName ) ;
int IsAsciiString ( const char *szString ) ;
int ConvertFtzToJtz ( int cUnicode, unsigned long dwConversionMode ) ;
int ConvertJtzToFtz ( int cUnicode, unsigned long dwConversionMode ) ;

int GetNewFontNumber ( CHNCONVDATA *pData, int nCodePage, int nDstFont, int nDstGothicFont, int nKgFont, int nKgGothicFont, int nCwnfFont, int nCwnfGothicFont, int *pIsToBeBold ) ;



// 儕僢僠僥僉僗僩偺奺怺搙偺忣曬
typedef struct {
   int nFont ;          // 僼僅儞僩斣崋
   int nAltFont ;       // 戙懼僼僅儞僩斣崋
   int nCharset ;       // 暥帤僙僢僩
   int nLang ;          // 尵岅偺巜掕
   int nLangFe ;        // 尵岅偺巜掕(fareast)
   int nLangFeNp ;      // 尵岅偺巜掕(no-proofing)
   int nIncreaseDepth ; // 僼僅儞僩傪曄偊傞偨傔偵怺搙傪堦偮怺偔偟偨偐
   unsigned long dwAttributes ;  // 懏惈
   int nDefaultCodePage ;
} DEPTH_INFO ;


// for dwAttributes
#define RTF_FONT_TABLE         1