Category

Development Platform
Home > SourceCode/Document > Windows Develop > Windows Kernel > View Code
utf7obj.cpp
Package: shell.rar　[view]
Upload User: xhy777
Upload Date: 2007-02-14
Package Size: 24088k
Code Size: 13k
Category:

Windows Kernel

Development Platform:

Visual C++

utf7obj.cpp：Code Content
  1. // ============================================================================
  2. // Internet Character Set Conversion: Input from UTF-7
  3. // ============================================================================
  5. #include "private.h"
  6. #include "fechrcnv.h"
  7. #include "utf7obj.h"
  9. //+-----------------------------------------------------------------------
  10. //
  11. //  Function:   IsBase64
  12. //
  13. //  Synopsis:   We use the following table to quickly determine if we have
  14. //              a valid base64 character.
  15. //
  16. //------------------------------------------------------------------------
  18. static UCHAR g_aBase64[256] =
  19. {
  20.   /*            0,   1,   2,   3,   4,   5,   6,   7,   8,   9,   A,   B,   C,   D,   E,   F, */
  22.   /* 00-0f */ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
  23.   /* 10-1f */ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
  24.   /* 20-2f */ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,  62, 255, 255, 255,  63,
  25.   /* 30-3f */  52,  53,  54,  55,  56,  57,  58,  59,  60,  61, 255, 255, 255, 255, 255, 255,
  26.   /* 40-4f */ 255,   0,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,  13,  14,
  27.   /* 50-5f */  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25, 255, 255, 255, 255, 255,
  28.   /* 60-6f */ 255,  26,  27,  28,  29,  30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  40,
  29.   /* 70-7f */  41,  42,  43,  44,  45,  46,  47,  48,  49,  50,  51, 255, 255, 255, 255, 255,
  30.   /* 80-8f */  255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
  31.   /* 90-9f */ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
  32.   /* a0-af */ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
  33.   /* b0-bf */ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
  34.   /* c0-cf */ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
  35.   /* d0-df */ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
  36.   /* e0-ef */ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
  37.   /* f0-ff */ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
  38. };
  41. // Direct encoded ASCII table
  42. static UCHAR g_aDirectChar[128] =
  43. {
  44.   /*            0,   1,   2,   3,   4,   5,   6,   7,   8,   9,   A,   B,   C,   D,   E,   F, */
  46.   /* 00-0f */ 255, 255, 255, 255, 255, 255, 255, 255, 255,  72,  73, 255, 255,  74, 255, 255,
  47.   /* 10-1f */ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
  48.   /* 20-2f */  71, 255, 255, 255, 255, 255, 255,  62,  63,  64, 255, 255,  65,  66,  67,  68,
  49.   /* 30-3f */  52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  69, 255, 255, 255, 255,  70,
  50.   /* 40-4f */ 255,   0,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,  13,  14,
  51.   /* 50-5f */  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25, 255, 255, 255, 255, 255,
  52.   /* 60-6f */ 255,  26,  27,  28,  29,  30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  40,
  53.   /* 70-7f */  41,  42,  43,  44,  45,  46,  47,  48,  49,  50,  51, 255, 255, 255, 255, 255,
  54. };
  56. // Base64 byte value table
  57. static UCHAR g_aInvBase64[] = { "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=" };
  59. static inline BOOL
  60. IsBase64(UCHAR t )
  61. {
  62.     return g_aBase64[t] < 64;
  63. }
  65. /******************************************************************************
  66. **************************   C O N S T R U C T O R   **************************
  67. ******************************************************************************/
  69. CInccUTF7In::CInccUTF7In(UINT uCodePage, int nCodeSet) : CINetCodeConverter(uCodePage, nCodeSet)
  70. {
  71.     Reset();    // initialization
  72.     return ;
  73. }
  75. /******************************************************************************
  76. *******************************   R E S E T   *********************************
  77. ******************************************************************************/
  79. void CInccUTF7In::Reset()
  80. {
  81.     m_pfnConv = ConvMain;
  82.     m_pfnCleanUp = CleanUpMain;
  83.     m_fUTF7Mode = FALSE ;
  84.     m_nBitCount = 0 ;
  85.     m_tcUnicode = 0 ;
  86.     m_nOutCount = 0 ;
  87.     return ;
  88. }
  91. /******************************************************************************
  92. *************************   C O N V E R T   C H A R   *************************
  93. ******************************************************************************/
  95. HRESULT CInccUTF7In::ConvertChar(UCHAR tc, int cchSrc)
  96. {
  97. BOOL fDone = (this->*m_pfnConv)(tc);
  98.     if (fDone)
  99.         return S_OK;
  100.     else
  101.         return E_FAIL;
  102. }
  104. /******************************************************************************
  105. *****************************   C L E A N   U P   *****************************
  106. ******************************************************************************/
  108. BOOL CInccUTF7In::CleanUp()
  109. {
  110.     return (this->*m_pfnCleanUp)();
  111. }
  113. /******************************************************************************
  114. ****************************   C O N V   M A I N   ****************************
  115. ******************************************************************************/
  117. BOOL CInccUTF7In::ConvMain(UCHAR tc)
  118. {
  119.     BOOL fDone = TRUE;
  121.     // are we in UTF-7 mode ?
  122.     if (m_fUTF7Mode )
  123.     {
  124.         if ( IsBase64(tc) )
  125.         {
  126.             UCHAR t64, outc ;
  127.             LONG tcUnicode ;
  129.             // save the Base64 value and update bit count
  130.             t64 = g_aBase64[tc] ;
  131.             m_tcUnicode = m_tcUnicode << 6 | t64 ;
  132.             m_nBitCount += 6 ;
  134.             // see if we accumulate enough bits
  135.             if ( m_nBitCount >= 16 )
  136.             {
  137.                 // get higher 16 bits data from buffer
  138.                 tcUnicode = m_tcUnicode >> ( m_nBitCount - 16 ) ;
  139.                 // output one Unicode char
  140.                 outc = (UCHAR) tcUnicode ;
  141.                 Output( outc );
  142.                 outc = (UCHAR) ( tcUnicode >> 8 ) ;
  143.                 fDone = Output( outc );
  145.                 // update output char count
  146.                 m_nOutCount ++ ;
  147.                 m_nBitCount -= 16 ;
  148.             }
  149.         }
  150.         // not a Base64 char, reset UTF-7 mode
  151.         else
  152.         {
  153.             // special case +- decodes to +
  154.             if ( tc == '-' && m_nOutCount == 0 && m_nBitCount == 0 )
  155.             {
  156.                 Output('+');
  157.                 fDone=Output(0);
  158.             }
  159.             // absorb shiht-out char '-', otherwise output char
  160.             else if ( tc != '-')
  161.             {
  162.                 Output(tc);
  163.                 fDone=Output(0);
  164.             }
  165.             // reset variables and UTF7Mode
  166.             m_fUTF7Mode = FALSE ;
  167.             m_nBitCount = 0 ;
  168.             m_tcUnicode = 0 ;
  169.             m_nOutCount = 0 ;
  170.         }
  171.     }
  172.     // is it a UTF-7 shift-in char ?
  173.     else if ( tc == '+' )
  174.     {
  175.         m_fUTF7Mode = TRUE ;
  176.         m_nBitCount = 0 ;
  177.         m_tcUnicode = 0 ;
  178.         m_nOutCount = 0 ;
  179.     }
  180.     else
  181.     // convert ASCII directly to Unicode if it is not in UFT-7 mode
  182.     {
  183.         Output(tc);
  184.         fDone = Output(0);
  185.     }
  187.     return fDone;
  188. }
  190. /******************************************************************************
  191. ************************   C L E A N   U P   M A I N   ************************
  192. ******************************************************************************/
  194. BOOL CInccUTF7In::CleanUpMain()
  195. {
  196.     return TRUE;
  197. }
  199. int CInccUTF7In::GetUnconvertBytes()
  200. {
  201.     return  0 ;
  202. }
  204. DWORD CInccUTF7In::GetConvertMode()
  205. {
  206.     DWORD dwMode ;
  208.     if ( m_fUTF7Mode )
  209.     {
  210.         dwMode = ( m_tcUnicode & 0xffff ) | ( m_nBitCount << 16 ) ;
  211.         if ( dwMode == 0 )
  212.             dwMode = 1L ; // it is ok, since bitcount is 0
  213.     }
  214.     else
  215.         dwMode = 0 ;
  217.     return dwMode;
  218. }
  220. void CInccUTF7In::SetConvertMode(DWORD mode)
  221. {
  222.     Reset();    // initialization
  223.     if (mode)
  224.     {
  225.         m_fUTF7Mode = TRUE ;
  226.         m_tcUnicode = ( mode & 0x7fff );
  227.         m_nBitCount = ( mode >> 16 ) & 0xffff ;
  228.     }
  229.     else
  230.         m_fUTF7Mode = FALSE ;
  231. }
  233. // ============================================================================
  234. // Internet Character Set Conversion: Output to UTF-7
  235. // ============================================================================
  237. /******************************************************************************
  238. **************************   C O N S T R U C T O R   **************************
  239. ******************************************************************************/
  241. CInccUTF7Out::CInccUTF7Out(UINT uCodePage, int nCodeSet) : CINetCodeConverter(uCodePage, nCodeSet)
  243. {
  244.     Reset();    // initialization
  245.     return ;
  246. }
  248. /******************************************************************************
  249. *******************************   R E S E T   *********************************
  250. ******************************************************************************/
  252. void CInccUTF7Out::Reset()
  253. {
  254.     m_fDoubleByte = FALSE;
  255.     m_fUTF7Mode = FALSE ;
  256.     m_nBitCount = 0 ;
  257.     m_tcUnicode = 0 ;
  258.     return;
  259. }
  261. HRESULT CInccUTF7Out::ConvertChar(UCHAR tc, int cchSrc)
  262. {
  263.     BOOL fDone = TRUE;
  264.     WORD uc ;
  266.     // 2nd byte of Unicode
  267.     if (m_fDoubleByte )
  268.     {
  269.         BOOL bNeedShift ;
  271.         // compose the 16 bits char
  272.         uc = ( (WORD) tc << 8 | m_tcFirstByte  ) ;
  274.         // check whether the char can be direct encoded ?
  275.         bNeedShift = uc > 0x7f ? TRUE : g_aDirectChar[(UCHAR)uc] == 255 ;
  277.         if ( bNeedShift && m_fUTF7Mode == FALSE)
  278.         {
  279.             // output Shift-in char to change to UTF-7 Mode
  280.             fDone = Output('+');
  282.             // handle special case '+-'
  283.             if ( uc == '+' ) // single byte "+"
  284.             {
  285.                 fDone=Output('-');
  286.             }
  287.             else
  288.                 m_fUTF7Mode = TRUE ;
  289.         }
  291.         if (m_fUTF7Mode)
  292.         {
  293.             LONG tcUnicode ;
  294.             UCHAR t64 ;
  295.             int pad_bits ;
  297.             // either write the char to the bit buffer 
  298.             // or pad bit buffer out to a full base64 char
  299.             if (bNeedShift)
  300.             {
  301.                 m_tcUnicode = m_tcUnicode << 16 | uc ;
  302.                 m_nBitCount += 16 ;
  303.             }
  304.             // pad bit buffer out to a full base64 char
  305.             else if (m_nBitCount % 6 )  
  306.             {
  307.                 pad_bits = 6 - (m_nBitCount % 6 ) ;
  308.                 // get to next 6 multiple, pad these bits with 0
  309.                 m_tcUnicode = m_tcUnicode << pad_bits ;
  310.                 m_nBitCount += pad_bits ;
  311.             }
  313.             // flush out as many full base64 char as possible
  314.             while ( m_nBitCount >= 6 && fDone )
  315.             {
  316.                 tcUnicode = ( m_tcUnicode >> ( m_nBitCount - 6 ) );
  317.                 t64 = (UCHAR) ( tcUnicode & 0x3f ) ;
  318.                 fDone = Output(g_aInvBase64[t64]);
  319.                 m_nBitCount -= 6 ;
  320.             }
  322.             if (!bNeedShift)
  323.             {
  324.                 // output Shift-out char
  325.                 fDone = Output('-');
  327.                 m_fUTF7Mode = FALSE ;
  328.                 m_nBitCount = 0 ;
  329.                 m_tcUnicode = 0 ;
  330.             }
  331.         }
  333.         // the character can be directly encoded as ASCII
  334.         if (!bNeedShift)
  335.         {
  336.             fDone = Output(m_tcFirstByte);
  337.         }
  339.         m_fDoubleByte = FALSE ;
  340.     }
  341.     // 1st byte of Unicode
  342.     else
  343.     {
  344.         m_tcFirstByte = tc ;
  345.         m_fDoubleByte = TRUE ;
  346.     }
  347.     
  348.     if (fDone)
  349.         return S_OK;
  350.     else
  351.         return E_FAIL;
  352. }
  354. /******************************************************************************
  355. *****************************   C L E A N   U P   *****************************
  356. ******************************************************************************/
  358. BOOL CInccUTF7Out::CleanUp()
  359. {
  360.     BOOL fDone = TRUE;
  362.     if (m_fUTF7Mode)
  363.     {
  364.         UCHAR t64 ;
  365.         LONG tcUnicode ;
  366.         int pad_bits ;
  368.         // pad bit buffer out to a full base64 char
  369.         if (m_nBitCount % 6 )  
  370.         {
  371.             pad_bits = 6 - (m_nBitCount % 6 ) ;
  372.             // get to next 6 multiple, pad these bits with 0
  373.             m_tcUnicode = m_tcUnicode << pad_bits ;
  374.             m_nBitCount += pad_bits ;
  375.         }
  377.         // flush out as many full base64 char as possible
  378.         while ( m_nBitCount >= 6 && fDone )
  379.         {
  380.             tcUnicode = ( m_tcUnicode >> ( m_nBitCount - 6 ) );
  381.             t64 = (UCHAR) ( tcUnicode & 0x3f ) ;
  382.             fDone = Output(g_aInvBase64[t64]);
  383.             m_nBitCount -= 6 ;
  384.         }
  386.         {
  387.             // output Shift-out char
  388.             fDone = Output('-');
  390.             m_fUTF7Mode = FALSE ;
  391.             m_nBitCount = 0 ;
  392.             m_tcUnicode = 0 ;
  393.         }
  394.     }
  395.     return fDone;
  396. }
  398. int CInccUTF7Out::GetUnconvertBytes()
  399. {
  400.     return  m_fDoubleByte ? 1 : 0 ;
  401. }
  403. DWORD CInccUTF7Out::GetConvertMode()
  404. {
  405.     return 0 ;
  406. }
  408. void CInccUTF7Out::SetConvertMode(DWORD mode)
  409. {
  410.     Reset();    // initialization
  411.     return ;
  412. }