diff options
Diffstat (limited to 'xfa/src/fxfa/src/parser/xfa_parser_imp.cpp')
| -rw-r--r-- | xfa/src/fxfa/src/parser/xfa_parser_imp.cpp | 1421 |
1 files changed, 1421 insertions, 0 deletions
diff --git a/xfa/src/fxfa/src/parser/xfa_parser_imp.cpp b/xfa/src/fxfa/src/parser/xfa_parser_imp.cpp new file mode 100644 index 0000000000..14c3e669a1 --- /dev/null +++ b/xfa/src/fxfa/src/parser/xfa_parser_imp.cpp @@ -0,0 +1,1421 @@ +// Copyright 2014 PDFium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
+
+#include "../../../foxitlib.h"
+#include "../common/xfa_utils.h"
+#include "../common/xfa_object.h"
+#include "../common/xfa_document.h"
+#include "../common/xfa_parser.h"
+#include "../common/xfa_script.h"
+#include "../common/xfa_docdata.h"
+#include "../common/xfa_doclayout.h"
+#include "../common/xfa_debug.h"
+#include "../common/xfa_localemgr.h"
+#include "../common/xfa_fm2jsapi.h"
+#include "xfa_debug_parser.h"
+#include "xfa_basic_imp.h"
+#include "xfa_parser_imp.h"
+IXFA_Parser* IXFA_Parser::Create(IXFA_ObjFactory *pFactory, FX_BOOL bDocumentParser)
+{
+ return FX_NEW CXFA_SimpleParser(pFactory, bDocumentParser);
+}
+CXFA_SimpleParser::CXFA_SimpleParser(IXFA_ObjFactory *pFactory, FX_BOOL bDocumentParser )
+ : m_pXMLParser(NULL)
+ , m_pXMLDoc(NULL)
+ , m_pStream(NULL)
+ , m_pFactory(pFactory)
+ , m_ePacketID(XFA_XDPPACKET_UNKNOWN)
+ , m_pRootNode(NULL)
+ , m_bDocumentParser(bDocumentParser)
+{
+}
+CXFA_SimpleParser::~CXFA_SimpleParser()
+{
+ CloseParser();
+}
+void CXFA_SimpleParser::SetFactory(IXFA_ObjFactory* pFactory)
+{
+ m_pFactory = pFactory;
+}
+static IFDE_XMLNode* XFA_FDEExtension_GetDocumentNode(IFDE_XMLDoc *pXMLDoc, FX_BOOL bVerifyWellFormness = FALSE)
+{
+ if(!pXMLDoc) {
+ return NULL;
+ }
+ IFDE_XMLNode* pXMLFakeRoot = pXMLDoc->GetRoot();
+ for(IFDE_XMLNode* pXMLNode = pXMLFakeRoot->GetNodeItem(IFDE_XMLNode::FirstChild); pXMLNode; pXMLNode = pXMLNode->GetNodeItem(IFDE_XMLNode::NextSibling)) {
+ if(pXMLNode->GetType() == FDE_XMLNODE_Element) {
+ if(bVerifyWellFormness) {
+ for(IFDE_XMLNode* pNextNode = pXMLNode->GetNodeItem(IFDE_XMLNode::NextSibling); pNextNode; pNextNode = pNextNode->GetNodeItem(IFDE_XMLNode::NextSibling)) {
+ if(pNextNode->GetType() == FDE_XMLNODE_Element) {
+ return FALSE;
+ }
+ }
+ }
+ return pXMLNode;
+ }
+ }
+ return NULL;
+}
+FX_INT32 CXFA_SimpleParser::StartParse(IFX_FileRead *pStream, XFA_XDPPACKET ePacketID)
+{
+ CloseParser();
+ m_pFileRead = pStream;
+ m_pStream = IFX_Stream::CreateStream(pStream, FX_STREAMACCESS_Read | FX_STREAMACCESS_Text);
+ if (m_pStream == NULL) {
+ return XFA_PARSESTATUS_StreamErr;
+ }
+ FX_WORD wCodePage = m_pStream->GetCodePage();
+ if (wCodePage != FX_CODEPAGE_UTF16LE && wCodePage != FX_CODEPAGE_UTF16BE && wCodePage != FX_CODEPAGE_UTF8) {
+ m_pStream->SetCodePage(FX_CODEPAGE_UTF8);
+ }
+ m_pXMLDoc = IFDE_XMLDoc::Create();
+ if (m_pXMLDoc == NULL) {
+ return XFA_PARSESTATUS_StatusErr;
+ }
+ m_pXMLParser = FX_NEW CXFA_XMLParser(m_pXMLDoc->GetRoot(), m_pStream);
+ if (m_pXMLParser == NULL) {
+ return XFA_PARSESTATUS_StatusErr;
+ }
+ if (!m_pXMLDoc->LoadXML(m_pXMLParser)) {
+ return XFA_PARSESTATUS_StatusErr;
+ }
+ m_ePacketID = ePacketID;
+ return XFA_PARSESTATUS_Ready;
+}
+FX_INT32 CXFA_SimpleParser::DoParse(IFX_Pause *pPause)
+{
+ if (m_pXMLDoc == NULL || m_ePacketID == XFA_XDPPACKET_UNKNOWN) {
+ return XFA_PARSESTATUS_StatusErr;
+ }
+ FX_INT32 iRet = m_pXMLDoc->DoLoad(pPause);
+ if (iRet < 0) {
+ return XFA_PARSESTATUS_SyntaxErr;
+ }
+ if (iRet < 100) {
+ return iRet / 2;
+ }
+ m_pRootNode = ParseAsXDPPacket(XFA_FDEExtension_GetDocumentNode(m_pXMLDoc), m_ePacketID);
+ m_pXMLDoc->CloseXML();
+ if (m_pStream) {
+ m_pStream->Release();
+ m_pStream = NULL;
+ }
+ if(!m_pRootNode) {
+ return XFA_PARSESTATUS_StatusErr;
+ }
+ return XFA_PARSESTATUS_Done;
+}
+FX_INT32 CXFA_SimpleParser::ParseXMLData(const CFX_WideString &wsXML, IFDE_XMLNode* &pXMLNode, IFX_Pause *pPause)
+{
+ CloseParser();
+ pXMLNode = NULL;
+ IFX_Stream* pStream = XFA_CreateWideTextRead(wsXML);
+ if (!pStream) {
+ return XFA_PARSESTATUS_StreamErr;
+ }
+ m_pStream = pStream;
+ m_pXMLDoc = IFDE_XMLDoc::Create();
+ if (m_pXMLDoc == NULL) {
+ return XFA_PARSESTATUS_StatusErr;
+ }
+ CXFA_XMLParser *pParser = FX_NEW CXFA_XMLParser(m_pXMLDoc->GetRoot(), m_pStream);
+ if (pParser == NULL) {
+ return XFA_PARSESTATUS_StatusErr;
+ }
+#ifdef _XFA_VERIFY_Checksum_
+ pParser->m_dwCheckStatus = 0x03;
+#endif
+ if (!m_pXMLDoc->LoadXML(pParser)) {
+ return XFA_PARSESTATUS_StatusErr;
+ }
+ FX_INT32 iRet = m_pXMLDoc->DoLoad(pPause);
+ if (iRet < 0 || iRet >= 100) {
+ m_pXMLDoc->CloseXML();
+ }
+ if (iRet < 0) {
+ return XFA_PARSESTATUS_SyntaxErr;
+ }
+ if (iRet < 100) {
+ return iRet / 2;
+ }
+ if (m_pStream) {
+ m_pStream->Release();
+ m_pStream = NULL;
+ }
+ pXMLNode = XFA_FDEExtension_GetDocumentNode(m_pXMLDoc);
+ return XFA_PARSESTATUS_Done;
+}
+void CXFA_SimpleParser::ConstructXFANode(CXFA_Node* pXFANode, IFDE_XMLNode* pXMLNode)
+{
+ XFA_XDPPACKET ePacketID = (XFA_XDPPACKET)pXFANode->GetPacketID();
+ if (ePacketID == XFA_XDPPACKET_Datasets) {
+ if (pXFANode->GetClassID() == XFA_ELEMENT_DataValue) {
+ for (IFDE_XMLNode *pXMLChild = pXMLNode->GetNodeItem(IFDE_XMLNode::FirstChild); pXMLChild; pXMLChild = pXMLChild->GetNodeItem(IFDE_XMLNode::NextSibling)) {
+ FDE_XMLNODETYPE eNodeType = pXMLChild->GetType();
+ if(eNodeType == FDE_XMLNODE_Instruction) {
+ continue;
+ }
+ if (eNodeType == FDE_XMLNODE_Element) {
+ CXFA_Node *pXFAChild = m_pFactory->CreateNode(XFA_XDPPACKET_Datasets, XFA_ELEMENT_DataValue);
+ if (pXFAChild == NULL) {
+ return;
+ }
+ CFX_WideString wsNodeStr;
+ ((IFDE_XMLElement*)pXMLChild)->GetLocalTagName(wsNodeStr);
+ pXFAChild->SetCData(XFA_ATTRIBUTE_Name, wsNodeStr);
+ CFX_WideString wsChildValue;
+#ifdef XFA_PARSE_HAS_LINEIDENTIFIER
+ XFA_GetPlainTextFromRichText((IFDE_XMLElement*)pXMLChild, wsChildValue);
+#else
+ XFA_ConvertRichTextToPlainText((IFDE_XMLElement*)pXMLChild, wsChildValue);
+#endif
+ if (!wsChildValue.IsEmpty()) {
+ pXFAChild->SetCData(XFA_ATTRIBUTE_Value, wsChildValue);
+ }
+ pXFANode->InsertChild(pXFAChild);
+ pXFAChild->SetXMLMappingNode(pXMLChild);
+ pXFAChild->SetFlag(XFA_NODEFLAG_Initialized, TRUE, FALSE);
+ break;
+ }
+ }
+ m_pRootNode = pXFANode;
+ } else {
+ m_pRootNode = DataLoader(pXFANode, pXMLNode, TRUE);
+ }
+ } else {
+ if (pXFANode->GetObjectType() == XFA_OBJECTTYPE_ContentNode) {
+ ParseContentNode(pXFANode, pXMLNode, ePacketID);
+ m_pRootNode = pXFANode;
+ } else {
+ m_pRootNode = NormalLoader(pXFANode, pXMLNode, ePacketID);
+ }
+ }
+}
+FX_BOOL XFA_FDEExtension_ResolveNamespaceQualifier(IFDE_XMLElement* pNode, FX_WSTR wsQualifier, CFX_WideString& wsNamespaceURI)
+{
+ if(!pNode) {
+ return FALSE;
+ }
+ IFDE_XMLNode* pFakeRoot = pNode->GetNodeItem(IFDE_XMLNode::Root);
+ CFX_WideString wsNSAttribute;
+ FX_BOOL bRet = FALSE;
+ if(wsQualifier.IsEmpty()) {
+ wsNSAttribute = FX_WSTRC(L"xmlns");
+ bRet = TRUE;
+ } else {
+ wsNSAttribute = FX_WSTRC(L"xmlns:") + wsQualifier;
+ }
+ for(; pNode != pFakeRoot; pNode = (IFDE_XMLElement*)pNode->GetNodeItem(IFDE_XMLNode::Parent)) {
+ if(pNode->GetType() != FDE_XMLNODE_Element) {
+ continue;
+ }
+ if(pNode->HasAttribute(wsNSAttribute)) {
+ pNode->GetString(wsNSAttribute, wsNamespaceURI);
+ return TRUE;
+ }
+ }
+ wsNamespaceURI.Empty();
+ return bRet;
+}
+static inline void XFA_FDEExtension_GetElementTagNamespaceURI(IFDE_XMLElement* pElement, CFX_WideString& wsNamespaceURI)
+{
+ CFX_WideString wsNodeStr;
+ pElement->GetNamespacePrefix(wsNodeStr);
+ if(!XFA_FDEExtension_ResolveNamespaceQualifier(pElement, wsNodeStr, wsNamespaceURI)) {
+ wsNamespaceURI.Empty();
+ }
+}
+static FX_BOOL XFA_FDEExtension_MatchNodeName(IFDE_XMLNode* pNode, FX_WSTR wsLocalTagName, FX_WSTR wsNamespaceURIPrefix, FX_DWORD eMatchFlags = XFA_XDPPACKET_FLAGS_NOMATCH)
+{
+ if(!pNode || pNode->GetType() != FDE_XMLNODE_Element) {
+ return FALSE;
+ }
+ IFDE_XMLElement* pElement = reinterpret_cast<IFDE_XMLElement*>(pNode);
+ CFX_WideString wsNodeStr;
+ pElement->GetLocalTagName(wsNodeStr);
+ if(wsNodeStr != wsLocalTagName) {
+ return FALSE;
+ }
+ XFA_FDEExtension_GetElementTagNamespaceURI(pElement, wsNodeStr);
+ if (eMatchFlags & XFA_XDPPACKET_FLAGS_NOMATCH) {
+ return TRUE;
+ }
+ if(eMatchFlags & XFA_XDPPACKET_FLAGS_PREFIXMATCH) {
+ return wsNodeStr.Left(wsNamespaceURIPrefix.GetLength()) == wsNamespaceURIPrefix;
+ }
+ return wsNodeStr == wsNamespaceURIPrefix;
+}
+static FX_BOOL XFA_FDEExtension_GetAttributeLocalName(FX_WSTR wsAttributeName, CFX_WideString& wsLocalAttrName)
+{
+ CFX_WideString wsAttrName(wsAttributeName);
+ FX_STRSIZE iFind = wsAttrName.Find(L':', 0);
+ if (iFind < 0) {
+ wsLocalAttrName = wsAttrName;
+ return FALSE;
+ } else {
+ wsLocalAttrName = wsAttrName.Right(wsAttrName.GetLength() - iFind - 1);
+ return TRUE;
+ }
+}
+static FX_BOOL XFA_FDEExtension_ResolveAttribute(IFDE_XMLElement *pElement, FX_WSTR wsAttributeName, CFX_WideString& wsLocalAttrName, CFX_WideString& wsNamespaceURI)
+{
+ CFX_WideString wsAttrName(wsAttributeName);
+ CFX_WideString wsNSPrefix;
+ if(XFA_FDEExtension_GetAttributeLocalName(wsAttributeName, wsLocalAttrName)) {
+ wsNSPrefix = wsAttrName.Left(wsAttributeName.GetLength() - wsLocalAttrName.GetLength() - 1);
+ }
+ if(wsLocalAttrName == FX_WSTRC(L"xmlns") || wsNSPrefix == FX_WSTRC(L"xmlns") || wsNSPrefix == FX_WSTRC(L"xml")) {
+ return FALSE;
+ }
+ if(!XFA_FDEExtension_ResolveNamespaceQualifier(pElement, wsNSPrefix, wsNamespaceURI)) {
+ wsNamespaceURI.Empty();
+ return FALSE;
+ }
+ return TRUE;
+}
+static FX_BOOL XFA_FDEExtension_FindAttributeWithNS(IFDE_XMLElement *pElement, FX_WSTR wsLocalAttributeName, FX_WSTR wsNamespaceURIPrefix, CFX_WideString& wsValue, FX_BOOL bMatchNSAsPrefix = FALSE)
+{
+ if(!pElement) {
+ return FALSE;
+ }
+ CFX_WideString wsAttrName;
+ CFX_WideString wsAttrValue;
+ CFX_WideString wsAttrNS;
+ for(FX_INT32 iAttrCount = pElement->CountAttributes(), i = 0; i < iAttrCount; i ++) {
+ pElement->GetAttribute(i, wsAttrName, wsAttrValue);
+ FX_STRSIZE iFind = wsAttrName.Find(L':', 0);
+ CFX_WideString wsNSPrefix;
+ if (iFind < 0) {
+ if(wsLocalAttributeName != wsAttrName) {
+ continue;
+ }
+ } else {
+ if(wsLocalAttributeName != wsAttrName.Right(wsAttrName.GetLength() - iFind - 1)) {
+ continue;
+ }
+ wsNSPrefix = wsAttrName.Left(iFind);
+ }
+ if(!XFA_FDEExtension_ResolveNamespaceQualifier(pElement, wsNSPrefix, wsAttrNS)) {
+ continue;
+ }
+ if(bMatchNSAsPrefix) {
+ if(wsAttrNS.Left(wsNamespaceURIPrefix.GetLength()) != wsNamespaceURIPrefix) {
+ continue;
+ }
+ } else {
+ if(wsAttrNS != wsNamespaceURIPrefix) {
+ continue;
+ }
+ }
+ wsValue = wsAttrValue;
+ return TRUE;
+ }
+ return FALSE;
+}
+CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket(IFDE_XMLNode* pXMLDocumentNode, XFA_XDPPACKET ePacketID)
+{
+ switch(ePacketID) {
+ case XFA_XDPPACKET_UNKNOWN:
+ return NULL;
+ case XFA_XDPPACKET_XDP:
+ return ParseAsXDPPacket_XDP(pXMLDocumentNode, ePacketID);
+ case XFA_XDPPACKET_Config:
+ return ParseAsXDPPacket_Config(pXMLDocumentNode, ePacketID);
+ case XFA_XDPPACKET_Template:
+ case XFA_XDPPACKET_Form:
+ return ParseAsXDPPacket_TemplateForm(pXMLDocumentNode, ePacketID);
+ case XFA_XDPPACKET_Datasets:
+ return ParseAsXDPPacket_Data(pXMLDocumentNode, ePacketID);
+ case XFA_XDPPACKET_Xdc:
+ return ParseAsXDPPacket_Xdc(pXMLDocumentNode, ePacketID);
+ case XFA_XDPPACKET_LocaleSet:
+ case XFA_XDPPACKET_ConnectionSet:
+ case XFA_XDPPACKET_SourceSet:
+ return ParseAsXDPPacket_LocaleConnectionSourceSet(pXMLDocumentNode, ePacketID);
+ default:
+ return ParseAsXDPPacket_User(pXMLDocumentNode, ePacketID);
+ }
+ return NULL;
+}
+CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket_XDP(IFDE_XMLNode* pXMLDocumentNode, XFA_XDPPACKET ePacketID)
+{
+ if(!XFA_FDEExtension_MatchNodeName(pXMLDocumentNode, XFA_GetPacketByIndex(XFA_PACKET_XDP)->pName, XFA_GetPacketByIndex(XFA_PACKET_XDP)->pURI, XFA_GetPacketByIndex(XFA_PACKET_XDP)->eFlags)) {
+ return NULL;
+ }
+ CXFA_Node* pXFARootNode = m_pFactory->CreateNode(XFA_XDPPACKET_XDP, XFA_ELEMENT_Xfa);
+ if(!pXFARootNode) {
+ return NULL;
+ }
+ m_pRootNode = pXFARootNode;
+ pXFARootNode->SetCData(XFA_ATTRIBUTE_Name, FX_WSTRC(L"xfa"));
+ {
+ IFDE_XMLElement* pElement = (IFDE_XMLElement*)pXMLDocumentNode;
+ FX_INT32 iAttributeCount = pElement->CountAttributes();
+ for(FX_INT32 i = 0; i < iAttributeCount; i++) {
+ CFX_WideString wsAttriName, wsAttriValue;
+ pElement->GetAttribute(i, wsAttriName, wsAttriValue);
+ if(wsAttriName == FX_WSTRC(L"uuid")) {
+ pXFARootNode->SetCData(XFA_ATTRIBUTE_Uuid, wsAttriValue);
+ } else if(wsAttriName == FX_WSTRC(L"timeStamp")) {
+ pXFARootNode->SetCData(XFA_ATTRIBUTE_TimeStamp, wsAttriValue);
+ }
+ }
+ }
+ IFDE_XMLNode* pXMLConfigDOMRoot = NULL;
+ CXFA_Node* pXFAConfigDOMRoot = NULL;
+ {
+ for (IFDE_XMLNode* pChildItem = pXMLDocumentNode->GetNodeItem(IFDE_XMLNode::FirstChild); pChildItem; pChildItem = pChildItem->GetNodeItem(IFDE_XMLNode::NextSibling)) {
+ XFA_LPCPACKETINFO pPacketInfo = XFA_GetPacketByIndex(XFA_PACKET_Config);
+ if(!XFA_FDEExtension_MatchNodeName(pChildItem, pPacketInfo->pName, pPacketInfo->pURI, pPacketInfo->eFlags)) {
+ continue;
+ }
+ if (CXFA_Node * pChildNode = pXFARootNode->GetFirstChildByName(pPacketInfo->uHash)) {
+ return NULL;
+ }
+ pXMLConfigDOMRoot = pChildItem;
+ pXFAConfigDOMRoot = ParseAsXDPPacket_Config(pXMLConfigDOMRoot, XFA_XDPPACKET_Config);
+ pXFARootNode->InsertChild(pXFAConfigDOMRoot, NULL);
+ }
+ }
+ IFDE_XMLNode* pXMLDatasetsDOMRoot = NULL;
+ IFDE_XMLNode* pXMLFormDOMRoot = NULL;
+ {
+ for (IFDE_XMLNode* pChildItem = pXMLDocumentNode->GetNodeItem(IFDE_XMLNode::FirstChild); pChildItem; pChildItem = pChildItem->GetNodeItem(IFDE_XMLNode::NextSibling)) {
+ if(!pChildItem || pChildItem->GetType() != FDE_XMLNODE_Element) {
+ continue;
+ }
+ if(pChildItem == pXMLConfigDOMRoot) {
+ continue;
+ }
+ IFDE_XMLElement* pElement = reinterpret_cast<IFDE_XMLElement*>(pChildItem);
+ CFX_WideString wsPacketName;
+ pElement->GetLocalTagName(wsPacketName);
+ XFA_LPCPACKETINFO pPacketInfo = XFA_GetPacketByName(wsPacketName);
+ if (pPacketInfo && pPacketInfo->pURI) {
+ if(!XFA_FDEExtension_MatchNodeName(pElement, pPacketInfo->pName, pPacketInfo->pURI, pPacketInfo->eFlags)) {
+ pPacketInfo = NULL;
+ }
+ }
+ XFA_XDPPACKET ePacket = pPacketInfo ? pPacketInfo->eName : XFA_XDPPACKET_USER;
+ if(ePacket == XFA_XDPPACKET_XDP) {
+ continue;
+ }
+ if(ePacket == XFA_XDPPACKET_Datasets) {
+ if (pXMLDatasetsDOMRoot) {
+ pXMLDatasetsDOMRoot = NULL;
+ return NULL;
+ }
+ pXMLDatasetsDOMRoot = pElement;
+ } else if(ePacket == XFA_XDPPACKET_Form) {
+ if (pXMLFormDOMRoot) {
+ pXMLFormDOMRoot = NULL;
+ return NULL;
+ }
+ pXMLFormDOMRoot = pElement;
+ } else {
+ CXFA_Node* pPacketNode = ParseAsXDPPacket(pElement, ePacket);
+ if(pPacketNode) {
+ if (pPacketInfo && (pPacketInfo->eFlags & XFA_XDPPACKET_FLAGS_SUPPORTONE) && pXFARootNode->GetFirstChildByName(pPacketInfo->uHash)) {
+ return NULL;
+ }
+ pXFARootNode->InsertChild(pPacketNode);
+ }
+ }
+ }
+ }
+ if(pXMLDatasetsDOMRoot) {
+ CXFA_Node* pPacketNode = ParseAsXDPPacket(pXMLDatasetsDOMRoot, XFA_XDPPACKET_Datasets);
+ if (pPacketNode) {
+ pXFARootNode->InsertChild(pPacketNode);
+ }
+ }
+ if(pXMLFormDOMRoot) {
+ CXFA_Node* pPacketNode = ParseAsXDPPacket(pXMLFormDOMRoot, XFA_XDPPACKET_Form);
+ if (pPacketNode) {
+ pXFARootNode->InsertChild(pPacketNode);
+ }
+ }
+ pXFARootNode->SetXMLMappingNode(pXMLDocumentNode);
+ return pXFARootNode;
+}
+CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket_Config(IFDE_XMLNode* pXMLDocumentNode, XFA_XDPPACKET ePacketID)
+{
+ if(!XFA_FDEExtension_MatchNodeName(pXMLDocumentNode, XFA_GetPacketByIndex(XFA_PACKET_Config)->pName, XFA_GetPacketByIndex(XFA_PACKET_Config)->pURI, XFA_GetPacketByIndex(XFA_PACKET_Config)->eFlags)) {
+ return NULL;
+ }
+ CXFA_Node* pNode = m_pFactory->CreateNode(XFA_XDPPACKET_Config, XFA_ELEMENT_Config);
+ if(!pNode) {
+ return NULL;
+ }
+ pNode->SetCData(XFA_ATTRIBUTE_Name, XFA_GetPacketByIndex(XFA_PACKET_Config)->pName);
+ if(!NormalLoader(pNode, pXMLDocumentNode, ePacketID)) {
+ return NULL;
+ }
+ pNode->SetXMLMappingNode(pXMLDocumentNode);
+ return pNode;
+}
+CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket_TemplateForm(IFDE_XMLNode* pXMLDocumentNode, XFA_XDPPACKET ePacketID)
+{
+ CXFA_Node* pNode = NULL;
+ if (ePacketID == XFA_XDPPACKET_Template) {
+ if(XFA_FDEExtension_MatchNodeName(pXMLDocumentNode, XFA_GetPacketByIndex(XFA_PACKET_Template)->pName, XFA_GetPacketByIndex(XFA_PACKET_Template)->pURI, XFA_GetPacketByIndex(XFA_PACKET_Template)->eFlags)) {
+ pNode = m_pFactory->CreateNode(XFA_XDPPACKET_Template, XFA_ELEMENT_Template);
+ if(!pNode) {
+ return NULL;
+ }
+ pNode->SetCData(XFA_ATTRIBUTE_Name, XFA_GetPacketByIndex(XFA_PACKET_Template)->pName);
+ if(m_bDocumentParser) {
+ CFX_WideString wsNamespaceURI;
+ IFDE_XMLElement* pXMLDocumentElement = (IFDE_XMLElement*)pXMLDocumentNode;
+ pXMLDocumentElement->GetNamespaceURI(wsNamespaceURI);
+ if (wsNamespaceURI.IsEmpty()) {
+ pXMLDocumentElement->GetString((FX_LPCWSTR)(L"xmlns:xfa"), wsNamespaceURI);
+ }
+ pNode->GetDocument()->RecognizeXFAVersionNumber(wsNamespaceURI);
+ }
+ if(!NormalLoader(pNode, pXMLDocumentNode, ePacketID)) {
+ return NULL;
+ }
+ }
+ } else if (ePacketID == XFA_XDPPACKET_Form) {
+ if(XFA_FDEExtension_MatchNodeName(pXMLDocumentNode, XFA_GetPacketByIndex(XFA_PACKET_Form)->pName, XFA_GetPacketByIndex(XFA_PACKET_Form)->pURI, XFA_GetPacketByIndex(XFA_PACKET_Form)->eFlags)) {
+ IFDE_XMLElement* pXMLDocumentElement = (IFDE_XMLElement*)pXMLDocumentNode;
+ CFX_WideString wsChecksum;
+ pXMLDocumentElement->GetString((FX_LPCWSTR)L"checksum", wsChecksum);
+#ifdef _XFA_VERIFY_Checksum_
+ if (wsChecksum.GetLength() != 28 || m_pXMLParser->m_dwCheckStatus != 0x03) {
+ return NULL;
+ }
+ IXFA_ChecksumContext *pChecksum = XFA_Checksum_Create();
+ pChecksum->StartChecksum();
+ pChecksum->UpdateChecksum(m_pFileRead, m_pXMLParser->m_nStart[0], m_pXMLParser->m_nSize[0]);
+ pChecksum->UpdateChecksum(m_pFileRead, m_pXMLParser->m_nStart[1], m_pXMLParser->m_nSize[1]);
+ pChecksum->FinishChecksum();
+ CFX_ByteString bsCheck;
+ pChecksum->GetChecksum(bsCheck);
+ pChecksum->Release();
+ if (bsCheck != wsChecksum.UTF8Encode()) {
+ return NULL;
+ }
+#endif
+ pNode = m_pFactory->CreateNode(XFA_XDPPACKET_Form, XFA_ELEMENT_Form);
+ if(!pNode) {
+ return NULL;
+ }
+ pNode->SetCData(XFA_ATTRIBUTE_Name, XFA_GetPacketByIndex(XFA_PACKET_Form)->pName);
+ pNode->SetAttribute(XFA_ATTRIBUTE_Checksum, wsChecksum);
+ CXFA_Node* pTemplateRoot = m_pRootNode->GetFirstChildByClass(XFA_ELEMENT_Template);
+ CXFA_Node* pTemplateChosen = pTemplateRoot ? pTemplateRoot->GetFirstChildByClass(XFA_ELEMENT_Subform) : NULL;
+ FX_BOOL bUseAttribute = TRUE;
+ if (pTemplateChosen && pTemplateChosen->GetEnum(XFA_ATTRIBUTE_RestoreState) != XFA_ATTRIBUTEENUM_Auto) {
+ bUseAttribute = FALSE;
+ }
+ if(!NormalLoader(pNode, pXMLDocumentNode, ePacketID, bUseAttribute)) {
+ return NULL;
+ }
+ }
+ }
+ if (pNode) {
+ pNode->SetXMLMappingNode(pXMLDocumentNode);
+ }
+ return pNode;
+}
+static IFDE_XMLNode* XFA_GetDataSetsFromXDP(IFDE_XMLNode* pXMLDocumentNode)
+{
+ if (XFA_FDEExtension_MatchNodeName(pXMLDocumentNode, XFA_GetPacketByIndex(XFA_PACKET_Datasets)->pName, XFA_GetPacketByIndex(XFA_PACKET_Datasets)->pURI, XFA_GetPacketByIndex(XFA_PACKET_Datasets)->eFlags)) {
+ return pXMLDocumentNode;
+ }
+ if (!XFA_FDEExtension_MatchNodeName(pXMLDocumentNode, XFA_GetPacketByIndex(XFA_PACKET_XDP)->pName, XFA_GetPacketByIndex(XFA_PACKET_XDP)->pURI, XFA_GetPacketByIndex(XFA_PACKET_XDP)->eFlags)) {
+ return NULL;
+ }
+ for(IFDE_XMLNode* pDatasetsNode = pXMLDocumentNode->GetNodeItem(IFDE_XMLNode::FirstChild); pDatasetsNode; pDatasetsNode = pDatasetsNode->GetNodeItem(IFDE_XMLNode::NextSibling)) {
+ if(!XFA_FDEExtension_MatchNodeName(pDatasetsNode, XFA_GetPacketByIndex(XFA_PACKET_Datasets)->pName, XFA_GetPacketByIndex(XFA_PACKET_Datasets)->pURI, XFA_GetPacketByIndex(XFA_PACKET_Datasets)->eFlags)) {
+ continue;
+ }
+ return pDatasetsNode;
+ }
+ return NULL;
+}
+CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket_Data(IFDE_XMLNode* pXMLDocumentNode, XFA_XDPPACKET ePacketID)
+{
+ IFDE_XMLNode* pDatasetsXMLNode = XFA_GetDataSetsFromXDP(pXMLDocumentNode);
+ if(pDatasetsXMLNode) {
+ CXFA_Node* pNode = m_pFactory->CreateNode(XFA_XDPPACKET_Datasets, XFA_ELEMENT_DataModel);
+ if(!pNode) {
+ return NULL;
+ }
+ pNode->SetCData(XFA_ATTRIBUTE_Name, XFA_GetPacketByIndex(XFA_PACKET_Datasets)->pName);
+ if(!DataLoader(pNode, pDatasetsXMLNode, FALSE)) {
+ return NULL;
+ }
+ pNode->SetXMLMappingNode(pDatasetsXMLNode);
+ return pNode;
+ }
+ IFDE_XMLNode* pDataXMLNode = NULL;
+ if (XFA_FDEExtension_MatchNodeName(pXMLDocumentNode, FX_WSTRC(L"data"), XFA_GetPacketByIndex(XFA_PACKET_Datasets)->pURI, XFA_GetPacketByIndex(XFA_PACKET_Datasets)->eFlags)) {
+ ((IFDE_XMLElement*)pXMLDocumentNode)->RemoveAttribute((FX_LPCWSTR)(L"xmlns:xfa"));
+ pDataXMLNode = pXMLDocumentNode;
+ } else {
+ IFDE_XMLElement* pDataElement = IFDE_XMLElement::Create(FX_WSTRC(L"xfa:data"));
+ IFDE_XMLNode* pParentXMLNode = pXMLDocumentNode->GetNodeItem(IFDE_XMLNode::Parent);
+ if (pParentXMLNode) {
+ pParentXMLNode->RemoveChildNode(pXMLDocumentNode);
+ }
+ FXSYS_assert(pXMLDocumentNode->GetType() == FDE_XMLNODE_Element);
+ if (pXMLDocumentNode->GetType() == FDE_XMLNODE_Element) {
+ ((IFDE_XMLElement*)pXMLDocumentNode)->RemoveAttribute((FX_LPCWSTR)(L"xmlns:xfa"));
+ }
+ pDataElement->InsertChildNode(pXMLDocumentNode);
+ pDataXMLNode = pDataElement;
+ }
+ if(pDataXMLNode) {
+ CXFA_Node* pNode = m_pFactory->CreateNode(XFA_XDPPACKET_Datasets, XFA_ELEMENT_DataGroup);
+ if(!pNode) {
+ if (pDataXMLNode != pXMLDocumentNode) {
+ pDataXMLNode->Release();
+ }
+ return NULL;
+ }
+ CFX_WideString wsLocalName;
+ ((IFDE_XMLElement*)pDataXMLNode)->GetLocalTagName(wsLocalName);
+ pNode->SetCData(XFA_ATTRIBUTE_Name, wsLocalName);
+ if(!DataLoader(pNode, pDataXMLNode, TRUE)) {
+ return NULL;
+ }
+ pNode->SetXMLMappingNode(pDataXMLNode);
+ if (pDataXMLNode != pXMLDocumentNode) {
+ pNode->SetFlag(XFA_NODEFLAG_OwnXMLNode, TRUE, FALSE);
+ }
+ return pNode;
+ }
+ return NULL;
+}
+CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket_LocaleConnectionSourceSet(IFDE_XMLNode* pXMLDocumentNode, XFA_XDPPACKET ePacketID)
+{
+ CXFA_Node* pNode = NULL;
+ if (ePacketID == XFA_XDPPACKET_LocaleSet) {
+ if(XFA_FDEExtension_MatchNodeName(pXMLDocumentNode, XFA_GetPacketByIndex(XFA_PACKET_LocaleSet)->pName, XFA_GetPacketByIndex(XFA_PACKET_LocaleSet)->pURI, XFA_GetPacketByIndex(XFA_PACKET_LocaleSet)->eFlags)) {
+ pNode = m_pFactory->CreateNode(XFA_XDPPACKET_LocaleSet, XFA_ELEMENT_LocaleSet);
+ if(!pNode) {
+ return NULL;
+ }
+ pNode->SetCData(XFA_ATTRIBUTE_Name, XFA_GetPacketByIndex(XFA_PACKET_LocaleSet)->pName);
+ if(!NormalLoader(pNode, pXMLDocumentNode, ePacketID)) {
+ return NULL;
+ }
+ }
+ } else if(ePacketID == XFA_XDPPACKET_ConnectionSet) {
+ if(XFA_FDEExtension_MatchNodeName(pXMLDocumentNode, XFA_GetPacketByIndex(XFA_PACKET_ConnectionSet)->pName, XFA_GetPacketByIndex(XFA_PACKET_ConnectionSet)->pURI, XFA_GetPacketByIndex(XFA_PACKET_ConnectionSet)->eFlags)) {
+ pNode = m_pFactory->CreateNode(XFA_XDPPACKET_ConnectionSet, XFA_ELEMENT_ConnectionSet);
+ if(!pNode) {
+ return NULL;
+ }
+ pNode->SetCData(XFA_ATTRIBUTE_Name, XFA_GetPacketByIndex(XFA_PACKET_ConnectionSet)->pName);
+ if(!NormalLoader(pNode, pXMLDocumentNode, ePacketID)) {
+ return NULL;
+ }
+ }
+ } else if(ePacketID == XFA_XDPPACKET_SourceSet) {
+ if(XFA_FDEExtension_MatchNodeName(pXMLDocumentNode, XFA_GetPacketByIndex(XFA_PACKET_SourceSet)->pName, XFA_GetPacketByIndex(XFA_PACKET_SourceSet)->pURI, XFA_GetPacketByIndex(XFA_PACKET_SourceSet)->eFlags)) {
+ pNode = m_pFactory->CreateNode(XFA_XDPPACKET_SourceSet, XFA_ELEMENT_SourceSet);
+ if(!pNode) {
+ return NULL;
+ }
+ pNode->SetCData(XFA_ATTRIBUTE_Name, XFA_GetPacketByIndex(XFA_PACKET_SourceSet)->pName);
+ if(!NormalLoader(pNode, pXMLDocumentNode, ePacketID)) {
+ return NULL;
+ }
+ }
+ }
+ if (pNode) {
+ pNode->SetXMLMappingNode(pXMLDocumentNode);
+ }
+ return pNode;
+}
+CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket_Xdc(IFDE_XMLNode* pXMLDocumentNode, XFA_XDPPACKET ePacketID)
+{
+ if(XFA_FDEExtension_MatchNodeName(pXMLDocumentNode, XFA_GetPacketByIndex(XFA_PACKET_Xdc)->pName, XFA_GetPacketByIndex(XFA_PACKET_Xdc)->pURI, XFA_GetPacketByIndex(XFA_PACKET_Xdc)->eFlags)) {
+ CXFA_Node* pNode = m_pFactory->CreateNode(XFA_XDPPACKET_Xdc, XFA_ELEMENT_Xdc);
+ if(!pNode) {
+ return NULL;
+ }
+ pNode->SetCData(XFA_ATTRIBUTE_Name, XFA_GetPacketByIndex(XFA_PACKET_Xdc)->pName);
+ pNode->SetXMLMappingNode(pXMLDocumentNode);
+ return pNode;
+ }
+ return NULL;
+}
+CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket_User(IFDE_XMLNode* pXMLDocumentNode, XFA_XDPPACKET ePacketID)
+{
+ CXFA_Node* pNode = m_pFactory->CreateNode(XFA_XDPPACKET_XDP, XFA_ELEMENT_Packet);
+ if(!pNode) {
+ return NULL;
+ }
+ CFX_WideString wsName;
+ ((IFDE_XMLElement*)pXMLDocumentNode)->GetLocalTagName(wsName);
+ pNode->SetCData(XFA_ATTRIBUTE_Name, wsName);
+ if(!UserPacketLoader(pNode, pXMLDocumentNode)) {
+ return NULL;
+ }
+ pNode->SetXMLMappingNode(pXMLDocumentNode);
+ return pNode;
+}
+CXFA_Node* CXFA_SimpleParser::UserPacketLoader(CXFA_Node* pXFANode, IFDE_XMLNode* pXMLDoc)
+{
+ return pXFANode;
+}
+static FX_BOOL XFA_FDEExtension_IsStringAllWhitespace(CFX_WideString wsText)
+{
+ wsText.TrimRight(L"\x20\x9\xD\xA");
+ return wsText.IsEmpty();
+}
+CXFA_Node* CXFA_SimpleParser::DataLoader(CXFA_Node* pXFANode, IFDE_XMLNode* pXMLDoc, FX_BOOL bDoTransform )
+{
+ ParseDataGroup(pXFANode, pXMLDoc, XFA_XDPPACKET_Datasets);
+ return pXFANode;
+}
+CXFA_Node* CXFA_SimpleParser::NormalLoader(CXFA_Node* pXFANode, IFDE_XMLNode* pXMLDoc, XFA_XDPPACKET ePacketID, FX_BOOL bUseAttribute)
+{
+ FX_BOOL bOneOfPropertyFound = FALSE;
+ for (IFDE_XMLNode *pXMLChild = pXMLDoc->GetNodeItem(IFDE_XMLNode::FirstChild); pXMLChild; pXMLChild = pXMLChild->GetNodeItem(IFDE_XMLNode::NextSibling)) {
+ switch (pXMLChild->GetType()) {
+ case FDE_XMLNODE_Element: {
+ IFDE_XMLElement *pXMLElement = (IFDE_XMLElement*)pXMLChild;
+ CFX_WideString wsTagName;
+ pXMLElement->GetLocalTagName(wsTagName);
+ XFA_LPCELEMENTINFO pElemInfo = XFA_GetElementByName(wsTagName);
+ if(!pElemInfo) {
+ continue;
+ }
+ XFA_LPCPROPERTY pPropertyInfo = XFA_GetPropertyOfElement(pXFANode->GetClassID(), pElemInfo->eName, ePacketID);
+ if (pPropertyInfo && ((pPropertyInfo->uFlags & (XFA_PROPERTYFLAG_OneOf | XFA_PROPERTYFLAG_DefaultOneOf)) != 0)) {
+ if (bOneOfPropertyFound) {
+ break;
+ }
+ bOneOfPropertyFound = TRUE;
+ }
+ CXFA_Node *pXFAChild = m_pFactory->CreateNode(ePacketID, pElemInfo->eName);
+ if (pXFAChild == NULL) {
+ return NULL;
+ }
+ if (ePacketID == XFA_XDPPACKET_Config) {
+ pXFAChild->SetAttribute(XFA_ATTRIBUTE_Name, wsTagName);
+ }
+ FX_BOOL IsNeedValue = TRUE;
+ for(FX_INT32 i = 0, count = pXMLElement->CountAttributes(); i < count; i++) {
+ CFX_WideString wsAttrQualifiedName;
+ CFX_WideString wsAttrName;
+ CFX_WideString wsAttrValue;
+ pXMLElement->GetAttribute(i, wsAttrQualifiedName, wsAttrValue);
+ XFA_FDEExtension_GetAttributeLocalName(wsAttrQualifiedName, wsAttrName);
+ if(wsAttrName == FX_WSTRC(L"nil") && wsAttrValue == FX_WSTRC(L"true")) {
+ IsNeedValue = FALSE;
+ }
+ XFA_LPCATTRIBUTEINFO lpAttrInfo = XFA_GetAttributeByName(wsAttrName);
+ if(!lpAttrInfo) {
+ continue;
+ }
+ if (!bUseAttribute && lpAttrInfo->eName != XFA_ATTRIBUTE_Name && lpAttrInfo->eName != XFA_ATTRIBUTE_Save) {
+ continue;
+ }
+ pXFAChild->SetAttribute(lpAttrInfo->eName, wsAttrValue);
+ }
+ pXFANode->InsertChild(pXFAChild);
+ if (pElemInfo->eName == XFA_ELEMENT_Validate || pElemInfo->eName == XFA_ELEMENT_Locale) {
+ if (ePacketID == XFA_XDPPACKET_Config) {
+ ParseContentNode(pXFAChild, pXMLElement, ePacketID);
+ } else {
+ NormalLoader(pXFAChild, pXMLElement, ePacketID, bUseAttribute);
+ }
+ break;
+ }
+ switch(pXFAChild->GetObjectType()) {
+ case XFA_OBJECTTYPE_ContentNode:
+ case XFA_OBJECTTYPE_TextNode:
+ case XFA_OBJECTTYPE_NodeC:
+ case XFA_OBJECTTYPE_NodeV:
+ if(IsNeedValue) {
+ ParseContentNode(pXFAChild, pXMLElement, ePacketID);
+ }
+ break;
+ default:
+ NormalLoader(pXFAChild, pXMLElement, ePacketID, bUseAttribute);
+ break;
+ }
+ }
+ break;
+ case FDE_XMLNODE_Instruction:
+ ParseInstruction(pXFANode, (IFDE_XMLInstruction*)pXMLChild, ePacketID);
+ break;
+ default:
+ break;
+ }
+ }
+ return pXFANode;
+}
+FX_BOOL XFA_RecognizeRichText(IFDE_XMLElement* pRichTextXMLNode)
+{
+ if (pRichTextXMLNode) {
+ CFX_WideString wsNamespaceURI;
+ XFA_FDEExtension_GetElementTagNamespaceURI(pRichTextXMLNode, wsNamespaceURI);
+ if (wsNamespaceURI == FX_WSTRC(L"http://www.w3.org/1999/xhtml")) {
+ return TRUE;
+ }
+ }
+ return FALSE;
+}
+class RichTextNodeVisitor
+{
+public:
+ static inline IFDE_XMLNode* GetFirstChild(IFDE_XMLNode* pNode)
+ {
+ return pNode->GetNodeItem(IFDE_XMLNode::FirstChild);
+ }
+ static inline IFDE_XMLNode* GetNextSibling(IFDE_XMLNode* pNode)
+ {
+ return pNode->GetNodeItem(IFDE_XMLNode::NextSibling);
+ }
+ static inline IFDE_XMLNode* GetParent(IFDE_XMLNode* pNode)
+ {
+ return pNode->GetNodeItem(IFDE_XMLNode::Parent);
+ }
+};
+#ifndef XFA_PARSE_HAS_LINEIDENTIFIER
+void XFA_ConvertRichTextToPlainText(IFDE_XMLElement* pRichTextXMLNode, CFX_WideString& wsOutput)
+{
+ CXFA_NodeIteratorTemplate<IFDE_XMLNode, RichTextNodeVisitor> sIterator(pRichTextXMLNode);
+ CFX_WideTextBuf wsPlainTextBuf;
+ for(IFDE_XMLNode* pNode = sIterator.GetCurrent(); pNode; pNode = sIterator.MoveToNext()) {
+ switch(pNode->GetType()) {
+ case FDE_XMLNODE_Text: {
+ CFX_WideString wsText;
+ ((IFDE_XMLText*)pNode)->GetText(wsText);
+ wsPlainTextBuf << wsText;
+ }
+ break;
+ case FDE_XMLNODE_CharData: {
+ CFX_WideString wsText;
+ ((IFDE_XMLCharData*)pNode)->GetCharData(wsText);
+ wsPlainTextBuf << wsText;
+ }
+ break;
+ default:
+ break;
+ }
+ }
+ wsOutput = wsPlainTextBuf.GetWideString();
+}
+#endif
+void XFA_ConvertXMLToPlainText(IFDE_XMLElement* pRootXMLNode, CFX_WideString& wsOutput)
+{
+ for (IFDE_XMLNode *pXMLChild = pRootXMLNode->GetNodeItem(IFDE_XMLNode::FirstChild); pXMLChild; pXMLChild = pXMLChild->GetNodeItem(IFDE_XMLNode::NextSibling)) {
+#ifdef _DEBUG
+ FDE_XMLNODETYPE nodeType = pXMLChild->GetType();
+#endif
+ switch(pXMLChild->GetType()) {
+ case FDE_XMLNODE_Element: {
+ CFX_WideString wsTextData;
+ ((IFDE_XMLElement*)pXMLChild)->GetTextData(wsTextData);
+ wsTextData += FX_WSTRC(L"\n");
+ wsOutput += wsTextData;
+ }
+ break;
+ case FDE_XMLNODE_Text: {
+ CFX_WideString wsText;
+ ((IFDE_XMLText*)pXMLChild)->GetText(wsText);
+ if (XFA_FDEExtension_IsStringAllWhitespace(wsText)) {
+ continue;
+ } else {
+ wsOutput = wsText;
+ }
+ }
+ break;
+ case FDE_XMLNODE_CharData: {
+ CFX_WideString wsCharData;
+ ((IFDE_XMLCharData*)pXMLChild)->GetCharData(wsCharData);
+ if (XFA_FDEExtension_IsStringAllWhitespace(wsCharData)) {
+ continue;
+ } else {
+ wsOutput = wsCharData;
+ }
+ }
+ break;
+ default:
+ FXSYS_assert(FALSE);
+ break;
+ }
+ }
+}
+void CXFA_SimpleParser::ParseContentNode(CXFA_Node* pXFANode, IFDE_XMLNode* pXMLNode, XFA_XDPPACKET ePacketID)
+{
+ XFA_ELEMENT element = XFA_ELEMENT_Sharptext;
+ if (pXFANode->GetClassID() == XFA_ELEMENT_ExData) {
+ CFX_WideStringC wsContentType = pXFANode->GetCData(XFA_ATTRIBUTE_ContentType);
+ if (wsContentType == FX_WSTRC(L"text/html")) {
+ element = XFA_ELEMENT_SharpxHTML;
+ } else if (wsContentType == FX_WSTRC(L"text/xml")) {
+ element = XFA_ELEMENT_Sharpxml;
+ }
+ }
+ if (element == XFA_ELEMENT_SharpxHTML) {
+ pXFANode->SetXMLMappingNode(pXMLNode);
+ }
+ CFX_WideString wsValue;
+ for (IFDE_XMLNode *pXMLChild = pXMLNode->GetNodeItem(IFDE_XMLNode::FirstChild); pXMLChild; pXMLChild = pXMLChild->GetNodeItem(IFDE_XMLNode::NextSibling)) {
+ FDE_XMLNODETYPE eNodeType = pXMLChild->GetType();
+ if(eNodeType == FDE_XMLNODE_Instruction) {
+ continue;
+ }
+ if(element == XFA_ELEMENT_SharpxHTML) {
+ if(eNodeType != FDE_XMLNODE_Element) {
+ break;
+ }
+ if (XFA_RecognizeRichText((IFDE_XMLElement*)pXMLChild)) {
+#ifdef XFA_PARSE_HAS_LINEIDENTIFIER
+ XFA_GetPlainTextFromRichText((IFDE_XMLElement*)pXMLChild, wsValue);
+#else
+ XFA_ConvertRichTextToPlainText((IFDE_XMLElement*)pXMLChild, wsValue);
+#endif
+ }
+ } else if (element == XFA_ELEMENT_Sharpxml) {
+ if(eNodeType != FDE_XMLNODE_Element) {
+ break;
+ }
+ XFA_ConvertXMLToPlainText((IFDE_XMLElement*)pXMLChild, wsValue);
+ } else {
+ if(eNodeType == FDE_XMLNODE_Element) {
+ break;
+ }
+ if(eNodeType == FDE_XMLNODE_Text) {
+ ((IFDE_XMLText*)pXMLChild)->GetText(wsValue);
+ } else if(eNodeType == FDE_XMLNODE_CharData) {
+ ((IFDE_XMLCharData*)pXMLChild)->GetCharData(wsValue);
+ }
+ }
+ break;
+ }
+ if(!wsValue.IsEmpty()) {
+ if (pXFANode->GetObjectType() == XFA_OBJECTTYPE_ContentNode) {
+ CXFA_Node *pContentRawDataNode = m_pFactory->CreateNode(ePacketID, element);
+ FXSYS_assert(pContentRawDataNode);
+ pContentRawDataNode->SetCData(XFA_ATTRIBUTE_Value, wsValue);
+ pXFANode->InsertChild(pContentRawDataNode);
+ } else {
+ pXFANode->SetCData(XFA_ATTRIBUTE_Value, wsValue);
+ }
+ }
+}
+void CXFA_SimpleParser::ParseDataGroup(CXFA_Node* pXFANode, IFDE_XMLNode* pXMLNode, XFA_XDPPACKET ePacketID)
+{
+ for (IFDE_XMLNode *pXMLChild = pXMLNode->GetNodeItem(IFDE_XMLNode::FirstChild); pXMLChild; pXMLChild = pXMLChild->GetNodeItem(IFDE_XMLNode::NextSibling)) {
+ switch (pXMLChild->GetType()) {
+ case FDE_XMLNODE_Element: {
+ IFDE_XMLElement *pXMLElement = (IFDE_XMLElement*)pXMLChild;
+ {
+ CFX_WideString wsNamespaceURI;
+ XFA_FDEExtension_GetElementTagNamespaceURI(pXMLElement, wsNamespaceURI);
+ if(wsNamespaceURI == FX_WSTRC(L"http://www.xfa.com/schema/xfa-package/") ||
+ wsNamespaceURI == FX_WSTRC(L"http://www.xfa.org/schema/xfa-package/") ||
+ wsNamespaceURI == FX_WSTRC(L"http://www.w3.org/2001/XMLSchema-instance")) {
+ continue;
+ }
+ if(0) {
+ continue;
+ }
+ }
+ XFA_ELEMENT eNodeType = XFA_ELEMENT_DataModel;
+ if (eNodeType == XFA_ELEMENT_DataModel) {
+ CFX_WideString wsDataNodeAttr;
+ if(XFA_FDEExtension_FindAttributeWithNS(pXMLElement, FX_WSTRC(L"dataNode"), FX_WSTRC(L"http://www.xfa.org/schema/xfa-data/1.0/"), wsDataNodeAttr)) {
+ if (wsDataNodeAttr == FX_WSTRC(L"dataGroup")) {
+ eNodeType = XFA_ELEMENT_DataGroup;
+ } else if (wsDataNodeAttr == FX_WSTRC(L"dataValue")) {
+ eNodeType = XFA_ELEMENT_DataValue;
+ }
+ }
+ }
+ CFX_WideString wsContentType;
+ if (eNodeType == XFA_ELEMENT_DataModel) {
+ if(XFA_FDEExtension_FindAttributeWithNS(pXMLElement, FX_WSTRC(L"contentType"), FX_WSTRC(L"http://www.xfa.org/schema/xfa-data/1.0/"), wsContentType)) {
+ if (!wsContentType.IsEmpty()) {
+ eNodeType = XFA_ELEMENT_DataValue;
+ }
+ }
+ }
+ if (eNodeType == XFA_ELEMENT_DataModel) {
+ for (IFDE_XMLNode *pXMLDataChild = pXMLElement->GetNodeItem(IFDE_XMLNode::FirstChild); pXMLDataChild; pXMLDataChild = pXMLDataChild->GetNodeItem(IFDE_XMLNode::NextSibling)) {
+ if(pXMLDataChild->GetType() == FDE_XMLNODE_Element) {
+ if (!XFA_RecognizeRichText((IFDE_XMLElement*)pXMLDataChild)) {
+ eNodeType = XFA_ELEMENT_DataGroup;
+ break;
+ }
+ }
+ }
+ }
+ if (eNodeType == XFA_ELEMENT_DataModel) {
+ eNodeType = XFA_ELEMENT_DataValue;
+ }
+ CXFA_Node *pXFAChild = m_pFactory->CreateNode(XFA_XDPPACKET_Datasets, eNodeType);
+ if (pXFAChild == NULL) {
+ return;
+ }
+ CFX_WideString wsNodeName;
+ pXMLElement->GetLocalTagName(wsNodeName);
+ pXFAChild->SetCData(XFA_ATTRIBUTE_Name, wsNodeName);
+ FX_BOOL bNeedValue = TRUE;
+ if (1) {
+ for(FX_INT32 i = 0, count = pXMLElement->CountAttributes(); i < count; i++) {
+ CFX_WideString wsAttrQualifiedName;
+ CFX_WideString wsAttrValue;
+ CFX_WideString wsAttrName;
+ CFX_WideString wsAttrNamespaceURI;
+ pXMLElement->GetAttribute(i, wsAttrQualifiedName, wsAttrValue);
+ if(!XFA_FDEExtension_ResolveAttribute(pXMLElement, wsAttrQualifiedName, wsAttrName, wsAttrNamespaceURI)) {
+ continue;
+ }
+ if(wsAttrName == FX_WSTRC(L"nil") && wsAttrValue == FX_WSTRC(L"true")) {
+ bNeedValue = FALSE;
+ continue;
+ }
+ if(wsAttrNamespaceURI == FX_WSTRC(L"http://www.xfa.com/schema/xfa-package/") ||
+ wsAttrNamespaceURI == FX_WSTRC(L"http://www.xfa.org/schema/xfa-package/") ||
+ wsAttrNamespaceURI == FX_WSTRC(L"http://www.w3.org/2001/XMLSchema-instance") ||
+ wsAttrNamespaceURI == FX_WSTRC(L"http://www.xfa.org/schema/xfa-data/1.0/")) {
+ continue;
+ }
+ if(0) {
+ continue;
+ }
+ CXFA_Node *pXFAMetaData = m_pFactory->CreateNode(XFA_XDPPACKET_Datasets, XFA_ELEMENT_DataValue);
+ if (pXFAMetaData == NULL) {
+ return;
+ }
+ pXFAMetaData->SetCData(XFA_ATTRIBUTE_Name, wsAttrName);
+ pXFAMetaData->SetCData(XFA_ATTRIBUTE_QualifiedName, wsAttrQualifiedName);
+ pXFAMetaData->SetCData(XFA_ATTRIBUTE_Value, wsAttrValue);
+ pXFAMetaData->SetEnum(XFA_ATTRIBUTE_Contains, XFA_ATTRIBUTEENUM_MetaData);
+ pXFAChild->InsertChild(pXFAMetaData);
+ pXFAMetaData->SetXMLMappingNode(pXMLElement);
+ pXFAMetaData->SetFlag(XFA_NODEFLAG_Initialized, TRUE, FALSE);
+ }
+ if(!bNeedValue) {
+ CFX_WideString wsNilName = FX_WSTRC(L"xsi:nil");
+ pXMLElement->RemoveAttribute(wsNilName);
+ }
+ }
+ pXFANode->InsertChild(pXFAChild);
+ if (eNodeType == XFA_ELEMENT_DataGroup) {
+ ParseDataGroup(pXFAChild, pXMLElement, ePacketID);
+ } else {
+ if(bNeedValue) {
+ ParseDataValue(pXFAChild, pXMLChild, XFA_XDPPACKET_Datasets);
+ }
+ }
+ pXFAChild->SetXMLMappingNode(pXMLElement);
+ pXFAChild->SetFlag(XFA_NODEFLAG_Initialized, TRUE, FALSE);
+ }
+ continue;
+ case FDE_XMLNODE_CharData: {
+ IFDE_XMLCharData *pXMLCharData = (IFDE_XMLCharData*)pXMLChild;
+ CFX_WideString wsCharData;
+ pXMLCharData->GetCharData(wsCharData);
+ if (XFA_FDEExtension_IsStringAllWhitespace(wsCharData)) {
+ continue;
+ }
+ CXFA_Node *pXFAChild = m_pFactory->CreateNode(XFA_XDPPACKET_Datasets, XFA_ELEMENT_DataValue);
+ if (pXFAChild == NULL) {
+ return;
+ }
+ pXFAChild->SetCData(XFA_ATTRIBUTE_Value, wsCharData);
+ pXFANode->InsertChild(pXFAChild);
+ pXFAChild->SetXMLMappingNode(pXMLCharData);
+ pXFAChild->SetFlag(XFA_NODEFLAG_Initialized, TRUE, FALSE);
+ }
+ continue;
+ case FDE_XMLNODE_Text: {
+ IFDE_XMLText *pXMLText = (IFDE_XMLText*)pXMLChild;
+ CFX_WideString wsText;
+ pXMLText->GetText(wsText);
+ if (XFA_FDEExtension_IsStringAllWhitespace(wsText)) {
+ continue;
+ }
+ CXFA_Node *pXFAChild = m_pFactory->CreateNode(XFA_XDPPACKET_Datasets, XFA_ELEMENT_DataValue);
+ if (pXFAChild == NULL) {
+ return;
+ }
+ pXFAChild->SetCData(XFA_ATTRIBUTE_Value, wsText);
+ pXFANode->InsertChild(pXFAChild);
+ pXFAChild->SetXMLMappingNode(pXMLText);
+ pXFAChild->SetFlag(XFA_NODEFLAG_Initialized, TRUE, FALSE);
+ }
+ continue;
+ case FDE_XMLNODE_Instruction:
+ continue;
+ default:
+ continue;
+ }
+ }
+}
+void CXFA_SimpleParser::ParseDataValue(CXFA_Node* pXFANode, IFDE_XMLNode* pXMLNode, XFA_XDPPACKET ePacketID)
+{
+ CFX_WideTextBuf wsValueTextBuf;
+ CFX_WideTextBuf wsCurValueTextBuf;
+ FX_BOOL bMarkAsCompound = FALSE;
+ IFDE_XMLNode *pXMLCurValueNode = NULL;
+ for (IFDE_XMLNode *pXMLChild = pXMLNode->GetNodeItem(IFDE_XMLNode::FirstChild); pXMLChild; pXMLChild = pXMLChild->GetNodeItem(IFDE_XMLNode::NextSibling)) {
+ FDE_XMLNODETYPE eNodeType = pXMLChild->GetType();
+ if(eNodeType == FDE_XMLNODE_Instruction) {
+ continue;
+ }
+ CFX_WideString wsText;
+ FX_BOOL bBreak = FALSE;
+ if(eNodeType == FDE_XMLNODE_Text) {
+ ((IFDE_XMLText*)pXMLChild)->GetText(wsText);
+ if(!pXMLCurValueNode) {
+ pXMLCurValueNode = pXMLChild;
+ }
+ wsCurValueTextBuf << wsText;
+ } else if(eNodeType == FDE_XMLNODE_CharData) {
+ ((IFDE_XMLCharData*)pXMLChild)->GetCharData(wsText);
+ if(!pXMLCurValueNode) {
+ pXMLCurValueNode = pXMLChild;
+ }
+ wsCurValueTextBuf << wsText;
+ } else if(XFA_RecognizeRichText((IFDE_XMLElement*)pXMLChild)) {
+#ifdef XFA_PARSE_HAS_LINEIDENTIFIER
+ XFA_GetPlainTextFromRichText((IFDE_XMLElement*)pXMLChild, wsText);
+#else
+ XFA_ConvertRichTextToPlainText((IFDE_XMLElement*)pXMLChild, wsText);
+#endif
+ if(!pXMLCurValueNode) {
+ pXMLCurValueNode = pXMLChild;
+ }
+ wsCurValueTextBuf << wsText;
+ } else {
+ bMarkAsCompound = TRUE;
+ if(pXMLCurValueNode) {
+ CFX_WideStringC wsCurValue = wsCurValueTextBuf.GetWideString();
+ if(!wsCurValue.IsEmpty()) {
+ CXFA_Node *pXFAChild = m_pFactory->CreateNode(ePacketID, XFA_ELEMENT_DataValue);
+ if (pXFAChild == NULL) {
+ return;
+ }
+ pXFAChild->SetCData(XFA_ATTRIBUTE_Name, FX_WSTRC(L""));
+ pXFAChild->SetCData(XFA_ATTRIBUTE_Value, wsCurValue);
+ pXFANode->InsertChild(pXFAChild);
+ pXFAChild->SetXMLMappingNode(pXMLCurValueNode);
+ pXFAChild->SetFlag(XFA_NODEFLAG_Initialized, TRUE, FALSE);
+ wsValueTextBuf << wsCurValue;
+ wsCurValueTextBuf.Clear();
+ }
+ pXMLCurValueNode = NULL;
+ }
+ CXFA_Node *pXFAChild = m_pFactory->CreateNode(ePacketID, XFA_ELEMENT_DataValue);
+ if (pXFAChild == NULL) {
+ return;
+ }
+ CFX_WideString wsNodeStr;
+ ((IFDE_XMLElement*)pXMLChild)->GetLocalTagName(wsNodeStr);
+ pXFAChild->SetCData(XFA_ATTRIBUTE_Name, wsNodeStr);
+ ParseDataValue(pXFAChild, pXMLChild, ePacketID);
+ pXFANode->InsertChild(pXFAChild);
+ pXFAChild->SetXMLMappingNode(pXMLChild);
+ pXFAChild->SetFlag(XFA_NODEFLAG_Initialized, TRUE, FALSE);
+ CFX_WideStringC wsCurValue = pXFAChild->GetCData(XFA_ATTRIBUTE_Value);
+ wsValueTextBuf << wsCurValue;
+ }
+ }
+ if(pXMLCurValueNode) {
+ CFX_WideStringC wsCurValue = wsCurValueTextBuf.GetWideString();
+ if(!wsCurValue.IsEmpty()) {
+ if(bMarkAsCompound) {
+ CXFA_Node *pXFAChild = m_pFactory->CreateNode(ePacketID, XFA_ELEMENT_DataValue);
+ if (pXFAChild == NULL) {
+ return;
+ }
+ pXFAChild->SetCData(XFA_ATTRIBUTE_Name, FX_WSTRC(L""));
+ pXFAChild->SetCData(XFA_ATTRIBUTE_Value, wsCurValue);
+ pXFANode->InsertChild(pXFAChild);
+ pXFAChild->SetXMLMappingNode(pXMLCurValueNode);
+ pXFAChild->SetFlag(XFA_NODEFLAG_Initialized, TRUE, FALSE);
+ }
+ wsValueTextBuf << wsCurValue;
+ wsCurValueTextBuf.Clear();
+ }
+ pXMLCurValueNode = NULL;
+ }
+ CFX_WideStringC wsNodeValue = wsValueTextBuf.GetWideString();
+ pXFANode->SetCData(XFA_ATTRIBUTE_Value, wsNodeValue);
+}
+void CXFA_SimpleParser::ParseInstruction(CXFA_Node *pXFANode, IFDE_XMLInstruction *pXMLInstruction, XFA_XDPPACKET ePacketID)
+{
+ if(!m_bDocumentParser) {
+ return;
+ }
+ CFX_WideString wsTargetName;
+ pXMLInstruction->GetTargetName(wsTargetName);
+ FX_INT32 iDataCount = pXMLInstruction->CountData();
+ if (wsTargetName == FX_WSTRC(L"originalXFAVersion")) {
+ CFX_WideString wsData;
+ if(pXMLInstruction->GetData(0, wsData) && (pXFANode->GetDocument()->RecognizeXFAVersionNumber(wsData) != XFA_VERSION_UNKNOWN)) {
+ wsData.Empty();
+ if (pXMLInstruction->GetData(1, wsData) && wsData == FX_WSTRC(L"v2.7-scripting:1")) {
+ pXFANode->GetDocument()->SetFlag(XFA_DOCFLAG_Scripting, TRUE);
+ }
+ }
+ } else if (wsTargetName == FX_WSTRC(L"acrobat")) {
+ CFX_WideString wsData;
+ if (pXMLInstruction->GetData(0, wsData) && wsData == FX_WSTRC(L"JavaScript")) {
+ if (pXMLInstruction->GetData(1, wsData) && wsData == FX_WSTRC(L"strictScoping")) {
+ pXFANode->GetDocument()->SetFlag(XFA_DOCFLAG_StrictScoping, TRUE);
+ }
+ }
+ }
+}
+void CXFA_SimpleParser::CloseParser()
+{
+ if (m_pXMLDoc) {
+ m_pXMLDoc->Release();
+ m_pXMLDoc = NULL;
+ }
+ if (m_pStream) {
+ m_pStream->Release();
+ m_pStream = NULL;
+ }
+}
+IXFA_DocParser* IXFA_DocParser::Create(IXFA_Notify *pNotify)
+{
+ return FX_NEW CXFA_DocumentParser(pNotify);
+}
+CXFA_DocumentParser::CXFA_DocumentParser(IXFA_Notify *pNotify)
+ : m_pNotify(pNotify)
+ , m_nodeParser(NULL, TRUE)
+ , m_pDocument(NULL)
+{
+}
+CXFA_DocumentParser::~CXFA_DocumentParser()
+{
+ CloseParser();
+}
+FX_INT32 CXFA_DocumentParser::StartParse(IFX_FileRead *pStream, XFA_XDPPACKET ePacketID )
+{
+ CloseParser();
+ FX_INT32 nRetStatus = m_nodeParser.StartParse(pStream, ePacketID);
+ if(nRetStatus == XFA_PARSESTATUS_Ready) {
+ m_pDocument = FX_NEW CXFA_Document(this);
+ m_nodeParser.SetFactory(m_pDocument);
+ }
+ return nRetStatus;
+}
+FX_INT32 CXFA_DocumentParser::DoParse(IFX_Pause *pPause )
+{
+ FX_INT32 nRetStatus = m_nodeParser.DoParse(pPause);
+ if (nRetStatus >= XFA_PARSESTATUS_Done) {
+ FXSYS_assert(m_pDocument);
+ m_pDocument->SetRoot(m_nodeParser.GetRootNode());
+ }
+ return nRetStatus;
+}
+FX_INT32 CXFA_DocumentParser::ParseXMLData(const CFX_WideString &wsXML, IFDE_XMLNode* &pXMLNode, IFX_Pause *pPause)
+{
+ CloseParser();
+ FX_INT32 nRetStatus = m_nodeParser.ParseXMLData(wsXML, pXMLNode, NULL);
+ if(nRetStatus == XFA_PARSESTATUS_Done && pXMLNode) {
+ m_pDocument = FX_NEW CXFA_Document(this);
+ m_nodeParser.SetFactory(m_pDocument);
+ }
+ return nRetStatus;
+}
+void CXFA_DocumentParser::ConstructXFANode(CXFA_Node* pXFANode, IFDE_XMLNode* pXMLNode)
+{
+ if (!pXFANode || !pXMLNode) {
+ return;
+ }
+ m_nodeParser.ConstructXFANode(pXFANode, pXMLNode);
+ CXFA_Node* pRootNode = m_nodeParser.GetRootNode();
+ if (m_pDocument && pRootNode) {
+ m_pDocument->SetRoot(pRootNode);
+ }
+}
+void CXFA_DocumentParser::CloseParser()
+{
+ if (m_pDocument) {
+ delete m_pDocument;
+ m_pDocument = NULL;
+ }
+ m_nodeParser.CloseParser();
+}
+CXFA_XMLParser::CXFA_XMLParser(IFDE_XMLNode *pRoot, IFX_Stream *pStream)
+ : m_pRoot(pRoot)
+ , m_pStream(pStream)
+ , m_pParser(NULL)
+ , m_dwStatus(FDE_XMLSYNTAXSTATUS_None)
+ , m_pParent(pRoot)
+ , m_pChild(NULL)
+ , m_NodeStack(16)
+ , m_ws1()
+ , m_ws2()
+#ifdef _XFA_VERIFY_Checksum_
+ , m_nElementStart(0)
+ , m_dwCheckStatus(0)
+ , m_dwCurrentCheckStatus(0)
+#endif
+{
+ ASSERT(m_pParent && m_pStream);
+ m_NodeStack.Push(m_pParent);
+ m_pParser = IFDE_XMLSyntaxParser::Create();
+ m_pParser->Init(m_pStream, 32 * 1024, 1024 * 1024);
+}
+CXFA_XMLParser::~CXFA_XMLParser()
+{
+ if (m_pParser) {
+ m_pParser->Release();
+ }
+ m_NodeStack.RemoveAll();
+ m_ws1.Empty();
+ m_ws2.Empty();
+}
+FX_INT32 CXFA_XMLParser::DoParser(IFX_Pause *pPause)
+{
+ if (m_dwStatus == FDE_XMLSYNTAXSTATUS_Error) {
+ return -1;
+ }
+ if (m_dwStatus == FDE_XMLSYNTAXSTATUS_EOS) {
+ return 100;
+ }
+ FX_INT32 iCount = 0;
+ while (TRUE) {
+ m_dwStatus = m_pParser->DoSyntaxParse();
+ switch (m_dwStatus) {
+ case FDE_XMLSYNTAXSTATUS_InstructionOpen:
+ break;
+ case FDE_XMLSYNTAXSTATUS_InstructionClose:
+ if (m_pChild) {
+ if (m_pChild->GetType() != FDE_XMLNODE_Instruction) {
+ m_dwStatus = FDE_XMLSYNTAXSTATUS_Error;
+ break;
+ }
+ }
+ m_pChild = m_pParent;
+ break;
+ case FDE_XMLSYNTAXSTATUS_ElementOpen:
+#ifdef _XFA_VERIFY_Checksum_
+ if (m_dwCheckStatus != 0x03 && m_NodeStack.GetSize() == 2) {
+ m_nElementStart = m_pParser->GetCurrentPos() - 1;
+ }
+#endif
+ break;
+ case FDE_XMLSYNTAXSTATUS_ElementBreak:
+ break;
+ case FDE_XMLSYNTAXSTATUS_ElementClose:
+ if (m_pChild->GetType() != FDE_XMLNODE_Element) {
+ m_dwStatus = FDE_XMLSYNTAXSTATUS_Error;
+ break;
+ }
+ m_pParser->GetTagName(m_ws1);
+ ((IFDE_XMLElement*)m_pChild)->GetTagName(m_ws2);
+ if (m_ws1.GetLength() > 0 && !m_ws1.Equal(m_ws2)) {
+ m_dwStatus = FDE_XMLSYNTAXSTATUS_Error;
+ break;
+ }
+ m_NodeStack.Pop();
+ if (m_NodeStack.GetSize() < 1) {
+ m_dwStatus = FDE_XMLSYNTAXSTATUS_Error;
+ break;
+ }
+#ifdef _XFA_VERIFY_Checksum_
+ else if (m_dwCurrentCheckStatus != 0 && m_NodeStack.GetSize() == 2) {
+ m_nSize[m_dwCurrentCheckStatus - 1] = m_pParser->GetCurrentBinaryPos() - m_nStart[m_dwCurrentCheckStatus - 1];
+ m_dwCurrentCheckStatus = 0;
+ }
+#endif
+ m_pParent = (IFDE_XMLNode*)*m_NodeStack.GetTopElement();
+ m_pChild = m_pParent;
+ iCount++;
+ break;
+ case FDE_XMLSYNTAXSTATUS_TargetName:
+ m_pParser->GetTargetName(m_ws1);
+ if (m_ws1 == FX_WSTRC(L"originalXFAVersion") || m_ws1 == FX_WSTRC(L"acrobat")) {
+ m_pChild = IFDE_XMLInstruction::Create(m_ws1);
+ m_pParent->InsertChildNode(m_pChild);
+ } else {
+ m_pChild = NULL;
+ }
+ m_ws1.Empty();
+ break;
+ case FDE_XMLSYNTAXSTATUS_TagName:
+ m_pParser->GetTagName(m_ws1);
+ m_pChild = IFDE_XMLElement::Create(m_ws1);
+ m_pParent->InsertChildNode(m_pChild);
+ m_NodeStack.Push(m_pChild);
+ m_pParent = m_pChild;
+#ifdef _XFA_VERIFY_Checksum_
+ if (m_dwCheckStatus != 0x03 && m_NodeStack.GetSize() == 3) {
+ CFX_WideString wsTag;
+ ((IFDE_XMLElement*)m_pChild)->GetLocalTagName(wsTag);
+ if (wsTag == FX_WSTRC(L"template")) {
+ m_dwCheckStatus |= 0x01;
+ m_dwCurrentCheckStatus = 0x01;
+ m_nStart[0] = m_pParser->GetCurrentBinaryPos() - (m_pParser->GetCurrentPos() - m_nElementStart);
+ } else if (wsTag == FX_WSTRC(L"datasets")) {
+ m_dwCheckStatus |= 0x02;
+ m_dwCurrentCheckStatus = 0x02;
+ m_nStart[1] = m_pParser->GetCurrentBinaryPos() - (m_pParser->GetCurrentPos() - m_nElementStart);
+ }
+ }
+#endif
+ break;
+ case FDE_XMLSYNTAXSTATUS_AttriName:
+ m_pParser->GetAttributeName(m_ws1);
+ break;
+ case FDE_XMLSYNTAXSTATUS_AttriValue:
+ if (m_pChild) {
+ m_pParser->GetAttributeName(m_ws2);
+ if (m_pChild->GetType() == FDE_XMLNODE_Element) {
+ ((IFDE_XMLElement*)m_pChild)->SetString(m_ws1, m_ws2);
+ }
+ }
+ m_ws1.Empty();
+ break;
+ case FDE_XMLSYNTAXSTATUS_Text:
+ m_pParser->GetTextData(m_ws1);
+ m_pChild = IFDE_XMLText::Create(m_ws1);
+ m_pParent->InsertChildNode(m_pChild);
+ m_pChild = m_pParent;
+ break;
+ case FDE_XMLSYNTAXSTATUS_CData:
+ m_pParser->GetTextData(m_ws1);
+ m_pChild = IFDE_XMLCharData::Create(m_ws1);
+ m_pParent->InsertChildNode(m_pChild);
+ m_pChild = m_pParent;
+ break;
+ case FDE_XMLSYNTAXSTATUS_TargetData:
+ if (m_pChild) {
+ if (m_pChild->GetType() != FDE_XMLNODE_Instruction) {
+ m_dwStatus = FDE_XMLSYNTAXSTATUS_Error;
+ break;
+ }
+ if (!m_ws1.IsEmpty()) {
+ ((IFDE_XMLInstruction*)m_pChild)->AppendData(m_ws1);
+ }
+ m_pParser->GetTargetData(m_ws1);
+ ((IFDE_XMLInstruction*)m_pChild)->AppendData(m_ws1);
+ }
+ m_ws1.Empty();
+ break;
+ default:
+ break;
+ }
+ if (m_dwStatus == FDE_XMLSYNTAXSTATUS_Error || m_dwStatus == FDE_XMLSYNTAXSTATUS_EOS) {
+ break;
+ }
+ if (pPause != NULL && iCount > 500 && pPause->NeedToPauseNow()) {
+ break;
+ }
+ }
+ return (m_dwStatus == FDE_XMLSYNTAXSTATUS_Error || m_NodeStack.GetSize() != 1) ? -1 : m_pParser->GetStatus();
+}
|