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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
xmlesc.cpp
资源名称：helix.src.0812.rar　[点击查看]
上传用户：zhongxx05
上传日期：2007-06-06
资源大小：33641k
文件大小：53k
源码类别：

Symbian

开发平台：

C/C++

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