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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > xml/soap/webservice > 查看源码
Markup.cpp
资源名称：CMarkup.rar　[点击查看]
上传用户：hawkcdm
上传日期：2013-02-10
资源大小：411k
文件大小：24k
源码类别：

xml/soap/webservice

开发平台：

Visual C++

Markup.cpp：源码内容
  1. // Markup.cpp: implementation of the CMarkup class.
  2. //
  3. // Markup Release 6.1 Lite
  4. // Copyright (C) 1999-2001 First Objective Software, Inc. All rights reserved
  5. // This entire notice must be retained in this source code
  6. // Redistributing this source code requires written permission
  7. // This software is provided "as is", with no warranty.
  8. // Latest fixes enhancements and documentation at www.firstobject.com
  10. #include "stdafx.h"
  11. #include "afxconv.h"
  12. #include "Markup.h"
  14. #ifdef _DEBUG
  15. #undef THIS_FILE
  16. static char THIS_FILE[]=__FILE__;
  17. #define new DEBUG_NEW
  18. #endif
  20. void CMarkup::operator=( const CMarkup& markup )
  21. {
  22. m_iPos = markup.m_iPos;
  23. m_iPosChild = markup.m_iPosChild;
  24. m_iPosFree = markup.m_iPosFree;
  25. m_aPos.RemoveAll();
  26. m_aPos.Append( markup.m_aPos );
  27. m_nLevel = markup.m_nLevel;
  28. m_csDoc = markup.m_csDoc;
  29. }
  31. void CMarkup::ResetPos()
  32. {
  33. // Reset the main and child positions
  34. m_iPos = 0;
  35. m_iPosChild = 0;
  36. m_nLevel = 0;
  37. };
  39. bool CMarkup::SetDoc( LPCTSTR szDoc )
  40. {
  41. // Reset indexes
  42. m_iPosFree = 1;
  43. ResetPos();
  45. // Set document text
  46. if ( szDoc )
  47. m_csDoc = szDoc;
  48. else
  49. m_csDoc.Empty();
  51. // Starting size of position array: 1 element per 64 bytes of document
  52. // Tight fit when parsing small doc, only 0 to 2 reallocs when parsing large doc
  53. // Start at 8 when creating new document
  54. int nStartSize = m_csDoc.GetLength() / 64 + 8;
  55. if ( m_aPos.GetSize() < nStartSize )
  56. m_aPos.SetSize( nStartSize );
  58. // Parse document
  59. bool bWellFormed = false;
  60. if ( m_csDoc.GetLength() )
  61. {
  62. m_aPos[0].Clear();
  63. int iPos = x_ParseElem( 0 );
  64. if ( iPos > 0 )
  65. {
  66. m_aPos[0].iElemChild = iPos;
  67. bWellFormed = true;
  68. }
  69. }
  71. // Clear indexes if parse failed or empty document
  72. if ( ! bWellFormed )
  73. {
  74. m_aPos[0].Clear();
  75. m_iPosFree = 1;
  76. }
  78. ResetPos();
  79. return bWellFormed;
  80. };
  82. bool CMarkup::IsWellFormed()
  83. {
  84. if ( m_aPos.GetSize() && m_aPos[0].iElemChild )
  85. return TRUE;
  86. return FALSE;
  87. }
  89. bool CMarkup::FindElem( LPCTSTR szName )
  90. {
  91. // If szName is NULL or empty, go to next sibling element
  92. // Otherwise go to next sibling element with matching tag name
  93. // If the current position is valid, start looking from next
  94. // Change current position only if found
  95. //
  96. int iPos = m_iPos;
  97. if ( ! iPos )
  98. {
  99. if ( m_aPos.GetSize() )
  100. iPos = m_aPos[0].iElemChild;
  101. }
  102. else
  103. {
  104. iPos = m_aPos[iPos].iElemNext;
  105. }
  107. while ( iPos )
  108. {
  109. // Compare tag name unless szName is not specified
  110. if ( szName == NULL || !szName[0] || x_GetTagName(iPos) == szName )
  111. {
  112. // Assign new position
  113. m_iPos = iPos;
  114. m_iPosChild = 0;
  115. return true;
  116. }
  117. iPos = m_aPos[iPos].iElemNext;
  118. }
  119. return false;
  120. }
  122. bool CMarkup::FindChildElem( LPCTSTR szName )
  123. {
  124. // If szName is NULL or empty, go to next sibling child element
  125. // Otherwise go to next sibling child element with matching tag name
  126. // If the current child position is valid, start looking from next
  127. // Change current child position only if found
  128. //
  129. // Shorthand: call this with no current position means under root element
  130. if ( ! m_iPos )
  131. FindElem();
  133. // Is main position valid and not empty?
  134. if ( ! m_iPos || m_aPos[m_iPos].IsEmptyElement() )
  135. return false;
  137. // Is current child position valid?
  138. int iPosChild = m_iPosChild;
  139. if ( iPosChild )
  140. iPosChild = m_aPos[iPosChild].iElemNext;
  141. else
  142. iPosChild = m_aPos[m_iPos].iElemChild;
  144. // Search
  145. while ( iPosChild )
  146. {
  147. // Compare tag name unless szName is not specified
  148. if ( szName == NULL || !szName[0] || x_GetTagName(iPosChild) == szName )
  149. {
  150. // Assign new position
  151. m_iPosChild = iPosChild;
  152. return true;
  153. }
  154. iPosChild = m_aPos[iPosChild].iElemNext;
  155. }
  156. return false;
  157. }
  159. bool CMarkup::IntoElem()
  160. {
  161. // Find child element unless there is already a child element position
  162. if ( ! m_iPosChild )
  163. FindChildElem();
  165. if ( m_iPosChild )
  166. {
  167. m_iPos = m_iPosChild;
  168. m_iPosChild = 0;
  169. ++m_nLevel;
  170. return true;
  171. }
  173. return false;
  174. }
  176. bool CMarkup::OutOfElem()
  177. {
  178. // Go to parent element
  179. if ( m_iPos && m_nLevel > 0 )
  180. {
  181. m_iPosChild = m_iPos;
  182. m_iPos = m_aPos[m_iPos].iElemParent;
  183. --m_nLevel;
  184. return true;
  185. }
  186. return false;
  187. }
  189. bool CMarkup::GetOffsets( int& nStart, int& nEnd ) const
  190. {
  191. // Return document offsets of current main position element
  192. // This is not part of EDOM but is used by the Markup project
  193. if ( m_iPos )
  194. {
  195. nStart = m_aPos[m_iPos].nStartL;
  196. nEnd = m_aPos[m_iPos].nEndR;
  197. return true;
  198. }
  199. return false;
  200. }
  202. bool CMarkup::AddElem( LPCTSTR szName, LPCTSTR szValue )
  203. {
  204. // Add an element after current main position
  205. int iPosParent = m_iPos? m_aPos[m_iPos].iElemParent : 0;
  206. m_iPosChild = 0;
  208. // Setting root element?
  209. if ( iPosParent == 0 )
  210. {
  211. if ( IsWellFormed() )
  212. return false;
  214. m_csDoc.Empty();
  215. }
  217. m_iPos = x_Add( iPosParent, m_iPos, szName, szValue );
  218. return true;
  219. }
  221. bool CMarkup::AddChildElem( LPCTSTR szName, LPCTSTR szValue )
  222. {
  223. // Add a child element under main position, after current child position
  224. if ( ! m_iPos )
  225. return false;
  227. // If no child position, add after last sibling
  228. int iPosLast = m_aPos[m_iPos].iElemChild;
  229. if ( ! m_iPosChild && iPosLast )
  230. {
  231. m_iPosChild = iPosLast;
  232. while ( (iPosLast=m_aPos[iPosLast].iElemNext) != 0 )
  233. m_iPosChild = iPosLast;
  234. }
  236. m_iPosChild = x_Add( m_iPos, m_iPosChild, szName, szValue );
  237. return true;
  238. }
  240. bool CMarkup::AddAttrib( LPCTSTR szAttrib, LPCTSTR szValue )
  241. {
  242. // Add attribute to current main position element
  243. if ( m_iPos )
  244. {
  245. x_AddAttrib( m_iPos, szAttrib, szValue );
  246. return true;
  247. }
  248. return false;
  249. }
  251. bool CMarkup::AddChildAttrib( LPCTSTR szAttrib, LPCTSTR szValue )
  252. {
  253. // Add attribute to current child position element
  254. if ( m_iPosChild )
  255. {
  256. x_AddAttrib( m_iPosChild, szAttrib, szValue );
  257. return true;
  258. }
  259. return false;
  260. }
  262. //////////////////////////////////////////////////////////////////////
  263. // Private Methods
  264. //////////////////////////////////////////////////////////////////////
  266. int CMarkup::x_GetFreePos()
  267. {
  268. //
  269. // This returns the index of the next unused ElemPos in the array
  270. //
  271. if ( m_iPosFree == m_aPos.GetSize() )
  272. m_aPos.SetSize( m_iPosFree + m_iPosFree / 2 );
  273. ++m_iPosFree;
  274. return m_iPosFree - 1;
  275. }
  277. int CMarkup::x_ReleasePos()
  278. {
  279. //
  280. // This decrements the index of the next unused ElemPos in the array
  281. // allowing the element index returned by GetFreePos() to be reused
  282. //
  283. --m_iPosFree;
  284. return 0;
  285. }
  287. int CMarkup::x_ParseError( LPCTSTR szError, LPCTSTR szTag )
  288. {
  289. if ( szTag )
  290. m_csError.Format( szError, szTag );
  291. else
  292. m_csError = szError;
  293. x_ReleasePos();
  294. return -1;
  295. }
  297. int CMarkup::x_ParseElem( int iPosParent )
  298. {
  299. // This is either called by SetDoc, x_AddSubDoc, or itself recursively
  300. // m_aPos[iPosParent].nEndL is where to start parsing for the child element
  301. // This returns the new position if a tag is found, otherwise zero
  302. // In all cases we need to get a new ElemPos, but release it if unused
  303. //
  304. int iPos = x_GetFreePos();
  305. m_aPos[iPos].nStartL = m_aPos[iPosParent].nEndL;
  306. m_aPos[iPos].nNext = m_aPos[iPosParent].nStartR + 1;
  307. m_aPos[iPos].iElemParent = iPosParent;
  308. m_aPos[iPos].iElemChild = 0;
  309. m_aPos[iPos].iElemNext = 0;
  311. // Start Tag
  312. // A loop is used to ignore all remarks tags and special tags
  313. // i.e. <?xml version="1.0"?>, and <!-- comment here -->
  314. // So any tag beginning with ? or ! is ignored
  315. // Loop past ignored tags
  316. TokenPos token;
  317. token.nNext = m_aPos[iPosParent].nEndL;
  318. CString csName;
  319. while ( csName.IsEmpty() )
  320. {
  321. // Look for left angle bracket of start tag
  322. m_aPos[iPos].nStartL = token.nNext;
  323. if ( ! x_FindChar( m_aPos[iPos].nStartL, _T('<') ) )
  324. return x_ParseError( _T("Element tag not found") );
  326. // Set parent's End tag to start looking from here (or later)
  327. m_aPos[iPosParent].nEndL = m_aPos[iPos].nStartL;
  329. // Determine whether this is an element, comment or version tag
  330. LPCTSTR szEndOfTag = NULL;
  331. token.nNext = m_aPos[iPos].nStartL + 1;
  332. if ( x_FindToken( token ) )
  333. {
  334. if ( token.bIsString )
  335. return x_ParseError( _T("Tag starts with quote") );
  336. TCHAR cFirstChar = m_csDoc[token.nL];
  337. if ( cFirstChar == _T('?') )
  338. szEndOfTag = _T("?>"); // version
  339. else if ( cFirstChar == _T('!') )
  340. {
  341. TCHAR cSecondChar = 0;
  342. if ( token.nL+1 < m_csDoc.GetLength() )
  343. cSecondChar = m_csDoc[token.nL+1];
  344. if ( cSecondChar == _T('[') )
  345. szEndOfTag = _T("]]>"); // CDATA section
  346. else if ( cSecondChar == _T('-') )
  347. szEndOfTag = _T("-->"); // comment
  348. else
  349. szEndOfTag = _T(">"); // DTD
  350. }
  351. else if ( cFirstChar != _T('/') )
  352. {
  353. csName = x_GetToken( token );
  354. szEndOfTag = _T(">");
  355. }
  356. else
  357. return x_ReleasePos(); // probably end tag of parent
  358. }
  359. else
  360. return x_ParseError( _T("Abrupt end within tag") );
  362. // Look for end of tag
  363. token.nNext = m_csDoc.Find( szEndOfTag, token.nNext );
  364. if ( token.nNext == -1 )
  365. return x_ParseError( _T("End of tag not found") );
  366. }
  367. m_aPos[iPos].nStartR = token.nNext;
  369. // Is ending mark within start tag, i.e. empty element?
  370. if ( m_csDoc[m_aPos[iPos].nStartR-1] == _T('/') )
  371. {
  372. // Empty element
  373. // Close tag left is set to ending mark, and right to open tag right
  374. m_aPos[iPos].nEndL = m_aPos[iPos].nStartR-1;
  375. m_aPos[iPos].nEndR = m_aPos[iPos].nStartR;
  376. }
  377. else // look for end tag
  378. {
  379. // Element probably has contents
  380. // Determine where to start looking for left angle bracket of end tag
  381. // This is done by recursively parsing the contents of this element
  382. int iInner, iInnerPrev = 0;
  383. m_aPos[iPos].nEndL = m_aPos[iPos].nStartR + 1;
  384. while ( (iInner = x_ParseElem( iPos )) > 0 )
  385. {
  386. // Set links to iInner
  387. if ( iInnerPrev )
  388. m_aPos[iInnerPrev].iElemNext = iInner;
  389. else
  390. m_aPos[iPos].iElemChild = iInner;
  391. iInnerPrev = iInner;
  393. // Set offset to reflect child
  394. m_aPos[iPos].nEndL = m_aPos[iInner].nEndR + 1;
  395. }
  396. if ( iInner == -1 )
  397. return -1;
  399. // Look for left angle bracket of end tag
  400. if ( ! x_FindChar( m_aPos[iPos].nEndL, _T('<') ) )
  401. return x_ParseError( _T("End tag of %s element not found"), csName );
  403. // Look through tokens of end tag
  404. token.nNext = m_aPos[iPos].nEndL + 1;
  405. int nTokenCount = 0;
  406. while ( x_FindToken( token ) )
  407. {
  408. ++nTokenCount;
  409. if ( ! token.bIsString )
  410. {
  411. // Is first token not an end slash mark?
  412. if ( nTokenCount == 1 && m_csDoc[token.nL] != _T('/') )
  413. return x_ParseError( _T("Expecting end tag of element %s"), csName );
  415. else if ( nTokenCount == 2 && csName != x_GetToken( token ) )
  416. return x_ParseError( _T("End tag does not correspond to %s"), csName );
  418. // Else is it a right angle bracket?
  419. else if ( m_csDoc[token.nL] == _T('>') )
  420. break;
  421. }
  422. }
  424. // Was a right angle bracket not found?
  425. if ( ! token.IsValid() || nTokenCount < 2 )
  426. return x_ParseError( _T("End tag not completed for element %s"), csName );
  427. m_aPos[iPos].nEndR = token.nL;
  428. }
  430. // Successfully found positions of angle brackets
  431. m_aPos[iPos].nNext = m_aPos[iPos].nEndR;
  432. x_FindChar( m_aPos[iPos].nNext, _T('<') );
  433. return iPos;
  434. }
  436. bool CMarkup::x_FindChar( int&n, _TCHAR c ) const
  437. {
  438. // Look for char c starting at n, and set n to point to it
  439. // c is always the first char of a multi-byte char
  440. // Return false if not found before end of document
  441. LPCTSTR szDoc = (LPCTSTR)m_csDoc;
  442. while ( szDoc[n] && szDoc[n] != c )
  443. n += _tclen( &szDoc[n] );
  444. if ( ! szDoc[n] )
  445. return false;
  446. return true;
  447. }
  449. bool CMarkup::x_FindToken( CMarkup::TokenPos& token ) const
  450. {
  451. // Starting at token.nNext, find the next token
  452. // upon successful return, token.nNext points after the retrieved token
  453. LPCTSTR szDoc = (LPCTSTR)m_csDoc;
  454. int n = token.nNext;
  456. // Statically defined CStrings for whitespace and special chars
  457. static CString csWhitespace = _T(" tnr");
  458. static CString csSpecial = _T("<>=\/?!");
  460. // By-pass leading whitespace
  461. while ( szDoc[n] && csWhitespace.Find(szDoc[n]) > -1 )
  462. ++n;
  464. // Are we still within the document?
  465. token.bIsString = false;
  466. if ( szDoc[n] )
  467. {
  468. // Is it an opening quote?
  469. if ( szDoc[n] == _T('"') )
  470. {
  471. // Move past opening quote
  472. ++n;
  473. token.nL = n;
  475. // Look for closing quote
  476. x_FindChar( n, _T('"') );
  478. // Set right to before closing quote
  479. token.nR = n-1;
  481. // Set n past closing quote unless at end of document
  482. if ( szDoc[n] )
  483. ++n;
  485. // Set flag
  486. token.bIsString = true;
  487. }
  488. else
  489. {
  490. // Go until special char or whitespace
  491. token.nL = n;
  492. while ( szDoc[n] &&
  493. csSpecial.Find(m_csDoc[n]) == -1 &&
  494. csWhitespace.Find(m_csDoc[n]) == -1
  495. )
  496. n += _tclen(&szDoc[n]);
  498. // Adjust end position if it is one special char
  499. if ( n == token.nL )
  500. ++n; // it is a special char
  501. token.nR = n-1;
  502. }
  503. }
  505. token.nNext = n;
  506. if ( ! szDoc[n] )
  507. return false;
  509. // nNext points to one past last char of token
  510. return true;
  511. }
  513. CString CMarkup::x_GetToken( const CMarkup::TokenPos& token ) const
  514. {
  515. // The token contains indexes into the document identifying a small substring
  516. // Build the substring from those indexes and return it
  517. if ( ! token.IsValid() )
  518. return _T("");
  519. return m_csDoc.Mid( token.nL,
  520. token.nR - token.nL + ((token.nR<m_csDoc.GetLength())? 1:0) );
  521. }
  523. CString CMarkup::x_GetTagName( int iPos ) const
  524. {
  525. // Return the tag name at specified element
  526. TokenPos token;
  527. token.nNext = m_aPos[iPos].nStartL + 1;
  528. if ( ! iPos || ! x_FindToken( token ) )
  529. return _T("");
  531. // Return substring of document
  532. return x_GetToken( token );
  533. }
  535. bool CMarkup::x_FindAttrib( CMarkup::TokenPos& token, LPCTSTR szAttrib ) const
  536. {
  537. // If szAttrib is NULL find next attrib, otherwise find named attrib
  538. // Return true if found
  539. int nAttrib = 0;
  540. for ( int nCount = 0; x_FindToken(token); ++nCount )
  541. {
  542. if ( ! token.bIsString )
  543. {
  544. // Is it the right angle bracket?
  545. if ( m_csDoc[token.nL] == _T('>') || m_csDoc[token.nL] == _T('/') )
  546. break; // attrib not found
  548. // Equal sign
  549. if ( m_csDoc[token.nL] == _T('=') )
  550. continue;
  552. // Potential attribute
  553. if ( ! nAttrib && nCount )
  554. {
  555. // Attribute name search?
  556. if ( ! szAttrib || ! szAttrib[0] )
  557. return true; // return with token at attrib name
  559. // Compare szAttrib
  560. if ( x_GetToken(token) == szAttrib )
  561. nAttrib = nCount;
  562. }
  563. }
  564. else if ( nAttrib && nCount == nAttrib + 2 )
  565. {
  566. return true;
  567. }
  568. }
  570. // Not found
  571. return false;
  572. }
  574. CString CMarkup::x_GetAttrib( int iPos, LPCTSTR szAttrib ) const
  575. {
  576. // Return the value of the attrib at specified element
  577. TokenPos token;
  578. token.nNext = m_aPos[iPos].nStartL + 1;
  579. if ( szAttrib && x_FindAttrib( token, szAttrib ) )
  580. return x_TextFromDoc( token.nL, token.nR - ((token.nR<m_csDoc.GetLength())?0:1) );
  581. return _T("");
  582. }
  584. CString CMarkup::x_GetData( int iPos ) const
  585. {
  586. // Return a string representing data between start and end tag
  587. // Return empty string if there are any children elements
  588. if ( ! m_aPos[iPos].iElemChild && ! m_aPos[iPos].IsEmptyElement() )
  589. {
  590. // See if it is a CDATA section
  591. TokenPos token;
  592. token.nNext = m_aPos[iPos].nStartR+1;
  593. if ( x_FindToken( token ) && m_csDoc[token.nL] == _T('<')
  594. && token.nL + 11 < m_aPos[iPos].nEndL
  595. && _tcsncmp( &((LPCTSTR)m_csDoc)[token.nL+1], _T("![CDATA["), 8 ) == 0 )
  596. {
  597. int nEndCDATA = m_csDoc.Find( _T("]]>"), token.nNext );
  598. if ( nEndCDATA != -1 && nEndCDATA < m_aPos[iPos].nEndL )
  599. {
  600. return m_csDoc.Mid( token.nL+9, nEndCDATA-token.nL-9 );
  601. }
  602. }
  603. return x_TextFromDoc( m_aPos[iPos].nStartR+1, m_aPos[iPos].nEndL-1 );
  604. }
  605. return "";
  606. }
  608. CString CMarkup::x_TextToDoc( LPCTSTR szText, bool bAttrib ) const
  609. {
  610. // Convert text as seen outside XML document to XML friendly
  611. // replacing special characters with ampersand escape codes
  612. // E.g. convert "6>7" to "6&gt;7"
  613. //
  614. // &lt;   less than
  615. // &amp;  ampersand
  616. // &gt;   greater than
  617. //
  618. // and for attributes:
  619. //
  620. // &apos; apostrophe or single quote
  621. // &quot; double quote
  622. //
  623. static _TCHAR* szaReplace[] = { _T("&lt;"),_T("&amp;"),_T("&gt;"),_T("&apos;"),_T("&quot;") };
  624. const _TCHAR* pFind = bAttrib?_T("<&>'""):_T("<&>");
  625. CString csText;
  626. const _TCHAR* pSource = szText;
  627. int nDestSize = _tcslen(pSource);
  628. nDestSize += nDestSize / 10 + 7;
  629. _TCHAR* pDest = csText.GetBuffer(nDestSize);
  630. int nLen = 0;
  631. _TCHAR cSource = *pSource;
  632. _TCHAR* pFound;
  633. while ( cSource )
  634. {
  635. if ( nLen > nDestSize - 6 )
  636. {
  637. csText.ReleaseBuffer(nLen);
  638. nDestSize *= 2;
  639. pDest = csText.GetBuffer(nDestSize);
  640. }
  641. if ( (pFound=_tcschr(pFind,cSource)) != NULL )
  642. {
  643. pFound = szaReplace[pFound-pFind];
  644. _tcscpy(&pDest[nLen],pFound);
  645. nLen += _tcslen(pFound);
  646. }
  647. else
  648. {
  649. _tccpy( &pDest[nLen], pSource );
  650. ++nLen;
  651. }
  652. pSource += _tclen( pSource );
  653. cSource = *pSource;
  654. }
  655. csText.ReleaseBuffer(nLen);
  656. return csText;
  657. }
  659. CString CMarkup::x_TextFromDoc( int nLeft, int nRight ) const
  660. {
  661. // Convert XML friendly text to text as seen outside XML document
  662. // replacing ampersand escape codes with special characters
  663. // E.g. convert "6&gt;7" to "6>7"
  664. //
  665. // Conveniently the result is always the same or shorter in length
  666. //
  667. static _TCHAR* szaCode[] = { _T("lt;"),_T("amp;"),_T("gt;"),_T("apos;"),_T("quot;") };
  668. static int anCodeLen[] = { 3,4,3,5,5 };
  669. static _TCHAR* szSymbol = _T("<&>'"");
  670. CString csText;
  671. const _TCHAR* pSource = m_csDoc;
  672. int nDestSize = nRight - nLeft + 1;
  673. _TCHAR* pDest = csText.GetBuffer(nDestSize);
  674. int nLen = 0;
  675. int nCharLen;
  676. int nChar = nLeft;
  677. while ( nChar <= nRight )
  678. {
  679. if ( pSource[nChar] == _T('&') )
  680. {
  681. // Look for matching &code;
  682. for ( int nMatch = 0; nMatch < 5; ++nMatch )
  683. {
  684. if ( nChar <= nRight - anCodeLen[nMatch]
  685. && _tcsncmp(szaCode[nMatch],&pSource[nChar+1],anCodeLen[nMatch]) == 0 )
  686. {
  687. pDest[nLen++] = szSymbol[nMatch];
  688. nChar += anCodeLen[nMatch] + 1;
  689. break;
  690. }
  691. }
  693. // If no match is found it means XML doc is invalid
  694. // no devastating harm done, ampersand code will just be left in result
  695. if ( nMatch == 5 )
  696. {
  697. pDest[nLen++] = _T('&');
  698. ++nChar;
  699. }
  700. }
  701. else
  702. {
  703. nCharLen = _tclen(&pSource[nChar]);
  704. _tccpy( &pDest[nLen], &pSource[nChar] );
  705. nLen += nCharLen;
  706. nChar += nCharLen;
  707. }
  708. }
  709. csText.ReleaseBuffer(nLen);
  710. return csText;
  711. }
  713. void CMarkup::x_DocChange( int nLeft, int nReplace, const CString& csInsert )
  714. {
  715. // Insert csInsert int m_csDoc at nLeft replacing nReplace chars
  716. // Do this with only one buffer reallocation if it grows
  717. //
  718. int nDocLength = m_csDoc.GetLength();
  719. int nInsLength = csInsert.GetLength();
  721. // Make sure nLeft and nReplace are within bounds
  722. nLeft = max( 0, min( nLeft, nDocLength ) );
  723. nReplace = max( 0, min( nReplace, nDocLength-nLeft ) );
  725. // Get pointer to buffer with enough room
  726. int nNewLength = nInsLength + nDocLength - nReplace;
  727. int nBufferLen = nNewLength;
  728. _TCHAR* pDoc = m_csDoc.GetBuffer( nBufferLen );
  730. // Move part of old doc that goes after insert
  731. if ( nLeft+nReplace < nDocLength )
  732. memmove( &pDoc[nLeft+nInsLength], &pDoc[nLeft+nReplace], (nDocLength-nLeft-nReplace)*sizeof(_TCHAR) );
  734. // Copy insert
  735. memcpy( &pDoc[nLeft], csInsert, nInsLength*sizeof(_TCHAR) );
  737. // Release
  738. m_csDoc.ReleaseBuffer( nNewLength );
  739. }
  741. void CMarkup::x_Adjust( int iPos, int nShift )
  742. {
  743. // Loop through affected elements and adjust indexes
  744. // Does not affect iPos itself
  745. // Algorithm:
  746. // 1. update next siblings and all their children
  747. // 2. then go up a level update end points and to step 1
  748. int iPosTop = m_aPos[iPos].iElemParent;
  749. while ( iPos )
  750. {
  751. // Were we at containing parent of affected position?
  752. bool bPosTop = false;
  753. if ( iPos == iPosTop )
  754. {
  755. // Move iPosTop up one towards root
  756. iPosTop = m_aPos[iPos].iElemParent;
  757. bPosTop = true;
  758. }
  760. // Traverse to the next update position
  761. if ( ! bPosTop && m_aPos[iPos].iElemChild )
  762. {
  763. // Depth first
  764. iPos = m_aPos[iPos].iElemChild;
  765. }
  766. else if ( m_aPos[iPos].iElemNext )
  767. {
  768. iPos = m_aPos[iPos].iElemNext;
  769. }
  770. else
  771. {
  772. // Look for next sibling of a parent of iPos
  773. // When going back up, parents have already been done except iPosTop
  774. while ( (iPos=m_aPos[iPos].iElemParent) != 0 && iPos != iPosTop )
  775. if ( m_aPos[iPos].iElemNext )
  776. {
  777. iPos = m_aPos[iPos].iElemNext;
  778. break;
  779. }
  780. }
  782. // Shift indexes at iPos
  783. if ( iPos != iPosTop )
  784. {
  785. // Move the start tag indexes
  786. // Don't do this for containing parent tag
  787. m_aPos[iPos].nStartL += nShift;
  788. m_aPos[iPos].nStartR += nShift;
  789. }
  790. // Move end tag indexes
  791. m_aPos[iPos].nEndL += nShift;
  792. m_aPos[iPos].nEndR += nShift;
  793. m_aPos[iPos].nNext += nShift;
  794. }
  795. }
  797. int CMarkup::x_Add( int iPosParent, int iPosBefore, LPCTSTR szName, LPCTSTR szValue )
  798. {
  799. // Create element and modify positions of affected elements
  800. // if iPosBefore is NULL, insert as first element under parent
  801. // If no szValue is specified, an empty element is created
  802. // i.e. either <NAME>value</NAME> or <NAME/>
  803. //
  804. int iPos = x_GetFreePos();
  805. bool bEmptyParent = false;
  806. if ( iPosBefore )
  807. {
  808. // Follow iPosBefore
  809. m_aPos[iPos].nStartL = m_aPos[iPosBefore].nNext;
  810. }
  811. else if ( m_aPos[iPosParent].iElemChild )
  812. {
  813. // Insert before first child of parent
  814. m_aPos[iPos].nStartL = m_aPos[m_aPos[iPosParent].iElemChild].nStartL;
  815. }
  816. else if ( m_aPos[iPosParent].IsEmptyElement() )
  817. {
  818. // Parent has no separate end tag
  819. m_aPos[iPos].nStartL = m_aPos[iPosParent].nStartR + 2;
  820. bEmptyParent = true;
  821. }
  822. else
  823. {
  824. // Parent has content, but no children
  825. m_aPos[iPos].nStartL = m_aPos[iPosParent].nEndL;
  826. }
  828. // Set links
  829. m_aPos[iPos].iElemParent = iPosParent;
  830. m_aPos[iPos].iElemChild = 0;
  831. if ( iPosBefore )
  832. {
  833. m_aPos[iPos].iElemNext = m_aPos[iPosBefore].iElemNext;
  834. m_aPos[iPosBefore].iElemNext = iPos;
  835. }
  836. else
  837. {
  838. m_aPos[iPos].iElemNext = m_aPos[iPosParent].iElemChild;
  839. m_aPos[iPosParent].iElemChild = iPos;
  840. }
  842. // Create string for insert
  843. CString csInsert;
  844. int nLenName = _tcslen(szName);
  845. int nLenValue = szValue? _tcslen(szValue) : 0;
  846. if ( ! nLenValue )
  847. {
  848. // <NAME/> empty element
  849. csInsert.Format( _T("<%s/>rn"), szName );
  850. m_aPos[iPos].nStartR = m_aPos[iPos].nStartL + nLenName + 2;
  851. m_aPos[iPos].nEndL = m_aPos[iPos].nStartR - 1;
  852. m_aPos[iPos].nEndR = m_aPos[iPos].nEndL + 1;
  853. m_aPos[iPos].nNext = m_aPos[iPos].nEndR + 3;
  854. }
  855. else
  856. {
  857. // <NAME>value</NAME>
  858. CString csValue = x_TextToDoc( szValue );
  859. nLenValue = csValue.GetLength();
  860. csInsert.Format( _T("<%s>%s</%s>rn"), szName, csValue, szName );
  861. m_aPos[iPos].nStartR = m_aPos[iPos].nStartL + nLenName + 1;
  862. m_aPos[iPos].nEndL = m_aPos[iPos].nStartR + nLenValue + 1;
  863. m_aPos[iPos].nEndR = m_aPos[iPos].nEndL + nLenName + 2;
  864. m_aPos[iPos].nNext = m_aPos[iPos].nEndR + 3;
  865. }
  867. // Insert
  868. int nReplace = 0, nLeft = m_aPos[iPos].nStartL;
  869. if ( bEmptyParent )
  870. {
  871. CString csParentTagName = x_GetTagName(iPosParent);
  872. csInsert = _T(">rn") + csInsert + _T("</") + csParentTagName;
  873. nLeft -= 3;
  874. nReplace = 1;
  875. // x_Adjust is going to update all affected indexes by one amount
  876. // This will satisfy all except the empty parent
  877. // Here we pre-adjust for the empty parent
  878. // The empty tag slash is removed
  879. m_aPos[iPosParent].nStartR -= 1;
  880. // For the newly created end tag, see the following example:
  881. // <A/> (len 4) becomes <A><B/></A> (len 11)
  882. // In x_Adjust everything will be adjusted 11 - 4 = 7
  883. // But the nEndL of element A should only be adjusted 5
  884. m_aPos[iPosParent].nEndL -= (csParentTagName.GetLength() + 1);
  885. }
  886. x_DocChange( nLeft, nReplace, csInsert );
  887. x_Adjust( iPos, csInsert.GetLength() - nReplace );
  889. // Return the index of the new element
  890. return iPos;
  891. }
  893. int CMarkup::x_AddAttrib( int iPos, LPCTSTR szAttrib, LPCTSTR szValue )
  894. {
  895. // Add attribute to iPos element
  896. CString csInsert;
  897. if ( iPos )
  898. {
  899. // Insert string taking into account whether it is a single tag
  900. CString csValue = x_TextToDoc( szValue, true );
  901. csInsert.Format( _T(" %s="%s""), szAttrib, csValue );
  902. int nL = m_aPos[iPos].nStartR - (m_aPos[iPos].IsEmptyElement()?1:0);
  903. x_DocChange( nL, 0, csInsert );
  905. int nLen = csInsert.GetLength();
  906. m_aPos[iPos].nStartR += nLen;
  907. m_aPos[iPos].nEndL += nLen;
  908. m_aPos[iPos].nEndR += nLen;
  909. m_aPos[iPos].nNext += nLen;
  910. x_Adjust( iPos, nLen );
  911. }
  912. return csInsert.GetLength();
  913. }