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

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

Symbian

开发平台：

Visual C++

smlparse.h：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: smlparse.h,v 1.6.12.1 2004/07/09 01:57:56 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. #ifndef _SMLPARSE_H_
  51. #define _SMLPARSE_H_
  53. #define MAX_PENDING_CHECK_CALLDEPTH 20
  55. /* <body dur="20s">[no sources]</body> is valid; we need to handle it: */
  56. #define DEFAULT_DUR_IF_NO_SOURCES_SCHEDULED   SMILTIME_INVALID
  58. // forward declarations
  59. typedef _INTERFACE IHXSystemRequired     IHXSystemRequired;
  60. typedef _INTERFACE IHXBuffer             IHXBuffer;
  61. typedef _INTERFACE IHXValues             IHXValues;
  62. typedef _INTERFACE IHXXMLParserResponse  IHXXMLParserResponse;
  63. typedef _INTERFACE IHXCommonClassFactory IHXCommonClassFactory;
  64. typedef _INTERFACE IHXXMLParser          IHXXMLParser;
  65. typedef void*                             LISTPOSITION;
  66. class CHXString;
  67. class SMILNodeList;
  68. class CSmilElement;
  69. class CHXSimpleList;
  70. class ErrorNotifier;
  71. class CSmilParser;
  72. class CSmilElementHandler;
  73. class SmilTimeValue;
  74. class CHXPtrArray;
  75. class CSmilAnchorElement;
  76. class CHXStack;
  77. class CSmilRegion;
  78. class CSmilRegPoint;
  79. #if defined(HELIX_FEATURE_SMIL2_MULTIWINDOWLAYOUT)
  80. class CSmilViewport;
  81. #endif /* #if defined(HELIX_FEATURE_SMIL2_MULTIWINDOWLAYOUT) */
  82. class CSmilTransition;
  83. class CSmilRootLayout;
  84. class CSmilMeta;
  85. class CSmilMetadata;
  86. class CSmilRendererPreFetch;
  87. class CSmilSource;
  88. class CSmilPriorityClassElement;
  89. class CSmilAAnchorElement;
  90. class CSmilSeqElement;
  91. class CSmilParElement;
  92. class CSmilExclElement;
  93. class CSmilAnimateElement;
  94. class CSmilParamElement;
  95. class CSmilCustomTest;
  96. class XMLError;
  97. class CHXMapLongToObj;
  98. class CHXMapStringToOb;
  99. #if defined(HELIX_FEATURE_SMIL2_VALIDATION)
  100. class CRNBinaryMap;
  101. #endif /* #if defined(HELIX_FEATURE_SMIL2_VALIDATION) */
  102. class CNamespaceInfo;
  103. class CSmilBodyElement;
  104. class CSmilTimelineElementManager;
  106. /* // /XXXEH- we can't do the following until the core starts notifying
  107. // us every time a repeated track begins:
  108. //#define XXXEH_REPEAT_VALUE_TIMING_SHOULD_BE_EVENT_BASED
  109. */
  112. #define NUM_SUPPORTED_SMIL_2_0_MODULE_NAMESPACES   55
  115. class SMILNamespace
  116. {
  117. public:
  118.     SMILNamespace(SMILNamespace* pNS);
  119.     SMILNamespace(const char* name, IHXBuffer* pVal);
  120.     virtual ~SMILNamespace();
  122.     char*       m_name;
  123.     IHXBuffer* m_pValue;
  124. };
  126. class SMILNode
  127. {
  128. public:
  129.     SMILNode();
  130.     virtual ~SMILNode();
  131. #if defined(XXXEH_REPEAT_VALUE_TIMING_SHOULD_BE_EVENT_BASED)
  132.     SMILNode(const SMILNode&, BOOL bKeepId=FALSE, CSmilParser* pParser = NULL);
  133. #else
  134.     SMILNode(const SMILNode&, BOOL bKeepId=FALSE, CSmilParser* pParser = NULL,
  135.              UINT32 ulRepeatNum=0);
  136. #endif
  138.     SMILNode* getFirstChild();
  139.     SMILNode* getNextChild();
  141.     CHXString      m_repeatid;
  142.     CHXString      m_id;
  143.     CHXString      m_name;
  144.     UINT32         m_num;    
  145.     SMILNodeTag    m_tag;
  146.     SMILNode*      m_pParent;
  147.     SMILNode*      m_pDependency;
  148.     SMILNodeList*  m_pNodeList;
  149.     IHXValues*    m_pValues;
  150.     CSmilElement*  m_pElement;
  151.     UINT16         m_nGroup;
  152.     RepeatTag      m_repeatTag;
  153.     CHXString      m_trackHint;
  154.     UINT32         m_ulTagStartLine;
  155.     UINT32         m_ulTagStartColumn;
  156.     UINT16         m_nPrefetchTrackNum;
  157.     double         m_fPartialPlayFactor;
  158.     UINT32         m_ulRepeatDur;
  159.     CHXSimpleList* m_pNamespaceList;
  160.     SMIL2Element   m_eElement;
  161.     // ONLY HX_BITFIELD MEMBERS SHOULD GO BELOW THIS LINE!
  162.     // ALL OTHER MEMBER TYPES SHOULD GO ABOVE THIS LINE!
  163.     HX_BITFIELD    m_bLastInGroup : 1;
  164.     HX_BITFIELD    m_bDelete : 1;
  165.     HX_BITFIELD    m_bSkipContent : 1;
  166.     HX_BITFIELD    m_bRepeatHandled : 1;
  167.     HX_BITFIELD    m_bIsSeqWrapperForRepeatElement : 1;
  168.     HX_BITFIELD    m_bIsOuterWrapperTimeContainer : 1;
  169.     HX_BITFIELD    m_bBeginHandledByWrapperParent : 1;
  170.     HX_BITFIELD    m_bEndHandledByWrapperParent : 1;
  171.     HX_BITFIELD    m_bMinHandledByWrapperParent : 1;
  172.     HX_BITFIELD    m_bMaxHandledByWrapperParent : 1;
  173.     HX_BITFIELD    m_bNeedToResolveRepeatDurVSRepeatCount : 1;
  174.     HX_BITFIELD    m_bCloseNode : 1;
  175.     HX_BITFIELD    m_bNamespacedElement : 1;
  176. private:
  177.     LISTPOSITION   m_curPosition;
  178. };
  180. class SMILNodeList: public CHXSimpleList
  181. {
  182. public:
  183.     SMILNodeList();
  184.     virtual ~SMILNodeList();
  186.     SMILNodeList* copy(SMILNode* pParent, BOOL bKeepId = FALSE, CSmilParser* pParser = NULL);
  188.     SMILNode* m_pParentNode;
  189. };
  191. class CNamespaceInfo
  192. {
  193. public:
  194.     CNamespaceInfo();
  195.     ~CNamespaceInfo();
  197.     char*              m_pszPrefix;
  198.     char*              m_pszURL;
  199.     SupportedNamespace m_eNamespace;
  200.     // ONLY HX_BITFIELD MEMBERS SHOULD GO BELOW THIS LINE!
  201.     // ALL OTHER MEMBER TYPES SHOULD GO ABOVE THIS LINE!
  202.     HX_BITFIELD        m_bImplemented : 1;
  203. };
  206. class CSmilParserResponse : public IHXXMLParserResponse,
  207.                             public ErrorNotifier
  208. {
  209. public:
  210.     CSmilParserResponse(CSmilParser* pParser);
  211.     virtual ~CSmilParserResponse();
  213.     // IUnknown methods
  214.     STDMETHOD(QueryInterface)    (THIS_ REFIID riid, void** ppvObj);
  215.     STDMETHOD_(ULONG32, AddRef)  (THIS);
  216.     STDMETHOD_(ULONG32, Release) (THIS);
  218.     // IHXXMLParserResponse methods
  219.     STDMETHOD(HandleStartElement)          (THIS_ const char* pName,
  220.                                                   IHXValues* pAttributes,
  221.                                                   UINT32      ulLineNumber,
  222.                                                   UINT32      ulColumNumber);
  223.     STDMETHOD(HandleEndElement)            (THIS_ const char* pName,
  224.                                                   UINT32      ulLineNumber,
  225.                                                   UINT32      ulColumNumber);
  226.     STDMETHOD(HandleCharacterData)         (THIS_ IHXBuffer* pBuffer,
  227.                                                   UINT32      ulLineNumber,
  228.                                                   UINT32      ulColumNumber);
  229.     STDMETHOD(HandleProcessingInstruction) (THIS_ const char* pTarget,
  230.                                                   IHXValues* pAttributes,
  231.                                                   UINT32      ulLineNumber,
  232.                                                   UINT32      ulColumNumber);
  233.     STDMETHOD(HandleUnparsedEntityDecl)    (THIS_ const char* pEntityName,
  234.                                                   const char* pSystemID,
  235.                                                   const char* pPublicID,
  236.                                                   const char* pNotationName,
  237.                                                   UINT32      ulLineNumber,
  238.                                                   UINT32      ulColumNumber);
  239.     STDMETHOD(HandleNotationDecl)          (THIS_ const char* pNotationName,
  240.                                                   const char* pSystemID,
  241.                                                   const char* pPublicID,
  242.                                                   UINT32      ulLineNumber,
  243.                                                   UINT32      ulColumNumber);
  244.     STDMETHOD(HandleComment)               (THIS_ const char* pComment,
  245.                                                   UINT32      ulLineNumber,
  246.                                                   UINT32      ulColumNumber);
  247.     STDMETHOD(HandleUnparsedDoctypeDecl)   (THIS_ const char* pName, 
  248.                                                   const char* pSystemID,
  249.                                                   const char* pPublicID, 
  250.                                                   UINT32      ulLineNumber,
  251.                                                   UINT32      ulColumNumber);
  252.     STDMETHOD(HandleDefault)               (THIS_ IHXBuffer* pBuffer,
  253.                                                   UINT32      ulLineNumber,
  254.                                                   UINT32      ulColumNumber);
  256.     // ErrorNotifer methods
  257.     HX_RESULT ErrorInLastTag(HX_RESULT   Error,
  258.                              const char* pErrorString,
  259.                              const char* pFrameString,
  260.                              UINT32      ulLineNumber,
  261.                              UINT32      ulLinePosition);
  262. private:
  263.     CSmilParser* m_pParser;
  264.     INT32        m_lRefCount;
  265.     SMILNode*    m_pCurrentNode;
  266. };
  268. struct ExternalEventInfo
  269. {
  270.     CHXString       m_EventBaseID;
  271.     CHXString       m_PrefixedEventName;
  272.     CHXString       m_EventName;
  273.     CNamespaceInfo* m_pInfo;
  274. };
  276. class CSmilParser
  277. {
  278. public:
  279.     CSmilParser(IUnknown* pContext);
  280.     virtual ~CSmilParser();
  282.     HX_RESULT            init(BOOL bStoreErrors = FALSE);
  283.     HX_RESULT            parse(IHXBuffer* pBuffer, BOOL bIsFinal);
  284.     HX_RESULT            parse(const char* pSmilText);
  285. #if defined(HELIX_FEATURE_SMIL2_VALIDATION)
  286.     HX_RESULT            validateContentModel(UINT32 ulElement, SMILNodeList* pChildren);
  287.     HX_RESULT            validateNode(SMILNode* pNode);
  288.     HX_RESULT            validateCDATA(const char* pszStr) const;
  289.     HX_RESULT            validateIDREF(const char* pszStr) const;
  290.     HX_RESULT            validateNMTOKEN(const char* pszStr) const;
  291.     HX_RESULT            validateEnumerated(UINT32 ulElem, UINT32 ulAttr, const char* pszStr);
  292.     BOOL                 isXMLLetter(char c) const;
  293.     BOOL                 isXMLDigit(char c) const;
  294.     BOOL                 isXMLNameChar(char c) const;
  295.     BOOL                 isNamespacePrefixed(const char* pszStr);
  296.     HX_RESULT            normalizeAttribute(const char* pszStr,
  297.                                             BOOL        bIsCDATA,
  298.                                             REF(char*)  rpszNormal);
  299.     HX_RESULT            validateAttribute(UINT32 ulElement, UINT32 ulAttrib,
  300.                                            const char* pszStr, REF(char*) rpszNormStr);
  301.     HX_RESULT            validateElementName(SMILNode* pNode);
  302.     HX_RESULT            setupValidationNamespaces(SMILNode* pNode);
  303.     HX_RESULT            validateAgainstDTD();
  304.     HX_RESULT            checkExtensionElementNamespace(SMIL2Element eElem,
  305.                                                         SupportedNamespace eNS);
  306.     HX_RESULT            checkExtensionAttributeNamespace(SMIL2Attribute eAttr,
  307.                                                           SupportedNamespace eNS);
  308. #endif /* #if defined(HELIX_FEATURE_SMIL2_VALIDATION) */
  309.     CNamespaceInfo*      getNamespaceInfo(const char* pszStr, REF(const char*) rpszAttr);
  310.     HX_RESULT            createElements();
  311.     HX_RESULT            durationResolved(const char* pID, UINT32 ulDuration,
  312.                                           BOOL bSetByParent=FALSE,
  313.                                           BOOL bDurationExtendingDueToPause=FALSE);
  314.     HX_RESULT            trackRemoved(const char* pID, UINT32 ulDuration);
  315.     HX_RESULT            adjustForNegativeOffset(const char* pID);
  316.     void                 insertTimelineElement(const char* pID, UINT32 ulDelay);
  317.     void                 resetTimelineElementDuration(const char* pID,
  318.                                                       UINT32 ulDuration,
  319.                                                       UINT32 ulPriorDuration);
  320.     void                 resetTimelineElementDelay(const char* pID, UINT32 ulDelay,
  321.                                                    UINT32 ulPriorDelay);
  322.     void                 resetTimeline();
  323.     HX_RESULT  prepForSeek(UINT32 ulOldTime, UINT32 ulNewTime);
  324.     HX_RESULT            handlePrefetchFinished(const char* pID, UINT32 ulTimeFinished);
  325.     UINT16               getFragmentGroup(const char* pFragment);
  326.     UINT32               getFragmentOffset(const char* pFragment,
  327.                                            BOOL& bFragFoundAndResolved,
  328.                                            BOOL bResolveBeginOfFragmentTarget=FALSE,
  329.                                            ULONG32 ulCurTime=0);
  330.     HX_RESULT            handleNextElement(CSmilElementHandler* pHandler);
  331.     HX_RESULT            setAllElementHandlers(CSmilElementHandler* pHandler);
  332.     SMILNode*            findFirstNode(SMILNodeTag tag);
  333.     SMILNode*            getFirstNodeChild(SMILNode* pNode);
  334.     SMILNode*            getPrevNode(SMILNode* pCurrentNode);
  335.     CSmilElement*        findElement(const char* pID);
  336.     SMILNode*            getNextNodeChild();
  337.     SMILNodeTag          getSyncTag(SMILNode* pNode);
  338.     void                 getPacketPending(UINT16 unStreamNumber);
  339.     HX_RESULT            addGlobalNamespace(const char* pNamespace, const char* pPrefix);
  340.     HX_RESULT            storeNamespaces(SMILNode* pNode);
  341.     HX_RESULT            addToNamespaceScope(SMILNode* pNode);
  342.     HX_RESULT            removeFromNamespaceScope(SMILNode* pNode);
  343.     BOOL                 isSupportedNonRNNamespace(const char* pNamespace);
  344.     HX_RESULT            addBeginTimeSyncElement(CSmilElement* pElement);
  345.     HX_RESULT            addEndTimeSyncElement(CSmilElement* pElement);
  346.     HX_RESULT            resolveSyncBaseElements();
  347.     HX_RESULT            handleExclDescendants();
  348.     HX_RESULT            addBeginEventElement(SmilTimeValue* pTimeVal);
  349.     HX_RESULT            tryToResolveBeginEndEvents(const char* pEventName,
  350.                                                     const char* pEventElementId,
  351.                                                     ULONG32     ulEventTime);
  352.     HX_RESULT            addEndEventElement(SmilTimeValue* pTimeVal);
  353.     HX_RESULT            addBeginMediaMarkerSyncElement(SmilTimeValue* pTmpVal);
  354.     HX_RESULT            addEndMediaMarkerSyncElement(SmilTimeValue* pTmpVal);
  355.     HX_RESULT            resolveMediaMarkerTime(const char* pszID,
  356.                                                 const char* pszMarkerName,
  357.                                                 UINT32      ulMarkerTime,
  358.                                                 REF(BOOL)   rbNeedHandleElements);
  359.     HX_RESULT            handlePendingScheduling(INT32 lCurTime,
  360.                                                  INT16 iCurrentGroupIndex,
  361.                                                  REF(BOOL) bSomeScheduleWasChanged,
  362.                                                  /*OUT*/ CHXSimpleList* pPauseDisplayElementHideList,
  363.                                                  /*OUT*/ CHXSimpleList* pPauseDisplayDisableElementList);
  364.     HX_RESULT            checkPendingBeginAndEndTimes(INT32     lCurTime,
  365.                                                       INT16 iCurrentGroupIndex,
  366.                                                       REF(BOOL) bREFSomeScheduleWasChanged,
  367.                                                       INT32     lRecursionCount,
  368.                                                       /*OUT*/ CHXSimpleList* pPauseDisplayElementHideList,
  369.                                                       /*OUT*/ CHXSimpleList* pPauseDisplayDisableElementList,
  370.                                                       BOOL bDoHandleExclBeforePlaybackStarts);
  371.     HX_RESULT            insertElementWithPendingBeginOrEnd(CSmilElement*      pElement,
  372.                                                             INT32              lCurTime,
  373.                                                             SmilTimingListType listType);
  374.     void                 handleAllXMMFReferences();
  375.     CHXMapStringToOb*    findNextPendingOnLoadURL(UINT32 lCurTime);
  376.     BOOL                 hasActivateEventListener(const char* pMediaID,
  377.                                                   INT16 iCurrentGroupIndex);
  378.     const char*          getDefaultNamespace();
  379.     // note -- the pErr array returned has the same scope as the SMILParser 
  380.     // object
  381.     HX_RESULT            getErrors(CHXPtrArray** pErrs);
  382.     SMILNode*            getSyncAncestor(SMILNode* pNode);
  383.     // /NOTE: sync base is not always begin of sync ancestor; in a seq, it's
  384.     // end of prior sibling (if any), so this calculates all that:
  385.     virtual ULONG32      getSyncBaseTimeInGroupTimeCoords(SMILNode* pNode);
  387.     // /Tells whether any node all the way up to the root has specified
  388.     // ancestor tag:
  389.     BOOL                 hasAncestor(SMILNodeTag ancestor, SMILNode* pNode);
  391.     // Added to be able to quickly lookup <anchor> or <area> tags
  392.     // by id and not by the region they map to.
  393.     CSmilAnchorElement*  getAnchorOrAreaElement(const char* pID);
  394.     // XXXMEH - moved this from private to public so that we 
  395.     // could animate the coords attribute. This method is needed
  396.     // to parse the coords attribute.
  397.     HX_RESULT            parseAnchorCoords(const char*         pCoords,
  398.                                            CSmilAnchorElement* pAnchor);
  399.     BOOL                 presentationContainsASource() {return m_bContainsSource; }
  400.     BOOL                 presentationContainsInitiallyScheduledTrack() {
  401.                     return m_bContainsInitiallyScheduledTrack; }
  402.     ULONG32              presentationDurIfNoInitialTracksScheduled() {
  403.                             return m_ulDurIfNoInitialTracksScheduled; }
  404.     BOOL                 EstablishBeginTimeList();
  405.     BOOL                 EstablishEndTimeList();
  406.     BOOL                 EstablishBeginEventList();
  407.     BOOL                 EstablishEndEventList();
  408.     CHXSimpleList*       GetPendingBeginTimeList() {return m_pPendingBeginTimeList;}
  409.     CHXSimpleList*       GetPendingEndTimeList() {return m_pPendingEndTimeList;}
  410.     CHXSimpleList*       GetBeginEventList() {return m_pBeginEventList;}
  411.     CHXSimpleList*       GetEndEventList()   {return m_pEndEventList;}
  412.     BOOL                 isDuplicateEntry(CHXSimpleList* pList,
  413.                                           SmilTimeValue* pTimeValue);
  414.     HX_RESULT            addResumeEvent(SmilTimeValue* pTimeValue,
  415.                                         REF(BOOL) bOldResumeEventWasRemoved);
  416.     HX_RESULT            addUndeferEvent(SmilTimeValue* pTimeValue,
  417.                                         REF(BOOL) bOldUndeferEventWasRemoved);
  418.     HX_RESULT            addResumeOrUndeferEvent(SmilTimeValue* pTimeValue,
  419.                                         REF(BOOL) bOldSuchEventWasRemoved,
  420. BOOL bIsResumeEvent);
  421.     HX_RESULT            computeRemoveTime(const char* pszID,
  422.                                            REF(UINT32) rulRemoveTime);
  423.     void                 InitPersistent(UINT32 ulPersistentComponentID, IHXValues* pProperties);
  424.     BOOL                 isTimelineObject(SMILNode* pNode);
  425.     static BOOL          isMediaObject(SMILNode* pNode);
  426.     BOOL                 isNonMediaPlayableObject(SMILNode* pNode);
  427.     BOOL                 isTimeContainerObject(SMILNode* pNode);
  428.     UINT16               getNumGroups() const { return m_usNumGroups; }
  429.     const char*          getEnumAttrString(SMIL2Attribute eAttr, BYTE ucVal);
  430.     void                 setParseError(HX_RESULT rv) { m_lParseError = rv;   }
  431.     HX_RESULT            getParseError() const       { return m_lParseError; }
  432.     BOOL                 isAttributeAnimated(const char* pszElementID,
  433.                                              UINT32      ulAttrName);
  434.     SMIL2Element         getSMIL2Element(const char* pszStr);
  435.     SMIL2Attribute       getSMIL2Attribute(const char* pszStr);
  436.     void                 checkForExternalEvents();
  437.     BOOL                 anyExternalEvents(const char* pszID);
  438.     ExternalEventInfo*   getFirstExternalEvent(const char* pszID);
  439.     ExternalEventInfo*   getNextExternalEvent(const char* pszID);
  440.     void                 checkForEventHandlers();
  441.     AccessErrorBehavior  getAccessErrorBehavior(SMILNode* pNode);
  442.     UINT32               GetUniqueNumber() { return m_ulNextVar++; }
  444.     // CSmilParser static public member methods
  445.     static HX_RESULT     parseRegionDimension(const char*   pszStr,
  446.                                               REF(double)   rdValue,
  447.                                               REF(CSS2Type) reType);
  448.     static HX_RESULT     parseZIndex(const char*   pszStr,
  449.                                      REF(INT32)    rlValue,
  450.                                      REF(CSS2Type) reType);
  451.     static HX_RESULT     parseColor(const char*   pszStr,
  452.                                     REF(UINT32)   rulColor,
  453.                                     REF(CSS2Type) reType);
  454.     static HX_RESULT     parseFit(const char*   pszStr,
  455.                                   REF(Fit)      reValue);
  456.     static HX_RESULT     parseRegAlign(const char*   pszStr,
  457.                                        REF(RegAlign) reValue);
  458.     static HX_RESULT     parseOpacity(const char* pszStr, REF(UINT32) rulOpacity);
  459.     static HX_RESULT     parseFill(const char* pszStr, REF(FillType) reFill);
  460.     static HX_RESULT     getFillString(FillType eFill, REF(CHXString) rcFill);
  461.     static HX_RESULT     getEraseString(EraseType eErase, REF(CHXString) rcErase);
  462.     static HX_RESULT     parseFillDefault(const char* pszStr, REF(FillDefaultType) reFillDefault);
  463.     static HX_RESULT     parseAccelDecel(const char* pszStr, REF(double) rdVal);
  464. #if defined(HELIX_FEATURE_SMIL2_TRANSITIONS)
  465.     static HX_RESULT     getDefaultTransitionSubType(const char* pszType, REF(CHXString) rcSubType);
  466.     static BOOL          isLegalTransitionType(const char* pszType);
  467.     static BOOL          isLegalTransitionSubType(const char* pszType, const char* pszSubType);
  468. #endif /* #if defined(HELIX_FEATURE_SMIL2_TRANSITIONS) */
  469.     static HX_RESULT     parseMarkerURI(const char*    pszStr,
  470.                                         REF(CHXString) rcMarker,
  471.                                         REF(BOOL)      rbExternal,
  472.                                         REF(CHXString) rcExternalFileName);
  473.     static HX_RESULT     parseHandlerForID(const char*    pszStr,
  474.                                            REF(CHXString) rcHandlerID);
  475.     static HX_RESULT     parseAccessErrorBehavior(const char* pszStr,
  476.                                                   REF(AccessErrorBehavior) reErr);
  477. #if defined(XXXMEH_SPLINE_ANIMATION)
  478.     static HX_RESULT     parseKeyTimes(const char* pszVal, CSmilAnimateElement* pAnim);
  479.     static HX_RESULT     parseKeySplines(const char* pszVal, CSmilAnimateElement* pAnim);
  480.     static HX_RESULT     parseSVGPath(const char* pszVal, CSmilAnimateElement* pAnim);
  481. #endif
  482.     static BOOL          isDataURL(const char* pszURL);
  483.     static HX_RESULT     validateDataURL(const char* pszURL);
  484.     static void          addStringProperty(IHXValues* pValues,
  485.                                            IUnknown*   pContext,
  486.                                            const char* pszName,
  487.                                            const char* pszValue);
  489.     BOOL                 allTracksNeedReflushHint() { return m_bAllTracksNeedReflushHint; }
  491.     // CSmilParser public members    
  492.     CHXStack*     m_pNodeListStack;
  493.     SMILNodeList* m_pNodeList;
  494.     UINT32        m_ulErrorLineNumber;
  495.     UINT32        m_ulErrorColumnNumber;
  496.     IHXBuffer*   m_pErrorText;
  497.     IHXBuffer*   m_pDefaultNamespace;
  498.     UINT32        m_ulPersistentComponentDelay;
  499.     UINT32        m_ulPersistentComponentDuration;
  500.     CSmilTimelineElementManager* m_pTimelineElementManager;
  501.     friend class CSmilParserResponse;
  502. private:
  503.     void                   close();
  504.     void                   initRequireTags();
  505.     void    GetSystemScreenInfo(REF(UINT32) rulScreenHeight,
  506.        REF(UINT32) rulScreenWidth,
  507.        REF(UINT32) rulScreenBitDepth);
  508.     void                   getPreferences();
  509.     HX_RESULT              createHeadElements(SMILNodeList* pNodeList);
  510.     HX_RESULT              createSeqWrapper(SMILNodeList* pNodeList, BOOL bMakeInnerPar);
  511.     HX_RESULT              createBodyElements(SMILNodeList* pNodeList);
  512.     HX_RESULT              createElementForAnchorTarget(CSmilAAnchorElement* pAnchor,
  513.                                                        SMILNodeList* pNodeList);
  514. #if 0  /*XXXEH- I wrote this and then didn't need it but it may come in
  515.          handy later so #if(0) it out: */
  516.     BOOL                   hasNoSourceChildren(SMILNode* pNode);
  517. #endif
  518.     HX_RESULT              assignGroupIndexes(SMILNodeList* pNodeList);
  519.     HX_RESULT              assignGroupIndexOnPar(SMILNode* pNode, UINT16 nGroup);
  520.     HX_RESULT              assignGroupIndexOnSeq(SMILNode* pNode, UINT16& nGroup);
  521.     HX_RESULT              constructTimelineElements(SMILNodeList* pNodeList);
  522.     HX_RESULT              setInitialDelays(SMILNodeList* pNodeList);
  523.     void                   setInitialDelay(SMILNode* pNode);
  524.     void                   setInitialDelayOnSeq(SMILNode* pNode);
  525.     HX_RESULT              expandRepeatElements(SMILNodeList* pNodeList);
  526.     HX_RESULT              printBodyElements(SMILNodeList* pNodeList);
  527.     HX_RESULT              updateEventElements(SMILNodeList* pNodeList);
  528.     HX_RESULT              insertElementByTimestamp(CSmilElement* pElement);
  529.     HX_RESULT              addGroup(SMILNode* pNode);
  530.     HX_RESULT              insertGroups();
  531.     HX_RESULT              mapID(SMILNode* pNode, BOOL bOverWrite = FALSE);
  532.     HX_RESULT              mapChildrenIDs(SMILNodeList* pNodeList, BOOL bOverWrite = FALSE);
  533.     HX_RESULT              markRepeatReplica(SMILNodeList* pNodeList, RepeatTag repeatTag);
  535.     BOOL                   testAttributeFailed(SMILNode* pNode);
  536.     BOOL                   customTestFailed(SMILNode* pNode);
  537.     BOOL                   systemComponentFailed(IHXBuffer* pRequiredValue);
  538.     HX_RESULT              markTestAttributeNodes(SMILNodeList* pNodeList);
  539.     HX_RESULT              selectSwitchNodes(SMILNode* pNode);
  541.     BOOL                   inSeq(SMILNode* pNode);
  542.     HX_RESULT              createParent(SMILNode* pChildNode, SMILNodeTag tag,
  543.                                         SMILNode*& pParent, SMILNode*& pParentEnd);
  544.     void                   resolveTimestamps();
  545.     void                   resolveTimestamps(SMILNodeList* pNodeList);
  546.     UINT32                 getStartTime(SMILNode* pNode);
  547.     CSmilRegion*           makeRegion(SMILNode* pNode);
  548.     CSmilRegPoint*         makeRegPoint(SMILNode* pNode);
  549. #if defined(HELIX_FEATURE_SMIL2_MULTIWINDOWLAYOUT)
  550.     CSmilViewport*         makeViewport(SMILNode* pNode);
  551. #endif /* #if defined(HELIX_FEATURE_SMIL2_MULTIWINDOWLAYOUT) */
  552.     CSmilTransition*       makeTransition(SMILNode* pNode, REF(HX_RESULT) retVal);
  553.     CSmilRootLayout*       makeRootLayout(SMILNode* pNode);
  554.     CSmilMeta*             makeMeta(SMILNode* pNode);
  555.     CSmilMetadata*         makeMetadata(SMILNode* pNode);
  556.     CSmilCustomTest*       makeCustomTest(SMILNode* pNode,
  557.                                     REF(HX_RESULT) retVal);
  558.     CSmilRendererPreFetch* makeRendererPreFetch(SMILNode* pNode);
  559.     CSmilSource*           makeSource(SMILNode* pNode);
  560.     CSmilPriorityClassElement* makePriorityClassElement(SMILNode* pNode);
  561.     CSmilAAnchorElement*   makeAAnchorElement(SMILNode* pNode);
  562.     CSmilAnchorElement*    makeAnchorElement(SMILNode* pNode);
  563.     CSmilSeqElement*       makeSeqElement(SMILNode* pNode);
  564.     CSmilParElement*       makeParElement(SMILNode* pNode);
  565.     CSmilExclElement*      makeExclElement(SMILNode* pNode);
  566.     CSmilParamElement*     makeParamElement(SMILNode* pNode);
  567.     CSmilBodyElement*      makeBodyElement(SMILNode* pNode);
  568. #if defined(HELIX_FEATURE_SMIL2_ANIMATION)
  569.     CSmilAnimateElement*   makeAnimateElement(SMILNode* pNode);
  570.     HX_RESULT              animSetupElement(CSmilAnimateElement* pAnim);
  571. #if defined(XXXMEH_SPLINE_ANIMATION)
  572.     HX_RESULT              checkSplineAnimation(CSmilAnimateElement* pAnim);
  573.     HX_RESULT              makeSVGPathExplicit(CSmilAnimateElement* pAnim);
  574. #endif
  575.     HX_RESULT              animCountValues(const char* pszStr, REF(char*)  rpStr,
  576.                                            REF(UINT32) rulNumValues, REF(char**) rppStr);
  577.     HX_RESULT              animParseValue(CSmilAnimateElement* pAnim,
  578.                                           const char*          pszVal,
  579.                                           UINT32               i);
  580. #endif /* #if defined(HELIX_FEATURE_SMIL2_ANIMATION) */
  581.     SMILNode*              getSpecificAncestor(SMILNodeTag ancestor, SMILNode* pNode);
  582.     SMILNode*              findAnyActiveDescendant(SMILNode* pNode,
  583.                                LONG32 lCurTime, SMILNode* pButNotThisNode);
  584.     SMILNode*              findActiveChildOfAncestorExcl(SMILNode* pNode, LONG32 lCurTime);
  585.     SMILNode*              findLastDeferredChildOfAncestorExcl(
  586.                                    SMILNode* pInterruptingNode, LONG32 lCurTime);
  587.     SMILNode*              findLastDeferredDescendant(SMILNode* pNode,
  588.                                      LONG32 lCurTime,
  589.                                      SMILNode* pButNotThisNode,
  590.                                      SMILNode* pLastDeferredChild);
  591.     BOOL                   firstDependentChild(SMILNode* pNode);
  592.     SMILNode*              findFirstNode(SMILNodeList* pNodelist, SMILNodeTag tag);
  593.     // /Finds parent's next child; doesn't have to be a timeline element:
  594.     SMILNode*              findNextSibling(SMILNode* pNode);
  595.     SMILNode*              getTimelineDescendent(SMILNode* pParentNode, SMILNode* pSiblingNode);
  596.     SMILNode*              getTimelineDescendent(SMILNode* pParentNode);
  597.     const char*            assignID(const char* pPrefix);
  598.     HX_RESULT              parseDuration(const char*          pDuration,
  599.                                          CSmilElement*        pElement,
  600.                                          SMILSyncAttributeTag nTag);
  601.     HX_RESULT              parseMarkerClipBeginEnd(const char* pszStr,
  602.                                                    REF(char*)  rpszMarkerName,
  603.                                                    REF(char*)  rpszExtFileName);
  604.     HX_RESULT              adjustDuration(CSmilElement* pElement);
  605.     HX_RESULT              parseClockValue(const char* pValue, UINT32& ulClockValue);
  606.     HX_RESULT              parseSyncBehaviorVal(const char*          pSyncBhvrBuf,
  607.                                                 CSmilElement*        pElement,
  608.                                                 SMILSyncAttributeTag nTag);
  609.     HX_RESULT              parsePeersHigherLower(const char* pBuf,
  610.                                 CSmilPriorityClassElement* pPCElement,
  611.                                 SMILPriorityClassPeersHigherLowerAttrib nAttrib);
  612.     HX_RESULT              parsePauseDisplay(const char* pBuf,
  613.                                 CSmilPriorityClassElement* pPCElement);
  614.     BOOL                   inLanguagePreference(const char* pLang);
  615.     BOOL                   isRelativeURL(const char* pURL);
  616.     UINT8                  getColorElement(const char* pColorFragment, int len);
  617.     void                   handleXMLParserError(XMLError* pError);
  618.     void                   badAttributeError(SMILNodeTag tag,
  619.                                              const char* pNodeName,
  620.                                              UINT32      ulLineNumber,
  621.                                              BOOL        bJustStore);
  622.     void                   initTagAttributes();
  623.     void                   deleteTagAttributes();
  624.     BOOL                   isLegalAttribute(SMILNodeTag tag, const char* pAttrName);
  625.     HX_RESULT              storeError(HX_RESULT   errCode, 
  626.                                       const char* pErrorString, 
  627.                                       const char* pFrameString,
  628.                                       UINT32      ulLineNumber, 
  629.                                       UINT32      ulLinePosition,
  630.                                       BOOL        bXml = TRUE);
  631.     BOOL                   isEndTagObject(SMILNode* pNode);
  632.     const char*            removeSurroundingWhitespace(const char* pValue);
  633.     HX_RESULT              parseBeginEnd(const char*          pBuffer, 
  634.                                          CSmilElement*        pElement,
  635.                                          SMILSyncAttributeTag nTag);
  636.     HX_RESULT              parseSmil1SyncbaseValue(const char*          pCh, 
  637.                                                    CSmilElement*        pElement,
  638.                                                    SMILSyncAttributeTag nTag);
  639.     HX_RESULT              parseCoord(IHXBuffer* pBuf, REF(float) f);
  640.     HX_RESULT              parseDigit(IHXBuffer* pBuf, REF(UINT32) ul);
  641.     HX_RESULT              parseRestart(const char* pBuffer, CSmilElement* pElement);
  642.     HX_RESULT              parseRestartDefault(const char* pBuffer, CSmilElement* pElement);
  643.     HX_RESULT              parseSensitivity(const char* pszValue, CSmilElement* pSource);
  644.     FillDefaultType        getFillDefault(CSmilElement* pElement);
  645.     void                   resolveFillValue(CSmilElement* pElement);
  646.     BOOL                   isAttributeSpecified(CSmilElement* pElement, const char* pszAttr);
  647. #if defined(HELIX_FEATURE_SMIL2_TRANSITIONS)
  648.     HX_RESULT              getNextTransitionEnd(CSmilElement* pElement, REF(UINT32) rulTime);
  649. #endif /* #if defined(HELIX_FEATURE_SMIL2_TRANSITIONS) */
  650.     void                   initParsingMaps();
  651. #if defined(HELIX_FEATURE_SMIL2_VALIDATION)
  652.     void                   processCollection(CRNBinaryMap* pMap,
  653.                                              UINT32        ulElement,
  654.                                              UINT32        ulCollection);
  655.     void                   deleteEnumAttrMaps();
  656.     void                   deleteReqAttrLists();
  657. #endif /* #if defined(HELIX_FEATURE_SMIL2_VALIDATION) */
  658.     void                   deleteValidationNamespaceList();
  659.     void                   checkForXMMFDependency(CSmilElement* pElement);
  660.     void                   handleBeginEndListXMMFReferences(CSmilElement*  pElement,
  661.                                                             CHXSimpleList* pList);
  662.     void                   handleClipBeginEndXMMFReference(CSmilElement*  pElement,
  663.                                                            BOOL           bIsClipBegin);
  664.     HX_RESULT              setElementHandler(SMILNode* pNode, CSmilElementHandler* pHandler);
  665.     void                   addToBeginOrEndTimeMap(SmilTimeValue*     pValue,
  666.                                                   SmilTimingListType eType);
  667.     void                   removeFromBeginOrEndTimeMap(SmilTimeValue*     pValue,
  668.                                                        SmilTimingListType eType);
  669.     BOOL                   isTimeValueListPresent(const char*         pszEventName,
  670.                                                   const char*         pszElementID,
  671.                                                   SmilTimingListType  eType,
  672.                                                   REF(CHXSimpleList*) rpList);
  673.     void                   clearTimeValueMap(SmilTimingListType eType);
  674.     void                   checkNodeForExternalEvents(SMILNode* pNode);
  675.     void                   checkNodeTimeListForExternalEvents(CHXSimpleList* pList);
  676.     void                   addExternalEventToList(const char*     pszID,
  677.                                                   const char*     pszFullName,
  678.                                                   const char*     pszName,
  679.                                                   CNamespaceInfo* pInfo);
  680.     void                   clearExternalEventList();
  682.     IUnknown*               m_pContext;
  683.     IHXCommonClassFactory* m_pClassFactory;
  684.     IHXSystemRequired*     m_pISystemRequired;
  685.     IHXXMLParser*          m_pParser;
  686.     CSmilParserResponse*    m_pResponse;
  687.     SMILNode*               m_pCurNode;
  688.     CHXStack*               m_pNodeDependencies;
  689.     SMILNode*               m_pCurrentDependentNode;
  690.     CHXStack*               m_pAnchorStack;
  691.     CSmilAAnchorElement*    m_pCurrentAnchor;
  692.     INT32                   m_lLastCheckPendingTime;
  693.     CHXSimpleList*          m_pPacketQueue;
  694.     CHXSimpleList*          m_pSourceUpdateList;
  695.     CHXMapLongToObj*        m_pAddGroupMap;
  696.     CHXMapLongToObj*        m_pTagAttributeMap;
  697.     CHXMapStringToOb*       m_pIDMap;
  698.     CHXMapStringToOb*       m_pRequireTagsMap;
  699. #if defined(HELIX_FEATURE_SMIL2_TRANSITIONS)
  700.     CHXMapStringToOb*       m_pTransitionMap;
  701. #endif /* #if defined(HELIX_FEATURE_SMIL2_TRANSITIONS) */
  702.     CHXMapStringToOb*       m_pActiveNamespaceMap;
  703.     CHXMapStringToOb*       m_pCustomTestMap;
  704.     CHXSimpleList*          m_pNSConflictList;
  705.     CHXSimpleList*          m_pBeginTimeSyncList;
  706.     CHXSimpleList*          m_pEndTimeSyncList;
  707.     CHXSimpleList*          m_pBeginEventList;
  708.     CHXSimpleList*          m_pEndEventList;
  709.     CHXSimpleList*          m_pBeginMediaMarkerList;
  710.     CHXSimpleList*          m_pEndMediaMarkerList;
  711.     CHXSimpleList*          m_pClipBeginMarkerList;
  712.     CHXSimpleList*          m_pClipEndMarkerList;
  713.     CHXSimpleList*          m_pPendingBeginTimeList;
  714.     CHXSimpleList*          m_pPendingEndTimeList;
  715.     CHXSimpleList*          m_pOnLoadURLList;
  716.     CHXSimpleList*          m_pOnLoadURLListCopyForPostSeek; 
  717.     BOOL                    m_bHandlePostSeekOnLoadURLs;
  718.     char*                   m_pBasePath;
  719.     CHXSimpleList*          m_pTrackHintList;
  720.     UINT32                  m_ulBandwidthPreference;
  721.     UINT32                  m_ulScreenHeightPreference;
  722.     UINT32                  m_ulScreenWidthPreference;
  723.     UINT32                  m_ulScreenDepthPreference;
  724.     UINT32                  m_ulDurIfNoInitialTracksScheduled;
  725.     char*                   m_pOverdubOrCaptionPreference;
  726.     char*                   m_pEncoding;
  727.     CHXSimpleList*          m_pLanguagePreferenceList;
  728.     CHXPtrArray*            m_pErrors;
  729.     time_t                  m_tRefTime;
  730.     HXVERSIONINFO           m_versionInfo;
  731.     ULONG32                 m_ulPlatformVer; // /Ret val of HXGetWinVer().
  732.     CHXMapStringToOb*       m_pElementMap;
  733.     CHXMapStringToOb*       m_pAttributeMap;
  734. #if defined(HELIX_FEATURE_SMIL2_VALIDATION)
  735.     CHXMapStringToOb*       m_pExtElementMap;
  736.     CHXMapStringToOb*       m_pExtAttributeMap;
  737.     CHXMapStringToOb*       m_pNamespaceMap;
  738.     CRNBinaryMap*           m_pLegalAttrMap;
  739.     CRNBinaryMap*           m_pContentModelMap;
  740.     XMLAttributeType*       m_pAttrType;
  741.     CHXMapStringToOb**      m_ppEnumAttrMap;
  742.     CHXSimpleList**         m_ppReqAttrList;
  743. #endif /* #if defined(HELIX_FEATURE_SMIL2_VALIDATION) */
  744.     CHXSimpleList*          m_pValNSList;
  745.     CHXSimpleList*          m_pXMMFElementList;
  746.     UINT32                  m_ulPersistentComponentID;
  747.     ElementWithinTag        m_elementWithinTag;
  748.     UINT16                  m_usNumGroups;
  749.     HX_RESULT               m_lParseError;
  750.     CHXSimpleList*          m_pAnimateElementList;
  751.     CHXMapStringToOb*       m_pBeginTimeMap;
  752.     CHXMapStringToOb*       m_pEndTimeMap;
  753.     CHXSimpleList*          m_pExternalEventList;
  754.     LISTPOSITION            m_pExternalEventListPos;
  755.     CHXSimpleList*          m_pElementsWithHandlerList;
  756.     char*                   m_pVarName;
  757.     UINT32                  m_ulNextVar;
  758.     static const char* const zm_pSupportedSMIL2ModuleNamespaces[
  759.                                NUM_SUPPORTED_SMIL_2_0_MODULE_NAMESPACES + 1];
  760.     // ONLY HX_BITFIELD MEMBERS SHOULD GO BELOW THIS LINE!
  761.     // ALL OTHER MEMBER TYPES SHOULD GO ABOVE THIS LINE!
  762.     HX_BITFIELD             m_bIgnoreUnrecognizedElements : 1;
  763.     HX_BITFIELD             m_bNoNamespaces : 1;
  764.     HX_BITFIELD             m_bRNNamespace : 1;
  765.     HX_BITFIELD             m_bSMILRootLayoutAlreadyFound : 1;
  766.     HX_BITFIELD             m_bCaptionsPreference : 1;
  767.     HX_BITFIELD             m_bSystemAudioDescPreference : 1;
  768.     HX_BITFIELD             m_bUseSystemCPU : 1;
  769.     HX_BITFIELD             m_bUseSystemOS : 1;
  770.     HX_BITFIELD             m_bContainsSource : 1;
  771.     HX_BITFIELD             m_bContainsInitiallyScheduledTrack: 1;
  772.     HX_BITFIELD             m_bStoreErrors : 1;
  773.     HX_BITFIELD             m_bFirstPacket : 1;
  774.     HX_BITFIELD             m_bTimestampsResolved : 1;
  775.     HX_BITFIELD             m_bAllowPlaylistBehavior : 1;
  776.     HX_BITFIELD             m_bAllTracksNeedReflushHint : 1;
  777. };
  779. #if defined(HELIX_FEATURE_SMIL2_VALIDATION)
  781. inline BOOL CSmilParser::isXMLLetter(char ch) const
  782. {
  783.     BOOL bRet = FALSE;
  785.     // /Fixes some gcc compiler warnings that might actually be bugs in our
  786.     // UNIX player; need to compare unsigneds with the 0x..'s which are unsigned:
  787.     const unsigned char c = (unsigned char)ch;
  789.     if ((c >= 0x41 && c <= 0x5A) ||
  790.         (c >= 0x61 && c <= 0x7A) ||
  791.         (c >= 0xC0 && c <= 0xD6) ||
  792.         (c >= 0xD8 && c <= 0xF6) ||
  793.         (c >= 0xF8 && c <= 0xFF))
  794.     {
  795.         bRet = TRUE;
  796.     }
  798.     return bRet;
  799. }
  801. inline BOOL CSmilParser::isXMLDigit(char c) const
  802. {
  803.     return ((c >= 0x30 && c <= 0x39) ? TRUE : FALSE);
  804. }
  806. inline BOOL CSmilParser::isXMLNameChar(char ch) const
  807. {
  808.     BOOL bRet = FALSE;
  810.     // /Fixes some gcc compiler warnings that might actually be bugs in our
  811.     // UNIX player; need to compare unsigneds with the 0x..'s which are unsigned:
  812.     const unsigned char c = (unsigned char)ch;
  814.     if (isXMLLetter(c) ||
  815.         isXMLDigit(c)  ||
  816.         c == '.'       ||
  817.         c == '-'       ||
  818.         c == '_'       ||
  819.         c == ':'       ||
  820.         c == 0xB7)
  821.     {
  822.         bRet = TRUE;
  823.     }
  825.     return bRet;
  826. }
  828. #endif /* #if defined(HELIX_FEATURE_SMIL2_VALIDATION) */
  830. #endif  /* _SMLPARSE_H_ */