Category

Development Platform
Home > SourceCode/Document > Windows Develop > Windows Kernel > View Code
kscobj.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++

kscobj.cpp：Code Content
  1. // ============================================================================
  2. // Internet Character Set Conversion: Input from ISO-2022-KR
  3. // ============================================================================
  5. #include "private.h"
  6. #include "fechrcnv.h"
  7. #include "kscobj.h"
  8. #include "codepage.h"
  10. /******************************************************************************
  11. **************************   C O N S T R U C T O R   **************************
  12. ******************************************************************************/
  14. CInccKscIn::CInccKscIn(UINT uCodePage, int nCodeSet) : CINetCodeConverter(uCodePage, nCodeSet)
  15. {
  16.     Reset();    // initialization
  17.     return ;
  18. }
  20. /******************************************************************************
  21. *******************************   R E S E T   *********************************
  22. ******************************************************************************/
  24. void CInccKscIn::Reset()
  25. {
  26. m_pfnConv = ConvMain;
  27. m_pfnCleanUp = CleanUpMain;
  28. m_fShift = FALSE;
  29.     // BUGBUG: bug #57570, Korean ISP DACOM only labels one designator in the 
  30.     // conversion of a MIME mail. To decode the other part of MIME correctly, 
  31.     // we need to decode the ISO document or MIME message even there is no
  32.     // designator "esc ) C".
  33. m_fKorea = TRUE;
  34. m_nESCBytes = 0 ;
  35. m_fLeadByte = FALSE ;
  36.     return ;
  37. }
  39. /******************************************************************************
  40. *************************   C O N V E R T   C H A R   *************************
  41. ******************************************************************************/
  43. HRESULT CInccKscIn::ConvertChar(UCHAR tc, int cchSrc)
  44. {
  45. BOOL fDone = (this->*m_pfnConv)(tc);
  46.     if (fDone)
  47.         return S_OK;
  48.     else
  49.         return E_FAIL;
  50. }
  52. /******************************************************************************
  53. *****************************   C L E A N   U P   *****************************
  54. ******************************************************************************/
  56. BOOL CInccKscIn::CleanUp()
  57. {
  58. return (this->*m_pfnCleanUp)();
  59. }
  61. /******************************************************************************
  62. ****************************   C O N V   M A I N   ****************************
  63. ******************************************************************************/
  65. BOOL CInccKscIn::ConvMain(UCHAR tc)
  66. {
  67. BOOL fDone = TRUE;
  69. if (tc == ESC) {
  70. m_pfnConv = ConvEsc;
  71. m_pfnCleanUp = CleanUpEsc;
  72. m_nESCBytes++ ;
  73. } else {
  74. if (m_fKorea) {
  75. switch (tc) {
  76. case SO:
  77. m_fShift = TRUE;
  78. break;
  80. case SI:
  81. m_fShift = FALSE;
  82. m_fLeadByte = FALSE ;
  83. break;
  85. default:
  86. if (m_fShift) {
  87. switch (tc) {
  88. case ' ':
  89. case 't':
  90. case 'n':
  91. fDone = Output(tc);
  92. break;
  94. default:
  95. fDone = Output(tc | 0x80);
  96. m_fLeadByte = ~m_fLeadByte ;
  97. break;
  98. }
  99. } else {
  100. fDone = Output(tc);
  101. }
  102. break;
  103. }
  104. } else {
  105. fDone = Output(tc);
  106. }
  107. }
  108. return fDone;
  109. }
  111. /******************************************************************************
  112. ************************   C L E A N   U P   M A I N   ************************
  113. ******************************************************************************/
  115. BOOL CInccKscIn::CleanUpMain()
  116. {
  117. return TRUE;
  118. }
  120. /******************************************************************************
  121. *****************************   C O N V   E S C   *****************************
  122. ******************************************************************************/
  124. BOOL CInccKscIn::ConvEsc(UCHAR tc)
  125. {
  126. if (tc == ISO2022_IN_CHAR) {
  127. m_pfnConv = ConvIsoIn;
  128. m_pfnCleanUp = CleanUpIsoIn;
  129. m_nESCBytes++ ;
  130. return TRUE;
  131. } else {
  132. m_pfnConv = ConvMain;
  133. m_pfnCleanUp = CleanUpMain;
  134. m_nESCBytes = 0 ;
  135. (void)Output(ESC);
  136.         if (SUCCEEDED(ConvertChar(tc)))
  137.             return TRUE;
  138.         else
  139.             return FALSE;
  140.     }
  141. }
  143. /******************************************************************************
  144. *************************   C L E A N   U P   E S C   *************************
  145. ******************************************************************************/
  147. BOOL CInccKscIn::CleanUpEsc()
  148. {
  149. m_pfnConv = ConvMain;
  150. m_pfnCleanUp = CleanUpMain;
  151. m_nESCBytes = 0 ;
  152. return Output(ESC);
  153. }
  155. /******************************************************************************
  156. **************************   C O N V   I S O   I N   **************************
  157. ******************************************************************************/
  159. BOOL CInccKscIn::ConvIsoIn(UCHAR tc)
  160. {
  161. if (tc == ISO2022_IN_KR_CHAR_1) {
  162. m_pfnConv = ConvIsoInKr;
  163. m_pfnCleanUp = CleanUpIsoInKr;
  164. m_nESCBytes++ ;
  165. return TRUE;
  166. } else {
  167. m_pfnConv = ConvMain;
  168. m_pfnCleanUp = CleanUpMain;
  169. m_nESCBytes = 0 ;
  170. (void)Output(ESC);
  171. (void)ConvertChar(ISO2022_IN_CHAR);
  172.         if (SUCCEEDED(ConvertChar(tc)))
  173.             return TRUE;
  174.         else
  175.             return FALSE;
  176. }
  177. }
  179. /******************************************************************************
  180. **********************   C L E A N   U P   I S O   I N   **********************
  181. ******************************************************************************/
  183. BOOL CInccKscIn::CleanUpIsoIn()
  184. {
  185. m_pfnConv = ConvMain;
  186. m_pfnCleanUp = CleanUpMain;
  187.     m_nESCBytes = 0 ;
  189. (void)Output(ESC);
  190. (void)ConvertChar(ISO2022_IN_CHAR);
  191. return CleanUp();
  192. }
  194. /******************************************************************************
  195. ***********************   C O N V   I S O   I N   K R   ***********************
  196. ******************************************************************************/
  198. BOOL CInccKscIn::ConvIsoInKr(UCHAR tc)
  199. {
  200. m_pfnConv = ConvMain;
  201. m_pfnCleanUp = CleanUpMain;
  202.     m_nESCBytes = 0 ;
  204. if (tc == ISO2022_IN_KR_CHAR_2) {
  205. m_fKorea = TRUE;
  206. return TRUE;
  207. } else {
  208. (void)Output(ESC);
  209. (void)ConvertChar(ISO2022_IN_CHAR);
  210. (void)ConvertChar(ISO2022_IN_KR_CHAR_1);
  211.         if (SUCCEEDED(ConvertChar(tc)))
  212.             return TRUE;
  213.         else
  214.             return FALSE;
  215. }
  216. }
  218. /******************************************************************************
  219. *******************   C L E A N   U P   I S O   I N   K R   *******************
  220. ******************************************************************************/
  222. BOOL CInccKscIn::CleanUpIsoInKr()
  223. {
  224. m_pfnConv = ConvMain;
  225. m_pfnCleanUp = CleanUpMain;
  226.     m_nESCBytes = 0 ;
  228. (void)Output(ESC);
  229. (void)ConvertChar(ISO2022_IN_CHAR);
  230. (void)ConvertChar(ISO2022_IN_KR_CHAR_1);
  231. return CleanUp();
  232. }
  234. int CInccKscIn::GetUnconvertBytes()
  235. {
  236.     if ( m_fLeadByte )
  237.         return 1 ;
  238.     else if ( m_nESCBytes )
  239.         return m_nESCBytes < 4 ? m_nESCBytes : 3 ;
  240.     else
  241.         return 0 ;
  242. }
  244. DWORD CInccKscIn::GetConvertMode()
  245. {
  246.     // 0xC431 -> 50225 ISO-2022-KR
  247.     return ( m_fKorea ? 1 : 0 ) + ( m_fShift ? 2 : 0 ) | 0xC4310000 ;
  248. }
  250. void CInccKscIn::SetConvertMode(DWORD mode)
  251. {
  252.     Reset();    // initialization
  254.     if ( mode & 0x00000001 )
  255.         m_fKorea = TRUE ;
  256.     if ( mode & 0x00000002 ) 
  257.         m_fShift = TRUE ;
  258.     return ;
  259. }
  261. // ============================================================================
  262. // Internet Character Set Conversion: Output to ISO-2022-KSC
  263. // ============================================================================
  265. /******************************************************************************
  266. **************************   C O N S T R U C T O R   **************************
  267. ******************************************************************************/
  269. CInccKscOut::CInccKscOut(UINT uCodePage, int nCodeSet, DWORD dwFlag, WCHAR *lpFallBack) : CINetCodeConverter(uCodePage, nCodeSet)
  270. {
  271.     Reset();    // initialization
  272.     _dwFlag = dwFlag;
  273.     _lpFallBack = lpFallBack;
  274.     return ;
  275. }
  277. /******************************************************************************
  278. *******************************   R E S E T   *********************************
  279. ******************************************************************************/
  281. void CInccKscOut::Reset()
  282. {
  283. m_fDoubleByte = FALSE;
  284. m_fShift = FALSE;
  285. m_fKorea = FALSE;
  286. m_tcLeadByte = 0 ;
  287.     return ;
  288. }
  290. /******************************************************************************
  291. *************************   C O N V E R T   C H A R   *************************
  292. ******************************************************************************/
  294. HRESULT CInccKscOut::ConvertChar(UCHAR tc, int cchSrc)
  295. {
  296. BOOL fDone = TRUE;
  297.     HRESULT hr = S_OK;
  299.     // put designator to the top of the document
  300. if (!m_fKorea) {
  301. (void)Output(ESC);
  302. (void)Output(ISO2022_IN_CHAR);
  303. (void)Output(ISO2022_IN_KR_CHAR_1);
  304. (void)Output(ISO2022_IN_KR_CHAR_2);
  305. m_fKorea = TRUE;
  306. }
  308. if (!m_fDoubleByte) {
  309. if (tc > 0x80) {
  310. m_fDoubleByte = TRUE;
  311. m_tcLeadByte = tc;
  312. } else {
  313. if (m_fKorea && m_fShift) {
  314. (void)Output(SI);
  315. m_fShift = FALSE;
  316. }
  317. fDone = Output(tc);
  318. }
  319. } else {
  320. m_fDoubleByte = FALSE;
  321. if (tc > 0x40) { // Check if trail byte indicates Hangeul
  322. if (m_tcLeadByte > 0xa0 && tc > 0xa0) { // Check if it's a Wansung
  323.     if (!m_fShift) {
  324.     if (!m_fKorea) {
  325.     (void)Output(ESC);
  326.     (void)Output(ISO2022_IN_CHAR);
  327.     (void)Output(ISO2022_IN_KR_CHAR_1);
  328.     (void)Output(ISO2022_IN_KR_CHAR_2);
  329.     m_fKorea = TRUE;
  330.     }
  331.     (void)Output(SO);
  332.     m_fShift = TRUE;
  333.     }                
  334. (void)Output(m_tcLeadByte & 0x7f);
  335. fDone = Output(tc & 0x7f);
  336. } else {
  337.                 UCHAR szDefaultChar[3] = {0x3f}; // possible DBCS + null    
  340.                 if (_lpFallBack && (_dwFlag & MLCONVCHARF_USEDEFCHAR))
  341.                 {
  342.                     // only take SBCS, no DBCS character
  343.                     if ( 1 != WideCharToMultiByte(CP_KOR_5601, 0,
  344.                                (LPCWSTR)_lpFallBack, 1,
  345.                                (LPSTR)szDefaultChar, ARRAYSIZE(szDefaultChar), NULL, NULL ))
  346.                         szDefaultChar[0] = 0x3f;
  347.                 }
  349.     // shift out if we're in DBCS mode
  350.                 if (m_fKorea && m_fShift) {
  351.     (void)Output(SI);
  352.     m_fShift = FALSE;
  353.     }
  355.                 if (_dwFlag & (MLCONVCHARF_NCR_ENTITIZE|MLCONVCHARF_NAME_ENTITIZE))
  356.                 {
  357.                     char    szChar[3] = {0};
  358.                     char    szDstStr[10] = {0};
  359.                     WCHAR   szwChar[2];
  360.                     int     cCount;
  362.                     szChar[0] = m_tcLeadByte;
  363.                     szChar[1] = tc;
  364.                 
  365.                     if (MultiByteToWideChar(CP_KOR_5601, 0, szChar, -1, szwChar, ARRAYSIZE(szwChar)))
  366.                     {
  367.                         // Output NCR entity
  368.                         Output('&');
  369.                         Output('#');
  370.                         _ultoa((unsigned long)szwChar[0], (char*)szDstStr, 10);
  371.                         cCount = lstrlenA(szDstStr);
  372.                         for (int i=0; i< cCount; i++)
  373.                         {
  374.                             Output(szDstStr[i]);
  375.                         }
  376.                         fDone = Output(';');
  377.                     }
  378.                     else
  379.                     {
  380.         fDone = Output(szDefaultChar[0]); // use default char
  381.                         hr = S_FALSE;
  382.                     }
  383.                 }
  384.                 else
  385.                 {
  386.     fDone = Output(szDefaultChar[0]); // use default char
  387.                     hr = S_FALSE;
  388.                 }
  389. }
  390. } else {
  391. if (m_fKorea && m_fShift) {
  392. (void)Output(SI);
  393. m_fShift = FALSE;
  394. }
  395. (void)Output(m_tcLeadByte);
  396. fDone = Output(tc);
  397. }
  398. m_tcLeadByte = 0 ;
  399. }
  401.     if (!fDone)
  402.         hr = E_FAIL;
  404. return hr;
  405. }
  407. /******************************************************************************
  408. *****************************   C L E A N   U P   *****************************
  409. ******************************************************************************/
  411. BOOL CInccKscOut::CleanUp()
  412. {
  413.     BOOL fDone = TRUE;
  415.     if ( m_fShift) 
  416.     {
  417.         fDone = Output(SI);
  418.         m_fShift = FALSE;
  419.     }
  420.     return fDone ;
  421. }
  423. int CInccKscOut::GetUnconvertBytes()
  424. {
  425.     if (m_tcLeadByte)
  426.         return 1 ;
  427.     else
  428.         return 0 ;
  429. }
  431. DWORD CInccKscOut::GetConvertMode()
  432. {
  433.     // for output, we don't need write back code page. 0xC431 -> 50225 ISO-2022-KR
  434.     return ( m_fKorea ? 1 : 0 ) +  ( m_fShift ? 2 : 0 ) ;
  435. }
  437. void CInccKscOut::SetConvertMode(DWORD mode)
  438. {
  439.     Reset();    // initialization
  441.     if ( mode & 0x00000001 ) 
  442.         m_fKorea = TRUE ;
  443.     if ( mode & 0x00000002 ) 
  444.         m_fShift = TRUE ;
  445.     return ;
  446. }