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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > GIS编程 > 查看源码
Markup.cpp
资源名称：北京市公交车查询系统VC源码.zip　[点击查看]
上传用户：yokoluohf
上传日期：2013-02-25
资源大小：769k
文件大小：37k
源码类别：

GIS编程

开发平台：

Visual C++

Markup.cpp：源码内容
  1. // Markup.cpp: implementation of the CMarkup class.
  2. //
  3. // Markup Release 6.3
  4. // Copyright (C) 1999-2002 First Objective Software, Inc. All rights reserved
  5. // Go to www.firstobject.com for the latest CMarkup and EDOM documentation
  6. // Use in commercial applications requires written permission
  7. // This software is provided "as is", with no warranty.
  9. #include "stdafx.h"
  10. #include "afxconv.h"
  11. #include "Markup.h"
  13. #ifdef _DEBUG
  14. #undef THIS_FILE
  15. static char THIS_FILE[]=__FILE__;
  16. #define new DEBUG_NEW
  17. #endif
  19. #ifdef _MBCS
  20. #pragma message( "Note: MBCS build (not UTF-8)" )
  21. // For UTF-8, remove _MBCS from project settings C/C++ preprocessor definitions
  22. #endif
  24. // Defines for Windows CE
  25. #ifndef _tclen
  26. #define _tclen(p) 1
  27. #define _tccpy(p1,p2) *(p1)=*(p2)
  28. #endif
  31. void CMarkup::operator=( const CMarkup& markup )
  32. {
  33. m_iPosParent = markup.m_iPosParent;
  34. m_iPos = markup.m_iPos;
  35. m_iPosChild = markup.m_iPosChild;
  36. m_iPosFree = markup.m_iPosFree;
  37. m_nNodeType = markup.m_nNodeType;
  38. m_aPos.RemoveAll();
  39. m_aPos.Append( markup.m_aPos );
  40. m_csDoc = markup.m_csDoc;
  41. MARKUP_SETDEBUGSTATE;
  42. }
  44. bool CMarkup::SetDoc( LPCTSTR szDoc )
  45. {
  46. // Reset indexes
  47. m_iPosFree = 1;
  48. ResetPos();
  49. m_mapSavedPos.RemoveAll();
  51. // Set document text
  52. if ( szDoc )
  53. m_csDoc = szDoc;
  54. else
  55. m_csDoc.Empty();
  57. // Starting size of position array: 1 element per 64 bytes of document
  58. // Tight fit when parsing small doc, only 0 to 2 reallocs when parsing large doc
  59. // Start at 8 when creating new document
  60. int nStartSize = m_csDoc.GetLength() / 64 + 8;
  61. if ( m_aPos.GetSize() < nStartSize )
  62. m_aPos.SetSize( nStartSize );
  64. // Parse document
  65. bool bWellFormed = false;
  66. if ( m_csDoc.GetLength() )
  67. {
  68. m_aPos[0].Clear();
  69. int iPos = x_ParseElem( 0 );
  70. if ( iPos > 0 )
  71. {
  72. m_aPos[0].iElemChild = iPos;
  73. bWellFormed = true;
  74. }
  75. }
  77. // Clear indexes if parse failed or empty document
  78. if ( ! bWellFormed )
  79. {
  80. m_aPos[0].Clear();
  81. m_iPosFree = 1;
  82. }
  84. ResetPos();
  85. return bWellFormed;
  86. };
  88. bool CMarkup::IsWellFormed()
  89. {
  90. if ( m_aPos.GetSize() && m_aPos[0].iElemChild )
  91. return true;
  92. return false;
  93. }
  95. bool CMarkup::Load( LPCTSTR szFileName )
  96. {
  97. CString csDoc;
  98. CFile file;
  99. if ( ! file.Open(szFileName,CFile::modeRead) )
  100. return false;
  101. int nLength = file.GetLength();
  103. #if defined(_UNICODE)
  104. // Allocate Buffer for UTF-8 file data
  105. unsigned char* pBuffer = new unsigned char[nLength + 1];
  106. nLength = file.Read( pBuffer, nLength );
  107. pBuffer[nLength] = '';
  109. // Convert file from UTF-8 to Windows UNICODE (AKA UCS-2)
  110. int nWideLength = MultiByteToWideChar(CP_UTF8,0,(const char*)pBuffer,nLength,NULL,0);
  111. nLength = MultiByteToWideChar(CP_UTF8,0,(const char*)pBuffer,nLength,
  112. csDoc.GetBuffer(nWideLength),nWideLength);
  113. ASSERT( nLength == nWideLength );
  114. delete [] pBuffer;
  115. #else
  116. nLength = file.Read( csDoc.GetBuffer(nLength), nLength );
  117. #endif
  118. csDoc.ReleaseBuffer(nLength);
  119. file.Close();
  121. return SetDoc( csDoc );
  122. }
  124. bool CMarkup::Save( LPCTSTR szFileName )
  125. {
  126. int nLength = m_csDoc.GetLength();
  127. CFile file;
  128. if ( ! file.Open(szFileName,CFile::modeWrite|CFile::modeCreate) )
  129. return false;
  130. #if defined( _UNICODE )
  131. int nUTF8Len = WideCharToMultiByte(CP_UTF8,0,m_csDoc,nLength,NULL,0,NULL,NULL);
  132. char* pBuffer = new char[nUTF8Len+1];
  133. nLength = WideCharToMultiByte(CP_UTF8,0,m_csDoc,nLength,pBuffer,nUTF8Len+1,NULL,NULL);
  134. file.Write( pBuffer, nLength );
  135. delete pBuffer;
  136. #else
  137. file.Write( (LPCTSTR)m_csDoc, nLength );
  138. #endif
  139. file.Close();
  140. return true;
  141. }
  143. bool CMarkup::FindElem( LPCTSTR szName )
  144. {
  145. // Change current position only if found
  146. //
  147. if ( m_aPos.GetSize() )
  148. {
  149. int iPos = x_FindElem( m_iPosParent, m_iPos, szName );
  150. if ( iPos )
  151. {
  152. // Assign new position
  153. x_SetPos( m_aPos[iPos].iElemParent, iPos, 0 );
  154. return true;
  155. }
  156. }
  157. return false;
  158. }
  160. bool CMarkup::FindChildElem( LPCTSTR szName )
  161. {
  162. // Change current child position only if found
  163. //
  164. // Shorthand: call this with no current main position
  165. // means find child under root element
  166. if ( ! m_iPos )
  167. FindElem();
  169. int iPosChild = x_FindElem( m_iPos, m_iPosChild, szName );
  170. if ( iPosChild )
  171. {
  172. // Assign new position
  173. int iPos = m_aPos[iPosChild].iElemParent;
  174. x_SetPos( m_aPos[iPos].iElemParent, iPos, iPosChild );
  175. return true;
  176. }
  178. return false;
  179. }
  181. CString CMarkup::GetTagName() const
  182. {
  183. // Return the tag name at the current main position
  184. CString csTagName;
  186. if ( m_iPos )
  187. csTagName = x_GetTagName( m_iPos );
  188. return csTagName;
  189. }
  191. bool CMarkup::IntoElem()
  192. {
  193. // If there is no child position and IntoElem is called it will succeed in release 6.3
  194. // (A subsequent call to FindElem will find the first element)
  195. // The following short-hand behavior was never part of EDOM and was misleading
  196. // It would find a child element if there was no current child element position and go into it
  197. // It is removed in release 6.3, this change is NOT backwards compatible!
  198. // if ( ! m_iPosChild )
  199. // FindChildElem();
  201. if ( m_iPos && m_nNodeType == MNT_ELEMENT )
  202. {
  203. x_SetPos( m_iPos, m_iPosChild, 0 );
  204. return true;
  205. }
  206. return false;
  207. }
  209. bool CMarkup::OutOfElem()
  210. {
  211. // Go to parent element
  212. if ( m_iPosParent )
  213. {
  214. x_SetPos( m_aPos[m_iPosParent].iElemParent, m_iPosParent, m_iPos );
  215. return true;
  216. }
  217. return false;
  218. }
  220. CString CMarkup::GetAttrName( int n ) const
  221. {
  222. // Return nth Attrute name of main position
  223. if ( ! m_iPos || m_nNodeType != MNT_ELEMENT )
  224. return _T("");
  226. TokenPos token( m_csDoc );
  227. token.nNext = m_aPos[m_iPos].nStartL + 1;
  228. for ( int nAttr=0; nAttr<=n; ++nAttr )
  229. if ( ! x_FindAttr(token) )
  230. return _T("");
  232. // Return substring of document
  233. return x_GetToken( token );
  234. }
  236. bool CMarkup::SavePos( LPCTSTR szPosName )
  237. {
  238. // Save current element position in saved position map
  239. if ( szPosName )
  240. {
  241. SavedPos savedpos;
  242. savedpos.iPosParent = m_iPosParent;
  243. savedpos.iPos = m_iPos;
  244. savedpos.iPosChild = m_iPosChild;
  245. m_mapSavedPos.SetAt( szPosName, savedpos );
  246. return true;
  247. }
  248. return false;
  249. }
  251. bool CMarkup::RestorePos( LPCTSTR szPosName )
  252. {
  253. // Restore element position if found in saved position map
  254. SavedPos savedpos;
  255. if ( szPosName && m_mapSavedPos.Lookup( szPosName, savedpos ) )
  256. {
  257. x_SetPos( savedpos.iPosParent, savedpos.iPos, savedpos.iPosChild );
  258. return true;
  259. }
  260. return false;
  261. }
  263. bool CMarkup::GetOffsets( int& nStart, int& nEnd ) const
  264. {
  265. // Return document offsets of current main position element
  266. // This is not part of EDOM but is used by the Markup project
  267. if ( m_iPos )
  268. {
  269. nStart = m_aPos[m_iPos].nStartL;
  270. nEnd = m_aPos[m_iPos].nEndR;
  271. return true;
  272. }
  273. return false;
  274. }
  276. CString CMarkup::GetChildSubDoc() const
  277. {
  278. if ( m_iPosChild )
  279. {
  280. int nL = m_aPos[m_iPosChild].nStartL;
  281. int nR = m_aPos[m_iPosChild].nEndR + 1;
  282. TokenPos token( m_csDoc );
  283. token.nNext = nR;
  284. if ( ! x_FindToken(token) || m_csDoc[token.nL] == _T('<') )
  285. nR = token.nL;
  286. return m_csDoc.Mid( nL, nR - nL );
  287. }
  288. return _T("");
  289. }
  291. bool CMarkup::RemoveElem()
  292. {
  293. // Remove current main position element
  294. if ( m_iPos && m_nNodeType == MNT_ELEMENT )
  295. {
  296. int iPos = x_RemoveElem( m_iPos );
  297. x_SetPos( m_iPosParent, iPos, 0 );
  298. return true;
  299. }
  300. return false;
  301. }
  303. bool CMarkup::RemoveChildElem()
  304. {
  305. // Remove current child position element
  306. if ( m_iPosChild )
  307. {
  308. int iPosChild = x_RemoveElem( m_iPosChild );
  309. x_SetPos( m_iPosParent, m_iPos, iPosChild );
  310. return true;
  311. }
  312. return false;
  313. }
  315. //////////////////////////////////////////////////////////////////////
  316. // Private Methods
  317. //////////////////////////////////////////////////////////////////////
  319. int CMarkup::x_GetFreePos()
  320. {
  321. //
  322. // This returns the index of the next unused ElemPos in the array
  323. //
  324. if ( m_iPosFree == m_aPos.GetSize() )
  325. m_aPos.SetSize( m_iPosFree + m_iPosFree / 2 );
  326. ++m_iPosFree;
  327. return m_iPosFree - 1;
  328. }
  330. int CMarkup::x_ReleasePos()
  331. {
  332. //
  333. // This decrements the index of the next unused ElemPos in the array
  334. // allowing the element index returned by GetFreePos() to be reused
  335. //
  336. --m_iPosFree;
  337. return 0;
  338. }
  340. int CMarkup::x_ParseError( LPCTSTR szError, LPCTSTR szName )
  341. {
  342. if ( szName )
  343. m_csError.Format( szError, szName );
  344. else
  345. m_csError = szError;
  346. x_ReleasePos();
  347. return -1;
  348. }
  350. int CMarkup::x_ParseElem( int iPosParent )
  351. {
  352. // This is either called by SetDoc, x_AddSubDoc, or itself recursively
  353. // m_aPos[iPosParent].nEndL is where to start parsing for the child element
  354. // This returns the new position if a tag is found, otherwise zero
  355. // In all cases we need to get a new ElemPos, but release it if unused
  356. //
  357. int iPos = x_GetFreePos();
  358. m_aPos[iPos].nStartL = m_aPos[iPosParent].nEndL;
  359. m_aPos[iPos].iElemParent = iPosParent;
  360. m_aPos[iPos].iElemChild = 0;
  361. m_aPos[iPos].iElemNext = 0;
  363. // Start Tag
  364. // A loop is used to ignore all remarks tags and special tags
  365. // i.e. <?xml version="1.0"?>, and <!-- comment here -->
  366. // So any tag beginning with ? or ! is ignored
  367. // Loop past ignored tags
  368. TokenPos token( m_csDoc );
  369. token.nNext = m_aPos[iPosParent].nEndL;
  370. CString csName;
  371. while ( csName.IsEmpty() )
  372. {
  373. // Look for left angle bracket of start tag
  374. m_aPos[iPos].nStartL = token.nNext;
  375. if ( ! x_FindChar( token.szDoc, m_aPos[iPos].nStartL, _T('<') ) )
  376. return x_ParseError( _T("Element tag not found") );
  378. // Set parent's End tag to start looking from here (or later)
  379. m_aPos[iPosParent].nEndL = m_aPos[iPos].nStartL;
  381. // Determine whether this is an element, or bypass other type of node
  382. token.nNext = m_aPos[iPos].nStartL + 1;
  383. if ( x_FindToken( token ) )
  384. {
  385. if ( token.bIsString )
  386. return x_ParseError( _T("Tag starts with quote") );
  387. _TCHAR cFirstChar = m_csDoc[token.nL];
  388. if ( cFirstChar == _T('?') || cFirstChar == _T('!') )
  389. {
  390. token.nNext = m_aPos[iPos].nStartL;
  391. if ( ! x_ParseNode(token) )
  392. return x_ParseError( _T("Invalid node") );
  393. }
  394. else if ( cFirstChar != _T('/') )
  395. {
  396. csName = x_GetToken( token );
  397. // Look for end of tag
  398. if ( ! x_FindChar(token.szDoc, token.nNext, _T('>')) )
  399. return x_ParseError( _T("End of tag not found") );
  400. }
  401. else
  402. return x_ReleasePos(); // probably end tag of parent
  403. }
  404. else
  405. return x_ParseError( _T("Abrupt end within tag") );
  406. }
  407. m_aPos[iPos].nStartR = token.nNext;
  409. // Is ending mark within start tag, i.e. empty element?
  410. if ( m_csDoc[m_aPos[iPos].nStartR-1] == _T('/') )
  411. {
  412. // Empty element
  413. // Close tag left is set to ending mark, and right to open tag right
  414. m_aPos[iPos].nEndL = m_aPos[iPos].nStartR-1;
  415. m_aPos[iPos].nEndR = m_aPos[iPos].nStartR;
  416. }
  417. else // look for end tag
  418. {
  419. // Element probably has contents
  420. // Determine where to start looking for left angle bracket of end tag
  421. // This is done by recursively parsing the contents of this element
  422. int iInner, iInnerPrev = 0;
  423. m_aPos[iPos].nEndL = m_aPos[iPos].nStartR + 1;
  424. while ( (iInner = x_ParseElem( iPos )) > 0 )
  425. {
  426. // Set links to iInner
  427. if ( iInnerPrev )
  428. m_aPos[iInnerPrev].iElemNext = iInner;
  429. else
  430. m_aPos[iPos].iElemChild = iInner;
  431. iInnerPrev = iInner;
  433. // Set offset to reflect child
  434. m_aPos[iPos].nEndL = m_aPos[iInner].nEndR + 1;
  435. }
  436. if ( iInner == -1 )
  437. return -1;
  439. // Look for left angle bracket of end tag
  440. if ( ! x_FindChar( token.szDoc, m_aPos[iPos].nEndL, _T('<') ) )
  441. return x_ParseError( _T("End tag of %s element not found"), csName );
  443. // Look through tokens of end tag
  444. token.nNext = m_aPos[iPos].nEndL + 1;
  445. int nTokenCount = 0;
  446. while ( x_FindToken( token ) )
  447. {
  448. ++nTokenCount;
  449. if ( ! token.bIsString )
  450. {
  451. // Is first token not an end slash mark?
  452. if ( nTokenCount == 1 && m_csDoc[token.nL] != _T('/') )
  453. return x_ParseError( _T("Expecting end tag of element %s"), csName );
  455. else if ( nTokenCount == 2 && ! token.Match(csName) )
  456. return x_ParseError( _T("End tag does not correspond to %s"), csName );
  458. // Else is it a right angle bracket?
  459. else if ( m_csDoc[token.nL] == _T('>') )
  460. break;
  461. }
  462. }
  464. // Was a right angle bracket not found?
  465. if ( ! token.szDoc[token.nL] || nTokenCount < 2 )
  466. return x_ParseError( _T("End tag not completed for element %s"), csName );
  467. m_aPos[iPos].nEndR = token.nL;
  468. }
  470. // Successfully parsed element (and contained elements)
  471. return iPos;
  472. }
  474. bool CMarkup::x_FindChar( LPCTSTR szDoc, int& nChar, _TCHAR c )
  475. {
  476. // static function
  477. LPCTSTR pChar = &szDoc[nChar];
  478. while ( *pChar && *pChar != c )
  479. pChar += _tclen( pChar );
  480. nChar = pChar - szDoc;
  481. if ( ! *pChar )
  482. return false;
  483. /*
  484. while ( szDoc[nChar] && szDoc[nChar] != c )
  485. nChar += _tclen( &szDoc[nChar] );
  486. if ( ! szDoc[nChar] )
  487. return false;
  488. */
  489. return true;
  490. }
  492. bool CMarkup::x_FindToken( CMarkup::TokenPos& token )
  493. {
  494. // Starting at token.nNext, bypass whitespace and find the next token
  495. // returns true on success, members of token point to token
  496. // returns false on end of document, members point to end of document
  497. LPCTSTR szDoc = token.szDoc;
  498. int nChar = token.nNext;
  499. token.bIsString = false;
  501. // By-pass leading whitespace
  502. while ( szDoc[nChar] && _tcschr(_T(" tnr"),szDoc[nChar]) )
  503. ++nChar;
  504. if ( ! szDoc[nChar] )
  505. {
  506. // No token was found before end of document
  507. token.nL = nChar;
  508. token.nR = nChar;
  509. token.nNext = nChar;
  510. return false;
  511. }
  513. // Is it an opening quote?
  514. _TCHAR cFirstChar = szDoc[nChar];
  515. if ( cFirstChar == _T('"') || cFirstChar == _T(''') )
  516. {
  517. token.bIsString = true;
  519. // Move past opening quote
  520. ++nChar;
  521. token.nL = nChar;
  523. // Look for closing quote
  524. x_FindChar( token.szDoc, nChar, cFirstChar );
  526. // Set right to before closing quote
  527. token.nR = nChar - 1;
  529. // Set nChar past closing quote unless at end of document
  530. if ( szDoc[nChar] )
  531. ++nChar;
  532. }
  533. else
  534. {
  535. // Go until special char or whitespace
  536. token.nL = nChar;
  537. while ( szDoc[nChar] && ! _tcschr(_T(" tnr<>=\/?!"),szDoc[nChar]) )
  538. nChar += _tclen(&szDoc[nChar]);
  540. // Adjust end position if it is one special char
  541. if ( nChar == token.nL )
  542. ++nChar; // it is a special char
  543. token.nR = nChar - 1;
  544. }
  546. // nNext points to one past last char of token
  547. token.nNext = nChar;
  548. return true;
  549. }
  551. CString CMarkup::x_GetToken( const CMarkup::TokenPos& token ) const
  552. {
  553. // The token contains indexes into the document identifying a small substring
  554. // Build the substring from those indexes and return it
  555. if ( token.nL > token.nR )
  556. return _T("");
  557. return m_csDoc.Mid( token.nL,
  558. token.nR - token.nL + ((token.nR<m_csDoc.GetLength())? 1:0) );
  559. }
  561. int CMarkup::x_FindElem( int iPosParent, int iPos, LPCTSTR szPath )
  562. {
  563. // If szPath is NULL or empty, go to next sibling element
  564. // Otherwise go to next sibling element with matching path
  565. //
  566. if ( iPos )
  567. iPos = m_aPos[iPos].iElemNext;
  568. else
  569. iPos = m_aPos[iPosParent].iElemChild;
  571. // Finished here if szPath not specified
  572. if ( szPath == NULL || !szPath[0] )
  573. return iPos;
  575. // Search
  576. TokenPos token( m_csDoc );
  577. while ( iPos )
  578. {
  579. // Compare tag name
  580. token.nNext = m_aPos[iPos].nStartL + 1;
  581. x_FindToken( token ); // Locate tag name
  582. if ( token.Match(szPath) )
  583. return iPos;
  584. iPos = m_aPos[iPos].iElemNext;
  585. }
  586. return 0;
  587. }
  589. int CMarkup::x_ParseNode( CMarkup::TokenPos& token )
  590. {
  591. // Call this with token.nNext set to the start of the node
  592. // This returns the node type and token.nNext set to the char after the node
  593. // If the node is not found or an element, token.nR is not determined
  594. // White space between elements is a text node
  595. int nTypeFound = 0;
  596. LPCTSTR szDoc = token.szDoc;
  597. token.nL = token.nNext;
  598. if ( szDoc[token.nL] == '<' )
  599. {
  600. // Started with <, could be:
  601. // <!--...--> comment
  602. // <!DOCTYPE ...> dtd
  603. // <?target ...?> processing instruction
  604. // <![CDATA[...]]> cdata section
  605. // <NAME ...> element
  606. //
  607. if ( ! szDoc[token.nL+1] || ! szDoc[token.nL+2] )
  608. return 0;
  609. _TCHAR cFirstChar = szDoc[token.nL+1];
  610. LPCTSTR szEndOfNode = NULL;
  611. if ( cFirstChar == _T('?') )
  612. {
  613. nTypeFound = MNT_PROCESSING_INSTRUCTION; // processing instruction
  614. szEndOfNode = _T("?>");
  615. }
  616. else if ( cFirstChar == _T('!') )
  617. {
  618. _TCHAR cSecondChar = szDoc[token.nL+2];
  619. if ( cSecondChar == _T('[') )
  620. {
  621. nTypeFound = MNT_CDATA_SECTION;
  622. szEndOfNode = _T("]]>");
  623. }
  624. else if ( cSecondChar == _T('-') )
  625. {
  626. nTypeFound = MNT_COMMENT;
  627. szEndOfNode = _T("-->");
  628. }
  629. else
  630. {
  631. // Document type requires tokenizing because of strings and brackets
  632. nTypeFound = 0;
  633. int nBrackets = 0;
  634. while ( x_FindToken(token) )
  635. {
  636. if ( ! token.bIsString )
  637. {
  638. _TCHAR cChar = szDoc[token.nL];
  639. if ( cChar == _T('[') )
  640. ++nBrackets;
  641. else if ( cChar == _T(']') )
  642. --nBrackets;
  643. else if ( nBrackets == 0 && cChar == _T('>') )
  644. {
  645. nTypeFound = MNT_DOCUMENT_TYPE;
  646. break;
  647. }
  648. }
  649. }
  650. if ( ! nTypeFound )
  651. return 0;
  652. }
  653. }
  654. else if ( cFirstChar == _T('/') )
  655. {
  656. // End tag means no node found within parent element
  657. return 0;
  658. }
  659. else
  660. {
  661. nTypeFound = MNT_ELEMENT;
  662. }
  664. // Search for end of node if not found yet
  665. if ( szEndOfNode )
  666. {
  667. LPCTSTR pEnd = _tcsstr( &szDoc[token.nNext], szEndOfNode );
  668. if ( ! pEnd )
  669. return 0; // not well-formed
  670. token.nNext = (pEnd - szDoc) + _tcslen(szEndOfNode);
  671. }
  672. }
  673. else if ( szDoc[token.nL] )
  674. {
  675. // It is text or whitespace because it did not start with <
  676. nTypeFound = MNT_WHITESPACE;
  677. if ( x_FindToken(token) )
  678. {
  679. if ( szDoc[token.nL] == _T('<') )
  680. token.nNext = token.nL;
  681. else
  682. {
  683. nTypeFound = MNT_TEXT;
  684. x_FindChar( token.szDoc, token.nNext, _T('<') );
  685. }
  686. }
  687. }
  688. return nTypeFound;
  689. }
  691. CString CMarkup::x_GetTagName( int iPos ) const
  692. {
  693. // Return the tag name at specified element
  694. TokenPos token( m_csDoc );
  695. token.nNext = m_aPos[iPos].nStartL + 1;
  696. if ( ! iPos || ! x_FindToken( token ) )
  697. return _T("");
  699. // Return substring of document
  700. return x_GetToken( token );
  701. }
  703. bool CMarkup::x_FindAttr( CMarkup::TokenPos& token, LPCTSTR szAttr ) const
  704. {
  705. // If szAttr is NULL find next Attr, otherwise find named Attr
  706. // Return true if found
  707. int nAttr = 0;
  708. for ( int nCount = 0; x_FindToken(token); ++nCount )
  709. {
  710. if ( ! token.bIsString )
  711. {
  712. // Is it the right angle bracket?
  713. if ( m_csDoc[token.nL] == _T('>') || m_csDoc[token.nL] == _T('/') )
  714. break; // Attr not found
  716. // Equal sign
  717. if ( m_csDoc[token.nL] == _T('=') )
  718. continue;
  720. // Potential Attrute
  721. if ( ! nAttr && nCount )
  722. {
  723. // Attrute name search?
  724. if ( ! szAttr || ! szAttr[0] )
  725. return true; // return with token at Attr name
  727. // Compare szAttr
  728. if ( token.Match(szAttr) )
  729. nAttr = nCount;
  730. }
  731. }
  732. else if ( nAttr && nCount == nAttr + 2 )
  733. {
  734. return true;
  735. }
  736. }
  738. // Not found
  739. return false;
  740. }
  742. CString CMarkup::x_GetAttr( int iPos, LPCTSTR szAttr ) const
  743. {
  744. // Return the value of the Attr at specified element
  745. if ( ! iPos || m_nNodeType != MNT_ELEMENT )
  746. return _T("");
  748. TokenPos token( m_csDoc );
  749. token.nNext = m_aPos[iPos].nStartL + 1;
  750. if ( szAttr && x_FindAttr( token, szAttr ) )
  751. return x_TextFromDoc( token.nL, token.nR - ((token.nR<m_csDoc.GetLength())?0:1) );
  752. return _T("");
  753. }
  755. bool CMarkup::x_SetAttr( int iPos, LPCTSTR szAttr, int nValue )
  756. {
  757. // Convert integer to string and call SetChildAttr
  758. _TCHAR szVal[25];
  759. _stprintf( szVal, _T("%d"), nValue );
  760. return x_SetAttr( iPos, szAttr, szVal );
  761. }
  763. bool CMarkup::x_SetAttr( int iPos, LPCTSTR szAttr, LPCTSTR szValue )
  764. {
  765. // Set Attrute in iPos element
  766. if ( ! iPos || m_nNodeType != MNT_ELEMENT )
  767. return false;
  769. TokenPos token( m_csDoc );
  770. token.nNext = m_aPos[iPos].nStartL + 1;
  771. int nInsertAt, nReplace = 0;
  772. CString csInsert;
  773. if ( x_FindAttr( token, szAttr ) )
  774. {
  775. // Decision: for empty value leaving Attr="" instead of removing Attr
  776. // Replace value only
  777. csInsert = x_TextToDoc( szValue, true );
  778. nInsertAt = token.nL;
  779. nReplace = token.nR-token.nL+1;
  780. }
  781. else
  782. {
  783. // Insert string name value pair
  784. CString csFormat;
  785. csFormat = _T(" ");
  786. csFormat += szAttr;
  787. csFormat += _T("="");
  788. csFormat += x_TextToDoc( szValue, true );
  789. csFormat += _T(""");
  790. csInsert = csFormat;
  792. // take into account whether it is an empty element
  793. nInsertAt = m_aPos[iPos].nStartR - (m_aPos[iPos].IsEmptyElement()?1:0);
  794. }
  796. x_DocChange( nInsertAt, nReplace, csInsert );
  797. int nAdjust = csInsert.GetLength() - nReplace;
  798. m_aPos[iPos].nStartR += nAdjust;
  799. m_aPos[iPos].AdjustEnd( nAdjust );
  800. x_Adjust( iPos, nAdjust );
  801. MARKUP_SETDEBUGSTATE;
  802. return true;
  803. }
  805. bool CMarkup::x_CreateNode( CString& csNode, int nNodeType, LPCTSTR szText )
  806. {
  807. // Set csNode based on nNodeType and szData
  808. // Return false if szData would jeopardize well-formed document
  809. //
  810. switch ( nNodeType )
  811. {
  812. case MNT_CDATA_SECTION:
  813. if ( _tcsstr(szText,_T("]]>")) != NULL )
  814. return false;
  815. csNode = "<![CDATA[";
  816. csNode += szText;
  817. csNode += "]]>";
  818. break;
  819. }
  820. return true;
  821. }
  823. bool CMarkup::x_SetData( int iPos, LPCTSTR szData, int nCDATA )
  824. {
  825. // Set data at specified position
  826. // if nCDATA==1, set content of element to a CDATA Section
  827. CString csInsert;
  829. // Set data in iPos element
  830. if ( ! iPos || m_aPos[iPos].iElemChild )
  831. return false;
  833. // Build csInsert from szData based on nCDATA
  834. // If CDATA section not valid, use parsed text (PCDATA) instead
  835. if ( nCDATA != 0 )
  836. if ( ! x_CreateNode(csInsert, MNT_CDATA_SECTION, szData) )
  837. nCDATA = 0;
  838. if ( nCDATA == 0 )
  839. csInsert = x_TextToDoc( szData );
  841. // Decide where to insert
  842. int nInsertAt, nReplace;
  843. if ( m_aPos[iPos].IsEmptyElement() )
  844. {
  845. nInsertAt = m_aPos[iPos].nEndL;
  846. nReplace = 1;
  848. // Pre-adjust since <NAME/> becomes <NAME>data</NAME>
  849. CString csTagName = x_GetTagName( iPos );
  850. m_aPos[iPos].nStartR -= 1;
  851. m_aPos[iPos].nEndL -= (1 + csTagName.GetLength());
  852. CString csFormat;
  853. csFormat = _T(">");
  854. csFormat += csInsert;
  855. csFormat += _T("</");
  856. csFormat += csTagName;
  857. csInsert = csFormat;
  858. }
  859. else
  860. {
  861. nInsertAt = m_aPos[iPos].nStartR+1;
  862. nReplace = m_aPos[iPos].nEndL - m_aPos[iPos].nStartR - 1;
  863. }
  864. x_DocChange( nInsertAt, nReplace, csInsert );
  865. int nAdjust = csInsert.GetLength() - nReplace;
  866. x_Adjust( iPos, nAdjust );
  867. m_aPos[iPos].AdjustEnd( nAdjust );
  868. MARKUP_SETDEBUGSTATE;
  869. return true;
  870. }
  872. CString CMarkup::x_GetData( int iPos ) const
  873. {
  874. // Return a string representing data between start and end tag
  875. // Return empty string if there are any children elements
  876. if ( ! m_aPos[iPos].iElemChild && ! m_aPos[iPos].IsEmptyElement() )
  877. {
  878. // See if it is a CDATA section
  879. TokenPos token( m_csDoc );
  880. token.nNext = m_aPos[iPos].nStartR+1;
  881. if ( x_FindToken( token ) && m_csDoc[token.nL] == _T('<')
  882. && token.nL + 11 < m_aPos[iPos].nEndL
  883. && _tcsncmp( &token.szDoc[token.nL+1], _T("![CDATA["), 8 ) == 0 )
  884. {
  885. int nEndCDATA = m_csDoc.Find( _T("]]>"), token.nNext );
  886. if ( nEndCDATA != -1 && nEndCDATA < m_aPos[iPos].nEndL )
  887. {
  888. return m_csDoc.Mid( token.nL+9, nEndCDATA-token.nL-9 );
  889. }
  890. }
  891. return x_TextFromDoc( m_aPos[iPos].nStartR+1, m_aPos[iPos].nEndL-1 );
  892. }
  893. return _T("");
  894. }
  896. CString CMarkup::x_TextToDoc( LPCTSTR szText, bool bAttr ) const
  897. {
  898. // Convert text as seen outside XML document to XML friendly
  899. // replacing special characters with ampersand escape codes
  900. // E.g. convert "6>7" to "6&gt;7"
  901. //
  902. // &lt;   less than
  903. // &amp;  ampersand
  904. // &gt;   greater than
  905. //
  906. // and for Attrutes:
  907. //
  908. // &apos; apostrophe or single quote
  909. // &quot; double quote
  910. //
  911. static _TCHAR* szaReplace[] = { _T("&lt;"),_T("&amp;"),_T("&gt;"),_T("&apos;"),_T("&quot;") };
  912. const _TCHAR* pFind = bAttr?_T("<&>'""):_T("<&>");
  913. CString csText;
  914. const _TCHAR* pSource = szText;
  915. int nDestSize = _tcslen(pSource);
  916. nDestSize += nDestSize / 10 + 7;
  917. _TCHAR* pDest = csText.GetBuffer(nDestSize);
  918. int nLen = 0;
  919. _TCHAR cSource = *pSource;
  920. _TCHAR* pFound;
  921. while ( cSource )
  922. {
  923. if ( nLen > nDestSize - 6 )
  924. {
  925. csText.ReleaseBuffer(nLen);
  926. nDestSize *= 2;
  927. pDest = csText.GetBuffer(nDestSize);
  928. }
  929. if ( (pFound=_tcschr(pFind,cSource)) != NULL )
  930. {
  931. pFound = szaReplace[pFound-pFind];
  932. _tcscpy(&pDest[nLen],pFound);
  933. nLen += _tcslen(pFound);
  934. }
  935. else
  936. {
  937. _tccpy( &pDest[nLen], pSource );
  938. ++nLen;
  939. }
  940. pSource += _tclen( pSource );
  941. cSource = *pSource;
  942. }
  943. csText.ReleaseBuffer(nLen);
  944. return csText;
  945. }
  947. CString CMarkup::x_TextFromDoc( int nLeft, int nRight ) const
  948. {
  949. // Convert XML friendly text to text as seen outside XML document
  950. // replacing ampersand escape codes with special characters
  951. // E.g. convert "6&gt;7" to "6>7"
  952. //
  953. // Conveniently the result is always the same or shorter in length
  954. //
  955. static _TCHAR* szaCode[] = { _T("lt;"),_T("amp;"),_T("gt;"),_T("apos;"),_T("quot;") };
  956. static int anCodeLen[] = { 3,4,3,5,5 };
  957. static _TCHAR* szSymbol = _T("<&>'"");
  958. CString csText;
  959. const _TCHAR* pSource = m_csDoc;
  960. int nDestSize = nRight - nLeft + 1;
  961. _TCHAR* pDest = csText.GetBuffer(nDestSize);
  962. int nLen = 0;
  963. int nCharLen;
  964. int nChar = nLeft;
  965. while ( nChar <= nRight )
  966. {
  967. if ( pSource[nChar] == _T('&') )
  968. {
  969. // Look for matching &code;
  970. for ( int nMatch = 0; nMatch < 5; ++nMatch )
  971. {
  972. if ( nChar <= nRight - anCodeLen[nMatch]
  973. && _tcsncmp(szaCode[nMatch],&pSource[nChar+1],anCodeLen[nMatch]) == 0 )
  974. {
  975. pDest[nLen++] = szSymbol[nMatch];
  976. nChar += anCodeLen[nMatch] + 1;
  977. break;
  978. }
  979. }
  981. // If no match is found it means XML doc is invalid
  982. // no devastating harm done, ampersand code will just be left in result
  983. if ( nMatch == 5 )
  984. {
  985. pDest[nLen++] = _T('&');
  986. ++nChar;
  987. }
  988. }
  989. else
  990. {
  991. nCharLen = _tclen(&pSource[nChar]);
  992. _tccpy( &pDest[nLen], &pSource[nChar] );
  993. nLen += nCharLen;
  994. nChar += nCharLen;
  995. }
  996. }
  997. csText.ReleaseBuffer(nLen);
  998. return csText;
  999. }
  1001. void CMarkup::x_DocChange( int nLeft, int nReplace, const CString& csInsert )
  1002. {
  1003. // Insert csInsert int m_csDoc at nLeft replacing nReplace chars
  1004. // Do this with only one buffer reallocation if it grows
  1005. //
  1006. int nDocLength = m_csDoc.GetLength();
  1007. int nInsLength = csInsert.GetLength();
  1009. // Make sure nLeft and nReplace are within bounds
  1010. nLeft = max( 0, min( nLeft, nDocLength ) );
  1011. nReplace = max( 0, min( nReplace, nDocLength-nLeft ) );
  1013. // Get pointer to buffer with enough room
  1014. int nNewLength = nInsLength + nDocLength - nReplace;
  1015. int nBufferLen = nNewLength;
  1016. _TCHAR* pDoc = m_csDoc.GetBuffer( nBufferLen );
  1018. // Move part of old doc that goes after insert
  1019. if ( nLeft+nReplace < nDocLength )
  1020. memmove( &pDoc[nLeft+nInsLength], &pDoc[nLeft+nReplace], (nDocLength-nLeft-nReplace)*sizeof(_TCHAR) );
  1022. // Copy insert
  1023. memcpy( &pDoc[nLeft], csInsert, nInsLength*sizeof(_TCHAR) );
  1025. // Release
  1026. m_csDoc.ReleaseBuffer( nNewLength );
  1027. }
  1029. void CMarkup::x_Adjust( int iPos, int nShift, bool bAfterPos )
  1030. {
  1031. // Loop through affected elements and adjust indexes
  1032. // Algorithm:
  1033. // 1. update children unless bAfterPos
  1034. //    (if no children or bAfterPos is true, end tag of iPos not affected)
  1035. // 2. update next siblings and their children
  1036. // 3. go up until there is a next sibling of a parent and update end tags
  1037. // 4. step 2
  1038. int iPosTop = m_aPos[iPos].iElemParent;
  1039. bool bPosFirst = bAfterPos; // mark as first to skip its children
  1040. while ( iPos )
  1041. {
  1042. // Were we at containing parent of affected position?
  1043. bool bPosTop = false;
  1044. if ( iPos == iPosTop )
  1045. {
  1046. // Move iPosTop up one towards root
  1047. iPosTop = m_aPos[iPos].iElemParent;
  1048. bPosTop = true;
  1049. }
  1051. // Traverse to the next update position
  1052. if ( ! bPosTop && ! bPosFirst && m_aPos[iPos].iElemChild )
  1053. {
  1054. // Depth first
  1055. iPos = m_aPos[iPos].iElemChild;
  1056. }
  1057. else if ( m_aPos[iPos].iElemNext )
  1058. {
  1059. iPos = m_aPos[iPos].iElemNext;
  1060. }
  1061. else
  1062. {
  1063. // Look for next sibling of a parent of iPos
  1064. // When going back up, parents have already been done except iPosTop
  1065. while ( (iPos=m_aPos[iPos].iElemParent) != 0 && iPos != iPosTop )
  1066. if ( m_aPos[iPos].iElemNext )
  1067. {
  1068. iPos = m_aPos[iPos].iElemNext;
  1069. break;
  1070. }
  1071. }
  1072. bPosFirst = false;
  1074. // Shift indexes at iPos
  1075. if ( iPos != iPosTop )
  1076. m_aPos[iPos].AdjustStart( nShift );
  1077. m_aPos[iPos].AdjustEnd( nShift );
  1078. }
  1079. }
  1081. void CMarkup::x_LocateNew( int iPosParent, int& iPosRel, int& nOffset, int nLength, int nFlags )
  1082. {
  1083. // Determine where to insert new element or node
  1084. //
  1085. bool bInsert = (nFlags&1)?true:false;
  1086. bool bHonorWhitespace = (nFlags&2)?true:false;
  1088. int nStartL;
  1089. if ( nLength )
  1090. {
  1091. // Located at a non-element node
  1092. if ( bInsert )
  1093. nStartL = nOffset;
  1094. else
  1095. nStartL = nOffset + nLength;
  1096. }
  1097. else if ( iPosRel )
  1098. {
  1099. // Located at an element
  1100. if ( bInsert ) // precede iPosRel
  1101. nStartL = m_aPos[iPosRel].nStartL;
  1102. else // follow iPosRel
  1103. nStartL = m_aPos[iPosRel].nEndR + 1;
  1104. }
  1105. else if ( m_aPos[iPosParent].IsEmptyElement() )
  1106. {
  1107. // Parent has no separate end tag, so split empty element
  1108. nStartL = m_aPos[iPosParent].nStartR;
  1109. }
  1110. else
  1111. {
  1112. if ( bInsert ) // after start tag
  1113. nStartL = m_aPos[iPosParent].nStartR + 1;
  1114. else // before end tag
  1115. nStartL = m_aPos[iPosParent].nEndL;
  1116. }
  1118. // Go up to start of next node, unless its splitting an empty element
  1119. if ( ! bHonorWhitespace && ! m_aPos[iPosParent].IsEmptyElement() )
  1120. {
  1121. TokenPos token( m_csDoc );
  1122. token.nNext = nStartL;
  1123. if ( ! x_FindToken(token) || m_csDoc[token.nL] == _T('<') )
  1124. nStartL = token.nL;
  1125. }
  1127. // Determine iPosBefore
  1128. int iPosBefore = 0;
  1129. if ( iPosRel )
  1130. {
  1131. if ( bInsert )
  1132. {
  1133. // Is iPosRel past first sibling?
  1134. int iPosPrev = m_aPos[iPosParent].iElemChild;
  1135. if ( iPosPrev != iPosRel )
  1136. {
  1137. // Find previous sibling of iPosRel
  1138. while ( m_aPos[iPosPrev].iElemNext != iPosRel )
  1139. iPosPrev = m_aPos[iPosPrev].iElemNext;
  1140. iPosBefore = iPosPrev;
  1141. }
  1142. }
  1143. else
  1144. {
  1145. iPosBefore = iPosRel;
  1146. }
  1147. }
  1148. else if ( m_aPos[iPosParent].iElemChild )
  1149. {
  1150. if ( ! bInsert )
  1151. {
  1152. // Find last element under iPosParent
  1153. int iPosLast = m_aPos[iPosParent].iElemChild;
  1154. int iPosNext = iPosLast;
  1155. while ( iPosNext )
  1156. {
  1157. iPosLast = iPosNext;
  1158. iPosNext = m_aPos[iPosNext].iElemNext;
  1159. }
  1160. iPosBefore = iPosLast;
  1161. }
  1162. }
  1164. nOffset = nStartL;
  1165. iPosRel = iPosBefore;
  1166. }
  1168. bool CMarkup::x_AddElem( LPCTSTR szName, LPCTSTR szValue, bool bInsert, bool bAddChild )
  1169. {
  1170. if ( bAddChild )
  1171. {
  1172. // Adding a child element under main position
  1173. if ( ! m_iPos )
  1174. return false;
  1175. }
  1176. else if ( m_iPosParent == 0 )
  1177. {
  1178. // Adding root element
  1179. if ( IsWellFormed() )
  1180. return false;
  1182. // Locate after any version and DTD
  1183. m_aPos[0].nEndL = m_csDoc.GetLength();
  1184. }
  1186. // Locate where to add element relative to current node
  1187. int iPosParent, iPosBefore, nOffset = 0, nLength = 0;
  1188. if ( bAddChild )
  1189. {
  1190. iPosParent = m_iPos;
  1191. iPosBefore = m_iPosChild;
  1192. }
  1193. else
  1194. {
  1195. iPosParent = m_iPosParent;
  1196. iPosBefore = m_iPos;
  1197. }
  1198. int nFlags = bInsert?1:0;
  1199. x_LocateNew( iPosParent, iPosBefore, nOffset, nLength, nFlags );
  1200. bool bEmptyParent = m_aPos[iPosParent].IsEmptyElement();
  1201. if ( bEmptyParent )
  1202. nOffset += 2; // include CRLF
  1204. // Create element and modify positions of affected elements
  1205. // If no szValue is specified, an empty element is created
  1206. // i.e. either <NAME>value</NAME> or <NAME/>
  1207. //
  1208. int iPos = x_GetFreePos();
  1209. m_aPos[iPos].nStartL = nOffset;
  1211. // Set links
  1212. m_aPos[iPos].iElemParent = iPosParent;
  1213. m_aPos[iPos].iElemChild = 0;
  1214. m_aPos[iPos].iElemNext = 0;
  1215. if ( iPosBefore )
  1216. {
  1217. // Link in after iPosBefore
  1218. m_aPos[iPos].iElemNext = m_aPos[iPosBefore].iElemNext;
  1219. m_aPos[iPosBefore].iElemNext = iPos;
  1220. }
  1221. else
  1222. {
  1223. // First child
  1224. m_aPos[iPos].iElemNext = m_aPos[iPosParent].iElemChild;
  1225. m_aPos[iPosParent].iElemChild = iPos;
  1226. }
  1228. // Create string for insert
  1229. CString csInsert;
  1230. int nLenName = _tcslen(szName);
  1231. int nLenValue = szValue? _tcslen(szValue) : 0;
  1232. if ( ! nLenValue )
  1233. {
  1234. // <NAME/> empty element
  1235. csInsert = _T("<");
  1236. csInsert += szName;
  1237. csInsert += _T("/>rn");
  1238. m_aPos[iPos].nStartR = m_aPos[iPos].nStartL + nLenName + 2;
  1239. m_aPos[iPos].nEndL = m_aPos[iPos].nStartR - 1;
  1240. m_aPos[iPos].nEndR = m_aPos[iPos].nEndL + 1;
  1241. }
  1242. else
  1243. {
  1244. // <NAME>value</NAME>
  1245. CString csValue = x_TextToDoc( szValue );
  1246. nLenValue = csValue.GetLength();
  1247. csInsert = _T("<");
  1248. csInsert += szName;
  1249. csInsert += _T(">");
  1250. csInsert += csValue;
  1251. csInsert += _T("</");
  1252. csInsert += szName;
  1253. csInsert += _T(">rn");
  1254. m_aPos[iPos].nStartR = m_aPos[iPos].nStartL + nLenName + 1;
  1255. m_aPos[iPos].nEndL = m_aPos[iPos].nStartR + nLenValue + 1;
  1256. m_aPos[iPos].nEndR = m_aPos[iPos].nEndL + nLenName + 2;
  1257. }
  1259. // Insert
  1260. int nReplace = 0, nLeft = m_aPos[iPos].nStartL;
  1261. if ( bEmptyParent )
  1262. {
  1263. CString csParentTagName = x_GetTagName(iPosParent);
  1264. CString csFormat;
  1265. csFormat = _T(">rn");
  1266. csFormat += csInsert;
  1267. csFormat += _T("</");
  1268. csFormat += csParentTagName;
  1269. csInsert = csFormat;
  1270. nLeft -= 3;
  1271. nReplace = 1;
  1272. // x_Adjust is going to update all affected indexes by one amount
  1273. // This will satisfy all except the empty parent
  1274. // Here we pre-adjust for the empty parent
  1275. // The empty tag slash is removed
  1276. m_aPos[iPosParent].nStartR -= 1;
  1277. // For the newly created end tag, see the following example:
  1278. // <A/> (len 4) becomes <A><B/></A> (len 11)
  1279. // In x_Adjust everything will be adjusted 11 - 4 = 7
  1280. // But the nEndL of element A should only be adjusted 5
  1281. m_aPos[iPosParent].nEndL -= (csParentTagName.GetLength() + 1);
  1282. }
  1283. x_DocChange( nLeft, nReplace, csInsert );
  1284. x_Adjust( iPos, csInsert.GetLength() - nReplace );
  1286. if ( bAddChild )
  1287. x_SetPos( m_iPosParent, iPosParent, iPos );
  1288. else
  1289. x_SetPos( iPosParent, iPos, 0 );
  1290. return true;
  1291. }
  1293. bool CMarkup::x_AddSubDoc( LPCTSTR szSubDoc, bool bInsert, bool bAddChild )
  1294. {
  1295. // Add subdocument, parse, and modify positions of affected elements
  1296. //
  1297. int nOffset = 0, iPosParent, iPosBefore;
  1298. if ( bAddChild )
  1299. {
  1300. // Add a subdocument under main position, after current child position
  1301. if ( ! m_iPos )
  1302. return false;
  1303. iPosParent = m_iPos;
  1304. iPosBefore = m_iPosChild;
  1305. }
  1306. else
  1307. {
  1308. iPosParent = m_iPosParent;
  1309. iPosBefore = m_iPos;
  1310. }
  1311. int nFlags = bInsert?1:0;
  1312. x_LocateNew( iPosParent, iPosBefore, nOffset, 0, nFlags );
  1313. bool bEmptyParent = m_aPos[iPosParent].IsEmptyElement();
  1314. if ( bEmptyParent )
  1315. nOffset += 2; // include CRLF
  1317. // if iPosBefore is NULL, insert as first element under parent
  1318. int nParentEndLBeforeAdd = m_aPos[iPosParent].nEndL;
  1319. int iPosFreeBeforeAdd = m_iPosFree;
  1321. // Skip version tag or DTD at start of subdocument
  1322. TokenPos token( szSubDoc );
  1323. int nNodeType = x_ParseNode( token );
  1324. while ( nNodeType && nNodeType != MNT_ELEMENT )
  1325. {
  1326. token.szDoc = &szSubDoc[token.nNext];
  1327. token.nNext = 0;
  1328. nNodeType = x_ParseNode( token );
  1329. }
  1330. CString csInsert = token.szDoc;
  1332. // Insert subdocument
  1333. m_aPos[iPosParent].nEndL = nOffset;
  1334. int nReplace = 0, nLeft = nOffset;
  1335. CString csParentTagName;
  1336. if ( bEmptyParent )
  1337. {
  1338. csParentTagName = x_GetTagName(iPosParent);
  1339. CString csFormat;
  1340. csFormat = _T(">rn");
  1341. csFormat += csInsert;
  1342. csFormat += _T("</");
  1343. csFormat += csParentTagName;
  1344. csInsert = csFormat;
  1345. m_aPos[iPosParent].nEndL = m_aPos[iPosParent].nStartR + 2;
  1346. nLeft = m_aPos[iPosParent].nStartR - 1;
  1347. nReplace = 1;
  1348. }
  1349. x_DocChange( nLeft, nReplace, csInsert );
  1351. // Parse subdocument
  1352. int iPos = x_ParseElem(iPosParent);
  1353. m_aPos[iPosParent].nEndL = nParentEndLBeforeAdd;
  1354. if ( iPos <= 0 )
  1355. {
  1356. // Abort because not well-formed
  1357. CString csRevert = bEmptyParent?_T("/"):_T("");
  1358. x_DocChange( nLeft, csInsert.GetLength(), csRevert );
  1359. m_iPosFree = iPosFreeBeforeAdd;
  1360. return false;
  1361. }
  1362. else
  1363. {
  1364. // Link in parent and siblings
  1365. m_aPos[iPos].iElemParent = iPosParent;
  1366. if ( iPosBefore )
  1367. {
  1368. m_aPos[iPos].iElemNext = m_aPos[iPosBefore].iElemNext;
  1369. m_aPos[iPosBefore].iElemNext = iPos;
  1370. }
  1371. else
  1372. {
  1373. m_aPos[iPos].iElemNext = m_aPos[iPosParent].iElemChild;
  1374. m_aPos[iPosParent].iElemChild = iPos;
  1375. }
  1377. // Make empty parent pre-adjustment
  1378. if ( bEmptyParent )
  1379. {
  1380. m_aPos[iPosParent].nStartR -= 1;
  1381. m_aPos[iPosParent].nEndL -= (csParentTagName.GetLength() + 1);
  1382. }
  1384. // Adjust, but don't adjust children of iPos (bAfterPos=true)
  1385. x_Adjust( iPos, csInsert.GetLength() - nReplace, true );
  1386. }
  1388. // Set position to top element of subdocument
  1389. if ( bAddChild )
  1390. x_SetPos( m_iPosParent, iPosParent, iPos );
  1391. else // Main
  1392. x_SetPos( m_iPosParent, iPos, 0 );
  1393. return true;
  1394. }
  1396. int CMarkup::x_RemoveElem( int iPos )
  1397. {
  1398. // Remove element and all contained elements
  1399. // Return new position
  1400. //
  1401. int iPosParent = m_aPos[iPos].iElemParent;
  1403. // Find previous sibling and bypass removed element
  1404. // This leaves orphan positions in m_aPos array
  1405. int iPosLook = m_aPos[iPosParent].iElemChild;
  1406. int iPosPrev = 0;
  1407. while ( iPosLook != iPos )
  1408. {
  1409. iPosPrev = iPosLook;
  1410. iPosLook = m_aPos[iPosLook].iElemNext;
  1411. }
  1412. if ( iPosPrev )
  1413. m_aPos[iPosPrev].iElemNext = m_aPos[iPos].iElemNext;
  1414. else
  1415. m_aPos[iPosParent].iElemChild = m_aPos[iPos].iElemNext;
  1417. // Remove from document
  1418. // Links have been changed to go around removed element
  1419. // But element position and links are still valid
  1420. int nAfterEnd = m_aPos[iPos].nEndR + 1;
  1421. TokenPos token( m_csDoc );
  1422. token.nNext = nAfterEnd;
  1423. if ( ! x_FindToken(token) || token.szDoc[token.nL] == _T('<') )
  1424. nAfterEnd = token.nL;
  1425. int nLen = nAfterEnd - m_aPos[iPos].nStartL;
  1426. x_DocChange( m_aPos[iPos].nStartL, nLen, CString() );
  1427. x_Adjust( iPos, - nLen, true );
  1428. return iPosPrev;
  1429. }