357 lines
12 KiB
C++
357 lines
12 KiB
C++
/////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// fusion\xmlparser\XMLParser.hxx
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////////
|
|
#ifndef _FUSION_XMLPARSER__XMLPARSER_H_INCLUDE_
|
|
#define _FUSION_XMLPARSER__XMLPARSER_H_INCLUDE_
|
|
#pragma once
|
|
|
|
#include <ole2.h>
|
|
#include <xmlparser.h>
|
|
#include "xmlhelper.hxx"
|
|
class XMLStream;
|
|
|
|
typedef _reference<IXMLParser> RXMLParser;
|
|
typedef _reference<IXMLNodeFactory> RNodeFactory;
|
|
typedef _reference<IUnknown> RUnknown;
|
|
typedef _reference<IBindStatusCallback> RIBindStatusCallback;
|
|
|
|
#include "encodingstream.hxx"
|
|
|
|
#include "_rawstack.hxx"
|
|
//#define XMLFLAG_RUNBUFFERONLY 0x1000
|
|
|
|
//------------------------------------------------------------------------
|
|
// An internal Parser IID so that DTDNodeFactory can call internal methods.
|
|
const IID IID_Parser = {0xa79b04fe,0x8b3c,0x11d2,{0x9c, 0xd3,0x00,0x60,0xb0,0xec,0x3d,0x30}};
|
|
|
|
class XMLParser : public _unknown<IXMLParser, &IID_IXMLParser>
|
|
{
|
|
public:
|
|
|
|
XMLParser();
|
|
~XMLParser();
|
|
|
|
// ======= IUnknown override ============================
|
|
virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void ** ppvObject);
|
|
|
|
virtual ULONG STDMETHODCALLTYPE AddRef(void);
|
|
|
|
virtual ULONG STDMETHODCALLTYPE Release(void);
|
|
|
|
// ====== IXMLNodeSource methods ========================
|
|
virtual HRESULT STDMETHODCALLTYPE SetFactory(
|
|
/* [in] */ IXMLNodeFactory __RPC_FAR *pNodeFactory);
|
|
|
|
virtual HRESULT STDMETHODCALLTYPE GetFactory(
|
|
/* [out] */ IXMLNodeFactory** ppNodeFactory);
|
|
|
|
virtual HRESULT STDMETHODCALLTYPE Abort(
|
|
/* [in] */ BSTR bstrErrorInfo);
|
|
|
|
virtual ULONG STDMETHODCALLTYPE GetLineNumber(void);
|
|
|
|
virtual ULONG STDMETHODCALLTYPE GetLinePosition(void);
|
|
|
|
virtual ULONG STDMETHODCALLTYPE GetAbsolutePosition(void);
|
|
|
|
virtual HRESULT STDMETHODCALLTYPE GetLineBuffer(
|
|
/* [out] */ const WCHAR **ppwcBuf,
|
|
/* [out] */ ULONG *pulLen,
|
|
/* [out] */ ULONG *pulStartPos);
|
|
|
|
virtual HRESULT STDMETHODCALLTYPE GetLastError(void);
|
|
|
|
virtual HRESULT STDMETHODCALLTYPE GetErrorInfo(/* [out] */ BSTR *pbstrErrorInfo)
|
|
{
|
|
ASSERT_NTC(FALSE);
|
|
UNUSED(pbstrErrorInfo);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
virtual ULONG STDMETHODCALLTYPE GetFlags() {
|
|
return 0;
|
|
}
|
|
|
|
virtual HRESULT STDMETHODCALLTYPE GetURL(
|
|
/* [out] */ const WCHAR **ppwcBuf) {
|
|
UNUSED(ppwcBuf);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
// ====== IXMLParser methods ==============================
|
|
|
|
virtual HRESULT STDMETHODCALLTYPE SetURL(
|
|
/* [in] */ const WCHAR* pszBaseUrl,
|
|
/* [in] */ const WCHAR* pszRelativeUrl,
|
|
/* [in] */ BOOL async) {
|
|
UNUSED(pszBaseUrl);
|
|
UNUSED(pszRelativeUrl);
|
|
UNUSED(async);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
virtual HRESULT STDMETHODCALLTYPE Load(
|
|
/* [in] */ BOOL fFullyAvailable,
|
|
/* [in] */ IMoniker *pimkName,
|
|
/* [in] */ LPBC pibc,
|
|
/* [in] */ DWORD grfMode) {
|
|
|
|
UNUSED(fFullyAvailable);
|
|
UNUSED(pimkName);
|
|
UNUSED(pibc);
|
|
UNUSED(grfMode);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
virtual HRESULT STDMETHODCALLTYPE SetInput(
|
|
/* [in] */ IUnknown*pStm);
|
|
|
|
virtual HRESULT STDMETHODCALLTYPE PushData(
|
|
/* [in] */ const char *pData,
|
|
/* [in] */ ULONG ulChars,
|
|
/* [in] */ BOOL bLastBuffer);
|
|
|
|
virtual HRESULT STDMETHODCALLTYPE LoadEntity(
|
|
/* [in] */ const WCHAR* pszBaseUrl,
|
|
/* [in] */ const WCHAR* pszRelativeUrl,
|
|
/* [in] */ BOOL fpe) {
|
|
UNUSED(pszBaseUrl);
|
|
UNUSED(pszRelativeUrl);
|
|
UNUSED(fpe);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
virtual HRESULT STDMETHODCALLTYPE ParseEntity(
|
|
/* [in] */ const WCHAR* pwcText,
|
|
/* [in] */ ULONG ulLen,
|
|
/* [in] */ BOOL fpe){
|
|
UNUSED(pwcText);
|
|
UNUSED(ulLen);
|
|
UNUSED(fpe);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
virtual HRESULT STDMETHODCALLTYPE ExpandEntity(
|
|
/* [in] */ const WCHAR* pwcText,
|
|
/* [in] */ ULONG ulLen) {
|
|
UNUSED(pwcText);
|
|
UNUSED(ulLen);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
virtual HRESULT STDMETHODCALLTYPE SetRoot(
|
|
/* [in] */ PVOID pRoot) {
|
|
UNUSED(pRoot);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
virtual HRESULT STDMETHODCALLTYPE GetRoot(
|
|
/* [in] */ PVOID __RPC_FAR *ppRoot){
|
|
UNUSED(ppRoot);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
virtual HRESULT STDMETHODCALLTYPE Run(
|
|
/* [in] */ long lChars);
|
|
|
|
virtual HRESULT STDMETHODCALLTYPE GetParserState(void) ;
|
|
|
|
virtual HRESULT STDMETHODCALLTYPE Suspend(void) ;
|
|
|
|
virtual HRESULT STDMETHODCALLTYPE Reset(void) ;
|
|
|
|
virtual HRESULT STDMETHODCALLTYPE SetFlags(
|
|
/* [in] */ ULONG iFlags) {
|
|
UNUSED(iFlags);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
virtual HRESULT STDMETHODCALLTYPE LoadDTD(
|
|
/* [in] */ const WCHAR * pszBaseUrl,
|
|
/* [in] */ const WCHAR * pszRelativeUrl){
|
|
UNUSED(pszBaseUrl);
|
|
UNUSED(pszRelativeUrl);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
virtual HRESULT STDMETHODCALLTYPE SetSecureBaseURL(
|
|
/* [in] */ const WCHAR* pszBaseUrl){
|
|
UNUSED(pszBaseUrl);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
virtual HRESULT STDMETHODCALLTYPE GetSecureBaseURL(
|
|
/* [out] */ const WCHAR ** ppwcBuf){
|
|
UNUSED(ppwcBuf);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
// ======= internal only methods for Parser
|
|
#ifdef FUSION_USE_OLD_XML_PARSER_SOURCE
|
|
HRESULT SetCurrentURL(
|
|
/* [in] */ const WCHAR* pszCurrentUrl); // SRC attribute on <SCRIPT island>
|
|
// used by SetInput()
|
|
HRESULT SetBaseURL(
|
|
/* [in] */ const WCHAR* pszBaseUrl); // in case PushData is called.
|
|
#endif
|
|
|
|
HRESULT ErrorCallback(HRESULT hr);
|
|
|
|
private:
|
|
void ctorInit();
|
|
#ifdef FUSION_USE_OLD_XML_PARSER_SOURCE
|
|
HRESULT PushURL(
|
|
/* [in] */ const WCHAR* pszBaseUrl,
|
|
/* [in] */ const WCHAR* pszRelativeUrl,
|
|
/* [in] */ bool async,
|
|
/* [in] */ bool tokenizer,
|
|
/* [in] */ bool dtd,
|
|
/* [in] */ bool fentity,
|
|
/* [in] */ bool fpe );
|
|
// used in SetURL(). LoadDTDDate(), LoadEntity();
|
|
#endif
|
|
|
|
#ifdef FUSION_USE_OLD_XML_PARSER_SOURCE
|
|
HRESULT PushTokenizer(URLStream* stream);
|
|
#else
|
|
HRESULT PushTokenizer();
|
|
#endif
|
|
|
|
#ifdef FUSION_USE_OLD_XML_PARSER_SOURCE
|
|
HRESULT PushDownload(URLStream* stream, XMLStream* tokenizer);
|
|
#else
|
|
HRESULT PushDownload(XMLStream* tokenizer);
|
|
#endif
|
|
|
|
HRESULT PopDownload();
|
|
|
|
XMLStream* _pTokenizer;
|
|
PVOID _pRoot;
|
|
HRESULT _fLastError;
|
|
BSTR _bstrError;
|
|
bool _fWaiting;
|
|
bool _fSuspended;
|
|
bool _fStopped;
|
|
bool _fStarted;
|
|
bool _fInXmlDecl;
|
|
bool _fFoundEncoding;
|
|
USHORT _usFlags;
|
|
bool _fCaseInsensitive;
|
|
//bool _fTokenizerChanged; // used in DTD, tokenizer may change in DTD file
|
|
bool _fGotVersion; // used in XML_VERSION
|
|
long _fRunEntryCount; // used in Run(), counting how many is running the Parsing-While
|
|
|
|
//bool _fInLoading; // used in PushURL(), Load(), HandleData(),
|
|
bool _fInsideRun; // used in Run()
|
|
bool _fFoundRoot;
|
|
|
|
//bool _fSeenDocType; // used in DTD
|
|
bool _fRootLevel; // whether we are at the root level in document.
|
|
bool _fFoundNonWS;
|
|
bool _fPendingBeginChildren;
|
|
bool _fPendingEndChildren;
|
|
|
|
//BSTR _fAttemptedURL; // used in PushURL(), Load(), GetErrorInfo();
|
|
|
|
struct Download
|
|
{
|
|
XMLStream* _pTokenizer;
|
|
//RURLStream _pURLStream;
|
|
REncodingStream _pEncodingStream;
|
|
bool _fAsync;
|
|
bool _fDTD;
|
|
bool _fEntity;
|
|
bool _fPEReference;
|
|
bool _fFoundNonWS;
|
|
bool _fFoundRoot; // saved values in case we're downloading a schema
|
|
bool _fSeenDocType;
|
|
bool _fRootLevel; // whether we are at the root level in document.
|
|
int _fDepth; // current depth of stack.
|
|
};
|
|
_rawstack<Download> _pDownloads;
|
|
Download* _pdc; // current download.
|
|
|
|
|
|
// the Context struct contains members that map to the XML_NODE_INFO struct
|
|
// defined in xmlparser.idl so that we can pass the contents of the Context
|
|
// as a XML_NODE_INFO* pointer in BeginChildren, EndChildren and Error.
|
|
|
|
typedef struct _MY_XML_NODE_INFO : public XML_NODE_INFO
|
|
{
|
|
// DWORD dwSize; // size of this struct
|
|
// DWORD dwType; // node type (XML_NODE_TYPE)
|
|
// DWORD dwSubType; // node sub type (XML_NODE_SUBTYPE)
|
|
// BOOL fTerminal; // whether this node can have any children
|
|
// WCHAR* pwcText; // element names, or text node contents.
|
|
// ULONG ulLen; // length of pwcText
|
|
// ULONG ulNsPrefixLen; // if element name, this is namespace prefix length.
|
|
// PVOID pNode; // optionally created by & returned from node factory
|
|
// PVOID pReserved; // reserved for factories to use between themselves.
|
|
WCHAR* _pwcTagName; // saved tag name
|
|
ULONG _ulBufLen;
|
|
} MY_XML_NODE_INFO;
|
|
typedef MY_XML_NODE_INFO* PMY_XML_NODE_INFO;
|
|
|
|
_rawstack<MY_XML_NODE_INFO> _pStack;
|
|
|
|
long _lCurrentElement;
|
|
PMY_XML_NODE_INFO _pCurrent;
|
|
USHORT _cAttributes; // count of attributes on stack.
|
|
|
|
// And we need a contiguous array of pointers to the XML_NODE_INFO
|
|
// structs for CreateNode.
|
|
PMY_XML_NODE_INFO* _paNodeInfo;
|
|
USHORT _cNodeInfoAllocated;
|
|
USHORT _cNodeInfoCurrent;
|
|
|
|
PVOID _pNode; // current node (== pCurrent->pNode OR _pRoot).
|
|
|
|
// Push saves this factory in the context and pop restores it
|
|
// from the context.
|
|
RNodeFactory _pFactory; // current factory (!= pCurrent->pParentFactory).
|
|
|
|
HRESULT push(XML_NODE_INFO& info);
|
|
HRESULT pushAttribute(XML_NODE_INFO& info);
|
|
HRESULT pushAttributeValue(XML_NODE_INFO& info);
|
|
|
|
HRESULT pop(const WCHAR* tag, ULONG len);
|
|
HRESULT pop();
|
|
HRESULT popAttributes();
|
|
void popAttribute();
|
|
HRESULT popDTDAttribute() { return E_NOTIMPL; }
|
|
|
|
HRESULT CopyContext();
|
|
HRESULT CopyText(PMY_XML_NODE_INFO pNodeInfo);
|
|
HRESULT ReportUnclosedTags(int index);
|
|
HRESULT GrowBuffer(PMY_XML_NODE_INFO pNodeInfo, long newlen);
|
|
HRESULT GrowNodeInfo();
|
|
|
|
|
|
CRITICAL_SECTION _cs;
|
|
|
|
HRESULT init();
|
|
|
|
HRESULT PushStream(IStream* pStm, bool fpe);
|
|
//Download* FindDownload(URLStream* pStream);
|
|
WCHAR* getSecureBaseURL()
|
|
{
|
|
if (_pszSecureBaseURL)
|
|
return _pszSecureBaseURL;
|
|
else if (_dwSafetyOptions)
|
|
return _pszBaseURL;
|
|
return NULL;
|
|
}
|
|
|
|
|
|
WCHAR* _pszSecureBaseURL;
|
|
WCHAR* _pszCurrentURL;
|
|
WCHAR* _pszBaseURL;
|
|
bool _fIgnoreEncodingAttr;
|
|
DWORD _dwSafetyOptions;
|
|
};
|
|
|
|
|
|
#endif // _FUSION_XMLPARSER__XMLPARSER_H_INCLUDE_
|