开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 生物技术 > 查看源码
unicode.cpp
资源名称：ncbi_cxx_win--Jul_08_2004.zip　[点击查看]
上传用户：yhdzpy8989
上传日期：2007-06-13
资源大小：13604k
文件大小：11k
源码类别：

生物技术

开发平台：

C/C++

unicode.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: unicode.cpp,v $
  4.  * PRODUCTION Revision 1000.0  2004/06/01 19:43:29  gouriano
  5.  * PRODUCTION PRODUCTION: IMPORTED [GCC34_MSVC7] Dev-tree R1.3
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: unicode.cpp,v 1000.0 2004/06/01 19:43:29 gouriano Exp $
  11.  * ==========================================================================
  12.  *
  13.  *                            PUBLIC DOMAIN NOTICE
  14.  *               National Center for Biotechnology Information
  15.  *
  16.  *  This software/database is a "United States Government Work" under the
  17.  *  terms of the United States Copyright Act.  It was written as part of
  18.  *  the author's official duties as a United States Government employee and
  19.  *  thus cannot be copyrighted.  This software/database is freely available
  20.  *  to the public for use. The National Library of Medicine and the U.S.
  21.  *  Government have not placed any restriction on its use or reproduction.
  22.  *
  23.  *  Although all reasonable efforts have been taken to ensure the accuracy
  24.  *  and reliability of the software and data, the NLM and the U.S.
  25.  *  Government do not and cannot warrant the performance or results that
  26.  *  may be obtained by using this software or data. The NLM and the U.S.
  27.  *  Government disclaim all warranties, express or implied, including
  28.  *  warranties of performance, merchantability or fitness for any particular
  29.  *  purpose.
  30.  *
  31.  *  Please cite the author in any work or product based on this material.
  32.  *
  33.  * ==========================================================================
  34.  *
  35.  * Author: Aleksey Vinokurov
  36.  *
  37.  * File Description:
  38.  *    Unicode transformation library
  39.  *
  40.  */
  42. #include <ncbi_pch.hpp>
  43. #include <util/unicode.hpp>
  45. BEGIN_NCBI_SCOPE
  46. BEGIN_SCOPE(utf8)
  48. #include "unicode_plans/plan00.inc"
  49. #include "unicode_plans/plan01.inc"
  50. #include "unicode_plans/plan02.inc"
  51. #include "unicode_plans/plan03.inc"
  52. #include "unicode_plans/plan04.inc"
  53. #include "unicode_plans/plan1e.inc"
  54. #include "unicode_plans/plan20.inc"
  55. #include "unicode_plans/plan21.inc"
  56. #include "unicode_plans/plan22.inc"
  57. #include "unicode_plans/plan23.inc"
  58. #include "unicode_plans/plan24.inc"
  59. #include "unicode_plans/plan25.inc"
  60. #include "unicode_plans/plan26.inc"
  61. #include "unicode_plans/plan27.inc"
  62. #include "unicode_plans/plan30.inc"
  63. #include "unicode_plans/plane0.inc"
  64. #include "unicode_plans/plane2.inc"
  65. #include "unicode_plans/plane3.inc"
  66. #include "unicode_plans/plane4.inc"
  67. #include "unicode_plans/plane5.inc"
  68. #include "unicode_plans/plane6.inc"
  69. #include "unicode_plans/plane7.inc"
  70. #include "unicode_plans/plane8.inc"
  71. #include "unicode_plans/planea.inc"
  72. #include "unicode_plans/planeb.inc"
  73. #include "unicode_plans/planfb.inc"
  74. #include "unicode_plans/planfe.inc"
  77. static TUnicodeTable g_DefaultUnicodeTable =
  78. {
  79.     &s_Plan_00h, &s_Plan_01h, &s_Plan_02h, &s_Plan_03h, &s_Plan_04h, 0, 0, 0,  // Plan 00 - 07
  80.     0, 0, 0, 0, 0, 0, 0, 0,  // Plan 08 - 0F
  82.     0, 0, 0, 0, 0, 0, 0, 0,  // Plan 10 - 17
  83.     0, 0, 0, 0, 0, 0, &s_Plan_1Eh, 0,  // Plan 18 - 1F
  85.     &s_Plan_20h, &s_Plan_21h, &s_Plan_22h, &s_Plan_23h, &s_Plan_24h, &s_Plan_25h, &s_Plan_26h, &s_Plan_27h,  // Plan 20 - 27
  86.     0, 0, 0, 0, 0, 0, 0, 0,  // Plan 28 - 2F
  88.     &s_Plan_30h, 0, 0, 0, 0, 0, 0, 0,  // Plan 30 - 37
  89.     0, 0, 0, 0, 0, 0, 0, 0,  // Plan 38 - 3F
  91.     0, 0, 0, 0, 0, 0, 0, 0,  // Plan 40 - 47
  92.     0, 0, 0, 0, 0, 0, 0, 0,  // Plan 48 - 4F
  94.     0, 0, 0, 0, 0, 0, 0, 0,  // Plan 50 - 57
  95.     0, 0, 0, 0, 0, 0, 0, 0,  // Plan 58 - 5F
  97.     0, 0, 0, 0, 0, 0, 0, 0,  // Plan 60 - 67
  98.     0, 0, 0, 0, 0, 0, 0, 0,  // Plan 68 - 6F
  100.     0, 0, 0, 0, 0, 0, 0, 0,  // Plan 70 - 77
  101.     0, 0, 0, 0, 0, 0, 0, 0,  // Plan 78 - 7F
  103.     0, 0, 0, 0, 0, 0, 0, 0,  // Plan 80 - 87
  104.     0, 0, 0, 0, 0, 0, 0, 0,  // Plan 88 - 8F
  106.     0, 0, 0, 0, 0, 0, 0, 0,  // Plan 90 - 97
  107.     0, 0, 0, 0, 0, 0, 0, 0,  // Plan 98 - 9F
  109.     0, 0, 0, 0, 0, 0, 0, 0,  // Plan A0 - A7
  110.     0, 0, 0, 0, 0, 0, 0, 0,  // Plan A8 - AF
  112.     0, 0, 0, 0, 0, 0, 0, 0,  // Plan B0 - B7
  113.     0, 0, 0, 0, 0, 0, 0, 0,  // Plan B8 - BF
  115.     0, 0, 0, 0, 0, 0, 0, 0,  // Plan C0 - C7
  116.     0, 0, 0, 0, 0, 0, 0, 0,  // Plan C8 - CF
  118.     0, 0, 0, 0, 0, 0, 0, 0,  // Plan D0 - D7
  119.     0, 0, 0, 0, 0, 0, 0, 0,  // Plan D8 - DF
  121.     &s_Plan_E0h, 0, &s_Plan_E2h, &s_Plan_E3h, &s_Plan_E4h, &s_Plan_E5h, &s_Plan_E6h, &s_Plan_E7h,  // Plan E0 - E7
  122.     &s_Plan_E8h, 0, &s_Plan_EAh, &s_Plan_EBh, 0, 0, 0, 0,  // Plan E8 - EF
  124.     0, 0, 0, 0, 0, 0, 0, 0,  // Plan F0 - F7
  125.     0, 0, 0, &s_Plan_FBh, 0, 0, &s_Plan_FEh, 0   // Plan F8 - FF
  126. };
  129. const SUnicodeTranslation*
  130. UnicodeToAscii(TUnicode character, const TUnicodeTable* table)
  131. {
  132.     if (!table) {
  133.         table = &g_DefaultUnicodeTable;
  134.     }
  135.     unsigned int thePlanNo   = (character & 0xFF00) >> 8;
  136.     unsigned int theOffset = character & 0xFF;
  137.     const TUnicodePlan* thePlan = (*table)[thePlanNo];
  138.     if ( !thePlan ) return 0;
  139.     return &((*thePlan)[theOffset]);
  140. }
  143. TUnicode UTF8ToUnicode( const char* theUTF )
  144. {
  145.     int seq_len;
  146.     const char *p = theUTF;
  147.     char counter = *p++;
  148.     unsigned char c;
  150.     if ( ((*theUTF) & 0xC0) != 0xC0 )
  151.     {
  152.         TUnicode RC = 0;
  153.         RC |= (unsigned char)theUTF[0];
  154.         return RC;
  155.     }
  157.     TUnicode acc = counter & 037;
  159.     while((counter <<= 1) < 0) {
  160.         c = *p++;
  161.         if((c & ~077) != 0200) { // Broken UTF-8 chain
  162.             seq_len = p - theUTF;
  163.             return ~0;
  164.         }
  165.         acc = (acc << 6) | (c & 077);
  166.     }
  167.     return acc;
  168. }
  171. int UTF8ToUnicode( const char* theUTF, TUnicode* theUnicode )
  172. {
  173.     int seq_len;
  174.     const char *p = theUTF;
  175.     char counter = *p++;
  176.     unsigned char c;
  178.     if ( (unsigned char )theUTF[0] < 0x80 ) {
  179.         // This is one character UTF8. I.e. regular character.
  180.         *theUnicode = *theUTF;
  181.         return 1;
  182.     }
  184.     if ( ((*theUTF) & 0xC0) != 0xC0 ) {
  185.         // This is not a unicode
  186.         return 0;
  187.     }
  189.     TUnicode acc = counter & 037;
  191.     while((counter <<= 1) < 0) {
  192.         c = *p++;
  193.         if((c & ~077) != 0200) { // Broken UTF-8 chain
  194.             seq_len = p - theUTF;
  195.             return ~0;
  196.         }
  197.         acc = (acc << 6) | (c & 077);
  198.     } // while
  199.     seq_len = p - theUTF;
  200.     *theUnicode = acc;
  201.     return seq_len;
  202. }
  205. string UnicodeToUTF8( TUnicode theUnicode )
  206. {
  207.     char theBuffer[10];
  208.     int theLength = UnicodeToUTF8( theUnicode, theBuffer, 10 );
  209.     return string( theBuffer, theLength );
  210. }
  213. int UnicodeToUTF8( TUnicode theUnicode, char *theBuffer, int theBufLength )
  214. {
  215.     int Length = 0;
  217.     if (theUnicode < 0x80) {
  218.         Length = 1;
  219.         if ( Length > theBufLength ) return 0;
  220.         theBuffer[0] = char(theUnicode);
  221.     }
  222.     else if (theUnicode < 0x800) {
  223.         Length = 2;
  224.         if ( Length > theBufLength ) return 0;
  225.         theBuffer[0] = char(0xC0 | theUnicode>>6);
  226.         theBuffer[1] = char(0x80 | theUnicode & 0x3F);
  227.     }
  228.     else if (theUnicode < 0x10000) {
  229.         Length = 3;
  230.         if ( Length > theBufLength ) return 0;
  231.         theBuffer[0] = char(0xE0 | theUnicode>>12);
  232.         theBuffer[1] = char(0x80 | theUnicode>>6 & 0x3F);
  233.         theBuffer[2] = char(0x80 | theUnicode & 0x3F);
  234.     }
  235.     else if (theUnicode < 0x200000) {
  236.         Length = 4;
  237.         if ( Length > theBufLength ) return 0;
  238.         theBuffer[0] = char(0xF0 | theUnicode>>18);
  239.         theBuffer[1] = char(0x80 | theUnicode>>12 & 0x3F);
  240.         theBuffer[2] = char(0x80 | theUnicode>>6 & 0x3F);
  241.         theBuffer[3] = char(0x80 | theUnicode & 0x3F);
  242.     }
  243.     return Length;
  244. }
  247. int UTF8ToAscii( const char* src, char* dst,
  248.                  int dstLen, const TUnicodeTable* table)
  249. {
  250.     if ( !src || !dst || dstLen == 0 ) return 0;
  251.     long srcPos = 0;
  252.     long dstPos = 0;
  253.     long srcLen = strlen( src );
  255.     for ( srcPos = 0; srcPos < srcLen; )
  256.     {
  257.         // Assign quck pointers
  258.         char* pDst = &(dst[dstPos]);
  259.         const char* pSrc = &(src[srcPos]);
  260.         TUnicode theUnicode;
  262.         int utfLen = UTF8ToUnicode( pSrc, &theUnicode );
  264.         if ( (utfLen == 0) || (utfLen == -1) ) {
  265.             // Skip the error.
  266.             srcPos++;
  267.             continue;
  268.         }
  270.         srcPos += utfLen;
  272.         // Find the correct substitution.
  273.         const SUnicodeTranslation*
  274.             pSubst = UnicodeToAscii( theUnicode, table );
  276.         // Check if the unicode has a translation
  277.         if ( !pSubst ) {
  278.             continue;
  279.         }
  281.         // Check if type is eSkip or substituting string is empty.
  282.         if ( (pSubst->Type ==  eSkip) ||
  283.              !(pSubst->Subst) ) {
  284.             continue;
  285.         }
  288.         // Check if type is eAsIs
  289.         if (pSubst->Type ==  eAsIs) {
  290.             memcpy( pDst, pSrc, utfLen );
  291.             dstPos += utfLen;
  292.             continue;
  293.         }
  295.         // Check the remaining length and put the result in there.
  296.         int substLen = strlen( pSubst->Subst );
  297.         if ( (dstPos + substLen) > dstLen ) {
  298.             return -1; // Unsufficient space;
  299.         }
  301.         // Copy the substituting value into the destignation string
  302.         memcpy( pDst, pSubst->Subst, substLen );
  303.         dstPos += substLen;
  304.     }
  305.     return dstPos;
  306. }
  309. string UTF8ToAsciiString( const char* src, const TUnicodeTable* table)
  310. {
  311.     if ( !src ) return 0;
  313.     string dst;
  314.     long srcPos = 0;
  315.     long srcLen = strlen( src );
  317.     for ( srcPos = 0; srcPos < srcLen; )
  318.     {
  319.         // Assign quck pointers
  320.         const char* pSrc = &(src[srcPos]);
  321.         TUnicode theUnicode;
  323.         int utfLen = UTF8ToUnicode( pSrc, &theUnicode );
  325.         if ( (utfLen == 0) || (utfLen == -1) ) {
  326.             // Skip the error.
  327.             srcPos++;
  328.             continue;
  329.         }
  331.         srcPos += utfLen;
  333.         // Find the correct substitution.
  334.         const SUnicodeTranslation*
  335.             pSubst = UnicodeToAscii( theUnicode, table );
  337.         // Check if the unicode has a translation
  338.         if ( !pSubst ) {
  339.             srcPos += utfLen;
  340.             continue;
  341.         }
  343.         // Check if type is eSkip or substituting string is empty.
  344.         if ( (pSubst->Type ==  eSkip) ||
  345.              !(pSubst->Subst) ) {
  346.             srcPos += utfLen;
  347.             continue;
  348.         }
  351.         // Check if type is eAsIs
  352.         if (pSubst->Type ==  eAsIs) {
  353.             dst += string( pSrc, utfLen );
  354.             srcPos += utfLen;
  355.             continue;
  356.         }
  358.         // Copy the substituting value into the destignation string
  359.         dst += pSubst->Subst;
  360.     }
  361.     return dst;
  362. }
  365. END_SCOPE(utf8)
  366. END_NCBI_SCOPE
  368. /*
  369.  * ==========================================================================
  370.  * $Log: unicode.cpp,v $
  371.  * Revision 1000.0  2004/06/01 19:43:29  gouriano
  372.  * PRODUCTION: IMPORTED [GCC34_MSVC7] Dev-tree R1.3
  373.  *
  374.  * Revision 1.3  2004/05/17 21:06:02  gorelenk
  375.  * Added include of PCH ncbi_pch.hpp
  376.  *
  377.  * Revision 1.2  2004/05/13 21:18:12  ucko
  378.  * Respect constness in UnicodeToAscii.
  379.  *
  380.  * Revision 1.1  2004/05/06 18:15:29  gouriano
  381.  * Imported from pubmed/xmldb
  382.  *
  383.  * ==========================================================================
  384.  */