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

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

Symbian

开发平台：

Visual C++

xmlesc.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: xmlesc.cpp,v 1.8.2.1 2004/07/19 21:04:07 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. //   $Id: xmlesc.cpp,v 1.8.2.1 2004/07/19 21:04:07 hubbe Exp $
  52. /*******************************************************************
  53.  *
  54.  *  NAME: xmlesc.cpp
  55.  *
  56.  *  CLASS
  57.  * CEscapeXMLtoHTML
  58.  *
  59.  *  DESCRIPTION:
  60.  * The implmentation for a class that escapes all the XML characters
  61.  * that are not printable in HTML.  A IHXBuffer is passed into the
  62.  * class on throgh the Convert Method. This is a pure virtual class.
  63.  * The CheckTag, and OnTag functions must be implemented in a child
  64.  * class.
  65.  *
  66.  *  NOTES:
  67.  * Started with Mozilla's ColorHTML function
  68.  *
  69.  *******************************************************************/
  71. #include "hxcom.h"     /* IUnknown */
  72. #include "hxtypes.h" 
  73. #include "hxbuffer.h"
  74. #include "hxiids.h"
  75. #include "hxstrutl.h"
  76. #include "hxstring.h"
  77. #include "perplex.h"
  78. #include "rtsputil.h"
  80. #include "growingq.h"
  81. #include "xmlesc.h"
  82. #include "vsrcinfo.h"
  84. #include "hlxclib/string.h"
  86. /*___________________________________________________________________________
  87.  *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  88.  * Static variable declarations
  89.  *___________________________________________________________________________
  90.  *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
  91. const char* const
  92. CEscapeXMLtoHTML::m_pDefaultTags[20] = 
  93. {
  94.      tag_BEGIN_TAG
  95.     ,tag_END_TAG
  96.     ,tag_BEGIN_TAG_NAME
  97.     ,tag_END_TAG_NAME
  98.     ,tag_BEGIN_ATTRIBUTE
  99.     ,tag_END_ATTRIBUTE
  100.     ,tag_BEGIN_BROKEN_ATT
  101.     ,tag_END_BROKEN_ATT
  102.     ,tag_BEGIN_COMMENT
  103.     ,tag_END_COMMENT
  104.     ,tag_BEGIN_AMPERSAND
  105.     ,tag_END_AMPERSAND
  106.     ,tag_BEGIN_HREF
  107.     ,tag_END_HREF
  108.     ,tag_PROCESSING_INSTRUCTIONS
  109.     ,tag_END_PI
  110.     ,tag_BEGIN_CDATA
  111.     ,tag_END_CDATA
  112.     ,tag_BEGIN_DTD
  113.     ,tag_END_DTD
  114. };
  116. const char* const
  117. CEscapeXMLtoHTML::m_pStyleTags[20] =
  118. {
  119.      style_BEGIN_TAG
  120.     ,style_END_TAG
  121.     ,style_BEGIN_TAG_NAME
  122.     ,style_END_TAG_NAME
  123.     ,style_BEGIN_ATTRIBUTE
  124.     ,style_END_ATTRIBUTE
  125.     ,style_BEGIN_BROKEN_ATT
  126.     ,style_END_BROKEN_ATT
  127.     ,style_BEGIN_COMMENT
  128.     ,style_END_COMMENT
  129.     ,style_BEGIN_AMPERSAND
  130.     ,style_END_AMPERSAND
  131.     ,style_BEGIN_HREF
  132.     ,style_END_HREF
  133.     ,style_PROCESSING_INSTRUCTIONS
  134.     ,style_END_PI
  135.     ,style_BEGIN_CDATA
  136.     ,style_END_CDATA
  137.     ,style_BEGIN_DTD
  138.     ,style_END_DTD
  139. };
  141. /*___________________________________________________________________________
  142.  *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  143.  * Public Methods
  144.  *___________________________________________________________________________
  145.  *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
  146. /*___________________________________________________________________________
  147.  *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  148.  *  CEscapeXMLtoHTML(pServerUrl, pOurPath)
  149.  *
  150.  *  PARAMETERS:
  151.  * pServerUrl  Full url to the server including the template file. 
  152.  * pOurPath    The Relative path of the file currently being parsed
  153.  *     no trailing "/"
  154.  * bMangleLinks    - to mangle or not
  155.  * bUseStyles - output in styles or regular HTML
  156.  * pHotTags - The tags that we will call OnTag For.
  157.  * pDefaultView    - The default viewsource to use for remote rstp
  158.  *   links ":port/viewmount/viewfile"
  159.  *  DESCRIPTION:
  160.  * Constructor.
  161.  * This is the primary means of creating an instance of CEscapeXMLtoHTML.
  162.  *___________________________________________________________________________
  163.  *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
  164. CEscapeXMLtoHTML::CEscapeXMLtoHTML(IHXValues* pOptions, const char** pHotTags) 
  165. : m_pEscapeStrings(NULL)
  166. , m_pServerUrl(NULL)
  167. , m_pOurPath(NULL)
  168. , m_pHotTags(NULL)
  169. , m_pDefaultView(NULL)
  170. , m_pFileName(NULL)
  171. , m_pRamGen(NULL)
  172. , m_ulModDate(0)
  173. , m_ulFileSize(0)
  174. {
  175.     m_pHotTags = pHotTags;
  177.     IHXBuffer* pViewURL = NULL;
  178.     IHXBuffer* pCurrentPath = NULL;
  179.     IHXBuffer* pRemoteView = NULL;
  180.     IHXBuffer* pFileName = NULL;
  181.     UINT32 ulMangle = 0;
  182.     UINT32 ulStyles = 0;
  183.     if ( FAILED(pOptions->GetPropertyCString("ViewSourceURL", pViewURL)) ||
  184.  FAILED(pOptions->GetPropertyCString("CurrentPath", pCurrentPath)) ||
  185.  FAILED(pOptions->GetPropertyULONG32("HidePaths", ulMangle)) ||
  186.  FAILED(pOptions->GetPropertyULONG32("UseStyles", ulStyles)) ||
  187.  FAILED(pOptions->GetPropertyCString("RemoteViewSourceURL", pRemoteView)) ||
  188.  FAILED(pOptions->GetPropertyCString("FileName", pFileName)) ||
  189.  FAILED(pOptions->GetPropertyULONG32("ModificationTime", m_ulModDate)) ||
  190.  FAILED(pOptions->GetPropertyULONG32("FileSize", m_ulFileSize)) )
  191.     {
  192. HX_ASSERT(FALSE);
  193. // return HXR_INVALID_PARAMETER;
  194.     }
  196.     m_bMangleLinks = ulMangle ? TRUE : FALSE;
  197.     BOOL bUseStyles = ulStyles ? TRUE : FALSE;
  199.     m_pServerUrl = new char[pViewURL->GetSize()+1];
  200.     strcpy(m_pServerUrl, (char*)pViewURL->GetBuffer()); /* Flawfinder: ignore */
  202.     m_pOurPath = new char[pCurrentPath->GetSize()+1];
  203.     strcpy(m_pOurPath, (char*)pCurrentPath->GetBuffer()); /* Flawfinder: ignore */
  205.     m_pDefaultView = new char[pRemoteView->GetSize()+1];
  206.     strcpy(m_pDefaultView, (char*)pRemoteView->GetBuffer()); /* Flawfinder: ignore */
  208.     m_pFileName = new char[pFileName->GetSize()+1];
  209.     strcpy(m_pFileName, (char*)pFileName->GetBuffer()); /* Flawfinder: ignore */
  211.     IHXBuffer* pRamGen = NULL;
  212.     if ( SUCCEEDED(pOptions->GetPropertyCString("RamGenURL", pRamGen)) )
  213.     {
  214. m_pRamGen = new char[pRamGen->GetSize()+1];
  215. strcpy(m_pRamGen, (char*)pRamGen->GetBuffer()); /* Flawfinder: ignore */
  216.     }
  218.     HX_RELEASE(pRamGen);
  219.     HX_RELEASE(pRemoteView);
  220.     HX_RELEASE(pViewURL);
  221.     HX_RELEASE(pCurrentPath);
  222.     HX_RELEASE(pFileName);
  224.     if ( bUseStyles )
  225.     {
  226. m_pEscapeStrings = (const char**) m_pStyleTags;
  227.     }
  228.     else
  229.     {
  230. m_pEscapeStrings = (const char**) m_pDefaultTags;
  231.     }
  232. }
  234. /*___________________________________________________________________________
  235.  *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  236.  *  ~CEscapeXMLtoHTML()
  237.  *
  238.  *  PARAMETERS:
  239.  * none
  240.  *
  241.  *  DESCRIPTION:
  242.  * Destructor.
  243.  *
  244.  *___________________________________________________________________________
  245.  *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
  246. CEscapeXMLtoHTML::~CEscapeXMLtoHTML()
  247. {
  248.     HX_VECTOR_DELETE(m_pRamGen);
  249.     HX_VECTOR_DELETE(m_pServerUrl);
  250.     HX_VECTOR_DELETE(m_pOurPath);
  251.     HX_VECTOR_DELETE(m_pDefaultView);
  252.     HX_VECTOR_DELETE(m_pFileName);
  253. }
  255. /*___________________________________________________________________________
  256.  *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  257.  *  Convert(pXMLsrc, pOutBuffer)
  258.  *
  259.  *  PARAMETERS:
  260.  * pXMLsrc Pointer to a IHXBuffer containing the src of xml to 
  261.  * be converted
  262.  * pOutBuffer A new IHXBuffer containing the parsed XML data ready
  263.  * to be displayed in an HTML browser.
  264.  *
  265.  *  DESCRIPTION:
  266.  * Creates a growing queue, copies the buffers to a cstring, then calls 
  267.  * the Parse(...) function to parse the string.  Next the outputed is 
  268.  * dequeued Off the growing queue and put in a new IHXBuffer and 
  269.  * returned
  270.  *
  271.  *  RETURNS
  272.  *
  273.  *___________________________________________________________________________
  274.  *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
  275. STDMETHODIMP CEscapeXMLtoHTML::Convert(IHXBuffer* pXMLsrc,
  276.        REF(IHXBuffer*) pOutBuffer)
  277. {
  278.     // TODO: UTF-16
  279.     UCHAR* pIn = NULL;
  280.     UINT32 ulLen;
  281.     
  282.     HX_ASSERT(pXMLsrc != NULL);
  283.     pXMLsrc->Get(pIn, ulLen);
  284.     
  285.     CBigByteGrowingQueue* pQueue = NULL;
  286.     
  287.     if ( ulLen )
  288.     {
  289. pQueue = new CBigByteGrowingQueue(ulLen*4);
  290. if ( !pQueue )
  291. {
  292.     // panic
  293.     HX_RELEASE(pXMLsrc);
  294.     return HXR_OUTOFMEMORY;
  295. }
  297. DataObject StateObj;
  298. StateObj.state = IN_CONTENT;
  299. StateObj.bPushChar = TRUE;
  300.     
  301. PushHeader(pQueue);
  302. pQueue->EnQueue("<pre><!--  Begin Source  -->n");
  303. Parse(pIn, ulLen, pQueue, &StateObj);
  304. pQueue->EnQueue("n<!--  End Source  --></pre>n");
  305. UINT32 ulOutLen;
  306. ulOutLen =  pQueue->GetQueuedItemCount();
  308. HX_RELEASE(pOutBuffer);
  309. pOutBuffer = new CHXBuffer();
  310. pOutBuffer->AddRef();
  311. if ( pOutBuffer->SetSize(ulOutLen) != HXR_OK )
  312. {
  313.     HX_RELEASE(pXMLsrc);
  314.     return HXR_OUTOFMEMORY;
  315. }
  316. UCHAR* pOut = pOutBuffer->GetBuffer();
  317. pQueue->DeQueue(pOut, ulOutLen);
  318.     }
  319.     else
  320.     { // just return an empty buffer.
  321. HX_RELEASE(pOutBuffer);
  322. pOutBuffer = new CHXBuffer();
  323. pOutBuffer->AddRef();
  324.     }
  325.     HX_DELETE(pQueue);
  326.     return HXR_OK;
  327. }
  329. /*___________________________________________________________________________
  330.  *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  331.  *  PushCommonHeader(queue)
  332.  *
  333.  *  PARAMETERS:
  334.  *
  335.  *  queue The queue to push the output to.
  336.  *
  337.  *  DESCRIPTION:
  338.  *
  339.  * Pushes the common information onto the queue.
  340.  *
  341.  *  RETURNS
  342.  *
  343.  *___________________________________________________________________________
  344.  *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
  345. void CEscapeXMLtoHTML::PushCommonHeader(CBigByteGrowingQueue* queue)
  346. {
  347.     queue->EnQueue(z_pFileName);
  348.     queue->EnQueue(m_pFileName);
  349.     queue->EnQueue(z_pEndLine);
  350.     
  351.     QueueModificationTime(queue, m_ulModDate);
  353.     QueueFileSize(queue, m_ulFileSize);
  355.     if ( m_pRamGen )
  356.     {
  357. queue->EnQueue(z_pRamLink);
  358. queue->EnQueue("<a href="");
  359. queue->EnQueue(m_pRamGen);
  360. const char* p = m_pOurPath;
  361. if ( *p == '/' )
  362. {
  363.     p++;
  364. }
  365. queue->EnQueue(p);
  366. queue->EnQueue("/");
  367. queue->EnQueue(m_pFileName);
  368. queue->EnQueue("">");
  369. queue->EnQueue(m_pRamGen);
  370. queue->EnQueue(p);
  371. queue->EnQueue("/");
  372. queue->EnQueue(m_pFileName);
  373. queue->EnQueue("</a>");
  374. queue->EnQueue(z_pEndLine);
  375.     }
  376. }
  378. /*___________________________________________________________________________
  379.  *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  380.  * Protected Methods
  381.  *___________________________________________________________________________
  382.  *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
  383. /*___________________________________________________________________________
  384.  *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  385.  *  WrapAttributeWithHREF (pPositionPointer, ulLen, pObj, pQueue, pAttribute)
  386.  *
  387.  *  PARAMETERS:
  388.  *
  389.  *  pPositionPointer Pointer to a character string.  It points to the first
  390.  * whitespace after the tagname
  391.  *  ulLen Length to end of pPositionPointer so we don't overrun the buffer
  392.  *  pObj The current state of the Parse Function, this can be used
  393.  * to continue parsing.
  394.  *  queue The queue to push the output to.
  395.  *  pAttribute The attribute we want to wrap.
  396.  *
  397.  *  DESCRIPTION:
  398.  * This method will take the given pPositionPointer and wrap the given attribute
  399.  * with an HREF
  400.  *
  401.  *  RETURNS
  402.  * UINT32
  403.  *     number of characters used off pPositionPointer, thus the position can be
  404.  *     adjusted after the function returns
  405.  *___________________________________________________________________________
  406.  *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
  407. UINT32 CEscapeXMLtoHTML::WrapAttributeWithHREF(const UCHAR* pPositionPointer, 
  408. UINT32 ulLen,
  409. DataObject* pObj,
  410. CBigByteGrowingQueue* pQueue, 
  411. const char* pAttribute)
  412. {
  413.     // we need to find two things
  414.     // 1 - the end of the tag
  415.     // 2 - the beggining of the attribute
  416.     const UCHAR* pBeginAttribute = NULL;
  417.     const UCHAR* pEndTag = NULL;
  418.     const char* walker = (const char*)pPositionPointer;
  419.     BOOL bInComment = FALSE;
  420.     UINT32 ulEscLen = 0;
  421.     UINT16 uAttribLen = strlen(pAttribute);
  422.     while ( (!pEndTag || bInComment) && ulEscLen < ulLen)
  423.     {
  424. if ( !bInComment )
  425. {
  426.     if ( *walker == '>')
  427.     {
  428. pEndTag = (const UCHAR*)walker;
  429. ++pEndTag;
  430.     }
  431.     else if ( ulEscLen + uAttribLen < ulLen &&
  432. isspace(*(walker-1)) &&
  433. !strncmp(walker, pAttribute, uAttribLen) )
  434.     {
  435. walker += uAttribLen;
  436. ulEscLen += uAttribLen;
  437. // eat ws.
  438. while ( isspace(*walker) && ulEscLen < ulLen )
  439. {
  440.     ++walker;
  441.     ++ulEscLen;
  442. }
  443. // assert for =
  444. HX_ASSERT(*walker == '=');
  445. if ( *walker == '=' )
  446. {
  447.     ++walker;
  448.     ++ulEscLen;
  449.     while ( isspace(*walker) && ulEscLen < ulLen )
  450.     {
  451. ++walker;
  452. ++ulEscLen;
  453.     }
  454.     // eat ws assert for " '
  455.     HX_ASSERT(*walker == '"' || *walker == ''');
  456.     if ( *walker == '"' || *walker == ''' )
  457.     {
  458. ++walker;
  459. ++ulEscLen;
  460. pBeginAttribute = (const UCHAR*)walker;
  461.     }
  462. }
  463.     }
  464.     else if ( ulEscLen + 4 < ulLen && !strncmp(walker, "<!--", 4) )
  465.     {
  466. bInComment = TRUE;
  467. walker += 3;
  468. ulEscLen += 3;
  469.     }
  470. }
  471. else
  472. {
  473.     if ( ulEscLen + 3 < ulLen && !strncmp(walker, "-->", 3) )
  474.     {
  475. bInComment = FALSE;
  476. walker += 2;
  477. ulEscLen += 2;
  478.     }
  479. }
  480. ++walker;
  481. ++ulEscLen;
  482.     }
  484.     UINT32 pos = 0;
  485.     if ( pBeginAttribute ) {
  486. // parse until the end of the attribute tag.
  487. pos = pBeginAttribute - pPositionPointer;
  488. Parse(pPositionPointer, pos, pQueue, pObj);
  489. // advance the character pointer by how much we parsed.
  490. pPositionPointer += pos;
  491. // push our wrapper on
  492. BOOL bPushed = PushOpenningHREF(pPositionPointer, pQueue, pObj->cQuote);
  493. // push mangled filename on
  494. UINT32 ulPathLen = PushMangledDisplayedPath(pPositionPointer, pQueue, pObj->cQuote);
  495. // advancd pPositionPointer by path length
  496. pPositionPointer += ulPathLen;
  497. pos += ulPathLen;
  498. // push ending HREF
  499. if ( bPushed )
  500. {
  501.     PushEndingHREF(pQueue);
  502. }
  503. // parse to end of tag
  504. Parse(pPositionPointer, ulEscLen - pos, pQueue, pObj);
  505. pObj->bPushChar = FALSE;
  506. // We want to return pointing to the last '>', therefore we can
  507. // catch anything that is imediatly following our tag.
  508. return ulEscLen - 1;
  509.     }
  511.     pObj->bPushChar = TRUE;
  512.     return 0;
  514. }
  516. /*___________________________________________________________________________
  517.  *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  518.  *  WrapHREF (pPositionPointer, ulLen, pObj, pQueue)
  519.  *
  520.  *  PARAMETERS:
  521.  *
  522.  *  pPositionPointer Pointer to a character string.  It points to the first
  523.  * whitespace after the tagname
  524.  *  ulLen Length to end of pPositionPointer so we don't overrun the buffer
  525.  *  pObj The current state of the Parse Function, this can be used
  526.  * to continue parsing.
  527.  *  queue The queue to push the output to.
  528.  *  pAttribute The attribute we want to wrap.
  529.  *
  530.  *  DESCRIPTION:
  531.  * This method will take the given pPositionPointer and wrap an HREF=
  532.  *  With a link to itself.
  533.  *
  534.  *  RETURNS
  535.  * UINT32
  536.  *     number of characters used off pPositionPointer, thus the position can be
  537.  *     adjusted after the function returns
  538.  *___________________________________________________________________________
  539.  *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
  541. #ifdef HYPER_LINKING_HREFS_XML
  543. UINT32 CEscapeXMLtoHTML::LinkHREF(const UCHAR* pPositionPointer, 
  544. UINT32 ulLen,
  545. DataObject* pObj,
  546. CBigByteGrowingQueue* pQueue)
  547. {
  548.     const UCHAR* pBeginHREF = NULL;
  549.     const UCHAR* pEndHREF = NULL;
  550.     const UCHAR* pEndTag = NULL;
  551.     const char* walker = (const char*)pPositionPointer;
  552.     BOOL bInComment = FALSE;
  553.     BOOL bInString = FALSE;
  554.     UINT32 ulEscLen = 0;
  555.     while ( (!pEndTag) && ulEscLen < ulLen)
  556.     {
  557. if ( bInString )
  558. {
  559.     if ( *walker == '"' || *walker == ''')
  560.     {
  561. bInString = FALSE;
  562. pEndHREF = (const UCHAR*)walker;
  563.     }
  564. }
  565. else if ( !bInComment )
  566. {
  567.     if ( *walker == '>')
  568.     {
  569. pEndTag = (const UCHAR*)walker;
  570. ++pEndTag;
  571.     }
  572.     else if ( ulEscLen + 6 < ulLen && 
  573. isspace(*(walker-1)) && 
  574. !strncmp(walker, "href", 4) &&
  575. (*(walker+4) == '=' || isspace(*(walker+4))) )
  576.     {
  577. walker += 4;
  578. ulEscLen += 4;
  579. while ( *walker != '"' && *walker != ''' && ulEscLen < ulLen &&
  580. (isspace(*walker) || *walker == '='))
  581. {
  582.     ++walker;
  583.     ++ulEscLen;
  584. }
  585. HX_ASSERT(*walker == '"' || *walker == ''');
  586. if ( *walker == '"' || *walker == ''')
  587. {
  588.     pBeginHREF = (const UCHAR*)walker + 1;
  589.     bInString = TRUE;
  590. }
  591.     }
  592.     else if ( ulEscLen + 4 < ulLen && 
  593. !strncmp(walker, "<!--", 4) )
  594.     {
  595. bInComment = TRUE;
  596. walker += 3;
  597. ulEscLen += 3;
  598.     }
  599. }
  600. else
  601. {
  602.     if ( ulEscLen + 3 < ulLen && !strncmp(walker, "-->", 3) )
  603.     {
  604. bInComment = FALSE;
  605. walker += 2;
  606. ulEscLen += 2;
  607.     }
  608. }
  609. ++walker;
  610. ++ulEscLen;
  611.     }
  613.     if ( pEndTag == NULL || pBeginHREF == NULL || pEndHREF == NULL )
  614.     {
  615. return 0;
  616.     }
  617.     else
  618.     {
  619. const UCHAR* cp = pPositionPointer;
  620. Parse(pPositionPointer, pBeginHREF - cp, pQueue, pObj);
  621. cp += pBeginHREF - cp;
  622. pQueue->EnQueue(m_pEscapeStrings[BeginHREF]);
  623. pQueue->EnQueue((void*)pBeginHREF, pEndHREF - pBeginHREF);
  624. pQueue->EnQueue("">");
  625. Parse(cp, pEndHREF - pBeginHREF, pQueue, pObj);
  626. cp += pEndHREF - pBeginHREF;
  627. pQueue->EnQueue(m_pEscapeStrings[EndHREF]);
  629. // parse to end of tag
  630. Parse(cp, pEndTag - cp, pQueue, pObj);
  631. pObj->bPushChar = FALSE;
  632. // We want to return pointing to the last '>', therefore we can
  633. // catch anything that is imediatly following our tag.
  634. return pEndTag - pPositionPointer - 1;
  635.     }
  636. }
  638. #endif //HYPER_LINKING_HREFS_XML
  640. /*___________________________________________________________________________
  641.  *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  642.  *  Parse(pIn, ulLen, pQueue, pObj)
  643.  *
  644.  *  PARAMETERS:
  645.  * pIn The string to be parsed.
  646.  * ulLen How far to parse through pIn
  647.  * pQueue The output Queue to push onto
  648.  * pObj The state object.  This is used to start the queue from a
  649.  * given state.
  650.  *
  651.  *  DESCRIPTION:
  652.  * This function walks through the string one character at a time.  
  653.  * Every tag is checked with the CheckTag(...) function to see if it 
  654.  * needs special attention.  If so the OnTag(...) function is called.  
  655.  * This function will be implemented in a child class that will replace 
  656.  * the tag with parsed imput returning how far along pIn it made it.
  657.  * This function is designed such that Inherited classes can recusivly 
  658.  * call it to parse thier stream from the given state.
  659.  *
  660.  *  RETURNS
  661.  * void
  662.  *___________________________________________________________________________
  663.  *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
  664. void
  665. CEscapeXMLtoHTML::Parse(const UCHAR* pIn, UINT32 ulLen, 
  666. CBigByteGrowingQueue* pQueue,
  667. DataObject* pObj)
  668. {
  669.     HX_ASSERT(pIn);
  670.     
  671.     const UCHAR* pPositionPointer;
  673.     UINT32 uPositionOffset;
  674.     for ( uPositionOffset = 0, pPositionPointer = pIn;
  675. uPositionOffset < ulLen; uPositionOffset++, pPositionPointer++ )
  676.     {
  677.         switch(pObj->state)
  678.         {
  679.             case IN_CONTENT:
  680.     {
  681.                 /* do nothing until you find a '<' "<!--" or '&' */
  682.                 if ( *pPositionPointer == '<' )
  683.                 {
  684.                     /* XXX we can miss a comment spanning a block boundary */
  685.     pObj->bPushChar = FALSE;
  686.                     if ( uPositionOffset + 4 <= ulLen && 
  687. !strncmp((char*)pPositionPointer, "<!--", 4) )
  688.                     {
  689.                         pQueue->EnQueue(m_pEscapeStrings[BeginCommentMarkup]);
  690.                         pQueue->EnQueue("&lt;");
  691.                         pObj->state = IN_COMMENT;
  692.                     }
  693.                    else if ( uPositionOffset + 2 <= ulLen && 
  694.        !strncmp((char*)pPositionPointer, "<?", 2) )
  695.                    {
  696.                        pQueue->EnQueue(m_pEscapeStrings[BeginTagMarkup]);
  697.        pQueue->EnQueue("&lt;");
  698.        pQueue->EnQueue(m_pEscapeStrings[EndTagMarkup]);
  699.                        pQueue->EnQueue(m_pEscapeStrings[BeginProcessingInstructions]);
  700.                        pQueue->EnQueue("?");
  701.                        pQueue->EnQueue(m_pEscapeStrings[BeginTagNameMarkup]);
  702.                        // increment pPositionPointer & uPositionOffset one because of ?
  703.                        ++pPositionPointer;
  704.                        ++uPositionOffset;
  705.                        pObj->bInProcessingInstructions = TRUE;
  706.                        pObj->bPushChar = FALSE;
  707.                        pObj->state = ABOUT_TO_BEGIN_TAG;
  708.                    }
  709.                    else if ( uPositionOffset + 9 <= ulLen && 
  710.        !strncmp((char*)pPositionPointer, "<![CDATA[", 9) )
  711.                    {
  712.        pQueue->EnQueue(m_pEscapeStrings[BeginTagMarkup]);
  713.                        pQueue->EnQueue("&lt;");
  714.                        pQueue->EnQueue(m_pEscapeStrings[BeginTagNameMarkup]);
  715.                        pQueue->EnQueue("![CDATA[");
  716.                        pQueue->EnQueue(m_pEscapeStrings[EndTagNameMarkup]);
  717.        pQueue->EnQueue(m_pEscapeStrings[EndTagMarkup]);
  718.                        pQueue->EnQueue(m_pEscapeStrings[BeginCDATA]);
  719.                        pObj->bPushChar = FALSE;
  720.                        pPositionPointer += 8;
  721.                        uPositionOffset += 8;
  722.                        pObj->state = IN_CDATA;
  723.                    }
  724.                    else if ( uPositionOffset + 2 <= ulLen && 
  725.        !strncmp((char*)pPositionPointer, "<!", 2) )
  726.                    {
  727.        pQueue->EnQueue(m_pEscapeStrings[BeginTagMarkup]);
  728.                        pQueue->EnQueue("&lt;");
  729.                        pQueue->EnQueue(m_pEscapeStrings[BeginTagNameMarkup]);
  730.                        pObj->state = IN_DOC_TYPE_DEC_TAG;
  731.                    }
  732.                     else
  733.                     {
  734.                         BeginColorTag(pQueue, pObj);
  735.                     }
  736.                 }
  737.                 else if ( *pPositionPointer == '&' )
  738.                 {
  739.                     pObj->bPushChar = FALSE;
  740.     pQueue->EnQueue(m_pEscapeStrings[BeginAmpersandThingyMarkup]);
  741.                     pQueue->EnQueue("&amp;");
  742.                     pObj->state = IN_AMPERSAND_THINGY;
  743.                 }
  744.     }
  745.             break;
  746.            case IN_DOC_TYPE_DEC_TAG:
  747.            {
  748.                 if ( IS_SPACE(*pPositionPointer) )
  749.                 {
  750.                     pQueue->EnQueue(m_pEscapeStrings[EndTagNameMarkup]);
  751.     pQueue->EnQueue(m_pEscapeStrings[EndTagMarkup]);
  752.     pQueue->EnQueue(m_pEscapeStrings[BeginDTD]);
  753.     pObj->bPushChar = TRUE; // we want to still push it
  754.                     pObj->state = IN_DOC_TYPE_DEC;
  755.                 }
  756.                 else if ( *pPositionPointer == '>' )
  757.                 {
  758.                     pQueue->EnQueue(m_pEscapeStrings[EndTagNameMarkup]);
  759.                     pQueue->EnQueue(m_pEscapeStrings[EndDTD]);
  760.                     pQueue->EnQueue("&gt;");
  761.                     pObj->bPushChar = FALSE;
  762.     pObj->state = IN_CONTENT;
  763.                 }
  764.            }
  765.            break;
  766.            case IN_DOC_TYPE_DEC:
  767.            {
  768.                if ( pObj->bInDataSection )
  769.                {
  770.                    if ( pObj->bInInternalComment )
  771.                    {
  772.                        /* do nothing until you find a closing '-->' */
  773.                        if ( !strncmp((char*)pPositionPointer, "-->", 3) )
  774.                        {
  775.                            pObj->bPushChar = FALSE;
  776.                            pObj->bInInternalComment = FALSE;
  777.                            pQueue->EnQueue("--&gt;");
  778.                            pPositionPointer += 2;
  779.                            uPositionOffset += 2;
  780.                            pQueue->EnQueue(m_pEscapeStrings[EndCommentMarkup]);
  781.                        }
  782.                    }
  783.                    else if ( !strncmp((char*)pPositionPointer, "<!--", 4) )
  784.                    {
  785.                         pQueue->EnQueue(m_pEscapeStrings[BeginCommentMarkup]);
  786.                         pQueue->EnQueue("&lt;");
  787.                         pObj->bPushChar = FALSE;
  788.                         pObj->bInInternalComment = TRUE;
  789.                    }
  790.                    else if ( *pPositionPointer == ']' )
  791.                    {
  792.                        pObj->bInDataSection = FALSE;
  793.                    }
  794.                }
  795.                else if ( *pPositionPointer == '[' )
  796.                {
  797.                    pObj->bInDataSection = TRUE;
  798.                }
  799.                else if ( *pPositionPointer == '>' )
  800.                {
  801.                    pObj->bPushChar = FALSE;
  802.                    pQueue->EnQueue(m_pEscapeStrings[EndDTD]);
  803.    pQueue->EnQueue(m_pEscapeStrings[BeginTagMarkup]);
  804.                    pQueue->EnQueue("&gt;");
  805.    pQueue->EnQueue(m_pEscapeStrings[EndTagMarkup]);
  806.                    pObj->state = IN_CONTENT;
  807.                }
  808.                if ( pObj->bPushChar )
  809.                {
  810.                    if ( *pPositionPointer == '<' )
  811.                    {
  812.                        pObj->bPushChar = FALSE;
  813.                        /* protect ourselves from markup */
  814.                        pQueue->EnQueue("&lt;");
  815.                    }
  816.                    else if ( *pPositionPointer == '&' )
  817.                    {
  818.                        /* protect ourselves from markup */
  819.                        pQueue->EnQueue("&amp;");
  820.                        pObj->bPushChar = FALSE;
  821.                    }
  822.                }
  824.            }
  825.            break;
  826.            case IN_CDATA:
  827.            {
  828.                if ( !strncmp((char*)pPositionPointer, "]]>", 3) )
  829.                {
  830.                    pQueue->EnQueue(m_pEscapeStrings[EndCDATA]);
  831.    pQueue->EnQueue(m_pEscapeStrings[BeginTagMarkup]);
  832.                    pQueue->EnQueue(m_pEscapeStrings[BeginTagNameMarkup]);
  833.                    pQueue->EnQueue("]]");
  834.                    pQueue->EnQueue(m_pEscapeStrings[EndTagNameMarkup]);
  835.                    pQueue->EnQueue("&gt;");
  836.    pQueue->EnQueue(m_pEscapeStrings[EndTagMarkup]);
  837.                    pPositionPointer += 2;
  838.                    uPositionOffset += 2;
  839.                    pObj->bPushChar = FALSE;
  840.                    pObj->state = IN_CONTENT;
  841.                }
  843.                if ( *pPositionPointer == '<' )
  844.                 {
  845.                    pObj->bPushChar = FALSE;
  846.                     /* protect ourselves from markup */
  847.                     pQueue->EnQueue("&lt;");
  848.                 }
  849.                else if ( *pPositionPointer == '&' )
  850.                {
  851.                     /* protect ourselves from markup */
  852.                    pQueue->EnQueue("&amp;");
  853.                    pObj->bPushChar = FALSE;
  854.                }
  855.            }
  856.            break;
  857.             case ABOUT_TO_BEGIN_TAG:
  858.     {
  859.                 /* we have seen the first '<'
  860.                  * once we see a non-whitespace character
  861.                  * we will be in the tag identifier
  862.                  */
  863.                 if ( *pPositionPointer == '>' )
  864.                 {
  865.     pQueue->EnQueue(m_pEscapeStrings[EndTagNameMarkup]);
  866.                     EndColorTag(pQueue, pObj);
  867.                 }
  868.                 else if ( !IS_SPACE(*pPositionPointer) )
  869.                 {
  870.                     pObj->state = IN_BEGIN_TAG;
  871.                     pObj->tag_index = 0;
  872.                     pObj->tag[pObj->tag_index++] = *pPositionPointer;
  873.                     
  874.          if ( *pPositionPointer == '<' )
  875.     {
  876.                         pObj->bPushChar = FALSE;
  877. pQueue->EnQueue("&lt;");
  878.     }
  879.                 }
  880.     }
  881.             break;
  882.             case IN_BEGIN_TAG:
  883.     {
  884.                 /* go to the IN_TAG state when we see
  885.                  * the first whitespace
  886.                  */
  887.                 if ( IS_SPACE(*pPositionPointer) )
  888.                 {
  889.                     pQueue->EnQueue(m_pEscapeStrings[EndTagNameMarkup]);
  890.     pObj->bPushChar = TRUE; // we want to still push it
  891.                     pObj->state = IN_TAG;
  892.                     if (pObj->tag_index < MAXTAGLEN) pObj->tag[pObj->tag_index] = '';
  893.     if ( CheckTag(pObj) )
  894.     {
  895. UINT32 pos = OnTag(pPositionPointer, ulLen - uPositionOffset, pObj, pQueue);
  896. pPositionPointer += pos;
  897. uPositionOffset += pos;
  898.     }
  899.                 }
  900.                 else if ( *pPositionPointer == '>' )
  901.                 {
  902.                     pQueue->EnQueue(m_pEscapeStrings[EndTagNameMarkup]);
  903.                     EndColorTag(pQueue, pObj);
  904.                 }
  905.                 else if ( *pPositionPointer == '<' )
  906.                 {
  907.     pObj->bPushChar = FALSE;
  908.                     /* protect ourselves from markup */
  909.                     if ( !pObj->bInBrokenXML )
  910.                     {
  911.                         pObj->bInBrokenXML = TRUE;
  912.                         pQueue->EnQueue(m_pEscapeStrings[BeginBrokenAttributeMarkup]);
  913.                         pQueue->EnQueue("&lt;");
  914.                     }
  915.                     else
  916.                     {
  917.                         pQueue->EnQueue("&lt;");
  918.                     }
  919.                 }
  920.                 else
  921.                 {
  922.                     if (pObj->tag_index < MAXTAGLEN)
  923.     {
  924.                         pObj->tag[pObj->tag_index++] = *pPositionPointer;
  925.     }
  926.                 }
  927.     }
  928.             break;
  929.             case IN_TAG:
  930.     {
  931.                 /* do nothing until you find a opening '=' or end '>' */
  932. if ( *pPositionPointer == '=' )
  933.                 {
  934.     pObj->bPushChar = FALSE;
  935.                     pQueue->EnQueue("=");
  936.                     pQueue->EnQueue(m_pEscapeStrings[BeginAttributeValueMarkup]);
  937.                     pObj->state = BEGIN_ATTRIBUTE_VALUE;
  938.                 }
  939.                 else if ( *pPositionPointer == '>' )
  940.                 {
  941.                     EndColorTag(pQueue, pObj);
  942.                 }
  943.                 else if ( *pPositionPointer == '<' )
  944.                 {
  945.     pObj->bPushChar = FALSE;
  946.                     /* protect ourselves from markup */
  947.                     pQueue->EnQueue("&lt;");
  948.                 }
  949.     }
  950.             break;
  951.             case BEGIN_ATTRIBUTE_VALUE:
  952.     {
  953.                 /* when we reach the first non-whitespace
  954.                  * we will enter the UNQUOTED or the QUOTED
  955.                  * ATTRIBUTE state
  956.                  */
  957.                 if ( !IS_SPACE(*pPositionPointer) )
  958.                 {
  959.                     if ( *pPositionPointer == '"' || *pPositionPointer == ''')
  960.                     {
  961. pObj->cQuote = *pPositionPointer;
  962.                         pObj->state = IN_QUOTED_ATTRIBUTE_VALUE;
  963.                         /* no need to jump to the quoted attr handler
  964.                          * since this char can't be a dangerous char
  965.                          */
  966.                     }
  967.                     else
  968.                     {
  969.                         pObj->state = IN_UNQUOTED_ATTRIBUTE_VALUE;
  970.                         /* need to jump to the unquoted attr handler
  971.                          * since this char can be a dangerous character
  972.                          */
  973.                         goto unquoted_attribute_jump_point;
  974.                     }
  975.                 }
  976.                 else if ( *pPositionPointer == '>' )
  977.                 {
  978.     pQueue->EnQueue(m_pEscapeStrings[EndAttributeValueMarkup]);
  979.                     EndColorTag(pQueue, pObj);
  980.                 }
  981.                 else if ( *pPositionPointer == '<' )
  982.                 {
  983.                     /* protect ourselves from markup */
  984.                     pObj->bPushChar = FALSE;
  985.     pQueue->EnQueue("&lt;");
  986.                 }
  987.     }
  988.             break;
  989.             case IN_UNQUOTED_ATTRIBUTE_VALUE:
  990.     {
  991. unquoted_attribute_jump_point:
  992.                 /* do nothing until you find a whitespace */
  993.                 if ( IS_SPACE(*pPositionPointer) )
  994.                 {
  995.                     pQueue->EnQueue(m_pEscapeStrings[EndAttributeValueMarkup]);
  996.                     pObj->state = IN_TAG;
  997.                 }
  998.                 else if ( *pPositionPointer == '>' )
  999.                 {
  1000.     pQueue->EnQueue(m_pEscapeStrings[EndAttributeValueMarkup]);
  1001.     EndColorTag(pQueue, pObj);
  1002.                 }
  1003.                 else if ( *pPositionPointer == '<' )
  1004.                 {
  1005.     pObj->bPushChar = FALSE;
  1006.                     /* protect ourselves from markup */
  1007.                     pQueue->EnQueue("&lt;");
  1008.                 }
  1009.                 else if ( *pPositionPointer == '&' )
  1010.                 {
  1011.     pObj->bPushChar = FALSE;
  1012.                     /* protect ourselves from markup */
  1013.                     pQueue->EnQueue("&amp;");
  1014.                 }
  1015.                 break;
  1016.     }
  1017.             case IN_QUOTED_ATTRIBUTE_VALUE:
  1018.     {
  1019.                 /* do nothing until you find a closing '"' */
  1020. if ( *pPositionPointer == pObj->cQuote )
  1021.                 {
  1022.     pObj->bPushChar = FALSE;
  1023.                     if ( pObj->bInBrokenXML )
  1024.                     {
  1025.                         pQueue->EnQueue(m_pEscapeStrings[EndBrokenAttributeMarkup]);
  1026.                         pObj->bInBrokenXML = FALSE;
  1027.                     }
  1028.                     pQueue->EnQueue((void*)&pObj->cQuote, 1);
  1029.                     pQueue->EnQueue(m_pEscapeStrings[EndAttributeValueMarkup]);
  1030.                     pObj->state = IN_TAG;
  1031.                 }
  1032.                 else if ( *pPositionPointer == '<' )
  1033.                 {
  1034.     pObj->bPushChar = FALSE;
  1035.                     /* protect ourselves from markup */
  1036.                     pQueue->EnQueue("&lt;");
  1037.                 }
  1038.                 else if ( *pPositionPointer == '&' )
  1039.                 {
  1040.     pObj->bPushChar = FALSE;
  1041.                     /* protect ourselves from markup */
  1042.                     pQueue->EnQueue("&amp;");
  1043.                 }
  1044.                 else if ( *pPositionPointer == '>' )
  1045.                 {
  1046.     pObj->bPushChar = FALSE;
  1047.                     /* probably a broken attribute value */
  1048.                     if ( !pObj->bInBrokenXML )
  1049.                     {
  1050.                         pObj->bInBrokenXML = TRUE;
  1051.                         pQueue->EnQueue(m_pEscapeStrings[BeginBrokenAttributeMarkup]);
  1052.                         pQueue->EnQueue(">");
  1053.                     }
  1054.                 }
  1055.     }
  1056.             break;
  1057.             case IN_COMMENT:
  1058.     {
  1059.                 /* do nothing until you find a closing '-->' */
  1060.                 if ( !strncmp((char*)pPositionPointer, "-->", 3) )
  1061.                 {
  1062.     pObj->bPushChar = FALSE;
  1063.                     pQueue->EnQueue("--&gt;");
  1064.                     pPositionPointer += 2;
  1065.                     uPositionOffset += 2;
  1066.                     pQueue->EnQueue(m_pEscapeStrings[EndCommentMarkup]);
  1067.                     pObj->state = IN_CONTENT;
  1068.                 }
  1069.                 else if ( *pPositionPointer == '<' )
  1070.                 {
  1071.     pObj->bPushChar = FALSE;
  1072.                     /* protect ourselves from markup */
  1073.                     pQueue->EnQueue("&lt;");
  1074.                 }
  1075.                 else if ( *pPositionPointer == '&' )
  1076.                 {
  1077.                      /* protect ourselves from markup */
  1078.                     pQueue->EnQueue("&amp;");
  1079.                     pObj->bPushChar = FALSE;
  1080.                 }
  1081.     }
  1082.             break;
  1083.             case IN_AMPERSAND_THINGY:
  1084.     {
  1085.                 /* do nothing until you find a ';' or space */
  1086.                 if ( *pPositionPointer == ';' || IS_SPACE(*pPositionPointer) )
  1087.                 {
  1088.     pObj->bPushChar = FALSE;
  1089.                     pQueue->EnQueue((char*)pPositionPointer, 1);
  1090.                     pQueue->EnQueue(m_pEscapeStrings[EndAmpersandThingyMarkup]);
  1091.                     pObj->state = IN_CONTENT;
  1092.                 }
  1093.                 else if ( *pPositionPointer == '<' )
  1094.                 {
  1095.     pObj->bPushChar = FALSE;
  1096.                     /* protect ourselves from markup */
  1097.                     pQueue->EnQueue("&lt;");
  1098.                 }
  1099.     }
  1100.             break;
  1101.             default:
  1102.                 HX_ASSERT(0);
  1103.             break;
  1104.         }
  1106. if ( pObj->bPushChar )
  1107. {
  1108.     pQueue->EnQueue((char*)pPositionPointer, 1);
  1109. }
  1110. pObj->bPushChar = TRUE;
  1111.     }
  1112. }
  1114. /*___________________________________________________________________________
  1115.  *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  1116.  * Private Methods
  1117.  *___________________________________________________________________________
  1118.  *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
  1119. /*___________________________________________________________________________
  1120.  *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  1121.  *  PushMangledDisplayedPath(pIn, pQueue, cEndQuote)
  1122.  *
  1123.  *  PARAMETERS:
  1124.  * pIn Pointer to a character string.  It is positioned
  1125.  * inside a quote right infront of the path or file to
  1126.  * to be mangled
  1127.  * pQueue A pointer to a CBigByteGrowingQueue that is used for queuing up 
  1128.  * the parsered output.
  1129.  *      cEndQuote - the character which ends the quote (either ' or ")
  1130.  *
  1131.  *  DESCRIPTION:
  1132.  * This Method replaces any path after a protocol with a /.../.
  1133.  * If there is no protocol, then it just replaces any relative path with
  1134.  * /.../
  1135.  *
  1136.  *  RETURNS:
  1137.  * The Number of characters off pIn that it pushed onto the queue
  1138.  *___________________________________________________________________________
  1139.  *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
  1140. UINT32
  1141. CEscapeXMLtoHTML::PushMangledDisplayedPath(const UCHAR*          pIn, 
  1142.    CBigByteGrowingQueue* pQueue,
  1143.                                            char                  cEndQuote)
  1144. {
  1145.     const char* pszQuote = strchr((const char*) pIn, cEndQuote);
  1146.     if (pszQuote)
  1147.     {
  1148.         UINT32 ulLen = ((const UCHAR*) pszQuote) - pIn;
  1149.         UINT32 ulPos = 0;
  1150.         if ( m_bMangleLinks )
  1151.         {
  1152.     const UCHAR* pProtocolEnd = (const UCHAR*)strnstr((const char*)pIn, 
  1153.         "://", (int)ulLen);
  1155.     if ( pProtocolEnd )  // we have protocol
  1156.     {
  1157.         pProtocolEnd += 2; // only push one slash
  1158.         UINT32 ulLenOfProtocol = pProtocolEnd - pIn;
  1159.         pQueue->EnQueue((void*)pIn, ulLenOfProtocol);
  1160.         pIn += ulLenOfProtocol;
  1161.         ulPos += ulLenOfProtocol;
  1162.     }
  1164.     // find last '/'
  1165.     while ( strnchr((const char*)pIn, '/', ulLen - ulPos) ) 
  1166.     {
  1167.         UINT32 temp = ulPos;
  1168.         temp += (const UCHAR*)strnchr((const char*)pIn, '/', ulLen - ulPos) 
  1169.         - pIn + 1;
  1170.         pIn  = (const UCHAR*)strnchr((const char*)pIn, '/', ulLen - ulPos) 
  1171.         + 1;
  1172.         ulPos = temp;
  1173.         
  1174.     }
  1176.     pQueue->EnQueue("/.../");
  1177.         }
  1178.         // else we just do the whole thing...
  1179.         pQueue->EnQueue((void*)pIn, ulLen - ulPos);
  1180.         return ulLen;
  1181.     }
  1182.     return 0;
  1183. }
  1185. /*___________________________________________________________________________
  1186.  *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  1187.  *  PushOpenningHREF(pPositionPointer, pQueue, cEndQuote)
  1188.  *
  1189.  *  PARAMETERS:
  1190.  * pPositionPointer Pointer to a character string.  It is positioned
  1191.  * inside a quote right infront of the path or file to
  1192.  * to be referenced to.
  1193.  * This contains the absolute url if that is needed, or it
  1194.  * is used in the call to GetParameter(...).
  1195.  * pQueue A pointer to a CBigByteGrowingQueue that is used for queuing up 
  1196.  * the output.
  1197.  *      cEndQuote - the character to end the quote (either ' or ")
  1198.  *
  1199.  *  DESCRIPTION:
  1200.  * This Method pushes HREF onto the output queue.  It must build the
  1201.  * Url from the m_pServerUrl and the parameter (GetParameter).
  1202.  *
  1203.  *
  1204.  *  RETURNS:
  1205.  * void
  1206.  *___________________________________________________________________________
  1207.  *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
  1208. BOOL
  1209. CEscapeXMLtoHTML::PushOpenningHREF(const UCHAR* pPositionPointer, CBigByteGrowingQueue* pQueue, char cEndQuote)
  1210. {
  1211.     // if relative path
  1212.     // TODO: else we need to take care of full paths - 
  1213.     //     pPositionPointer or if m_pOurPath has a protocol as well.
  1214.     const char* pszQuote = strchr((const char*) pPositionPointer, cEndQuote);
  1215.     if (pszQuote)
  1216.     {
  1217.         UINT32 ulLen = ((const UCHAR*) pszQuote) - pPositionPointer;
  1219.         if ( strncmp((const char*)pPositionPointer, "rtsp://", 7) == 0 )
  1220.         {
  1221.     const char* p = (const char*)pPositionPointer;
  1222.     const char* pEnd = p + ulLen;
  1223.     p += 7;
  1224.     // move p to the end of server name find the first : or /
  1225.     while ( *p != ':' && *p != '/' && ++p != pEnd) {} ;
  1227.     pQueue->EnQueue(m_pEscapeStrings[BeginHREF]);
  1228.     // replacing rtsp with http
  1229.     
  1230.     //XXXJHUG  -- If the server in m_pServerUrl is the same as the 
  1231.     // server we are about queue we will use m_pServerUrl
  1232.     // instead of the default port and mountpoint.
  1233.     
  1234.     // mover past http://
  1235.     char* pBeginServer = m_pServerUrl + 7;
  1236.     
  1237.     UINT32 ulServerLen = 0;
  1238.     char* pServerPort = strchr(pBeginServer, ':');
  1239.     // m_pServerURL will always have a port.
  1240.     HX_ASSERT(pServerPort);
  1241.     if ( pServerPort )
  1242.     {
  1243.         ulServerLen = pServerPort - pBeginServer;
  1244.     }
  1245.     // 7 for rtsp://
  1246.     UINT32 ulXMLServerLen = p - (const char*)pPositionPointer - 7;
  1247.     if ( ulServerLen == ulXMLServerLen &&
  1248.         strncmp(pBeginServer, (const char*)pPositionPointer + 7, ulServerLen) == 0 )
  1249.     {
  1250.         // use m_pServerURL
  1251.         pQueue->EnQueue(m_pServerUrl);
  1252.     }
  1253.     else
  1254.     {
  1255.         // use the Default Port
  1256.         pQueue->EnQueue("http");
  1257.         pQueue->EnQueue((void*)(pPositionPointer + 4), p - (const char*)pPositionPointer - 4);
  1258.         pQueue->EnQueue(m_pDefaultView);
  1259.     }
  1261.     while ( *p != '/' && ++p != pEnd) {} ;
  1262.     UCHAR* pParam = GetParameter((const UCHAR*)p, pEnd - p);
  1264.     pQueue->EnQueue("?");
  1265.     pQueue->EnQueue((const char*)pParam);
  1266.     HX_VECTOR_DELETE(pParam);
  1267.     pQueue->EnQueue("">");
  1268.         }
  1269.         else if ( strnchr((const char*)pPositionPointer, ':', min(6, ulLen)) )
  1270.         {
  1271.     if ( strncmp((const char*)pPositionPointer, "pnm://", 6) != 0 &&
  1272.         (strncmp(m_pServerUrl, "http://localhost", sizeof("http://localhost") - 1) == 0 ||
  1273.         strncmp(m_pServerUrl, "http://127.0.0.1", sizeof("http://127.0.0.1") - 1) == 0) )
  1274.     {
  1275.         pQueue->EnQueue(m_pEscapeStrings[BeginHREF]);
  1276.         pQueue->EnQueue(m_pServerUrl);
  1277.         pQueue->EnQueue("?");
  1278.         UCHAR* pParam = GetParameter(pPositionPointer, ulLen, TRUE);
  1279.         pQueue->EnQueue((const char*)pParam);
  1280.         HX_VECTOR_DELETE(pParam);
  1281.         pQueue->EnQueue("">");
  1282.     }
  1283.     else
  1284.     {
  1285.         return FALSE;
  1286.     }
  1287.         }
  1288.         else
  1289.         {
  1290.     pQueue->EnQueue(m_pEscapeStrings[BeginHREF]);
  1291.     pQueue->EnQueue(m_pServerUrl);
  1292.     pQueue->EnQueue("?");
  1293.     UCHAR* pParam = GetParameter(pPositionPointer, ulLen);
  1295.     pQueue->EnQueue((const char*)pParam);
  1296.     HX_VECTOR_DELETE(pParam);
  1297.     pQueue->EnQueue("">");
  1298.         }
  1299.     }
  1300.     return TRUE;
  1301. }
  1303. /*___________________________________________________________________________
  1304.  *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  1305.  *  PushEndingHREF(pQueue)
  1306.  *
  1307.  *  PARAMETERS:
  1308.  * pQueue A pointer to a CBigByteGrowingQueue that is used for queuing up 
  1309.  * the parsered output.
  1310.  *
  1311.  *  DESCRIPTION:
  1312.  * Pushes end of HREF onto the output queue.
  1313.  *
  1314.  *  RETURNS
  1315.  * void
  1316.  *___________________________________________________________________________
  1317.  *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
  1318. void
  1319. CEscapeXMLtoHTML::PushEndingHREF(CBigByteGrowingQueue* pQueue)
  1320. {
  1321.     pQueue->EnQueue(m_pEscapeStrings[EndHREF]);
  1322. }
  1324. /*___________________________________________________________________________
  1325.  *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  1326.  *  GetParameter(pPositionPointer, ulNameLen)
  1327.  *
  1328.  *  PARAMETERS:
  1329.  * pPositionPointer Pointer to a character string.  It is positioned
  1330.  * inside a quote right infront of the path or file to
  1331.  * to be referenced to.
  1332.  * ulNameLen The length of the name.  It is not zero terminated.
  1333.  *
  1334.  *  DESCRIPTION:
  1335.  * This method builds a relative path and paramiterizes it.  Then the
  1336.  * parameter is encrypted with a call to EncryptParameter().  A string 
  1337.  * is allocated to be returned
  1338.  *
  1339.  *  RETURNS
  1340.  * a pointer to a new string that is to be used after the ? for an 
  1341.  * option in a url
  1342.  *___________________________________________________________________________
  1343.  *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
  1344. UCHAR*
  1345. CEscapeXMLtoHTML::GetParameter(const UCHAR* pPositionPointer, UINT32 ulNameLen, 
  1346.        BOOL bFullPath)
  1347. {
  1348.     // allocate longest possible string
  1349.     char* pReturnBuffer = new char[(strlen(m_pOurPath) + ulNameLen) + 10]; 
  1350.     //  2 for a possible starting '/' and a null terminator
  1351.     // 4 for the starting src=
  1352.     // 4 for extra bytes in case we have to pad the buffer when we encypt it.
  1353.     strcpy(pReturnBuffer, "src="); /* Flawfinder: ignore */
  1355.     char* pLinkPath = pReturnBuffer + 4;
  1356.     
  1358.     // if it starts with '/' then it is a full path
  1359.     if ( *pPositionPointer == '/' || bFullPath )
  1360.     {
  1361. strncpy(pLinkPath, (const char*)pPositionPointer, ulNameLen); /* Flawfinder: ignore */
  1362. pLinkPath[ulNameLen] = '';
  1363.     }
  1364.     // if it is alpha it is simply a file name
  1365.     else if ( isalnum(*pPositionPointer) )
  1366.     {
  1367. // 1 for "/"
  1368. UINT32 len = strlen(m_pOurPath) + ulNameLen + 1;
  1369. strcpy(pLinkPath, m_pOurPath); /* Flawfinder: ignore */
  1370. strcat(pLinkPath, "/"); /* Flawfinder: ignore */
  1371. strncat(pLinkPath, (const char*)pPositionPointer, ulNameLen); /* Flawfinder: ignore */
  1372. pLinkPath[len] = '';
  1373.     }
  1374.     else if ( !strncmp((const char*)pPositionPointer, "./", 2) )
  1375.     {
  1376. // -1 for .
  1377. UINT32 len = strlen(m_pOurPath) + ulNameLen - 1;
  1378. strcpy(pLinkPath, m_pOurPath); /* Flawfinder: ignore */
  1379. pPositionPointer += 1;
  1380. strncat(pLinkPath, (const char*)pPositionPointer, ulNameLen - 1); /* Flawfinder: ignore */
  1381. pLinkPath[len] = '';
  1382.     }
  1383.     else if ( !strncmp((const char*)pPositionPointer, "../", 3 ) )
  1384.     {
  1385. int count = 0;
  1387. // copy m_pOurPath into pLinkPath ourselves cause we need to be at
  1388. // the end anyway.
  1389. const char* pSrc = m_pOurPath;
  1390. char* pCurrentEndOfPath = pLinkPath;
  1391. const char* pRelativePath = (const char*)pPositionPointer;
  1393. // Walk to take care of any ../ that might be in the path...
  1394. char* pDest = pCurrentEndOfPath;
  1395. while ( *pSrc )
  1396. {
  1397.     while ( *pSrc == '.' && *(pSrc + 1) == '.' && *(pSrc + 2) == '/' )
  1398.     {
  1399. --pDest;
  1400. while ( *(pDest-1) != '/' && (pDest-1) >= pLinkPath )
  1401. {
  1402.     --pDest;
  1403. }
  1404. pSrc += 3;
  1405.     }
  1406.     *pDest = *pSrc;
  1407.     ++pDest;
  1408.     ++pSrc;
  1409. }
  1410. *pDest = '';
  1412. pCurrentEndOfPath += strlen(pCurrentEndOfPath);
  1414. // back up a directory off of the file path for
  1415. // every ../ we find
  1416. while (!strncmp((const char*)pRelativePath, "../", 3 ))
  1417. {
  1418.     // we found a ../ so back up a directory on the path,
  1419.     // walk backwards to the previous / and set it to null
  1420.     while (*pCurrentEndOfPath != '/' && 
  1421. pCurrentEndOfPath >= pLinkPath)
  1422.     {
  1423. pCurrentEndOfPath--;
  1424.     }
  1425.     // watch to make sure we don't have more ../ than directories
  1426.     if ( pCurrentEndOfPath < pLinkPath)
  1427.     {
  1428. ++pCurrentEndOfPath;
  1429.     }
  1430.     *pCurrentEndOfPath = '';
  1431.     pRelativePath +=3;
  1432. }
  1434.         UINT32 len = (pCurrentEndOfPath - pLinkPath) + 
  1435.     ulNameLen - (pRelativePath - (const char*)pPositionPointer) + 1;
  1437. // back 1 off of pRelativePath so we get the / that's there.
  1438. strncat(pLinkPath, (const char*)pRelativePath - 1, /* Flawfinder: ignore */
  1439.     ulNameLen - (pRelativePath - (const char*)pPositionPointer) + 1);
  1440. pLinkPath[len] = '';
  1441.     }
  1442.     else
  1443.     {
  1444. HX_ASSERT(FALSE);
  1445. pLinkPath = '';
  1446.     }
  1448.     char* pParam = EncryptParameter(pReturnBuffer);
  1449.     HX_VECTOR_DELETE(pReturnBuffer);
  1450.     return (UCHAR*)pParam;
  1451. }
  1453. /*___________________________________________________________________________
  1454.  *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  1455.  *  EncryptParameter(pPath)
  1456.  *
  1457.  *  PARAMETERS:
  1458.  * pPath Pointer to a string to be parameterized and encrypted.
  1459.  *
  1460.  *  DESCRIPTION:
  1461.  * First it is assigned to a variable (src), and then the parameter is
  1462.  * encrypted
  1463.  *
  1464.  *  RETURNS
  1465.  * a pointer to a new string that is to be used after the ? for an 
  1466.  * option in a url
  1467.  *___________________________________________________________________________
  1468.  *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
  1469. char*
  1470. CEscapeXMLtoHTML::EncryptParameter(char* pPath)
  1471. {
  1472.     UINT32 FinalLen;     // length of encoded data
  1473.     UINT32 Offset = strlen(pPath);
  1474.     UINT32 nAlign = Offset % sizeof(ULONG32);
  1475.     if (nAlign > 0)
  1476.     {
  1477. for (; nAlign < sizeof(ULONG32); nAlign++)
  1478. {
  1479.     pPath[Offset++] = 0;
  1480. }
  1481.     }
  1482.     FinalLen = (Offset) * Perplex_PER_ULONG32 / sizeof(ULONG32);
  1483.     // calc size of the outout (Perplexed) buffer.
  1484.     // alloc mem for final perplexed buffer
  1485.     // Add one to length 'cause low level perplex adds
  1486.     // a '' to the resulting string
  1488.     char* output = new char[FinalLen+1];
  1490.     CHXPerplex::DumpToPerplex((char*)output,FinalLen+1,(UCHAR*) pPath, Offset);
  1491.     return output;
  1492. }
  1494. /*___________________________________________________________________________
  1495.  *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  1496.  *  CheckTag (pObj)
  1497.  *
  1498.  *  PARAMETERS:
  1499.  * pObj current state
  1500.  *
  1501.  *  DESCRIPTION:
  1502.  * This method pushes the begging of a color tag onto the queue
  1503.  *
  1504.  *  RETURNS
  1505.  * void
  1506.  *___________________________________________________________________________
  1507.  *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
  1508. BOOL
  1509. CEscapeXMLtoHTML::CheckTag(DataObject* pObj)
  1510. {
  1511.     if ( m_pHotTags ) 
  1512.     {
  1513. for ( INT32 i = 0; m_pHotTags[i]; i++ )
  1514. {
  1515.     if ( !strcmp(pObj->tag, m_pHotTags[i]) )
  1516.     {
  1517.     return TRUE;
  1518.     }
  1519. }
  1520.     }
  1521.     return FALSE;
  1522. }
  1523. /*___________________________________________________________________________
  1524.  *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  1525.  *  BeginColorTag (CBigByteGrowingQueue* qu, DataObject *pObj)
  1526.  *
  1527.  *  PARAMETERS:
  1528.  * qu queue to output to
  1529.  * pObj current state
  1530.  *  DESCRIPTION:
  1531.  * This method pushes the begging of a color tag onto the queue
  1532.  * RETURNS
  1533.  * void
  1534.  *___________________________________________________________________________
  1535.  *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
  1536. void
  1537. CEscapeXMLtoHTML::BeginColorTag (CBigByteGrowingQueue* qu, DataObject *pObj)
  1538. {
  1539.     qu->EnQueue(m_pEscapeStrings[BeginTagMarkup]);
  1540.     qu->EnQueue("&lt;");
  1541.     qu->EnQueue(m_pEscapeStrings[BeginTagNameMarkup]);
  1542.     pObj->state = ABOUT_TO_BEGIN_TAG;
  1543.     pObj->bPushChar = FALSE;
  1544. }
  1546. /*___________________________________________________________________________
  1547.  *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  1548.  *  EndColorTag (CBigByteGrowingQueue* qu, DataObject *pObj)
  1549.  *
  1550.  *  PARAMETERS:
  1551.  * qu queue to output to
  1552.  * pObj current state
  1553.  *
  1554.  *  DESCRIPTION:
  1555.  * This method pushes the end of a color tag onto the queue
  1556.  *
  1557.  *  RETURNS
  1558.  * void
  1559.  *___________________________________________________________________________
  1560.  *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
  1561. void
  1562. CEscapeXMLtoHTML::EndColorTag (CBigByteGrowingQueue* qu, DataObject *pObj)
  1563. {
  1564.     if ( pObj->bInBrokenXML )
  1565.     {
  1566.         qu->EnQueue(m_pEscapeStrings[EndBrokenAttributeMarkup]);
  1567.         pObj->bInBrokenXML = FALSE;
  1568.     }
  1569.     if ( pObj->bInProcessingInstructions )
  1570.     {
  1571.        qu->EnQueue(m_pEscapeStrings[EndProcessingInstructions]);
  1572.        qu->EnQueue(m_pEscapeStrings[BeginTagMarkup]);
  1573.        qu->EnQueue("&gt;");
  1574.        qu->EnQueue(m_pEscapeStrings[EndTagMarkup]);
  1575.        pObj->bInProcessingInstructions = FALSE;
  1576.     }
  1577.     else
  1578.     {
  1579.        qu->EnQueue("&gt;");
  1580.        qu->EnQueue(m_pEscapeStrings[EndTagMarkup]);
  1581.     }
  1582.     pObj->state = IN_CONTENT;
  1583.     pObj->bPushChar = FALSE;
  1584. }