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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
looseprs.cpp
资源名称：142_61_thumb_advanced.rar　[点击查看]
上传用户：dangjiwu
上传日期：2013-07-19
资源大小：42019k
文件大小：40k
源码类别：

Symbian

开发平台：

Visual C++

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