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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
xmlencod.cpp
资源名称：helix.src.0812.rar　[点击查看]
上传用户：zhongxx05
上传日期：2007-06-06
资源大小：33641k
文件大小：10k
源码类别：

Symbian

开发平台：

C/C++

xmlencod.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  36. #include "hxresult.h"
  37. #include "hxassert.h"
  38. #include "hxheap.h"
  40. #include "hxstrutl.h"
  41. #include "xmlencod.h"
  42. #include "xmlvalid.h"
  44. #ifdef _DEBUG
  45. #undef HX_THIS_FILE
  46. static const char HX_THIS_FILE[] = __FILE__;
  47. #endif
  49. struct xmlEncodingInfo
  50. {
  51.     char*   m_pIANAName; // name of charset, case-insensitive
  52.     BOOL    m_bDoubleByte; // true if DBCS charset
  53.     BYTE    m_szLeadingByteRange[12]; // up to 5 zero-terminated
  54. // pairs of lead byte ranges
  55. } ;
  57. // Removed static here because it exercises a bug in gcc.  pgodman, 3/2/2000
  58. const xmlEncodingInfo XMLEncodingInfo[] =
  59. {
  60.     { "Default", TRUE,     // assume DBCS; any non-ASCII char is a lead byte
  61. 0x81, 0xFF, 0x00, 0x00, 0x00, 0x00,
  62. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
  64.     { "US-ASCII", FALSE, 
  65. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  66. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
  68.     { "Shift-JIS", TRUE, 
  69. 0x81, 0x9F, 0xE0, 0xFC, 0x00, 0x00, 
  70. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
  72.     { "Big5", TRUE,
  73. 0x81, 0xFE, 0x00, 0x00, 0x00, 0x00,
  74. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
  76.     { "GB2312", TRUE,
  77. 0xA1, 0xFE, 0x00, 0x00, 0x00, 0x00,
  78. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
  80.     { "EUC-KR", TRUE,
  81. 0x84, 0xD3, 0xD8, 0xD8, 0xD9, 0xDE,
  82. 0xE0, 0xF9, 0x00, 0x00, 0x00, 0x00 },
  84.     { "ISO-2022-KR", TRUE,
  85. 0x81, 0xFE, 0x00, 0x00, 0x00, 0x00,
  86. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
  88.     { "ISO-8859-1", FALSE,
  89. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  90. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
  92. };
  94. CHXXMLEncode::CHXXMLEncode(const char* pEncoding,
  95.    BYTE* pBuffer,
  96.    UINT32 ulLength):
  97.     m_ulBufferLength(ulLength),
  98.     m_pBuffer(pBuffer),
  99.     m_pCurrent(pBuffer)
  100. {
  101.     m_lEncodingIndex = GetEncodingIndex(pEncoding);
  102. }
  104. CHXXMLEncode::CHXXMLEncode(const char* pEncoding,
  105.    BYTE* pStr):
  106.     m_pBuffer(pStr),
  107.     m_pCurrent(pStr)
  108. {
  109.     m_ulBufferLength = strlen((char*)pStr) + 1;
  110.     m_lEncodingIndex = GetEncodingIndex(pEncoding);
  111. }
  113. CHXXMLEncode::CHXXMLEncode(const CHXXMLEncode& lhs)
  114. {
  115.     m_ulBufferLength = lhs.m_ulBufferLength;
  116.     m_pBuffer = lhs.m_pBuffer;
  117.     m_pCurrent = m_pBuffer;
  118.     m_lEncodingIndex = lhs.m_lEncodingIndex;
  119. }
  121. CHXXMLEncode::~CHXXMLEncode()
  122. {
  123. }
  125. const CHXXMLEncode&
  126. CHXXMLEncode::operator=(const CHXXMLEncode& lhs)
  127. {
  128.     m_ulBufferLength = lhs.m_ulBufferLength;
  129.     m_pBuffer = lhs.m_pBuffer;
  130.     m_pCurrent = m_pBuffer; // start at 0
  131.     m_lEncodingIndex = lhs.m_lEncodingIndex;
  133.     return *this;
  134. }
  136. CHXXMLEncode::operator const BYTE*() const
  137. {
  138.     return (const BYTE*)m_pBuffer;
  139. }
  141. BYTE*
  142. CHXXMLEncode::operator+(int offset)
  143. {
  144.     BYTE* pCh = m_pCurrent;
  145.     for(int nCount = 0; nCount < offset; ++nCount)
  146.     {
  147. UINT16 uLen = 0;
  148. GetNextChar(uLen);
  149.     }
  150.     BYTE* pOffset = m_pCurrent;
  151.     m_pCurrent = pCh;
  152.     return pOffset;
  153. }
  155. BYTE*
  156. CHXXMLEncode::operator+=(int offset)
  157. {
  158.     BYTE* pCh = m_pCurrent;
  159.     for(int nCount = 0; nCount < offset; ++nCount)
  160.     {
  161. UINT16 uLen = 0;
  162. pCh = GetNextChar(uLen);
  163.     }
  164.     return pCh;
  165. }
  167. BYTE*
  168. CHXXMLEncode::operator++(int)
  169. {
  170.     UINT16 uLen = 0;
  171.     return GetNextChar(uLen);
  172. }
  174. BYTE*
  175. CHXXMLEncode::operator--(int)
  176. {
  177.     UINT16 uLen = 0;
  178.     return GetPrevChar(uLen);
  179. }
  181. BOOL
  182. CHXXMLEncode::IsLeadByte(BYTE ch)
  183. {
  184.     int bRange = 0;
  186.     const xmlEncodingInfo* pEncInfo = &(XMLEncodingInfo[m_lEncodingIndex]);
  187.     if(pEncInfo->m_bDoubleByte)
  188.     {
  189. while((bRange < 12) &&
  190.       (pEncInfo->m_szLeadingByteRange[bRange] != 0))
  191. {
  192.     if(ch >= pEncInfo->m_szLeadingByteRange[bRange] &&
  193.        ch <= pEncInfo->m_szLeadingByteRange[bRange + 1])
  194.     {
  195. return TRUE;
  196.     }
  197.     bRange += 2;
  198. }
  199.     }
  200.     return FALSE;
  201. }
  203. BYTE*
  204. CHXXMLEncode::GetNextChar(UINT16& uLen)
  205. {
  206.     BYTE* pCh = m_pCurrent;
  207.     if(IsLeadByte(*m_pCurrent))
  208.     {
  209. m_pCurrent += 2;    // skip 2 bytes
  210. uLen = 2;
  211. return pCh;
  212.     }
  213.     m_pCurrent++;   // skip 1 byte
  214.     uLen = 1;
  215.     return pCh;
  216. }
  218. BYTE*
  219. CHXXMLEncode::GetPrevChar(UINT16& uLen)
  220. {
  221.     BYTE* pCh = m_pCurrent;
  222.     // assumes the m_pCurrent is on a boundary, i.e. it doesn't
  223.     // point to the middle of a DBCS character
  225.     // if current is at beginning or the previous byte is
  226.     // at the beginning, return current
  227.     if(m_pCurrent - 1 <= m_pBuffer)
  228.     {
  229. return pCh;
  230.     }
  232.     // point to the previous byte
  233.     BYTE* pTemp = m_pCurrent - 1;
  235.     // if pTemp points to a lead byte, then it must be a trail byte;
  236.     // decrement current 2 bytes to lead byte
  237.     if(IsLeadByte(*pTemp))
  238.     {
  239. m_pCurrent -= 2;
  240. pCh = m_pCurrent;
  241. uLen = 2;
  242. return pCh;
  243.     }
  245.     // otherwise, step back unil a non-lead byte is found
  246.     while(m_pCurrent <= --pTemp && IsLeadByte(*pTemp))
  247.     {
  248. ;
  249.     }
  251.     // now pTemp + 1 must point to the beginning of a character,
  252.     // so figure out whether we went back to an even or an odd
  253.     // number of bytes and go back 1 or 2 bytes, respectively.
  254.     m_pCurrent = m_pCurrent - 1 - ((m_pCurrent - pTemp) & 1);
  256.     pCh = m_pCurrent;
  257.     if(IsLeadByte(*pCh))
  258.     {
  259. uLen = 2;
  260.     }
  261.     else
  262.     {
  263. uLen = 1;
  264.     }
  265.     return pCh;
  266. }
  268. BYTE*
  269. CHXXMLEncode::SetCurrent(BYTE* pCh)
  270. {
  271.     // no checking other than boundary;
  272.     // if it is set on the trail byte
  273.     // of a DBCS character, bad things
  274.     // will happen...
  275.     HX_ASSERT(pCh >= m_pBuffer &&
  276.       pCh <= m_pBuffer + m_ulBufferLength);
  277.     m_pCurrent = pCh;
  278.     return m_pCurrent;
  279. }
  281. UINT32
  282. CHXXMLEncode::CharCount()
  283. {
  284.     UINT32 ulLength = 0;
  285.     BYTE* pCh = m_pBuffer;
  287.     if(XMLEncodingInfo[m_lEncodingIndex].m_bDoubleByte)
  288.     {
  289. UINT16 uLen = 0;
  290. for(; *pCh; pCh = GetNextChar(uLen))
  291. {
  292.     ++ulLength;
  293. }
  294.     }
  295.     else
  296.     {
  297. for(; *pCh; pCh++)
  298. {
  299.     ++ulLength;
  300. }
  301.     }
  302.     return ulLength;
  303. }
  305. INT32
  306. CHXXMLEncode::GetEncodingIndex(const char* pEncoding)
  307. {
  308.     INT32 lIndex = 0; // default
  309.     for(INT32 lCount = 0; 
  310. lCount < sizeof(XMLEncodingInfo) / sizeof(XMLEncodingInfo[0]);
  311. ++lCount)
  312.     {
  313. if(strcasecmp(pEncoding, XMLEncodingInfo[lCount].m_pIANAName) == 0)
  314. {
  315.     lIndex = lCount;
  316.     break;
  317. }
  318.     }
  319.     return lIndex;
  320. }
  322. BOOL
  323. CHXXMLEncode::IsRefValid(const BYTE* p, UINT32 len)
  324. {
  325.     if (!XMLEncodingInfo[m_lEncodingIndex].m_bDoubleByte)
  326.     {
  327. return ISO8859Valid::IsRefValid(p, len);
  328.     }
  329.     else
  330.     {
  331. // TODO: Double byte Validation
  332. return TRUE;
  333.     }
  334. }
  336. BOOL
  337. CHXXMLEncode::IsNameValid(const BYTE* p, UINT32 len)
  338. {
  339.     if (!XMLEncodingInfo[m_lEncodingIndex].m_bDoubleByte)
  340.     {
  341. return ISO8859Valid::IsNameValid(p, len);
  342.     }
  343.     else
  344.     {
  345. // TODO: Double byte Validation.
  346. return TRUE;
  347.     }
  348. }
  350. BOOL
  351. CHXXMLEncode::IsNmtokenValid(const BYTE*p, UINT32 len)
  352. {
  353.     if (!XMLEncodingInfo[m_lEncodingIndex].m_bDoubleByte)
  354.     {
  355. return ISO8859Valid::IsNmtokenValid(p, len);
  356.     }
  357.     else
  358.     {
  359. // TODO: Double byte Validation.
  360. return TRUE;
  361.     }
  362. }
  364. BOOL
  365. CHXXMLEncode::IsEntityValueValid(const BYTE* p, UINT32 len)
  366. {
  367.     if (!XMLEncodingInfo[m_lEncodingIndex].m_bDoubleByte)
  368.     {
  369. return ISO8859Valid::IsEntityValueValid(p, len);
  370.     }
  371.     else
  372.     {
  373. return TRUE;
  374.     }
  375. }
  377. BOOL 
  378. CHXXMLEncode::IsAttValueValid(const BYTE* p, UINT32 len)
  379. {
  380.     if (!XMLEncodingInfo[m_lEncodingIndex].m_bDoubleByte)
  381.     {
  382. return ISO8859Valid::IsAttValueValid(p, len);
  383.     }
  384.     else
  385.     {
  386. // TODO: Double byte Validation.
  387. return TRUE;
  388.     }
  389. }
  391. BOOL 
  392. CHXXMLEncode::IsSystemLiteralValid(const BYTE* p, UINT32 len)
  393. {
  394.     if (!XMLEncodingInfo[m_lEncodingIndex].m_bDoubleByte)
  395.     {
  396. return ISO8859Valid::IsSystemLiteralValid(p, len);
  397.     }
  398.     else
  399.     {
  400. // TODO: Double byte Validation.
  401. return TRUE;
  402.     }
  403. }
  405. BOOL
  406. CHXXMLEncode::IsPubidLiteralValid(const BYTE* p, UINT32 len)
  407. {
  408.     if (!XMLEncodingInfo[m_lEncodingIndex].m_bDoubleByte)
  409.     {
  410. return ISO8859Valid::IsPubidLiteralValid(p, len);
  411.     }
  412.     else
  413.     {
  414. // TODO: Double byte Validation.
  415. return TRUE;
  416.     }
  417. }