Category

Development Platform
Home > SourceCode/Document > Communication-Mobile > Symbian > View Code
looseprs.cpp
Package: helix.src.0812.rar　[view]
Upload User: zhongxx05
Upload Date: 2007-06-06
Package Size: 33641k
Code Size: 39k
Category:

Symbian

Development Platform:

C/C++

looseprs.cpp：Code Content
  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 "hxcom.h"
  37. #include "hxtypes.h"
  38. #include "hxstrutl.h"
  39. #include "hxmap.h"
  40. #include "xmlencod.h"
  41. #include "looseprs.h"
  42. #include <ctype.h>
  44. #include "hxheap.h"
  45. #ifdef _DEBUG
  46. #undef HX_THIS_FILE
  47. static const char HX_THIS_FILE[] = __FILE__;
  48. #endif
  50. static const int MAX_ERROR_LEN = 80;
  52. XMLParser::XMLParser(BOOL bStrictCompliance, const char* pEncoding,
  53.      BOOL bAllowNonXMLComments):
  54.     m_bStrictCompliance(bStrictCompliance),
  55.     m_bAllowNonXMLComments(bAllowNonXMLComments),
  56.     m_bCommentWasFound(FALSE),
  57.     m_bXMLandSMIL10FullCompliance(FALSE),
  58.     m_ulCurrentLine(1),
  59.     m_ulCurrentCol(1),
  60.     m_ulTagStartLine(1),
  61.     m_ulTagStartCol(1),
  62.     m_pLastError(0)
  63.     , m_bStoreErrors(FALSE)
  64. {
  65.     m_pCurrentFrame = new XMLFrame;
  66.     m_comment_state = 0;
  67.     m_comment_get_arg = 0;
  68.     m_comment_pos = 0;
  69.     if(pEncoding)
  70.     {
  71. m_pEncoding = new_string(pEncoding);
  72.     }
  73.     else
  74.     {
  75. m_pEncoding = new_string("US-ASCII"); // default encoding
  76.     }
  77. }
  79. XMLParser::~XMLParser()
  80. {
  81.     HX_DELETE(m_pLastError);
  82.     HX_VECTOR_DELETE(m_pEncoding);
  83.     delete m_pCurrentFrame;
  84. }
  86. void
  87. XMLParser::Reset(void)
  88. {
  89.     if (m_pCurrentFrame != NULL) delete m_pCurrentFrame;
  90.     m_pCurrentFrame = NULL;
  91. }
  93. // class function to get version/encoding of XML content
  94. HX_RESULT
  95. XMLParser::GetPrologInfo(const char* pBuf,
  96.  UINT32 ulBufLen,
  97.  char*& pVersion,
  98.  char*& pEncoding)
  99. {
  100.     HX_RESULT rc = HXR_FAIL;
  102.     const char* pCh = pBuf;
  103.     enum { VERSION, ENCODING } nPrologAttribute = VERSION;
  104.     char quoteType = '"';
  106.     BOOL bDone = FALSE;
  107.     BOOL bInComment = FALSE;
  108.     int state = 0;
  109.     const char* pValueStart = NULL;
  111.     while(!bDone &&
  112.         pCh < pBuf + ulBufLen)
  113.     {
  114.         switch(state)
  115.         {
  116.             case 0: // looking for either a comment open
  117.                     // or a prolog
  118.             {
  119.                 if(*pCh == '<')
  120.                 {
  121.                     if(*(pCh + 1) == '!' &&
  122.                        *(pCh + 2) == '-' &&
  123.                        *(pCh + 3) == '-')
  124.                     {
  125.                         if(bInComment)
  126.                         {
  127.                             bDone = TRUE;   // no nested comments
  128.                         }
  129.                         pCh += 4;   // skip over
  130.                         bInComment = TRUE;
  131.                         state = 1;
  132.                     }
  133.                     else if(*(pCh + 1) == '?' &&
  134.                             *(pCh + 2) == 'x' &&
  135.                             *(pCh + 3) == 'm' &&
  136.                             *(pCh + 4) == 'l')
  137.                     {
  138.                         pCh += 5;   // skip over 
  139.                         state = 2;
  140.                     }
  141.                     else
  142.                     {
  143.                         bDone = TRUE;   // no prolog
  144.                     }
  145.                 }
  146.                 else if(isspace(*pCh))
  147.                 {
  148.                     pCh++;
  149.                 }
  150.                 else
  151.                 {
  152.                     bDone = TRUE;   // can't find prolog
  153.                 }
  154.             }
  155.             break;
  157.             case 1: // comment end
  158.             {
  159.                 if(*pCh == '-' &&
  160.                    *(pCh + 1) == '-' &&
  161.                    *(pCh + 2) == '>')
  162.                 {
  163.                     pCh += 3;
  164.                     bInComment = FALSE;
  165.                     state = 0;
  166.                 }
  167.                 else
  168.                 {
  169.                     pCh++;
  170.                 }
  171.             }
  172.             break;
  174.             case 2: // known attribute in prolog
  175.             {
  176.                 if(strncmp(pCh, "version", 7) == 0)
  177.                 {
  178.                     pCh += 7;
  179.                     nPrologAttribute = VERSION;
  180.                     state = 3;
  181.                 }
  182.                 else if(strncmp(pCh, "encoding", 8) == 0)
  183.                 {
  184.                     pCh += 8;
  185.                     nPrologAttribute = ENCODING;
  186.                     state = 3;
  187.                 }
  188.                 else
  189.                 {
  190.                     pCh++;
  191.                 }
  192.             }
  193.             break;
  195.             case 3: // '='
  196.             {
  197.                 if(*pCh == '=')
  198.                 {
  199.                     state = 4;
  200.                 }
  201.                 pCh++;
  202.             }
  203.             break;
  205.             case 4: // quote type
  206.             {
  207.                 if(*pCh == '"')
  208.                 {
  209.                     quoteType = '"';
  210.                     pValueStart = pCh + 1;
  211.                     state = 5;
  212.                 }
  213.                 else if(*pCh == ''')
  214.                 {
  215.                     quoteType = ''';
  216.                     pValueStart = pCh + 1;
  217.                     state = 5;
  218.                 }
  219.                 else
  220.                 {
  221.                     bDone = TRUE;   // badly formed
  222.                 }
  223.                 pCh++;
  224.             }
  225.             break;
  227.             case 5: // get value
  228.             {
  229.                 if(*pCh == quoteType)
  230.                 {
  231.                     if (pValueStart)
  232.                     {
  233.                         INT32 lValLen = pCh - pValueStart;
  234.                         if (lValLen > 0)
  235.                         {
  236.                             char* pTmp = new char [lValLen + 1];
  237.                             if (pTmp)
  238.                             {
  239.                                 strncpy(pTmp, pValueStart, lValLen);
  240.                                 pTmp[lValLen] = '';
  241.                                 if(nPrologAttribute == VERSION)
  242.                                 {
  243.                                     pVersion = pTmp;
  244.                                 }
  245.                                 else if(nPrologAttribute == ENCODING)
  246.                                 {
  247.                                     pEncoding = pTmp;
  248.                                 }
  249.                                 rc = HXR_OK;    // got one!
  250.                                 // reset for next string
  251.                                 state = 2;
  252.                             }
  253.                         }
  254.                     }
  255.                 }
  256.                 pCh++;
  257.             }
  258.             break;
  259.         }
  260.     }
  261.     return rc;
  262. }
  264. char
  265. XMLParser::GetEscapeMacro(const char*& ptr, const char* end)
  266. {
  267.     char returnCh;
  268.     if(*ptr != '&')
  269.     {
  270. returnCh = *ptr;
  271.     }
  272.     else
  273.     {
  274. int maxLen = end - ptr;
  275. if((maxLen > 5) && strncmp(ptr, "&apos;", 6) == 0)
  276. {
  277.     returnCh = ''';
  278.     ptr += 6;
  279. }
  280. else if((maxLen > 5) && strncmp(ptr, "&quot;", 6) == 0)
  281. {
  282.     returnCh = '"';
  283.     ptr += 6;
  284. }
  285. else if((maxLen > 3) && strncmp(ptr, "&lt;", 4) == 0)
  286. {
  287.     returnCh = '<';
  288.     ptr += 4;
  289. }
  290. else if((maxLen > 3) && strncmp(ptr, "&gt;", 4) == 0)
  291. {
  292.     returnCh = '>';
  293.     ptr += 4;
  294. }
  295. else if((maxLen > 4) && strncmp(ptr, "&amp;", 5) == 0)
  296. {
  297.     returnCh = '&';
  298.     ptr += 5;
  299. }
  300. else
  301. {
  302.     returnCh = '&';
  303.     ptr++;
  304. }
  305.     }
  306.     return returnCh;
  307. }
  309. GetStringResult
  310. XMLParser::GetString(const char*& ptr, const char* end, 
  311.       char*& val, UINT32 type)
  312. {
  313.     GetStringResult retval = GSInvalid;
  315.     CHXXMLEncode xmlStr(m_pEncoding, (BYTE*)ptr, end - ptr);
  316.     UINT16 uLen = 0;
  317.     ptr = (const char*)xmlStr.GetNextChar(uLen);
  318.     while(isspace(*ptr) && ptr < end)
  319.     {
  320. ptr = (const char*)xmlStr.GetNextChar(uLen);
  321.     }
  322.     if((const char*)ptr >= end)
  323.     {
  324. return GSNoValue;
  325.     }
  326.     if(*ptr == '>')
  327.     {
  328. ptr = (const char*)xmlStr.GetNextChar(uLen);
  329. return GSNoValue;
  330.     }
  331.     if(*ptr == '/' && *(ptr + 1) == '>')
  332.     {
  333. xmlStr += 2;
  334. ptr = (const char*)xmlStr++;
  335. return GSNoValue;
  336.     }
  338.     // temp buffer to copy string value
  339.     char* pVal = new char[end - ptr + 1];
  340.     char* pValPtr = pVal;
  341.     char* pValStartPtr = pVal;
  343.     switch(type)
  344.     {
  345. case TagType:
  346. {
  347.     // The main tag name, delimited by space
  348.     if(*ptr == '/')
  349.     {
  350. retval = GSEndTag;
  351. pValStartPtr++;
  352.     }
  353.     while(!isspace(*ptr) && *ptr != '>' && ptr < end)
  354.     {
  355. *pValPtr++ = *ptr;
  356. if(uLen == 2)
  357. {
  358.     *pValPtr++ = *(ptr + 1);
  359. }
  360. ptr = (const char*)xmlStr.GetNextChar(uLen);
  361.     }
  362.     break;
  363. }
  364. case AttributeName:
  365. {
  366.     // Delimited by whitespace or =
  367.     while(!isspace(*ptr) && *ptr != '=' && *ptr != '>' && ptr < end)
  368.     {
  369. *pValPtr++ = *ptr;
  370. if(uLen == 2)
  371. {
  372.     *pValPtr++ = *(ptr + 1);
  373. }
  374. ptr = (const char*)xmlStr.GetNextChar(uLen);
  375.     }
  376.     BOOL foundequals = FALSE;
  377.     if(ptr < end)
  378.     {
  379. // Set the ptr to past the =
  380. while((isspace(*ptr) || *ptr == '=') && ptr < end)
  381. {
  382.     if(*ptr == '=')
  383. foundequals=TRUE;
  384.     ptr = (const char*)xmlStr.GetNextChar(uLen);
  385. }
  386.     }
  387.     if(!foundequals)
  388.     {
  389. retval = GSValueOnly;
  390.     }
  391.     break;
  392. }
  393. case AttributeValue:
  394. case AttributeValueNoQuote:
  395. case AttributeValueDirective:
  396. {
  397.     if(*ptr == '"')
  398.     {
  399. ptr = (const char*)xmlStr.GetNextChar(uLen);
  400. while(ptr<end && *ptr != '"')
  401. {
  402.     if(*ptr == '&')
  403.     {
  404. *pValPtr = GetEscapeMacro(ptr, end);
  405. pValPtr++;
  406. xmlStr.SetCurrent((BYTE*)ptr);
  407.     }
  408.     else
  409.     {
  410. *pValPtr++ = *ptr;
  411. if(uLen == 2)
  412. {
  413.     *pValPtr++ = *(ptr + 1);
  414. }
  415.     }
  416.     ptr = (const char*)xmlStr.GetNextChar(uLen);
  417. }
  418. if(*ptr != '"')
  419. {
  420.     return GSMissingQuote;
  421. }
  422. /* Skip the quote */
  423. ptr = (const char*)xmlStr.GetNextChar(uLen);
  424. //Fixes 28799 (which is really an XML authoring error)
  425. // if m_bXMLandSMIL10FullCompliance is FALSE:
  426. if (m_bXMLandSMIL10FullCompliance  &&
  427. !isspace(*ptr)  &&  '>' != *ptr  &&
  428. (('/' != *ptr  &&  '?' != *ptr)
  429. ||  '>' != *(ptr+1)) )
  430. {
  431.     //[SMIL 1.0 Compliance] Fixes PR 23995.  Junk following a
  432.     // name="value" construct should be treated as an error,
  433.     // e.g., the comma should be treated as an error in the
  434.     // following: <region height="10", width="20"/>
  435.     return GSInvalid;
  436. }
  437.     }
  438.     else if(*ptr == ''')
  439.     {
  440. ptr = (const char*)xmlStr.GetNextChar(uLen);
  441. while(*ptr != ''' && ptr < end)
  442. {
  443.     if(*ptr == '&')
  444.     {
  445. *pValPtr = GetEscapeMacro(ptr, end);
  446. pValPtr++;
  447. xmlStr.SetCurrent((BYTE*)ptr);
  448.     }
  449.     else
  450.     {
  451. *pValPtr++ = *ptr;
  452. if(uLen == 2)
  453. {
  454.     *pValPtr++ = *(ptr + 1);
  455. }
  456.     }
  457.     ptr = (const char*)xmlStr.GetNextChar(uLen);
  458. }
  459. if(*ptr != ''')
  460. {
  461.     delete [] pVal;
  462.     return GSMissingQuote;
  463. }
  464. /* Skip the quote */
  465. ptr = (const char*)xmlStr.GetNextChar(uLen);
  466.     }
  467.     else if(*ptr == '[' && type == AttributeValueDirective)
  468.     {
  469. ptr = (const char*)xmlStr.GetNextChar(uLen);
  470. while(*ptr != ']' && ptr < end)
  471. {
  472.     *pValPtr++ = *ptr;
  473.     if(uLen == 2)
  474.     {
  475. *pValPtr++ = *(ptr + 1);
  476.     }
  477.     ptr = (const char*)xmlStr.GetNextChar(uLen);
  478. }
  479. if(*ptr != ']')
  480. {
  481.     delete[] pVal;
  482.     return GSMissingQuote;
  483. }
  484. /* skip the ']' */
  485. ptr = (const char*)xmlStr.GetNextChar(uLen);
  486.     }
  487.     else
  488.     {
  489. if(m_bStrictCompliance && 
  490.    type != AttributeValueNoQuote &&
  491.    type != AttributeValueDirective)
  492. {
  493.     /* error - value must be quoted */
  494.     delete [] pVal;
  495.     return GSMissingQuote;
  496. }
  497. else
  498. {
  499.     /* don't care!!! */
  500.     while(!isspace(*ptr) && *ptr != '>' && ptr < end)
  501.     {
  502. *pValPtr++ = *ptr;
  503. if(uLen == 2)
  504. {
  505.     *pValPtr++ = *(ptr + 1);
  506. }
  507. ptr = (const char*)xmlStr.GetNextChar(uLen);
  508.     }
  509. }
  510.     }
  511.     break;
  512. }
  513.     }
  515.     *pValPtr = '';
  517.     val = new_string(pValStartPtr);
  518.     delete [] pVal;
  520.     if(retval == GSInvalid)
  521. return GSFoundExpected;
  522.     else
  523. return retval;
  524. }
  526. void
  527. XMLParser::FindCommentClose(const char*& buf, const char* start,
  528.     const char* end)
  529. {
  530.     BOOL   bResult  = FALSE;
  531.     UINT16 nCommentDepth = 1;
  533.     CHXXMLEncode xmlStr(m_pEncoding, (BYTE*)start, end - start);
  534.     UINT16 uLen = 0;
  536.     const char* pos = (const char*)xmlStr.GetNextChar(uLen);
  537.     while(pos < end && m_comment_state > 0)
  538.     {
  539. switch(m_comment_state)
  540. {
  541.     case 1:
  542. if(*pos == '-')
  543.     m_comment_state = 2;
  544. else if (*pos == '<')
  545.     m_comment_state = 4;
  546. else if (*pos == '>' && m_bAllowNonXMLComments)
  547. {
  548.     nCommentDepth--;
  549.     if (nCommentDepth == 0)
  550.     {
  551. m_comment_state = 0;
  552. buf = (const char*)xmlStr.GetNextChar(uLen);
  553.     }
  554.     else
  555. m_comment_state = 1;
  556. }
  557. else if(m_comment_start)
  558. {
  559.     if(*pos == '#')
  560.     {
  561. if(end - pos < 8)
  562. {
  563.     buf = pos;
  564.     return;
  565. }
  566. pos = (const char*)xmlStr.GetNextChar(uLen);
  567. if(strncasecmp(pos, "include", 7) == 0)
  568. {
  569.     pos += 7;
  570.     m_comment_get_arg = 1;
  571.     m_comment_pos = 0;
  572.     strcpy(m_comment_command, "include");
  573. }
  574.     }
  575. }
  576. break;
  577.     case 2:
  578. if(*pos == '-')
  579.     m_comment_state = 3;
  580. else
  581.     m_comment_state = 1;
  582. break;
  583.     case 3:
  584. if(*pos == '>')
  585. {
  586.     nCommentDepth--;
  587.     if (nCommentDepth == 0)
  588.     {
  589. m_comment_state = 0;
  590. buf = (const char*)xmlStr.GetNextChar(uLen);
  591.     }
  592.     else
  593. m_comment_state = 1;
  594. }
  595. else
  596.     m_comment_state = 1;
  597. break;
  598.     case 4:
  599. // Ignore nested comments while looking for our end tag
  600. if (*pos == '!')
  601.     m_comment_state = 5;
  602. else
  603.     m_comment_state = 1;
  604. break;
  605.     case 5:
  606. if (*pos == '-')
  607.     m_comment_state = 6;
  608. else
  609.     m_comment_state = 1;
  610. break;
  611.     case 6:
  612. if (*pos == '-')
  613. {
  614.     nCommentDepth++;
  615. }
  616. m_comment_state = 1;
  617. break;
  618. }
  619. if(m_comment_state > 0)
  620. {
  621.     switch(m_comment_get_arg)
  622.     {
  623. case 1:
  624.     if(*pos != '"' && !isspace(*pos))
  625. m_comment_get_arg = 0;
  626.     else if(*pos == '"')
  627. m_comment_get_arg = 2;
  628.     break;
  629. case 2:
  630.     if(*pos != '"')
  631. if (m_comment_pos < 1023) m_comment_arg[m_comment_pos++] = *pos;
  632.     else
  633.     {
  634. if (m_comment_pos < 1024) m_comment_arg[m_comment_pos] = 0;
  635. m_comment_get_arg = 3;
  636.     }
  637.     break;
  638. default:
  639.     break;
  640.     }
  641. }
  642. pos = (const char*)xmlStr.GetNextChar(uLen);
  643.     }
  644. }
  646. XMLParseResult
  647. XMLParser::Parse(const char*& buf, UINT32 len, XMLTag*& tag, BOOL bIsFinal)
  648. {
  649.     const char* open;
  650.     const char* close;
  651.     const char* cur;
  652.     const char* afterclose;
  653.     
  654.     tag = NULL;
  656.     if(m_comment_state > 0)
  657.     {
  658. FindCommentClose(buf, buf, buf+len);
  659. if(m_comment_state != 0)
  660. {
  661.     SetError(m_pLastError, XMLErrorNoClose, 0, 0, buf, len, 0);
  662.     return XMLPNoClose;
  663. }
  664. else if(m_comment_get_arg != 3)
  665. {
  666.     tag = new XMLTag(m_bStrictCompliance, m_bStoreErrors);
  667.     tag->new_attribute()->value = new_string("");   // dummy tag
  668.     return XMLPComment;
  669. }
  670. // Got a comment command
  671. tag = new XMLTag(m_bStrictCompliance, m_bStoreErrors);
  672. tag->new_attribute()->value = new_string(m_comment_arg);
  673. tag->m_cur_attribute->name = new_string(m_comment_command);
  674. return XMLPComment;
  675.     }
  677.     if(*buf != '<')
  678.     {
  679. // If there isn't a tag right away, tell the user there's just plain
  680. // text here.
  681. UINT32 ulLine = 0;
  682. UINT32 ulCol = 0;
  683. const char* errPos = NULL;
  684. UINT32 errLen = 0;
  686. cur = buf;
  687. while(((UINT32)(cur - buf) < len) && (*cur != '<'))
  688. {
  689.     if(*cur == 'n')
  690.     {
  691. m_ulCurrentLine++;
  692. m_ulCurrentCol = 1;
  693.     }
  694.     else
  695.     {
  696. m_ulCurrentCol++;
  697.     }
  699.     if (m_bStoreErrors)
  700.     {
  701. // check for ]]>
  702. // validate refferences.
  703. if (cur - buf > 3 && *cur == ']' && *(cur+1) == ']' &&
  704.     *(cur+2) == '>' && !errPos)
  705. {
  706.     ulLine = m_ulCurrentLine;
  707.     ulCol = m_ulCurrentCol;
  708.     errPos = buf;
  709.     errLen = len;
  710. }
  711.     }
  712.     cur++;
  713. }
  714. tag = new XMLTag(m_bStrictCompliance, m_bStoreErrors);
  715. char* pText = new char[cur - buf + 1];
  716. strncpy(pText, buf, cur - buf); /* Flawfinder: ignore */
  717. pText[cur - buf] = '';
  718. tag->new_attribute()->value = new_string(pText);
  719. if (errPos)
  720. {
  721.     XMLError* err = NULL;
  722.     SetError(err, XMLErrorInvalidGTafter2RSQB, 
  723. ulLine, ulCol, errPos, errLen, 0);
  724.     tag->m_errs->Add(err);
  725. }
  726. delete [] pText;
  727. buf = cur;
  728. return XMLPPlainText;
  729.     }
  730.     open = buf;
  731.     CHXXMLEncode xmlStr(m_pEncoding, (BYTE*)open, len);
  732.     UINT16 uLen = 0;
  734.     m_ulTagStartLine = m_ulCurrentLine;
  735.     m_ulTagStartCol = m_ulCurrentCol;
  737.     BOOL   bInDoubleQuote = FALSE;
  738.     BOOL   bInSingleQuote = FALSE;
  739.     BOOL   bInComment   = FALSE;
  740.     BOOL   bInDeclaration = FALSE;
  741.     UINT16 nCommentDepth  = 0;
  742.     
  743.     UINT32 ulLine = 0;
  744.     UINT32 ulCol = 0;
  745.     const char* errPos = NULL;
  746.     UINT32 errLen = 0;
  748.     if(*(open+1) && *(open+1) == '!' &&
  749.        *(open+2) && *(open+2) == '-' && 
  750.        *(open+3) && *(open+3) == '-')
  751.     {
  752. // '<!--' starts a comment
  753. bInComment = TRUE;
  754.     }
  755.     for(close = (const char*)xmlStr.GetNextChar(uLen); close < buf+len; close = (const char*)xmlStr.GetNextChar(uLen))
  756.     {
  757. if(*close == 'n')
  758. {
  759.     m_ulCurrentLine++;
  760.     m_ulCurrentCol = 1;
  761. }
  762. else
  763. {
  764.     m_ulCurrentCol++;
  765. }
  766. if(*close == '"' && !bInComment)
  767. {
  768.     if(!bInSingleQuote)
  769.     {
  770. if(bInDoubleQuote)
  771. {
  772.     bInDoubleQuote = FALSE;
  773. }
  774. else
  775. {
  776.     bInDoubleQuote = TRUE;
  777. }
  778.     }
  779. }
  780. else if(*close == ''' && !bInComment)
  781. {
  782.     if(!bInDoubleQuote)
  783.     {
  784. if(bInSingleQuote)
  785. {
  786.     bInSingleQuote = FALSE;
  787. }
  788. else
  789. {
  790.     bInSingleQuote = TRUE;
  791. }
  792.     }
  793. }
  794. else if(*close == '[' && !bInDeclaration)
  795. {
  796.     bInDeclaration = TRUE;
  797. }
  798. else if(*close == ']' && bInDeclaration)
  799. {
  800.     bInDeclaration = FALSE;
  801. }
  802. // Increase the depth if we find a comment within a comment
  803. else if(*(close) == '<' && bInComment)
  804. {
  805.     if(*(close+1) && *(close+1) == '!' &&
  806.        *(close+2) && *(close+2) == '-' && 
  807.        *(close+3) && *(close+3) == '-')
  808.     {
  809. // '<!--' starts a comment
  810. nCommentDepth++;
  811.     }
  812. }
  813. else if(*close == '>')
  814. {
  815.     // If we are in a comment, we should only stop at a comment end
  816.     // (Comments must end with "-->")
  817.     if (bInComment)
  818.     {
  819. if ((!m_bAllowNonXMLComments &&
  820.      (close - open) > 5      && 
  821.      *(close-1) == '-'       && 
  822.      *(close-2) == '-')          ||
  823.     (m_bAllowNonXMLComments  &&
  824.      (close - open) > 3))
  825. {
  826.     nCommentDepth--;
  827.     if (!nCommentDepth)
  828.     {
  829. break;
  830.     }
  831. }
  832.     }
  833.     else
  834.     {
  835. if (!bInDoubleQuote && !bInSingleQuote && !bInDeclaration)
  836. {
  837.     break;
  838. }
  839.     }
  840. }
  842. if (m_bStoreErrors && bInComment && !errPos)
  843. {
  844.     if (*close == '-' && *(close+1) == '-' 
  845. && *(close + 2) != '>' && (close - open > 4))
  846.     {
  847. ulLine = m_ulCurrentLine;
  848. ulCol = m_ulCurrentCol;
  849. errPos = buf;
  850. errLen = len;
  851.     }
  852. }
  853.     }
  855.     if( (close<=buf+len) && *close != '>')
  856.     {
  857. if(!bIsFinal)
  858. {
  859.     return XMLPNotDone;
  860. }
  861. SetError(m_pLastError, XMLErrorNoClose, 0, 0, buf, len, 0);
  862. buf = open;
  863. return XMLPNoClose;
  864.     }
  866.     afterclose = close+1;
  868.     if(*(open+1) == '!')
  869.     {
  870. if(*(open+2) == '-' && *(open+3) == '-')
  871. {
  872.     // '<!--' starts a comment
  873.     m_comment_state = 1;
  874.     m_comment_start = TRUE;
  875.     m_bCommentWasFound = TRUE;
  876.     FindCommentClose(buf, open+4, buf + len);
  877.     if(m_comment_state != 0)
  878.     {
  879. SetError(m_pLastError, XMLErrorNoClose, 0, 0, buf, len, 0);
  880. return XMLPNoClose;
  881.     }
  882.     else if(m_comment_get_arg != 3)
  883.     {
  884. tag = new XMLTag(m_bStrictCompliance, m_bStoreErrors);
  885. const char* pBeginComment = open + 4;
  886. int commentLen = buf - pBeginComment - 3;
  887. tag->new_attribute()->value = new_string(pBeginComment, commentLen);
  888. if (errPos)
  889. {
  890.     XMLError* err = NULL;
  891.     SetError(err, XMLErrorTwoDashNotAllowed, ulLine,
  892. ulCol, errPos, errLen, 0);
  893.     tag->m_errs->Add(err);
  894. }
  895. return XMLPComment;
  896.     }
  897.     // Got a comment command
  898.     tag = new XMLTag(m_bStrictCompliance, m_bStoreErrors);
  899.     tag->new_attribute()->value = new_string(m_comment_arg);
  900.     tag->m_cur_attribute->name = new_string(m_comment_command);
  901.     return XMLPComment;
  902. }
  903. XMLParseResult rc = ParseTag(open+1, close, XMLDirectiveTag, tag);
  904. if(XMLPTag == rc)
  905. {
  906.     // TODO - Scan Directive 
  907.     buf = afterclose;
  908.     return XMLPDirective;
  909. }
  910. else if(XMLPAttributeValueNotQuoted == rc)
  911. {
  912.     SetError(m_pLastError, XMLErrorMissingQuote, 0, 0, buf, len, 0);
  913. }
  914. else
  915. {
  916.     SetError(m_pLastError, XMLErrorNoClose, 0, 0, buf, len, 0);
  917. }
  918. buf = afterclose;
  919. return XMLPBadDirective;
  920.     }
  921.     
  922.     if(*(open + 1) == '?')
  923.     {
  924. // A Processing Instruction
  925. XMLParseResult rc = ParseTag(open+1, close, XMLProcInstTag, tag);
  926. if(XMLPTag == rc)
  927. {
  928.     buf = afterclose;
  929.     if (m_bStrictCompliance)
  930.     {
  931. //[SMIL 1.0 Compliance] Fixes PR 9862.  No comment can
  932. // precede a processor instruction (xml prolog):
  933. if (m_bCommentWasFound  &&  m_bXMLandSMIL10FullCompliance)
  934. {
  935.     SetError(m_pLastError, XMLErrorCommentBeforeProcInst,
  936.     0, 0, buf, len, 0);
  937.     return XMLPCommentBeforeProcInst;
  938. }
  940. if (m_bStoreErrors)
  941. {
  942.     XMLError* err = NULL;
  943.     SetError(err, XMLErrorCommentBeforeProcInst,
  944.     0, 0, buf, len, 0);
  945.     tag->m_errs->Add(err);
  946. }
  947.     }
  949.     if (m_bStoreErrors)
  950.     {
  951. ScanTag(open+1, close, tag);
  952.     }
  953.     
  954.     return XMLPProcInst;
  955. }
  956.         SetError(m_pLastError, XMLErrorNoClose, 0, 0, buf, len, 0);
  957. return XMLPBadProcInst;
  958.     }
  959.     // just a plain old tag
  960.     XMLParseResult rc = ParseTag(open, close, XMLPlainTag, tag);
  961.     if(XMLPTag == rc)
  962.     {
  963. buf = afterclose;
  964. if (m_bStoreErrors)
  965. {
  966.     ScanTag(open, close, tag);
  967. }
  968. return XMLPTag;
  969.     }
  970.     else if(XMLPBadEndTag == rc)
  971.     {
  972. if(m_pCurrentFrame && m_pCurrentFrame->name)
  973. {
  974.     SetError(m_pLastError, XMLErrorBadEndTag, 0, 0, buf, len, m_pCurrentFrame->name);
  975. }
  976. else
  977. {
  978.     SetError(m_pLastError, XMLErrorBadEndTag, 0, 0, buf, len, 0);
  979. }
  980.     }
  981.     else if(XMLPBadAttribute == rc)
  982.     {
  983. SetError(m_pLastError, XMLErrorBadAttribute, 0, 0, buf, len, 0);
  984.     }
  985.     else if(XMLPAttributeValueNotQuoted == rc)
  986.     {
  987. SetError(m_pLastError, XMLErrorMissingQuote, 0, 0, buf, len, 0);
  988.     }
  989.     else if(XMLPDupAttribute == rc)
  990.     {
  991. SetError(m_pLastError, XMLErrorDupAttribute, 0, 0, buf, len, 0);
  992.     }
  993.     else
  994.     {
  995. SetError(m_pLastError, XMLUnknownError, 0, 0, buf, len, 0);
  996.     }
  998.     return rc;
  999. }
  1001. XMLParseResult
  1002. XMLParser::ParseTag(const char* open, const char* close, XMLTagType tType, XMLTag*& tag)
  1003. {
  1004.     const char* cur = open+1;
  1005.     const char* afterclose = close+1;
  1006.     BOOL bHasAttributeNames = TRUE;
  1007.     BOOL bUseNonQuotedValues = FALSE;
  1008.     BOOL bHasDirectives = FALSE;
  1010.     tag = new XMLTag(m_bStrictCompliance, m_bStoreErrors);
  1012.     switch(tType)
  1013.     {
  1014. case XMLPlainTag:
  1015. {
  1016.     if(*(close - 1) == '/')
  1017.     {
  1018. tag->m_need_close = FALSE;
  1019. close--;
  1020.     }
  1021. }
  1022. break;
  1023. case XMLProcInstTag:
  1024. {
  1025.     tag->m_need_close = FALSE;
  1026.     if(*(close - 1) == '?')
  1027.     {
  1028. close--;
  1029.     }
  1030. }
  1031. break;
  1032. case XMLDirectiveTag:
  1033. {
  1034.     bHasAttributeNames = FALSE;
  1035.     bUseNonQuotedValues = TRUE;
  1036.     bHasDirectives = TRUE;
  1037.     tag->m_need_close = FALSE;
  1038. }
  1039. break;
  1040. default:
  1041. {
  1042.     tag->m_need_close = FALSE;
  1043. }
  1044. break;
  1045.     }
  1046.     tag->m_type = tType;
  1048.     GetStringResult res = GetString(cur, close, tag->m_name, TagType);
  1049.     if(res == GSEndTag)
  1050.     {
  1051. tag->m_type = XMLEndTag;
  1052. tag->m_need_close = FALSE;
  1053. if(!m_pCurrentFrame ||
  1054.     !m_pCurrentFrame->name)
  1055. {
  1056.     return XMLPBadEndTag;
  1057. }
  1059. if(m_bStrictCompliance)
  1060. {
  1061.     if(strcmp(tag->m_name, m_pCurrentFrame->name) != 0)
  1062.     {
  1063. return XMLPBadEndTag;
  1064.     }
  1065. }
  1066. else
  1067. {
  1068.     if(strcasecmp(tag->m_name, m_pCurrentFrame->name) != 0)
  1069.     {
  1070. return XMLPBadEndTag;
  1071.     }
  1072. }
  1073. tag->elem = m_pCurrentFrame->elemcount;
  1074. if(m_pCurrentFrame)
  1075.     delete m_pCurrentFrame;
  1076. m_pCurrentFrame = (XMLFrame*)m_pStack.Pop();
  1077. return XMLPTag;
  1078.     }
  1079.     else if(res == GSMissingQuote)
  1080.     {
  1081. delete tag;
  1082. tag = NULL;
  1083. return XMLPAttributeValueNotQuoted;
  1084.     }
  1085.     else if(tag->m_name && tag->m_need_close)
  1086.     {
  1087. tag->elem = m_pCurrentFrame->elemcount++;
  1089. XMLFrame* frame = new XMLFrame;
  1090. frame->elemcount = 0;
  1091. frame->name = new_string(tag->m_name);
  1092. m_pStack.Push(m_pCurrentFrame);
  1093. m_pCurrentFrame = frame;
  1094.     }
  1095.     else
  1096.     {
  1097. tag->elem = m_pCurrentFrame->elemcount++;
  1098.     }
  1100.     if(GSFoundExpected != res)
  1101.     {
  1102. delete tag;
  1103. tag = NULL;
  1104. return XMLPNoTagType;
  1105.     }
  1106.     else
  1107.     {
  1108. while(cur < close)
  1109. {
  1110.     if(bHasAttributeNames)
  1111.     {
  1112. GetStringResult res = GetString(cur, close, 
  1113. tag->new_attribute()->name,
  1114. AttributeName);
  1115. if(res == GSNoValue)
  1116. {
  1117.     delete tag->m_cur_attribute;
  1118.     tag->m_numAttributes--;
  1119.     break;
  1120. }
  1121. switch(res)
  1122. {
  1123.     case GSValueOnly:
  1124. // The user of this parser will fill in the name of this
  1125. // attribute
  1126. tag->m_cur_attribute->value = tag->m_cur_attribute->name;
  1127. tag->m_cur_attribute->name = NULL;
  1128. continue;
  1129.     case GSFoundExpected:
  1130. break;
  1131.     default:
  1132. delete tag;
  1133. tag = NULL;
  1134. return XMLPBadAttribute;
  1135. }
  1136.     }
  1137.     else
  1138.     {
  1139. tag->new_attribute()->name = 0;
  1140.     }
  1142.     if(bUseNonQuotedValues)
  1143.     {
  1144. if(bHasDirectives)
  1145. {
  1146.     res = GetString(cur, close,
  1147.     tag->m_cur_attribute->value,
  1148.     AttributeValueDirective);
  1149. }
  1150. else
  1151. {
  1152.     res = GetString(cur, close,
  1153.     tag->m_cur_attribute->value,
  1154.     AttributeValueNoQuote);
  1155. }
  1156.     }
  1157.     else
  1158.     {
  1159. res = GetString(cur, close,
  1160. tag->m_cur_attribute->value,
  1161. AttributeValue);
  1162.     }
  1163.     if(res == GSMissingQuote)
  1164.     {
  1165. delete tag;
  1166. tag = NULL;
  1167. return XMLPAttributeValueNotQuoted;
  1168.     }
  1169.     else if(res != GSFoundExpected)
  1170.     {
  1171. delete tag;
  1172. tag = NULL;
  1173. return XMLPBadAttribute;
  1174.     }
  1175. }
  1176.     }
  1178.     if(m_bStrictCompliance)
  1179.     {
  1180. // error on duplicate attributes
  1181. CHXMapStringToOb dupMap;
  1182. BOOL bDupFound = FALSE;
  1183. XMLAttribute* pAttr = NULL;
  1184. for(UINT32 i=0;i<tag->m_numAttributes;++i)
  1185. {
  1186.     pAttr = tag->attribute(i);
  1188.     void* pLookupValue = NULL;
  1189.     if(pAttr->name)
  1190.     {
  1191. if(dupMap.Lookup(pAttr->name, pLookupValue))
  1192. {
  1193.     bDupFound = TRUE;
  1194.     break;
  1195. }
  1196. else
  1197. {
  1198.     dupMap.SetAt(pAttr->name, NULL);
  1199. }
  1200.     }
  1201. }
  1202. if(bDupFound)
  1203. {
  1204. #if defined(XXXEH_CHECK_THIS_IN_AFTER_U2_RELEASE)
  1205.     return XMLPDupAttribute;
  1206. #else /* XXXEH- Back out BAB's fix for PR 9172 because it breaks a lot of
  1207.        * old content (this rebreaks PR 9172 and fixes PR 12447)
  1208.        */
  1209.     HX_ASSERT(1); //line exists only for setting a breakpoint.
  1210. #endif
  1211. }
  1212.     }
  1214.     return XMLPTag;
  1215. }
  1219. XMLParseResult
  1220. XMLParser::ScanTag(const char* open, const char* close, XMLTag* tag)
  1221. {
  1222.     const char* cur = open+1;
  1223.     const char* afterclose = close+1;
  1224.     char cQuote = '"';
  1226.     CHXXMLEncode xmlStr(m_pEncoding, (BYTE*)cur, close - cur);
  1227.     UINT16 uLen = 0;
  1228.     const char* ptr = (const char*)xmlStr.GetNextChar(uLen);
  1230.     //tag->m_need_close
  1231.     //tag->m_type;
  1234.     // check the spacing....
  1235.     switch (tag->m_type)
  1236.     {
  1237.     case XMLEndTag:
  1238. {
  1239.     // scan name...
  1240.     if (!xmlStr.IsNameValid((const BYTE*)tag->m_name, strlen(tag->m_name)))
  1241.     {
  1242. XMLError* err = NULL;
  1243. SetError(err, XMLErrorInvalidName, m_ulTagStartLine, m_ulTagStartCol, 
  1244.     tag->m_name, strlen(tag->m_name), 0);
  1245. tag->m_errs->Add(err);
  1246.     }
  1247. }
  1248. break;
  1249.     case XMLPlainTag:
  1250.     case XMLProcInstTag:
  1251. {
  1252.     // scan tag
  1253.     if (!xmlStr.IsNameValid((const BYTE*)tag->m_name, strlen(tag->m_name)))
  1254.     {
  1255. XMLError* err = NULL;
  1256. SetError(err, XMLErrorInvalidName, m_ulTagStartLine, m_ulTagStartCol, 
  1257.     tag->m_name, strlen(tag->m_name), 0);
  1258. tag->m_errs->Add(err);
  1259.     }
  1261.     // check PI name
  1262.     //if (!xmlStr.IsPINameValid(tag->m_name, strlen(tag->m_name)))
  1263.     //{
  1264. // XMLError* err = NULL;
  1265. // SetError(err, XMLErrorInvalidPITarget, m_ulTagStartLine, m_ulTagStartCol, 
  1266. //     tag->m_name, strlen(tag->m_name), 0);
  1267. // tag->m_errs->Add(err);
  1268.   //  }
  1270.     // check the spacing.
  1271.     enum { InTagName, InTag, InBeginAttributeName, InAttributeName, 
  1272. InEndAttributeName, InBeginAttributeValue, InAttributeValue, Done } state;
  1273.     state = InTagName;
  1274.     
  1275.     for (const char* pos = cur; *pos && pos < close && state != Done;
  1276. pos = (const char*)xmlStr.GetNextChar(uLen))
  1277.     {
  1278. switch (state)
  1279. {
  1280. case InTagName:
  1281.     {
  1282. // go to first white space
  1283. if ( isspace(*pos) )
  1284. {
  1285.     state = InBeginAttributeName;
  1286. }
  1287. else if ( *pos == '>' )
  1288. {
  1289.     // done
  1290.     state = Done;
  1291. }
  1292.     }
  1293.     break;
  1294. case InTag:
  1295.     {
  1296. if ( *pos == '>' || (*pos == '/' && 
  1297.     *(pos+1) == '>'))
  1298. {
  1299.     // done.
  1300.     state = Done;
  1301. }
  1302. else
  1303. {
  1304.     // grab the first char... keep it and switch states.
  1305.     // it should be a space... 
  1306.     state = InBeginAttributeName;
  1307.     if (!isspace(*pos))
  1308.     {
  1309. XMLError* err = NULL;
  1310. SetError(err, XMLErrorMissingReqSpace, m_ulTagStartLine, m_ulTagStartCol, 
  1311.     tag->m_name, strlen(tag->m_name), 0);
  1312. tag->m_errs->Add(err);
  1313.     }
  1314. }
  1315.     }
  1316.     break;
  1317. case InBeginAttributeName:
  1318.     {
  1319. if ( isspace(*pos) )
  1320. {
  1321.     // continue...
  1322. }
  1323. else if ( *pos == '=' )
  1324. {
  1325.     XMLError* err = NULL;
  1326.     SetError(err, XMLErrorMissingEquals, m_ulTagStartLine, m_ulTagStartCol, 
  1327. tag->m_name, strlen(tag->m_name), 0);
  1328.     tag->m_errs->Add(err);
  1329.     state = InBeginAttributeValue;
  1330. }
  1331. else if ( *pos == '>' || (*pos == '/' 
  1332.     && *(pos+1) == '>'))
  1333. {
  1334.     // done
  1335.     state = Done;
  1336. }
  1337. else
  1338. {
  1339.     state = InAttributeName;
  1340. }
  1341.     }
  1342.     break;
  1343. case InAttributeName:
  1344.     {
  1345. if ( isspace(*pos) )
  1346. {
  1347.     state = InEndAttributeName;
  1348. }
  1349. else if ( *pos == '=' )
  1350. {
  1351.     state = InBeginAttributeValue;
  1352. }
  1353. else if ( *pos == '>' )
  1354. {
  1355.     XMLError* err = NULL;
  1356.     SetError(err, XMLErrorMissingEquals, m_ulTagStartLine, m_ulTagStartCol, 
  1357. tag->m_name, strlen(tag->m_name), 0);
  1358.     
  1359.     tag->m_errs->Add(err);
  1360.     // done
  1361.     state = Done;
  1362. }
  1363. else if (*pos == ''' || *pos == '"')
  1364. {
  1365.     XMLError* err = NULL;
  1366.     SetError(err, XMLErrorBadAttribute, m_ulTagStartLine, m_ulTagStartCol, 
  1367. tag->m_name, strlen(tag->m_name), 0);
  1368.     tag->m_errs->Add(err);
  1370.     cQuote = *pos;
  1371.     state = InAttributeValue;
  1372. }
  1373.     }
  1374.     break;
  1375. case InEndAttributeName:
  1376.     {
  1377. if ( isspace(*pos) )
  1378. {
  1379.     // continue..
  1380. }
  1381. else if ( *pos == '=' )
  1382. {
  1383.     state = InBeginAttributeValue;
  1384. }
  1385. else if ( *pos == '>' )
  1386. {
  1387.     XMLError* err = NULL;
  1388.     SetError(err, XMLErrorMissingEquals, m_ulTagStartLine, m_ulTagStartCol, 
  1389. tag->m_name, strlen(tag->m_name), 0);
  1390.     tag->m_errs->Add(err);
  1391.     state = Done;
  1392. }
  1393. else
  1394. {
  1395.     // hmm. we got a non whitespace before the =
  1397.     //First, let's see if we have a ["] or a [']
  1398.     // (i.e., an attribute value start) in which
  1399.     // case the author must have forgotten to
  1400.     // put an '=' between the name/value pair.
  1401.     // In this case, we need to keep the renderers
  1402.     // from firing off an error with old bad content,
  1403.     // so we pretend we're in the "InAttributeValue"
  1404.     // state:
  1405.     if ( *pos == ''' )
  1406.     {
  1407. XMLError* err = NULL;
  1408. SetError(err, XMLErrorBadAttribute, m_ulTagStartLine, m_ulTagStartCol, 
  1409.     tag->m_name, strlen(tag->m_name), 0);
  1410. tag->m_errs->Add(err);
  1411. cQuote = *pos;
  1412. state = InAttributeValue;
  1413.     }
  1414.     else if ( *pos == '"' )
  1415.     {
  1416. XMLError* err = NULL;
  1417. SetError(err, XMLErrorBadAttribute, m_ulTagStartLine, m_ulTagStartCol, 
  1418.     tag->m_name, strlen(tag->m_name), 0);
  1419. tag->m_errs->Add(err);
  1420. cQuote = *pos;
  1421. state = InAttributeValue;
  1422.     }
  1423.     else
  1424.     {
  1425. XMLError* err = NULL;
  1426. SetError(err, XMLErrorBadAttribute, m_ulTagStartLine, m_ulTagStartCol, 
  1427. tag->m_name, strlen(tag->m_name), 0);
  1428. tag->m_errs->Add(err);
  1429. // lets go back to the attribute name state.
  1430. state = InAttributeName;
  1431.     }
  1432. }
  1433.     }
  1434.     break;
  1435. case InBeginAttributeValue:
  1436.     {
  1437. if ( isspace(*pos) )
  1438. {
  1439. }
  1440. else if ( *pos == ''' || *pos == '"')
  1441. {
  1442.     cQuote = *pos;
  1443.     state = InAttributeValue;
  1444. }
  1445. else if ( *pos == '>' )
  1446. {
  1447.     XMLError* err = NULL;
  1448.     SetError(err, XMLErrorMissingEquals, m_ulTagStartLine, m_ulTagStartCol, 
  1449. tag->m_name, strlen(tag->m_name), 0);
  1450.     tag->m_errs->Add(err);
  1451.     // done
  1452.     state = Done;
  1453. }
  1454.     }
  1455.     break;
  1456. case InAttributeValue:
  1457.     {
  1458. if ( *pos == cQuote )
  1459. {
  1460.     state = InTag;
  1461. }
  1462.     }
  1463.     break;
  1464. }
  1465.     }
  1467. }
  1468. break;
  1469.     case XMLCommentTag:
  1470. {
  1471.     // we will not scan...
  1472. }
  1473. break;
  1474.     case XMLDirectiveTag:
  1475. {
  1476.     // TODO: scan Directive.
  1477. }
  1478. break;
  1479.     }
  1481.     // error on duplicate attributes
  1482.     // also validate the names and attributes.
  1483.     CHXMapStringToOb dupMap;
  1484.     BOOL bDupFound = FALSE;
  1485.     XMLAttribute* pAttr = NULL;
  1486.     const char* name = NULL;
  1487.     for(UINT32 i=0;i<tag->m_numAttributes;++i)
  1488.     {
  1489. pAttr = tag->attribute(i);
  1491. if (!xmlStr.IsNameValid((const BYTE*)pAttr->name, strlen(pAttr->name)))
  1492. {
  1493.     XMLError* err = NULL;
  1494.     SetError(err, XMLErrorInvalidName, m_ulTagStartLine, m_ulTagStartCol, 
  1495.     pAttr->name, strlen(pAttr->name), 0);
  1496.     tag->m_errs->Add(err);
  1497. }
  1498. if (!xmlStr.IsAttValueValid((const BYTE*)pAttr->value, strlen(pAttr->value)))
  1499. {
  1500.     XMLError* err = NULL;
  1501.     SetError(err, XMLErrorInvalidCharInDoc, m_ulTagStartLine, m_ulTagStartCol, 
  1502.     pAttr->value, strlen(pAttr->value), 0);
  1503.     tag->m_errs->Add(err);
  1504. }
  1507. void* pLookupValue = NULL;
  1508. if(pAttr->name)
  1509. {
  1510.     if(dupMap.Lookup(pAttr->name, pLookupValue))
  1511.     {
  1512. name = pAttr->name;
  1513. bDupFound = TRUE;
  1514. break;
  1515.     }
  1516.     else
  1517.     {
  1518. dupMap.SetAt(pAttr->name, NULL);
  1519.     }
  1520. }
  1521.     }
  1523.     if (bDupFound)
  1524.     {
  1525. XMLError* err = NULL;
  1526. SetError(err, XMLErrorDupAttribute, m_ulTagStartLine, m_ulTagStartCol, 
  1527. name, strlen(name), 0);
  1528. tag->m_errs->Add(err);
  1529.     }
  1531.     return XMLPTag;
  1532. }
  1533.     
  1534. void XMLParser::SetEncoding(const char* pszEncoding)
  1535. {
  1536.     if (pszEncoding)
  1537.     {
  1538.         INT32 lLen = strlen(pszEncoding);
  1539.         if (lLen > 0)
  1540.         {
  1541.             HX_VECTOR_DELETE(m_pEncoding);
  1542.             m_pEncoding = new char [lLen + 1];
  1543.             if (m_pEncoding)
  1544.             {
  1545.                 strcpy(m_pEncoding, pszEncoding);
  1546.             }
  1547.         }
  1548.     }
  1549. }
  1551. HX_RESULT XMLParser::GetEncoding(REF(char*) rpszEncoding)
  1552. {
  1553.     HX_RESULT retVal = HXR_FAIL;
  1555.     if (m_pEncoding)
  1556.     {
  1557.         HX_VECTOR_DELETE(rpszEncoding);
  1558.         rpszEncoding = new char [strlen(m_pEncoding) + 1];
  1559.         if (rpszEncoding)
  1560.         {
  1561.             strcpy(rpszEncoding, m_pEncoding);
  1562.             retVal = HXR_OK;
  1563.         }
  1564.     }
  1566.     return retVal;
  1567. }
  1569. void
  1570. XMLParser::SetError(REF(XMLError*) pErr, XMLErrorTag tag, INT32 lLine,
  1571.     INT32 lPos, const char* pErrorText, INT32 lErrorTextLen,
  1572.     const char* pFrameText)
  1573. {
  1574.     HX_DELETE(m_pLastError);
  1576.     INT32 lTextLen = 
  1577. (lErrorTextLen > MAX_ERROR_LEN) ? MAX_ERROR_LEN: lErrorTextLen;
  1578.     char tmpBuf[MAX_ERROR_LEN * 2]; // overdo it a bit...
  1580.     // convert control characters to spaces
  1581.     INT32 j = 0;
  1582.     for(INT32 i = 0; i < lTextLen; ++i)
  1583.     {
  1584. if(iscntrl(pErrorText[i]))
  1585. {
  1586.     tmpBuf[j++] = ' ';
  1587. }
  1588. else
  1589. {
  1590.     tmpBuf[j++] = pErrorText[i];
  1591. }
  1592.     }
  1593.     tmpBuf[j] = 0;
  1595.     pErr = new XMLError(tag, lLine, lPos, tmpBuf, pFrameText);
  1596. }
  1598. XMLTag::XMLTag(BOOL bStrictCompliance, BOOL bStoreErrors):
  1599.     m_bStrictCompliance(bStrictCompliance)
  1600. {
  1601.     m_numAttributes = 0;
  1602.     m_name = NULL;
  1603.     m_type = XMLPlainTag;
  1604.     m_need_close = TRUE;
  1605.     m_errs = NULL;
  1607.     if (bStoreErrors)
  1608.     {
  1609. m_errs = new CHXPtrArray();
  1610.     }
  1611. }
  1613. XMLTag::~XMLTag()
  1614. {
  1615.     UINT32 i;
  1616.     for(i = 0; i < m_numAttributes; i++)
  1617.     {
  1618. delete (XMLAttribute*)m_attributes[(int)i];
  1619.     }
  1621.     HX_VECTOR_DELETE(m_name);
  1623.     if (m_errs)
  1624.     {
  1625. UINT32 size = m_errs->GetSize();
  1626. for(i = 0; i < size; i++)
  1627. {
  1628.     delete (XMLError*)(*m_errs)[(int)i];
  1629. }
  1630. HX_DELETE(m_errs);
  1631.     }
  1632. }
  1634. XMLAttribute*
  1635. XMLTag::new_attribute()
  1636. {
  1637.     m_cur_attribute = new XMLAttribute;
  1638.     
  1639.     m_attributes.SetAtGrow((int)m_numAttributes, m_cur_attribute);
  1640.     m_numAttributes++;
  1642.     return m_cur_attribute;
  1643. }
  1645. const char*
  1646. XMLTag::get_attribute(const char* name)
  1647. {
  1648.     for(UINT32 i = 0; i < m_numAttributes; i++)
  1649.     {
  1650. if(((XMLAttribute*)m_attributes[(int)i])->name)
  1651. {
  1652.     if(m_bStrictCompliance)
  1653.     {
  1654. if(strcmp(((XMLAttribute*)m_attributes[(int)i])->name, name) == 0)
  1655. {
  1656.     return (const char*)((XMLAttribute*)m_attributes[(int)i])->value;
  1657. }
  1658.     }
  1659.     else
  1660.     {
  1661. if(strcasecmp(((XMLAttribute*)m_attributes[(int)i])->name, name) == 0)
  1662. {
  1663.     return (const char*)((XMLAttribute*)m_attributes[(int)i])->value;
  1664. }
  1665.     }
  1666. }
  1667.     }
  1668.     return NULL;
  1669. }
  1672. /*
  1673.  * XMLError methods
  1674.  */
  1676. XMLError::XMLError(XMLErrorTag errorTag,
  1677.    INT32 lLineNumber,
  1678.    INT32 lLinePosition,
  1679.    const char* pErrorString,
  1680.    const char* pFrameString):
  1681.     m_errorTag(errorTag),
  1682.     m_lLineNumber(lLineNumber),
  1683.     m_lLinePosition(lLinePosition),
  1684.     m_pErrorString(0),
  1685.     m_pFrameString(0)
  1686. {
  1687.     if(pErrorString)
  1688.     {
  1689. m_pErrorString = new_string(pErrorString);
  1690.     }
  1691.     if(pFrameString)
  1692.     {
  1693. m_pFrameString = new_string(pFrameString);
  1694.     }
  1695. }
  1697. XMLError::~XMLError()
  1698. {
  1699.     delete[] m_pErrorString;
  1700.     delete[] m_pFrameString;
  1701. }