Category

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

Windows Kernel

Development Platform:

Visual C++

eucjobj.cpp：Code Content
  1. // ============================================================================
  2. // Internet Character Set Conversion: Input from EUC-JP
  3. // ============================================================================
  5. #include "private.h"
  6. #include "fechrcnv.h"
  7. #include "eucjobj.h"
  8. #include "codepage.h"
  10. /******************************************************************************
  11. **************************   C O N S T R U C T O R   **************************
  12. ******************************************************************************/
  14. CInccEucJIn::CInccEucJIn(UINT uCodePage, int nCodeSet) : CINetCodeConverter(uCodePage, nCodeSet)
  15. {
  16.     Reset();    // initialization
  17.     return ;
  18. }
  20. /******************************************************************************
  21. *******************************   R E S E T   *********************************
  22. ******************************************************************************/
  24. void CInccEucJIn::Reset()
  25. {
  26. m_pfnConv = ConvMain;
  27. m_pfnCleanUp = CleanUpMain;
  28. m_tcLeadByte = 0 ;
  29.     return ;
  30. }
  32. /******************************************************************************
  33. *************************   C O N V E R T   C H A R   *************************
  34. ******************************************************************************/
  36. HRESULT CInccEucJIn::ConvertChar(UCHAR tc, int cchSrc)
  37. {
  38. BOOL fDone = (this->*m_pfnConv)(tc);
  39.     if (fDone)
  40.         return S_OK;
  41.     else
  42.         return E_FAIL;
  43. }
  45. /******************************************************************************
  46. *****************************   C L E A N   U P   *****************************
  47. ******************************************************************************/
  49. BOOL CInccEucJIn::CleanUp()
  50. {
  51. return (this->*m_pfnCleanUp)();
  52. }
  54. /******************************************************************************
  55. ****************************   C O N V   M A I N   ****************************
  56. ******************************************************************************/
  58. BOOL CInccEucJIn::ConvMain(UCHAR tc)
  59. {
  60. BOOL fDone = TRUE;
  64. if (tc >= 0xa1 && tc <= 0xfe) {
  65. m_pfnConv = ConvDoubleByte;
  66. m_pfnCleanUp = CleanUpDoubleByte;
  67. m_tcLeadByte = tc;
  68. } else if (tc == 0x8e) { // Single Byte Katakana
  69. m_pfnConv = ConvKatakana;
  70. m_pfnCleanUp = CleanUpKatakana;
  71. } else {
  72. fDone = Output(tc);
  73. }
  74. return fDone;
  75. }
  77. /******************************************************************************
  78. ************************   C L E A N   U P   M A I N   ************************
  79. ******************************************************************************/
  81. BOOL CInccEucJIn::CleanUpMain()
  82. {
  83. return TRUE;
  84. }
  86. /******************************************************************************
  87. *********************   C O N V   D O U B L E   B Y T E   *********************
  88. ******************************************************************************/
  90. BOOL CInccEucJIn::ConvDoubleByte(UCHAR tc)
  91. {
  92. BOOL fRet ;
  94. m_pfnConv = ConvMain;
  95. m_pfnCleanUp = CleanUpMain;
  96. if (m_tcLeadByte <= 0xde) { // && m_tcLeadByte >= 0xa1
  97. if (m_tcLeadByte % 2) // odd
  98. (void)Output((m_tcLeadByte - 0xa1) / 2 + 0x81);
  99. else // even
  100. (void)Output((m_tcLeadByte - 0xa2) / 2 + 0x81);
  101. } else { // m_tcLeadByte >= 0xdf && m_tcLeadByte <= 0xfe
  102. if (m_tcLeadByte % 2) // odd
  103. (void)Output((m_tcLeadByte - 0xdf) / 2 + 0xe0);
  104. else // even
  105. (void)Output((m_tcLeadByte - 0xe0) / 2 + 0xe0);
  106. }
  107. if (m_tcLeadByte % 2) { // odd
  108. if (tc >= 0xa1 && tc <= 0xdf)
  109. fRet = Output(tc - 0x61);
  110. else
  111. fRet = Output(tc - 0x60);
  112. } else { // even
  113. fRet = Output(tc - 2);
  114. }
  115. m_tcLeadByte = 0 ;
  116. return fRet ;
  117. }
  119. /******************************************************************************
  120. *****************   C L E A N   U P   D O U B L E   B Y T E   *****************
  121. ******************************************************************************/
  123. BOOL CInccEucJIn::CleanUpDoubleByte()
  124. {
  125. m_pfnConv = ConvMain;
  126. m_pfnCleanUp = CleanUpMain;
  127. return TRUE;
  128. }
  130. /******************************************************************************
  131. ************************   C O N V   K A T A K A N A   ************************
  132. ******************************************************************************/
  134. BOOL CInccEucJIn::ConvKatakana(UCHAR tc)
  135. {
  136. m_pfnConv = ConvMain;
  137. m_pfnCleanUp = CleanUpMain;
  138. return Output(tc);
  139. }
  141. /******************************************************************************
  142. ********************   C L E A N   U P   K A T A K A N A   ********************
  143. ******************************************************************************/
  145. BOOL CInccEucJIn::CleanUpKatakana()
  146. {
  147. m_pfnConv = ConvMain;
  148. m_pfnCleanUp = CleanUpMain;
  149. return TRUE;
  150. }
  152. int CInccEucJIn::GetUnconvertBytes()
  153. {
  154.     if (m_tcLeadByte || m_pfnConv == ConvKatakana)
  155.      return 1;
  156.     else
  157.      return 0;
  158. }
  160. DWORD CInccEucJIn::GetConvertMode()
  161. {
  162.     // 0xCADC -> 51932 EUC-JP (codepage)
  163.   return 0xCADC0000 ;
  164. }
  166. void CInccEucJIn::SetConvertMode(DWORD mode)
  167. {
  168.     Reset();
  169.   return ;
  170. }
  173. // ============================================================================
  174. // Internet Character Set Conversion: Output to EUC-JP
  175. // ============================================================================
  177. /******************************************************************************
  178. **************************   C O N S T R U C T O R   **************************
  179. ******************************************************************************/
  181. CInccEucJOut::CInccEucJOut(UINT uCodePage, int nCodeSet, DWORD dwFlag, WCHAR *lpFallBack) : CINetCodeConverter(uCodePage, nCodeSet)
  182. {
  183.     Reset();    // initialization
  184.     _dwFlag = dwFlag;
  185.     _lpFallBack = lpFallBack;
  186.     return ;
  187. }
  189. /******************************************************************************
  190. *******************************   R E S E T   *********************************
  191. ******************************************************************************/
  192. void CInccEucJOut::Reset()
  193. {
  194. m_fDoubleByte = FALSE;
  195. m_tcLeadByte = 0 ;
  196.     return ;
  197. }
  199. /******************************************************************************
  200. *************************   C O N V E R T   C H A R   *************************
  201. ******************************************************************************/
  203. HRESULT CInccEucJOut::ConvertChar(UCHAR tc, int cchSrc)
  204. {
  205. BOOL fDone = TRUE;
  206.     HRESULT hr = S_OK;
  208. if (!m_fDoubleByte) {
  209. if ((tc >= 0x81 && tc <= 0x9f) || (tc >= 0xe0 && tc <= 0xfc )) { // Double Byte Code
  210. m_fDoubleByte = TRUE;
  211. m_tcLeadByte = tc;
  212. } else if (tc >= 0xa1 && tc <= 0xdf) { // Single Byte Katakana Code
  213. (void) Output( (UCHAR) 0x8e);
  214. fDone = Output(tc);
  215. } else {
  216. fDone = Output(tc);
  217. }
  218. } else {
  220.         // map extended char (0xfa40-0xfc4b) to a special range
  221.         if (m_tcLeadByte >= 0xfa && m_tcLeadByte <= 0xfc && tc >= 0x40 )
  222.         {
  223.             WCHAR  wcDBCS ;
  225.             wcDBCS = ((WCHAR) m_tcLeadByte ) << 8 | tc ;
  227.             if ( wcDBCS >= 0xfa40 && wcDBCS <= 0xfa5b )
  228.             {
  229.                 if ( wcDBCS <= 0xfa49 )
  230.                     wcDBCS = wcDBCS - 0x0b51 ;
  231.                 else if ( wcDBCS >= 0xfa4a && wcDBCS <= 0xfa53 )
  232.                     wcDBCS = wcDBCS - 0x072f6 ;
  233.                 else if ( wcDBCS >= 0xfa54 && wcDBCS <= 0xfa57 )
  234.                     wcDBCS = wcDBCS - 0x0b5b ;
  235.                 else if ( wcDBCS == 0xfa58 )
  236.                     wcDBCS = 0x878a ;
  237.                 else if ( wcDBCS == 0xfa59 )
  238.                     wcDBCS = 0x8782 ;
  239.                 else if ( wcDBCS == 0xfa5a )
  240.                     wcDBCS = 0x8784 ;
  241.                 else if ( wcDBCS == 0xfa5b )
  242.                     wcDBCS = 0x879a ;
  243.             }
  244.             else if ( wcDBCS >= 0xfa5c && wcDBCS <= 0xfc4b )
  245.             {
  246.                 if ( tc < 0x5c )
  247.                     wcDBCS = wcDBCS - 0x0d5f;
  248.                 else if ( tc >= 0x80 && tc <= 0x9B )
  249.                     wcDBCS = wcDBCS - 0x0d1d;
  250.                 else
  251.                     wcDBCS = wcDBCS - 0x0d1c;
  252.             }
  253.             tc = (UCHAR) wcDBCS ;
  254.             m_tcLeadByte = (UCHAR) ( wcDBCS >> 8 ) ;
  255.         }
  257.         // Do conversion
  258. if (m_tcLeadByte <= 0xef) {
  259. if (m_tcLeadByte <= 0x9f) { // && m_tcLeadByte >= 0x81
  260. if (tc <= 0x9e)
  261. (void)Output((m_tcLeadByte - 0x81) * 2 + 0xa1);
  262. else
  263. (void)Output((m_tcLeadByte - 0x81) * 2 + 0xa2);
  264. } else { // m_tcLeadByte >= 0xe0 && m_tcLeadByte <= 0xef
  265. if (tc <= 0x9e)
  266. (void)Output((m_tcLeadByte - 0xe0) * 2 + 0xdf);
  267. else
  268. (void)Output((m_tcLeadByte - 0xe0) * 2 + 0xe0);
  269. }
  270. if (tc >= 0x40 && tc <= 0x7e)
  271. fDone = Output(tc + 0x61);
  272. else if (tc >= 0x80 && tc <= 0x9e)
  273. fDone = Output(tc + 0x60);
  274. else
  275. fDone = Output(tc + 0x02);
  276. } else if (m_tcLeadByte >= 0xfa) { // && m_tcLeadByte <= 0xfc; IBM Extended Char
  277.             UCHAR szDefaultChar[3] = {0x3f}; // possible DBCS + null    
  280.             if (_lpFallBack && (_dwFlag & MLCONVCHARF_USEDEFCHAR))
  281.             {
  282.                 // only take SBCS, no DBCS character
  283.                 if ( 1 != WideCharToMultiByte(CP_JPN_SJ, 0,
  284.                                (LPCWSTR)_lpFallBack, 1,
  285.                                (LPSTR)szDefaultChar, ARRAYSIZE(szDefaultChar), NULL, NULL ))
  286.                     szDefaultChar[0] = 0x3f;
  287.             }
  289.             if (_dwFlag & (MLCONVCHARF_NCR_ENTITIZE|MLCONVCHARF_NAME_ENTITIZE))
  290.             {
  291.                 char    szChar[3] = {0};
  292.                 char    szDstStr[10] = {0};
  293.                 WCHAR   szwChar[2];
  294.                 int     cCount;
  296.                 szChar[0] = m_tcLeadByte;
  297.                 szChar[1] = tc;
  298.                 
  299.                 if (MultiByteToWideChar(CP_JPN_SJ, 0, szChar, -1, szwChar, ARRAYSIZE(szwChar)))
  300.                 {
  302.                     // Output NCR entity
  303.                     Output('&');
  304.                     Output('#');
  305.                     _ultoa((unsigned long)szwChar[0], (char*)szDstStr, 10);
  306.                     cCount = lstrlenA(szDstStr);
  307.                     for (int i=0; i< cCount; i++)
  308.                     {
  309.                         Output(szDstStr[i]);
  310.                     }
  311.                     fDone = Output(';');
  312.                 }
  313.                 else
  314.                 {
  315.              fDone = Output(szDefaultChar[0]);
  316.                     hr = S_FALSE;
  317.                 }
  318.             }
  319.             else
  320.             {
  321.              fDone = Output(szDefaultChar[0]);
  322.                     hr = S_FALSE;
  323.             }
  324. } else {
  325. (void)Output(m_tcLeadByte);
  326. fDone = Output(tc);
  327. }
  328. m_fDoubleByte = FALSE;
  329. m_tcLeadByte = 0 ;
  330. }
  332.     if (!fDone)
  333.         hr = E_FAIL;
  335.     return hr;
  336. }
  338. /******************************************************************************
  339. *****************************   C L E A N   U P   *****************************
  340. ******************************************************************************/
  342. BOOL CInccEucJOut::CleanUp()
  343. {
  344. m_fDoubleByte = FALSE;
  345. return TRUE;
  346. }
  348. int CInccEucJOut::GetUnconvertBytes()
  349. {
  350.     if (m_tcLeadByte)
  351.      return 1;
  352.     else
  353.      return 0;
  354. }
  356. DWORD CInccEucJOut::GetConvertMode()
  357. {
  358.   return 0 ;
  359. }
  361. void CInccEucJOut::SetConvertMode(DWORD mode)
  362. {
  363.     Reset();
  364.   return ;
  365. }