1 // Copyright 2014 PDFium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com 6 7 #include "xfa/src/foxitlib.h" 8 #include "xfa/src/fxfa/src/common/xfa_utils.h" 9 #include "xfa/src/fxfa/src/common/xfa_object.h" 10 #include "xfa/src/fxfa/src/common/xfa_document.h" 11 #include "xfa/src/fxfa/src/common/xfa_parser.h" 12 #include "xfa/src/fxfa/src/common/xfa_script.h" 13 #include "xfa/src/fxfa/src/common/xfa_docdata.h" 14 #include "xfa/src/fxfa/src/common/xfa_doclayout.h" 15 #include "xfa/src/fxfa/src/common/xfa_localemgr.h" 16 #include "xfa/src/fxfa/src/common/xfa_fm2jsapi.h" 17 #include "xfa_basic_imp.h" 18 #include "xfa_parser_imp.h" 19 IXFA_Parser* IXFA_Parser::Create(IXFA_ObjFactory* pFactory, 20 FX_BOOL bDocumentParser) { 21 return new CXFA_SimpleParser(pFactory, bDocumentParser); 22 } 23 CXFA_SimpleParser::CXFA_SimpleParser(IXFA_ObjFactory* pFactory, 24 FX_BOOL bDocumentParser) 25 : m_pXMLParser(nullptr), 26 m_pXMLDoc(nullptr), 27 m_pStream(nullptr), 28 m_pFileRead(nullptr), 29 m_pFactory(pFactory), 30 m_pRootNode(nullptr), 31 m_ePacketID(XFA_XDPPACKET_UNKNOWN), 32 m_bDocumentParser(bDocumentParser) { 33 } 34 CXFA_SimpleParser::~CXFA_SimpleParser() { 35 CloseParser(); 36 } 37 void CXFA_SimpleParser::SetFactory(IXFA_ObjFactory* pFactory) { 38 m_pFactory = pFactory; 39 } 40 static IFDE_XMLNode* XFA_FDEExtension_GetDocumentNode( 41 IFDE_XMLDoc* pXMLDoc, 42 FX_BOOL bVerifyWellFormness = FALSE) { 43 if (!pXMLDoc) { 44 return NULL; 45 } 46 IFDE_XMLNode* pXMLFakeRoot = pXMLDoc->GetRoot(); 47 for (IFDE_XMLNode* pXMLNode = 48 pXMLFakeRoot->GetNodeItem(IFDE_XMLNode::FirstChild); 49 pXMLNode; pXMLNode = pXMLNode->GetNodeItem(IFDE_XMLNode::NextSibling)) { 50 if (pXMLNode->GetType() == FDE_XMLNODE_Element) { 51 if (bVerifyWellFormness) { 52 for (IFDE_XMLNode* pNextNode = 53 pXMLNode->GetNodeItem(IFDE_XMLNode::NextSibling); 54 pNextNode; 55 pNextNode = pNextNode->GetNodeItem(IFDE_XMLNode::NextSibling)) { 56 if (pNextNode->GetType() == FDE_XMLNODE_Element) { 57 return FALSE; 58 } 59 } 60 } 61 return pXMLNode; 62 } 63 } 64 return NULL; 65 } 66 int32_t CXFA_SimpleParser::StartParse(IFX_FileRead* pStream, 67 XFA_XDPPACKET ePacketID) { 68 CloseParser(); 69 m_pFileRead = pStream; 70 m_pStream = IFX_Stream::CreateStream( 71 pStream, FX_STREAMACCESS_Read | FX_STREAMACCESS_Text); 72 if (m_pStream == NULL) { 73 return XFA_PARSESTATUS_StreamErr; 74 } 75 FX_WORD wCodePage = m_pStream->GetCodePage(); 76 if (wCodePage != FX_CODEPAGE_UTF16LE && wCodePage != FX_CODEPAGE_UTF16BE && 77 wCodePage != FX_CODEPAGE_UTF8) { 78 m_pStream->SetCodePage(FX_CODEPAGE_UTF8); 79 } 80 m_pXMLDoc = IFDE_XMLDoc::Create(); 81 if (m_pXMLDoc == NULL) { 82 return XFA_PARSESTATUS_StatusErr; 83 } 84 m_pXMLParser = new CXFA_XMLParser(m_pXMLDoc->GetRoot(), m_pStream); 85 if (m_pXMLParser == NULL) { 86 return XFA_PARSESTATUS_StatusErr; 87 } 88 if (!m_pXMLDoc->LoadXML(m_pXMLParser)) { 89 return XFA_PARSESTATUS_StatusErr; 90 } 91 m_ePacketID = ePacketID; 92 return XFA_PARSESTATUS_Ready; 93 } 94 int32_t CXFA_SimpleParser::DoParse(IFX_Pause* pPause) { 95 if (m_pXMLDoc == NULL || m_ePacketID == XFA_XDPPACKET_UNKNOWN) { 96 return XFA_PARSESTATUS_StatusErr; 97 } 98 int32_t iRet = m_pXMLDoc->DoLoad(pPause); 99 if (iRet < 0) { 100 return XFA_PARSESTATUS_SyntaxErr; 101 } 102 if (iRet < 100) { 103 return iRet / 2; 104 } 105 m_pRootNode = ParseAsXDPPacket(XFA_FDEExtension_GetDocumentNode(m_pXMLDoc), 106 m_ePacketID); 107 m_pXMLDoc->CloseXML(); 108 if (m_pStream) { 109 m_pStream->Release(); 110 m_pStream = NULL; 111 } 112 if (!m_pRootNode) { 113 return XFA_PARSESTATUS_StatusErr; 114 } 115 return XFA_PARSESTATUS_Done; 116 } 117 int32_t CXFA_SimpleParser::ParseXMLData(const CFX_WideString& wsXML, 118 IFDE_XMLNode*& pXMLNode, 119 IFX_Pause* pPause) { 120 CloseParser(); 121 pXMLNode = NULL; 122 IFX_Stream* pStream = XFA_CreateWideTextRead(wsXML); 123 if (!pStream) { 124 return XFA_PARSESTATUS_StreamErr; 125 } 126 m_pStream = pStream; 127 m_pXMLDoc = IFDE_XMLDoc::Create(); 128 if (m_pXMLDoc == NULL) { 129 return XFA_PARSESTATUS_StatusErr; 130 } 131 CXFA_XMLParser* pParser = new CXFA_XMLParser(m_pXMLDoc->GetRoot(), m_pStream); 132 if (pParser == NULL) { 133 return XFA_PARSESTATUS_StatusErr; 134 } 135 #ifdef _XFA_VERIFY_Checksum_ 136 pParser->m_dwCheckStatus = 0x03; 137 #endif 138 if (!m_pXMLDoc->LoadXML(pParser)) { 139 return XFA_PARSESTATUS_StatusErr; 140 } 141 int32_t iRet = m_pXMLDoc->DoLoad(pPause); 142 if (iRet < 0 || iRet >= 100) { 143 m_pXMLDoc->CloseXML(); 144 } 145 if (iRet < 0) { 146 return XFA_PARSESTATUS_SyntaxErr; 147 } 148 if (iRet < 100) { 149 return iRet / 2; 150 } 151 if (m_pStream) { 152 m_pStream->Release(); 153 m_pStream = NULL; 154 } 155 pXMLNode = XFA_FDEExtension_GetDocumentNode(m_pXMLDoc); 156 return XFA_PARSESTATUS_Done; 157 } 158 void CXFA_SimpleParser::ConstructXFANode(CXFA_Node* pXFANode, 159 IFDE_XMLNode* pXMLNode) { 160 XFA_XDPPACKET ePacketID = (XFA_XDPPACKET)pXFANode->GetPacketID(); 161 if (ePacketID == XFA_XDPPACKET_Datasets) { 162 if (pXFANode->GetClassID() == XFA_ELEMENT_DataValue) { 163 for (IFDE_XMLNode* pXMLChild = 164 pXMLNode->GetNodeItem(IFDE_XMLNode::FirstChild); 165 pXMLChild; 166 pXMLChild = pXMLChild->GetNodeItem(IFDE_XMLNode::NextSibling)) { 167 FDE_XMLNODETYPE eNodeType = pXMLChild->GetType(); 168 if (eNodeType == FDE_XMLNODE_Instruction) { 169 continue; 170 } 171 if (eNodeType == FDE_XMLNODE_Element) { 172 CXFA_Node* pXFAChild = m_pFactory->CreateNode(XFA_XDPPACKET_Datasets, 173 XFA_ELEMENT_DataValue); 174 if (pXFAChild == NULL) { 175 return; 176 } 177 CFX_WideString wsNodeStr; 178 ((IFDE_XMLElement*)pXMLChild)->GetLocalTagName(wsNodeStr); 179 pXFAChild->SetCData(XFA_ATTRIBUTE_Name, wsNodeStr); 180 CFX_WideString wsChildValue; 181 #ifdef XFA_PARSE_HAS_LINEIDENTIFIER 182 XFA_GetPlainTextFromRichText((IFDE_XMLElement*)pXMLChild, 183 wsChildValue); 184 #else 185 XFA_ConvertRichTextToPlainText((IFDE_XMLElement*)pXMLChild, 186 wsChildValue); 187 #endif 188 if (!wsChildValue.IsEmpty()) { 189 pXFAChild->SetCData(XFA_ATTRIBUTE_Value, wsChildValue); 190 } 191 pXFANode->InsertChild(pXFAChild); 192 pXFAChild->SetXMLMappingNode(pXMLChild); 193 pXFAChild->SetFlag(XFA_NODEFLAG_Initialized, TRUE, FALSE); 194 break; 195 } 196 } 197 m_pRootNode = pXFANode; 198 } else { 199 m_pRootNode = DataLoader(pXFANode, pXMLNode, TRUE); 200 } 201 } else { 202 if (pXFANode->GetObjectType() == XFA_OBJECTTYPE_ContentNode) { 203 ParseContentNode(pXFANode, pXMLNode, ePacketID); 204 m_pRootNode = pXFANode; 205 } else { 206 m_pRootNode = NormalLoader(pXFANode, pXMLNode, ePacketID); 207 } 208 } 209 } 210 FX_BOOL XFA_FDEExtension_ResolveNamespaceQualifier( 211 IFDE_XMLElement* pNode, 212 const CFX_WideStringC& wsQualifier, 213 CFX_WideString& wsNamespaceURI) { 214 if (!pNode) { 215 return FALSE; 216 } 217 IFDE_XMLNode* pFakeRoot = pNode->GetNodeItem(IFDE_XMLNode::Root); 218 CFX_WideString wsNSAttribute; 219 FX_BOOL bRet = FALSE; 220 if (wsQualifier.IsEmpty()) { 221 wsNSAttribute = FX_WSTRC(L"xmlns"); 222 bRet = TRUE; 223 } else { 224 wsNSAttribute = FX_WSTRC(L"xmlns:") + wsQualifier; 225 } 226 for (; pNode != pFakeRoot; 227 pNode = (IFDE_XMLElement*)pNode->GetNodeItem(IFDE_XMLNode::Parent)) { 228 if (pNode->GetType() != FDE_XMLNODE_Element) { 229 continue; 230 } 231 if (pNode->HasAttribute(wsNSAttribute)) { 232 pNode->GetString(wsNSAttribute, wsNamespaceURI); 233 return TRUE; 234 } 235 } 236 wsNamespaceURI.Empty(); 237 return bRet; 238 } 239 static inline void XFA_FDEExtension_GetElementTagNamespaceURI( 240 IFDE_XMLElement* pElement, 241 CFX_WideString& wsNamespaceURI) { 242 CFX_WideString wsNodeStr; 243 pElement->GetNamespacePrefix(wsNodeStr); 244 if (!XFA_FDEExtension_ResolveNamespaceQualifier(pElement, wsNodeStr, 245 wsNamespaceURI)) { 246 wsNamespaceURI.Empty(); 247 } 248 } 249 static FX_BOOL XFA_FDEExtension_MatchNodeName( 250 IFDE_XMLNode* pNode, 251 const CFX_WideStringC& wsLocalTagName, 252 const CFX_WideStringC& wsNamespaceURIPrefix, 253 FX_DWORD eMatchFlags = XFA_XDPPACKET_FLAGS_NOMATCH) { 254 if (!pNode || pNode->GetType() != FDE_XMLNODE_Element) { 255 return FALSE; 256 } 257 IFDE_XMLElement* pElement = reinterpret_cast<IFDE_XMLElement*>(pNode); 258 CFX_WideString wsNodeStr; 259 pElement->GetLocalTagName(wsNodeStr); 260 if (wsNodeStr != wsLocalTagName) { 261 return FALSE; 262 } 263 XFA_FDEExtension_GetElementTagNamespaceURI(pElement, wsNodeStr); 264 if (eMatchFlags & XFA_XDPPACKET_FLAGS_NOMATCH) { 265 return TRUE; 266 } 267 if (eMatchFlags & XFA_XDPPACKET_FLAGS_PREFIXMATCH) { 268 return wsNodeStr.Left(wsNamespaceURIPrefix.GetLength()) == 269 wsNamespaceURIPrefix; 270 } 271 return wsNodeStr == wsNamespaceURIPrefix; 272 } 273 static FX_BOOL XFA_FDEExtension_GetAttributeLocalName( 274 const CFX_WideStringC& wsAttributeName, 275 CFX_WideString& wsLocalAttrName) { 276 CFX_WideString wsAttrName(wsAttributeName); 277 FX_STRSIZE iFind = wsAttrName.Find(L':', 0); 278 if (iFind < 0) { 279 wsLocalAttrName = wsAttrName; 280 return FALSE; 281 } else { 282 wsLocalAttrName = wsAttrName.Right(wsAttrName.GetLength() - iFind - 1); 283 return TRUE; 284 } 285 } 286 static FX_BOOL XFA_FDEExtension_ResolveAttribute( 287 IFDE_XMLElement* pElement, 288 const CFX_WideStringC& wsAttributeName, 289 CFX_WideString& wsLocalAttrName, 290 CFX_WideString& wsNamespaceURI) { 291 CFX_WideString wsAttrName(wsAttributeName); 292 CFX_WideString wsNSPrefix; 293 if (XFA_FDEExtension_GetAttributeLocalName(wsAttributeName, 294 wsLocalAttrName)) { 295 wsNSPrefix = wsAttrName.Left(wsAttributeName.GetLength() - 296 wsLocalAttrName.GetLength() - 1); 297 } 298 if (wsLocalAttrName == FX_WSTRC(L"xmlns") || 299 wsNSPrefix == FX_WSTRC(L"xmlns") || wsNSPrefix == FX_WSTRC(L"xml")) { 300 return FALSE; 301 } 302 if (!XFA_FDEExtension_ResolveNamespaceQualifier(pElement, wsNSPrefix, 303 wsNamespaceURI)) { 304 wsNamespaceURI.Empty(); 305 return FALSE; 306 } 307 return TRUE; 308 } 309 static FX_BOOL XFA_FDEExtension_FindAttributeWithNS( 310 IFDE_XMLElement* pElement, 311 const CFX_WideStringC& wsLocalAttributeName, 312 const CFX_WideStringC& wsNamespaceURIPrefix, 313 CFX_WideString& wsValue, 314 FX_BOOL bMatchNSAsPrefix = FALSE) { 315 if (!pElement) { 316 return FALSE; 317 } 318 CFX_WideString wsAttrName; 319 CFX_WideString wsAttrValue; 320 CFX_WideString wsAttrNS; 321 for (int32_t iAttrCount = pElement->CountAttributes(), i = 0; i < iAttrCount; 322 i++) { 323 pElement->GetAttribute(i, wsAttrName, wsAttrValue); 324 FX_STRSIZE iFind = wsAttrName.Find(L':', 0); 325 CFX_WideString wsNSPrefix; 326 if (iFind < 0) { 327 if (wsLocalAttributeName != wsAttrName) { 328 continue; 329 } 330 } else { 331 if (wsLocalAttributeName != 332 wsAttrName.Right(wsAttrName.GetLength() - iFind - 1)) { 333 continue; 334 } 335 wsNSPrefix = wsAttrName.Left(iFind); 336 } 337 if (!XFA_FDEExtension_ResolveNamespaceQualifier(pElement, wsNSPrefix, 338 wsAttrNS)) { 339 continue; 340 } 341 if (bMatchNSAsPrefix) { 342 if (wsAttrNS.Left(wsNamespaceURIPrefix.GetLength()) != 343 wsNamespaceURIPrefix) { 344 continue; 345 } 346 } else { 347 if (wsAttrNS != wsNamespaceURIPrefix) { 348 continue; 349 } 350 } 351 wsValue = wsAttrValue; 352 return TRUE; 353 } 354 return FALSE; 355 } 356 CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket(IFDE_XMLNode* pXMLDocumentNode, 357 XFA_XDPPACKET ePacketID) { 358 switch (ePacketID) { 359 case XFA_XDPPACKET_UNKNOWN: 360 return NULL; 361 case XFA_XDPPACKET_XDP: 362 return ParseAsXDPPacket_XDP(pXMLDocumentNode, ePacketID); 363 case XFA_XDPPACKET_Config: 364 return ParseAsXDPPacket_Config(pXMLDocumentNode, ePacketID); 365 case XFA_XDPPACKET_Template: 366 case XFA_XDPPACKET_Form: 367 return ParseAsXDPPacket_TemplateForm(pXMLDocumentNode, ePacketID); 368 case XFA_XDPPACKET_Datasets: 369 return ParseAsXDPPacket_Data(pXMLDocumentNode, ePacketID); 370 case XFA_XDPPACKET_Xdc: 371 return ParseAsXDPPacket_Xdc(pXMLDocumentNode, ePacketID); 372 case XFA_XDPPACKET_LocaleSet: 373 case XFA_XDPPACKET_ConnectionSet: 374 case XFA_XDPPACKET_SourceSet: 375 return ParseAsXDPPacket_LocaleConnectionSourceSet(pXMLDocumentNode, 376 ePacketID); 377 default: 378 return ParseAsXDPPacket_User(pXMLDocumentNode, ePacketID); 379 } 380 return NULL; 381 } 382 CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket_XDP( 383 IFDE_XMLNode* pXMLDocumentNode, 384 XFA_XDPPACKET ePacketID) { 385 if (!XFA_FDEExtension_MatchNodeName( 386 pXMLDocumentNode, XFA_GetPacketByIndex(XFA_PACKET_XDP)->pName, 387 XFA_GetPacketByIndex(XFA_PACKET_XDP)->pURI, 388 XFA_GetPacketByIndex(XFA_PACKET_XDP)->eFlags)) { 389 return nullptr; 390 } 391 CXFA_Node* pXFARootNode = 392 m_pFactory->CreateNode(XFA_XDPPACKET_XDP, XFA_ELEMENT_Xfa); 393 if (!pXFARootNode) { 394 return nullptr; 395 } 396 m_pRootNode = pXFARootNode; 397 pXFARootNode->SetCData(XFA_ATTRIBUTE_Name, FX_WSTRC(L"xfa")); 398 { 399 IFDE_XMLElement* pElement = (IFDE_XMLElement*)pXMLDocumentNode; 400 int32_t iAttributeCount = pElement->CountAttributes(); 401 for (int32_t i = 0; i < iAttributeCount; i++) { 402 CFX_WideString wsAttriName, wsAttriValue; 403 pElement->GetAttribute(i, wsAttriName, wsAttriValue); 404 if (wsAttriName == FX_WSTRC(L"uuid")) { 405 pXFARootNode->SetCData(XFA_ATTRIBUTE_Uuid, wsAttriValue); 406 } else if (wsAttriName == FX_WSTRC(L"timeStamp")) { 407 pXFARootNode->SetCData(XFA_ATTRIBUTE_TimeStamp, wsAttriValue); 408 } 409 } 410 } 411 IFDE_XMLNode* pXMLConfigDOMRoot = nullptr; 412 CXFA_Node* pXFAConfigDOMRoot = nullptr; 413 { 414 for (IFDE_XMLNode* pChildItem = 415 pXMLDocumentNode->GetNodeItem(IFDE_XMLNode::FirstChild); 416 pChildItem; 417 pChildItem = pChildItem->GetNodeItem(IFDE_XMLNode::NextSibling)) { 418 XFA_LPCPACKETINFO pPacketInfo = XFA_GetPacketByIndex(XFA_PACKET_Config); 419 if (!XFA_FDEExtension_MatchNodeName(pChildItem, pPacketInfo->pName, 420 pPacketInfo->pURI, 421 pPacketInfo->eFlags)) { 422 continue; 423 } 424 if (pXFARootNode->GetFirstChildByName(pPacketInfo->uHash)) { 425 return nullptr; 426 } 427 pXMLConfigDOMRoot = pChildItem; 428 pXFAConfigDOMRoot = 429 ParseAsXDPPacket_Config(pXMLConfigDOMRoot, XFA_XDPPACKET_Config); 430 pXFARootNode->InsertChild(pXFAConfigDOMRoot, NULL); 431 } 432 } 433 IFDE_XMLNode* pXMLDatasetsDOMRoot = nullptr; 434 IFDE_XMLNode* pXMLFormDOMRoot = nullptr; 435 IFDE_XMLNode* pXMLTemplateDOMRoot = nullptr; 436 { 437 for (IFDE_XMLNode* pChildItem = 438 pXMLDocumentNode->GetNodeItem(IFDE_XMLNode::FirstChild); 439 pChildItem; 440 pChildItem = pChildItem->GetNodeItem(IFDE_XMLNode::NextSibling)) { 441 if (!pChildItem || pChildItem->GetType() != FDE_XMLNODE_Element) { 442 continue; 443 } 444 if (pChildItem == pXMLConfigDOMRoot) { 445 continue; 446 } 447 IFDE_XMLElement* pElement = 448 reinterpret_cast<IFDE_XMLElement*>(pChildItem); 449 CFX_WideString wsPacketName; 450 pElement->GetLocalTagName(wsPacketName); 451 XFA_LPCPACKETINFO pPacketInfo = XFA_GetPacketByName(wsPacketName); 452 if (pPacketInfo && pPacketInfo->pURI) { 453 if (!XFA_FDEExtension_MatchNodeName(pElement, pPacketInfo->pName, 454 pPacketInfo->pURI, 455 pPacketInfo->eFlags)) { 456 pPacketInfo = nullptr; 457 } 458 } 459 XFA_XDPPACKET ePacket = 460 pPacketInfo ? pPacketInfo->eName : XFA_XDPPACKET_USER; 461 if (ePacket == XFA_XDPPACKET_XDP) { 462 continue; 463 } 464 if (ePacket == XFA_XDPPACKET_Datasets) { 465 if (pXMLDatasetsDOMRoot) { 466 return nullptr; 467 } 468 pXMLDatasetsDOMRoot = pElement; 469 } else if (ePacket == XFA_XDPPACKET_Form) { 470 if (pXMLFormDOMRoot) { 471 return nullptr; 472 } 473 pXMLFormDOMRoot = pElement; 474 } else if (ePacket == XFA_XDPPACKET_Template) { 475 if (pXMLTemplateDOMRoot) { 476 // Found a duplicate template packet. 477 return nullptr; 478 } 479 CXFA_Node* pPacketNode = ParseAsXDPPacket(pElement, ePacket); 480 if (pPacketNode) { 481 pXMLTemplateDOMRoot = pElement; 482 pXFARootNode->InsertChild(pPacketNode); 483 } 484 } else { 485 CXFA_Node* pPacketNode = ParseAsXDPPacket(pElement, ePacket); 486 if (pPacketNode) { 487 if (pPacketInfo && 488 (pPacketInfo->eFlags & XFA_XDPPACKET_FLAGS_SUPPORTONE) && 489 pXFARootNode->GetFirstChildByName(pPacketInfo->uHash)) { 490 return nullptr; 491 } 492 pXFARootNode->InsertChild(pPacketNode); 493 } 494 } 495 } 496 } 497 if (!pXMLTemplateDOMRoot) { 498 // No template is found. 499 return nullptr; 500 } 501 if (pXMLDatasetsDOMRoot) { 502 CXFA_Node* pPacketNode = 503 ParseAsXDPPacket(pXMLDatasetsDOMRoot, XFA_XDPPACKET_Datasets); 504 if (pPacketNode) { 505 pXFARootNode->InsertChild(pPacketNode); 506 } 507 } 508 if (pXMLFormDOMRoot) { 509 CXFA_Node* pPacketNode = 510 ParseAsXDPPacket(pXMLFormDOMRoot, XFA_XDPPACKET_Form); 511 if (pPacketNode) { 512 pXFARootNode->InsertChild(pPacketNode); 513 } 514 } 515 pXFARootNode->SetXMLMappingNode(pXMLDocumentNode); 516 return pXFARootNode; 517 } 518 CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket_Config( 519 IFDE_XMLNode* pXMLDocumentNode, 520 XFA_XDPPACKET ePacketID) { 521 if (!XFA_FDEExtension_MatchNodeName( 522 pXMLDocumentNode, XFA_GetPacketByIndex(XFA_PACKET_Config)->pName, 523 XFA_GetPacketByIndex(XFA_PACKET_Config)->pURI, 524 XFA_GetPacketByIndex(XFA_PACKET_Config)->eFlags)) { 525 return NULL; 526 } 527 CXFA_Node* pNode = 528 m_pFactory->CreateNode(XFA_XDPPACKET_Config, XFA_ELEMENT_Config); 529 if (!pNode) { 530 return NULL; 531 } 532 pNode->SetCData(XFA_ATTRIBUTE_Name, 533 XFA_GetPacketByIndex(XFA_PACKET_Config)->pName); 534 if (!NormalLoader(pNode, pXMLDocumentNode, ePacketID)) { 535 return NULL; 536 } 537 pNode->SetXMLMappingNode(pXMLDocumentNode); 538 return pNode; 539 } 540 CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket_TemplateForm( 541 IFDE_XMLNode* pXMLDocumentNode, 542 XFA_XDPPACKET ePacketID) { 543 CXFA_Node* pNode = NULL; 544 if (ePacketID == XFA_XDPPACKET_Template) { 545 if (XFA_FDEExtension_MatchNodeName( 546 pXMLDocumentNode, XFA_GetPacketByIndex(XFA_PACKET_Template)->pName, 547 XFA_GetPacketByIndex(XFA_PACKET_Template)->pURI, 548 XFA_GetPacketByIndex(XFA_PACKET_Template)->eFlags)) { 549 pNode = 550 m_pFactory->CreateNode(XFA_XDPPACKET_Template, XFA_ELEMENT_Template); 551 if (!pNode) { 552 return NULL; 553 } 554 pNode->SetCData(XFA_ATTRIBUTE_Name, 555 XFA_GetPacketByIndex(XFA_PACKET_Template)->pName); 556 if (m_bDocumentParser) { 557 CFX_WideString wsNamespaceURI; 558 IFDE_XMLElement* pXMLDocumentElement = 559 (IFDE_XMLElement*)pXMLDocumentNode; 560 pXMLDocumentElement->GetNamespaceURI(wsNamespaceURI); 561 if (wsNamespaceURI.IsEmpty()) { 562 pXMLDocumentElement->GetString(L"xmlns:xfa", wsNamespaceURI); 563 } 564 pNode->GetDocument()->RecognizeXFAVersionNumber(wsNamespaceURI); 565 } 566 if (!NormalLoader(pNode, pXMLDocumentNode, ePacketID)) { 567 return NULL; 568 } 569 } 570 } else if (ePacketID == XFA_XDPPACKET_Form) { 571 if (XFA_FDEExtension_MatchNodeName( 572 pXMLDocumentNode, XFA_GetPacketByIndex(XFA_PACKET_Form)->pName, 573 XFA_GetPacketByIndex(XFA_PACKET_Form)->pURI, 574 XFA_GetPacketByIndex(XFA_PACKET_Form)->eFlags)) { 575 IFDE_XMLElement* pXMLDocumentElement = (IFDE_XMLElement*)pXMLDocumentNode; 576 CFX_WideString wsChecksum; 577 pXMLDocumentElement->GetString(L"checksum", wsChecksum); 578 #ifdef _XFA_VERIFY_Checksum_ 579 if (wsChecksum.GetLength() != 28 || 580 m_pXMLParser->m_dwCheckStatus != 0x03) { 581 return NULL; 582 } 583 IXFA_ChecksumContext* pChecksum = XFA_Checksum_Create(); 584 pChecksum->StartChecksum(); 585 pChecksum->UpdateChecksum(m_pFileRead, m_pXMLParser->m_nStart[0], 586 m_pXMLParser->m_nSize[0]); 587 pChecksum->UpdateChecksum(m_pFileRead, m_pXMLParser->m_nStart[1], 588 m_pXMLParser->m_nSize[1]); 589 pChecksum->FinishChecksum(); 590 CFX_ByteString bsCheck; 591 pChecksum->GetChecksum(bsCheck); 592 pChecksum->Release(); 593 if (bsCheck != wsChecksum.UTF8Encode()) { 594 return NULL; 595 } 596 #endif 597 pNode = m_pFactory->CreateNode(XFA_XDPPACKET_Form, XFA_ELEMENT_Form); 598 if (!pNode) { 599 return NULL; 600 } 601 pNode->SetCData(XFA_ATTRIBUTE_Name, 602 XFA_GetPacketByIndex(XFA_PACKET_Form)->pName); 603 pNode->SetAttribute(XFA_ATTRIBUTE_Checksum, wsChecksum); 604 CXFA_Node* pTemplateRoot = 605 m_pRootNode->GetFirstChildByClass(XFA_ELEMENT_Template); 606 CXFA_Node* pTemplateChosen = 607 pTemplateRoot 608 ? pTemplateRoot->GetFirstChildByClass(XFA_ELEMENT_Subform) 609 : NULL; 610 FX_BOOL bUseAttribute = TRUE; 611 if (pTemplateChosen && 612 pTemplateChosen->GetEnum(XFA_ATTRIBUTE_RestoreState) != 613 XFA_ATTRIBUTEENUM_Auto) { 614 bUseAttribute = FALSE; 615 } 616 if (!NormalLoader(pNode, pXMLDocumentNode, ePacketID, bUseAttribute)) { 617 return NULL; 618 } 619 } 620 } 621 if (pNode) { 622 pNode->SetXMLMappingNode(pXMLDocumentNode); 623 } 624 return pNode; 625 } 626 static IFDE_XMLNode* XFA_GetDataSetsFromXDP(IFDE_XMLNode* pXMLDocumentNode) { 627 if (XFA_FDEExtension_MatchNodeName( 628 pXMLDocumentNode, XFA_GetPacketByIndex(XFA_PACKET_Datasets)->pName, 629 XFA_GetPacketByIndex(XFA_PACKET_Datasets)->pURI, 630 XFA_GetPacketByIndex(XFA_PACKET_Datasets)->eFlags)) { 631 return pXMLDocumentNode; 632 } 633 if (!XFA_FDEExtension_MatchNodeName( 634 pXMLDocumentNode, XFA_GetPacketByIndex(XFA_PACKET_XDP)->pName, 635 XFA_GetPacketByIndex(XFA_PACKET_XDP)->pURI, 636 XFA_GetPacketByIndex(XFA_PACKET_XDP)->eFlags)) { 637 return NULL; 638 } 639 for (IFDE_XMLNode* pDatasetsNode = 640 pXMLDocumentNode->GetNodeItem(IFDE_XMLNode::FirstChild); 641 pDatasetsNode; 642 pDatasetsNode = pDatasetsNode->GetNodeItem(IFDE_XMLNode::NextSibling)) { 643 if (!XFA_FDEExtension_MatchNodeName( 644 pDatasetsNode, XFA_GetPacketByIndex(XFA_PACKET_Datasets)->pName, 645 XFA_GetPacketByIndex(XFA_PACKET_Datasets)->pURI, 646 XFA_GetPacketByIndex(XFA_PACKET_Datasets)->eFlags)) { 647 continue; 648 } 649 return pDatasetsNode; 650 } 651 return NULL; 652 } 653 CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket_Data( 654 IFDE_XMLNode* pXMLDocumentNode, 655 XFA_XDPPACKET ePacketID) { 656 IFDE_XMLNode* pDatasetsXMLNode = XFA_GetDataSetsFromXDP(pXMLDocumentNode); 657 if (pDatasetsXMLNode) { 658 CXFA_Node* pNode = 659 m_pFactory->CreateNode(XFA_XDPPACKET_Datasets, XFA_ELEMENT_DataModel); 660 if (!pNode) { 661 return NULL; 662 } 663 pNode->SetCData(XFA_ATTRIBUTE_Name, 664 XFA_GetPacketByIndex(XFA_PACKET_Datasets)->pName); 665 if (!DataLoader(pNode, pDatasetsXMLNode, FALSE)) { 666 return NULL; 667 } 668 pNode->SetXMLMappingNode(pDatasetsXMLNode); 669 return pNode; 670 } 671 IFDE_XMLNode* pDataXMLNode = NULL; 672 if (XFA_FDEExtension_MatchNodeName( 673 pXMLDocumentNode, FX_WSTRC(L"data"), 674 XFA_GetPacketByIndex(XFA_PACKET_Datasets)->pURI, 675 XFA_GetPacketByIndex(XFA_PACKET_Datasets)->eFlags)) { 676 ((IFDE_XMLElement*)pXMLDocumentNode)->RemoveAttribute(L"xmlns:xfa"); 677 pDataXMLNode = pXMLDocumentNode; 678 } else { 679 IFDE_XMLElement* pDataElement = 680 IFDE_XMLElement::Create(FX_WSTRC(L"xfa:data")); 681 IFDE_XMLNode* pParentXMLNode = 682 pXMLDocumentNode->GetNodeItem(IFDE_XMLNode::Parent); 683 if (pParentXMLNode) { 684 pParentXMLNode->RemoveChildNode(pXMLDocumentNode); 685 } 686 FXSYS_assert(pXMLDocumentNode->GetType() == FDE_XMLNODE_Element); 687 if (pXMLDocumentNode->GetType() == FDE_XMLNODE_Element) { 688 ((IFDE_XMLElement*)pXMLDocumentNode)->RemoveAttribute(L"xmlns:xfa"); 689 } 690 pDataElement->InsertChildNode(pXMLDocumentNode); 691 pDataXMLNode = pDataElement; 692 } 693 if (pDataXMLNode) { 694 CXFA_Node* pNode = 695 m_pFactory->CreateNode(XFA_XDPPACKET_Datasets, XFA_ELEMENT_DataGroup); 696 if (!pNode) { 697 if (pDataXMLNode != pXMLDocumentNode) { 698 pDataXMLNode->Release(); 699 } 700 return NULL; 701 } 702 CFX_WideString wsLocalName; 703 ((IFDE_XMLElement*)pDataXMLNode)->GetLocalTagName(wsLocalName); 704 pNode->SetCData(XFA_ATTRIBUTE_Name, wsLocalName); 705 if (!DataLoader(pNode, pDataXMLNode, TRUE)) { 706 return NULL; 707 } 708 pNode->SetXMLMappingNode(pDataXMLNode); 709 if (pDataXMLNode != pXMLDocumentNode) { 710 pNode->SetFlag(XFA_NODEFLAG_OwnXMLNode, TRUE, FALSE); 711 } 712 return pNode; 713 } 714 return NULL; 715 } 716 CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket_LocaleConnectionSourceSet( 717 IFDE_XMLNode* pXMLDocumentNode, 718 XFA_XDPPACKET ePacketID) { 719 CXFA_Node* pNode = NULL; 720 if (ePacketID == XFA_XDPPACKET_LocaleSet) { 721 if (XFA_FDEExtension_MatchNodeName( 722 pXMLDocumentNode, XFA_GetPacketByIndex(XFA_PACKET_LocaleSet)->pName, 723 XFA_GetPacketByIndex(XFA_PACKET_LocaleSet)->pURI, 724 XFA_GetPacketByIndex(XFA_PACKET_LocaleSet)->eFlags)) { 725 pNode = m_pFactory->CreateNode(XFA_XDPPACKET_LocaleSet, 726 XFA_ELEMENT_LocaleSet); 727 if (!pNode) { 728 return NULL; 729 } 730 pNode->SetCData(XFA_ATTRIBUTE_Name, 731 XFA_GetPacketByIndex(XFA_PACKET_LocaleSet)->pName); 732 if (!NormalLoader(pNode, pXMLDocumentNode, ePacketID)) { 733 return NULL; 734 } 735 } 736 } else if (ePacketID == XFA_XDPPACKET_ConnectionSet) { 737 if (XFA_FDEExtension_MatchNodeName( 738 pXMLDocumentNode, 739 XFA_GetPacketByIndex(XFA_PACKET_ConnectionSet)->pName, 740 XFA_GetPacketByIndex(XFA_PACKET_ConnectionSet)->pURI, 741 XFA_GetPacketByIndex(XFA_PACKET_ConnectionSet)->eFlags)) { 742 pNode = m_pFactory->CreateNode(XFA_XDPPACKET_ConnectionSet, 743 XFA_ELEMENT_ConnectionSet); 744 if (!pNode) { 745 return NULL; 746 } 747 pNode->SetCData(XFA_ATTRIBUTE_Name, 748 XFA_GetPacketByIndex(XFA_PACKET_ConnectionSet)->pName); 749 if (!NormalLoader(pNode, pXMLDocumentNode, ePacketID)) { 750 return NULL; 751 } 752 } 753 } else if (ePacketID == XFA_XDPPACKET_SourceSet) { 754 if (XFA_FDEExtension_MatchNodeName( 755 pXMLDocumentNode, XFA_GetPacketByIndex(XFA_PACKET_SourceSet)->pName, 756 XFA_GetPacketByIndex(XFA_PACKET_SourceSet)->pURI, 757 XFA_GetPacketByIndex(XFA_PACKET_SourceSet)->eFlags)) { 758 pNode = m_pFactory->CreateNode(XFA_XDPPACKET_SourceSet, 759 XFA_ELEMENT_SourceSet); 760 if (!pNode) { 761 return NULL; 762 } 763 pNode->SetCData(XFA_ATTRIBUTE_Name, 764 XFA_GetPacketByIndex(XFA_PACKET_SourceSet)->pName); 765 if (!NormalLoader(pNode, pXMLDocumentNode, ePacketID)) { 766 return NULL; 767 } 768 } 769 } 770 if (pNode) { 771 pNode->SetXMLMappingNode(pXMLDocumentNode); 772 } 773 return pNode; 774 } 775 CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket_Xdc( 776 IFDE_XMLNode* pXMLDocumentNode, 777 XFA_XDPPACKET ePacketID) { 778 if (XFA_FDEExtension_MatchNodeName( 779 pXMLDocumentNode, XFA_GetPacketByIndex(XFA_PACKET_Xdc)->pName, 780 XFA_GetPacketByIndex(XFA_PACKET_Xdc)->pURI, 781 XFA_GetPacketByIndex(XFA_PACKET_Xdc)->eFlags)) { 782 CXFA_Node* pNode = 783 m_pFactory->CreateNode(XFA_XDPPACKET_Xdc, XFA_ELEMENT_Xdc); 784 if (!pNode) { 785 return NULL; 786 } 787 pNode->SetCData(XFA_ATTRIBUTE_Name, 788 XFA_GetPacketByIndex(XFA_PACKET_Xdc)->pName); 789 pNode->SetXMLMappingNode(pXMLDocumentNode); 790 return pNode; 791 } 792 return NULL; 793 } 794 CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket_User( 795 IFDE_XMLNode* pXMLDocumentNode, 796 XFA_XDPPACKET ePacketID) { 797 CXFA_Node* pNode = 798 m_pFactory->CreateNode(XFA_XDPPACKET_XDP, XFA_ELEMENT_Packet); 799 if (!pNode) { 800 return NULL; 801 } 802 CFX_WideString wsName; 803 ((IFDE_XMLElement*)pXMLDocumentNode)->GetLocalTagName(wsName); 804 pNode->SetCData(XFA_ATTRIBUTE_Name, wsName); 805 if (!UserPacketLoader(pNode, pXMLDocumentNode)) { 806 return NULL; 807 } 808 pNode->SetXMLMappingNode(pXMLDocumentNode); 809 return pNode; 810 } 811 CXFA_Node* CXFA_SimpleParser::UserPacketLoader(CXFA_Node* pXFANode, 812 IFDE_XMLNode* pXMLDoc) { 813 return pXFANode; 814 } 815 static FX_BOOL XFA_FDEExtension_IsStringAllWhitespace(CFX_WideString wsText) { 816 wsText.TrimRight(L"\x20\x9\xD\xA"); 817 return wsText.IsEmpty(); 818 } 819 CXFA_Node* CXFA_SimpleParser::DataLoader(CXFA_Node* pXFANode, 820 IFDE_XMLNode* pXMLDoc, 821 FX_BOOL bDoTransform) { 822 ParseDataGroup(pXFANode, pXMLDoc, XFA_XDPPACKET_Datasets); 823 return pXFANode; 824 } 825 CXFA_Node* CXFA_SimpleParser::NormalLoader(CXFA_Node* pXFANode, 826 IFDE_XMLNode* pXMLDoc, 827 XFA_XDPPACKET ePacketID, 828 FX_BOOL bUseAttribute) { 829 FX_BOOL bOneOfPropertyFound = FALSE; 830 for (IFDE_XMLNode* pXMLChild = pXMLDoc->GetNodeItem(IFDE_XMLNode::FirstChild); 831 pXMLChild; 832 pXMLChild = pXMLChild->GetNodeItem(IFDE_XMLNode::NextSibling)) { 833 switch (pXMLChild->GetType()) { 834 case FDE_XMLNODE_Element: { 835 IFDE_XMLElement* pXMLElement = (IFDE_XMLElement*)pXMLChild; 836 CFX_WideString wsTagName; 837 pXMLElement->GetLocalTagName(wsTagName); 838 XFA_LPCELEMENTINFO pElemInfo = XFA_GetElementByName(wsTagName); 839 if (!pElemInfo) { 840 continue; 841 } 842 XFA_LPCPROPERTY pPropertyInfo = XFA_GetPropertyOfElement( 843 pXFANode->GetClassID(), pElemInfo->eName, ePacketID); 844 if (pPropertyInfo && 845 ((pPropertyInfo->uFlags & 846 (XFA_PROPERTYFLAG_OneOf | XFA_PROPERTYFLAG_DefaultOneOf)) != 0)) { 847 if (bOneOfPropertyFound) { 848 break; 849 } 850 bOneOfPropertyFound = TRUE; 851 } 852 CXFA_Node* pXFAChild = 853 m_pFactory->CreateNode(ePacketID, pElemInfo->eName); 854 if (pXFAChild == NULL) { 855 return NULL; 856 } 857 if (ePacketID == XFA_XDPPACKET_Config) { 858 pXFAChild->SetAttribute(XFA_ATTRIBUTE_Name, wsTagName); 859 } 860 FX_BOOL IsNeedValue = TRUE; 861 for (int32_t i = 0, count = pXMLElement->CountAttributes(); i < count; 862 i++) { 863 CFX_WideString wsAttrQualifiedName; 864 CFX_WideString wsAttrName; 865 CFX_WideString wsAttrValue; 866 pXMLElement->GetAttribute(i, wsAttrQualifiedName, wsAttrValue); 867 XFA_FDEExtension_GetAttributeLocalName(wsAttrQualifiedName, 868 wsAttrName); 869 if (wsAttrName == FX_WSTRC(L"nil") && 870 wsAttrValue == FX_WSTRC(L"true")) { 871 IsNeedValue = FALSE; 872 } 873 XFA_LPCATTRIBUTEINFO lpAttrInfo = XFA_GetAttributeByName(wsAttrName); 874 if (!lpAttrInfo) { 875 continue; 876 } 877 if (!bUseAttribute && lpAttrInfo->eName != XFA_ATTRIBUTE_Name && 878 lpAttrInfo->eName != XFA_ATTRIBUTE_Save) { 879 continue; 880 } 881 pXFAChild->SetAttribute(lpAttrInfo->eName, wsAttrValue); 882 } 883 pXFANode->InsertChild(pXFAChild); 884 if (pElemInfo->eName == XFA_ELEMENT_Validate || 885 pElemInfo->eName == XFA_ELEMENT_Locale) { 886 if (ePacketID == XFA_XDPPACKET_Config) { 887 ParseContentNode(pXFAChild, pXMLElement, ePacketID); 888 } else { 889 NormalLoader(pXFAChild, pXMLElement, ePacketID, bUseAttribute); 890 } 891 break; 892 } 893 switch (pXFAChild->GetObjectType()) { 894 case XFA_OBJECTTYPE_ContentNode: 895 case XFA_OBJECTTYPE_TextNode: 896 case XFA_OBJECTTYPE_NodeC: 897 case XFA_OBJECTTYPE_NodeV: 898 if (IsNeedValue) { 899 ParseContentNode(pXFAChild, pXMLElement, ePacketID); 900 } 901 break; 902 default: 903 NormalLoader(pXFAChild, pXMLElement, ePacketID, bUseAttribute); 904 break; 905 } 906 } break; 907 case FDE_XMLNODE_Instruction: 908 ParseInstruction(pXFANode, (IFDE_XMLInstruction*)pXMLChild, ePacketID); 909 break; 910 default: 911 break; 912 } 913 } 914 return pXFANode; 915 } 916 FX_BOOL XFA_RecognizeRichText(IFDE_XMLElement* pRichTextXMLNode) { 917 if (pRichTextXMLNode) { 918 CFX_WideString wsNamespaceURI; 919 XFA_FDEExtension_GetElementTagNamespaceURI(pRichTextXMLNode, 920 wsNamespaceURI); 921 if (wsNamespaceURI == FX_WSTRC(L"http://www.w3.org/1999/xhtml")) { 922 return TRUE; 923 } 924 } 925 return FALSE; 926 } 927 class RichTextNodeVisitor { 928 public: 929 static inline IFDE_XMLNode* GetFirstChild(IFDE_XMLNode* pNode) { 930 return pNode->GetNodeItem(IFDE_XMLNode::FirstChild); 931 } 932 static inline IFDE_XMLNode* GetNextSibling(IFDE_XMLNode* pNode) { 933 return pNode->GetNodeItem(IFDE_XMLNode::NextSibling); 934 } 935 static inline IFDE_XMLNode* GetParent(IFDE_XMLNode* pNode) { 936 return pNode->GetNodeItem(IFDE_XMLNode::Parent); 937 } 938 }; 939 #ifndef XFA_PARSE_HAS_LINEIDENTIFIER 940 void XFA_ConvertRichTextToPlainText(IFDE_XMLElement* pRichTextXMLNode, 941 CFX_WideString& wsOutput) { 942 CXFA_NodeIteratorTemplate<IFDE_XMLNode, RichTextNodeVisitor> sIterator( 943 pRichTextXMLNode); 944 CFX_WideTextBuf wsPlainTextBuf; 945 for (IFDE_XMLNode* pNode = sIterator.GetCurrent(); pNode; 946 pNode = sIterator.MoveToNext()) { 947 switch (pNode->GetType()) { 948 case FDE_XMLNODE_Text: { 949 CFX_WideString wsText; 950 ((IFDE_XMLText*)pNode)->GetText(wsText); 951 wsPlainTextBuf << wsText; 952 } break; 953 case FDE_XMLNODE_CharData: { 954 CFX_WideString wsText; 955 ((IFDE_XMLCharData*)pNode)->GetCharData(wsText); 956 wsPlainTextBuf << wsText; 957 } break; 958 default: 959 break; 960 } 961 } 962 wsOutput = wsPlainTextBuf.GetWideString(); 963 } 964 #endif 965 void XFA_ConvertXMLToPlainText(IFDE_XMLElement* pRootXMLNode, 966 CFX_WideString& wsOutput) { 967 for (IFDE_XMLNode* pXMLChild = 968 pRootXMLNode->GetNodeItem(IFDE_XMLNode::FirstChild); 969 pXMLChild; 970 pXMLChild = pXMLChild->GetNodeItem(IFDE_XMLNode::NextSibling)) { 971 #ifdef _DEBUG 972 FDE_XMLNODETYPE nodeType = pXMLChild->GetType(); 973 #endif 974 switch (pXMLChild->GetType()) { 975 case FDE_XMLNODE_Element: { 976 CFX_WideString wsTextData; 977 ((IFDE_XMLElement*)pXMLChild)->GetTextData(wsTextData); 978 wsTextData += FX_WSTRC(L"\n"); 979 wsOutput += wsTextData; 980 } break; 981 case FDE_XMLNODE_Text: { 982 CFX_WideString wsText; 983 ((IFDE_XMLText*)pXMLChild)->GetText(wsText); 984 if (XFA_FDEExtension_IsStringAllWhitespace(wsText)) { 985 continue; 986 } else { 987 wsOutput = wsText; 988 } 989 } break; 990 case FDE_XMLNODE_CharData: { 991 CFX_WideString wsCharData; 992 ((IFDE_XMLCharData*)pXMLChild)->GetCharData(wsCharData); 993 if (XFA_FDEExtension_IsStringAllWhitespace(wsCharData)) { 994 continue; 995 } else { 996 wsOutput = wsCharData; 997 } 998 } break; 999 default: 1000 FXSYS_assert(FALSE); 1001 break; 1002 } 1003 } 1004 } 1005 void CXFA_SimpleParser::ParseContentNode(CXFA_Node* pXFANode, 1006 IFDE_XMLNode* pXMLNode, 1007 XFA_XDPPACKET ePacketID) { 1008 XFA_ELEMENT element = XFA_ELEMENT_Sharptext; 1009 if (pXFANode->GetClassID() == XFA_ELEMENT_ExData) { 1010 CFX_WideStringC wsContentType = 1011 pXFANode->GetCData(XFA_ATTRIBUTE_ContentType); 1012 if (wsContentType == FX_WSTRC(L"text/html")) { 1013 element = XFA_ELEMENT_SharpxHTML; 1014 } else if (wsContentType == FX_WSTRC(L"text/xml")) { 1015 element = XFA_ELEMENT_Sharpxml; 1016 } 1017 } 1018 if (element == XFA_ELEMENT_SharpxHTML) { 1019 pXFANode->SetXMLMappingNode(pXMLNode); 1020 } 1021 CFX_WideString wsValue; 1022 for (IFDE_XMLNode* pXMLChild = 1023 pXMLNode->GetNodeItem(IFDE_XMLNode::FirstChild); 1024 pXMLChild; 1025 pXMLChild = pXMLChild->GetNodeItem(IFDE_XMLNode::NextSibling)) { 1026 FDE_XMLNODETYPE eNodeType = pXMLChild->GetType(); 1027 if (eNodeType == FDE_XMLNODE_Instruction) { 1028 continue; 1029 } 1030 if (element == XFA_ELEMENT_SharpxHTML) { 1031 if (eNodeType != FDE_XMLNODE_Element) { 1032 break; 1033 } 1034 if (XFA_RecognizeRichText((IFDE_XMLElement*)pXMLChild)) { 1035 #ifdef XFA_PARSE_HAS_LINEIDENTIFIER 1036 XFA_GetPlainTextFromRichText((IFDE_XMLElement*)pXMLChild, wsValue); 1037 #else 1038 XFA_ConvertRichTextToPlainText((IFDE_XMLElement*)pXMLChild, wsValue); 1039 #endif 1040 } 1041 } else if (element == XFA_ELEMENT_Sharpxml) { 1042 if (eNodeType != FDE_XMLNODE_Element) { 1043 break; 1044 } 1045 XFA_ConvertXMLToPlainText((IFDE_XMLElement*)pXMLChild, wsValue); 1046 } else { 1047 if (eNodeType == FDE_XMLNODE_Element) { 1048 break; 1049 } 1050 if (eNodeType == FDE_XMLNODE_Text) { 1051 ((IFDE_XMLText*)pXMLChild)->GetText(wsValue); 1052 } else if (eNodeType == FDE_XMLNODE_CharData) { 1053 ((IFDE_XMLCharData*)pXMLChild)->GetCharData(wsValue); 1054 } 1055 } 1056 break; 1057 } 1058 if (!wsValue.IsEmpty()) { 1059 if (pXFANode->GetObjectType() == XFA_OBJECTTYPE_ContentNode) { 1060 CXFA_Node* pContentRawDataNode = 1061 m_pFactory->CreateNode(ePacketID, element); 1062 FXSYS_assert(pContentRawDataNode); 1063 pContentRawDataNode->SetCData(XFA_ATTRIBUTE_Value, wsValue); 1064 pXFANode->InsertChild(pContentRawDataNode); 1065 } else { 1066 pXFANode->SetCData(XFA_ATTRIBUTE_Value, wsValue); 1067 } 1068 } 1069 } 1070 void CXFA_SimpleParser::ParseDataGroup(CXFA_Node* pXFANode, 1071 IFDE_XMLNode* pXMLNode, 1072 XFA_XDPPACKET ePacketID) { 1073 for (IFDE_XMLNode* pXMLChild = 1074 pXMLNode->GetNodeItem(IFDE_XMLNode::FirstChild); 1075 pXMLChild; 1076 pXMLChild = pXMLChild->GetNodeItem(IFDE_XMLNode::NextSibling)) { 1077 switch (pXMLChild->GetType()) { 1078 case FDE_XMLNODE_Element: { 1079 IFDE_XMLElement* pXMLElement = (IFDE_XMLElement*)pXMLChild; 1080 { 1081 CFX_WideString wsNamespaceURI; 1082 XFA_FDEExtension_GetElementTagNamespaceURI(pXMLElement, 1083 wsNamespaceURI); 1084 if (wsNamespaceURI == 1085 FX_WSTRC(L"http://www.xfa.com/schema/xfa-package/") || 1086 wsNamespaceURI == 1087 FX_WSTRC(L"http://www.xfa.org/schema/xfa-package/") || 1088 wsNamespaceURI == 1089 FX_WSTRC(L"http://www.w3.org/2001/XMLSchema-instance")) { 1090 continue; 1091 } 1092 if (0) { 1093 continue; 1094 } 1095 } 1096 XFA_ELEMENT eNodeType = XFA_ELEMENT_DataModel; 1097 if (eNodeType == XFA_ELEMENT_DataModel) { 1098 CFX_WideString wsDataNodeAttr; 1099 if (XFA_FDEExtension_FindAttributeWithNS( 1100 pXMLElement, FX_WSTRC(L"dataNode"), 1101 FX_WSTRC(L"http://www.xfa.org/schema/xfa-data/1.0/"), 1102 wsDataNodeAttr)) { 1103 if (wsDataNodeAttr == FX_WSTRC(L"dataGroup")) { 1104 eNodeType = XFA_ELEMENT_DataGroup; 1105 } else if (wsDataNodeAttr == FX_WSTRC(L"dataValue")) { 1106 eNodeType = XFA_ELEMENT_DataValue; 1107 } 1108 } 1109 } 1110 CFX_WideString wsContentType; 1111 if (eNodeType == XFA_ELEMENT_DataModel) { 1112 if (XFA_FDEExtension_FindAttributeWithNS( 1113 pXMLElement, FX_WSTRC(L"contentType"), 1114 FX_WSTRC(L"http://www.xfa.org/schema/xfa-data/1.0/"), 1115 wsContentType)) { 1116 if (!wsContentType.IsEmpty()) { 1117 eNodeType = XFA_ELEMENT_DataValue; 1118 } 1119 } 1120 } 1121 if (eNodeType == XFA_ELEMENT_DataModel) { 1122 for (IFDE_XMLNode* pXMLDataChild = 1123 pXMLElement->GetNodeItem(IFDE_XMLNode::FirstChild); 1124 pXMLDataChild; pXMLDataChild = pXMLDataChild->GetNodeItem( 1125 IFDE_XMLNode::NextSibling)) { 1126 if (pXMLDataChild->GetType() == FDE_XMLNODE_Element) { 1127 if (!XFA_RecognizeRichText((IFDE_XMLElement*)pXMLDataChild)) { 1128 eNodeType = XFA_ELEMENT_DataGroup; 1129 break; 1130 } 1131 } 1132 } 1133 } 1134 if (eNodeType == XFA_ELEMENT_DataModel) { 1135 eNodeType = XFA_ELEMENT_DataValue; 1136 } 1137 CXFA_Node* pXFAChild = 1138 m_pFactory->CreateNode(XFA_XDPPACKET_Datasets, eNodeType); 1139 if (pXFAChild == NULL) { 1140 return; 1141 } 1142 CFX_WideString wsNodeName; 1143 pXMLElement->GetLocalTagName(wsNodeName); 1144 pXFAChild->SetCData(XFA_ATTRIBUTE_Name, wsNodeName); 1145 FX_BOOL bNeedValue = TRUE; 1146 if (1) { 1147 for (int32_t i = 0, count = pXMLElement->CountAttributes(); i < count; 1148 i++) { 1149 CFX_WideString wsAttrQualifiedName; 1150 CFX_WideString wsAttrValue; 1151 CFX_WideString wsAttrName; 1152 CFX_WideString wsAttrNamespaceURI; 1153 pXMLElement->GetAttribute(i, wsAttrQualifiedName, wsAttrValue); 1154 if (!XFA_FDEExtension_ResolveAttribute( 1155 pXMLElement, wsAttrQualifiedName, wsAttrName, 1156 wsAttrNamespaceURI)) { 1157 continue; 1158 } 1159 if (wsAttrName == FX_WSTRC(L"nil") && 1160 wsAttrValue == FX_WSTRC(L"true")) { 1161 bNeedValue = FALSE; 1162 continue; 1163 } 1164 if (wsAttrNamespaceURI == 1165 FX_WSTRC(L"http://www.xfa.com/schema/xfa-package/") || 1166 wsAttrNamespaceURI == 1167 FX_WSTRC(L"http://www.xfa.org/schema/xfa-package/") || 1168 wsAttrNamespaceURI == 1169 FX_WSTRC(L"http://www.w3.org/2001/XMLSchema-instance") || 1170 wsAttrNamespaceURI == 1171 FX_WSTRC(L"http://www.xfa.org/schema/xfa-data/1.0/")) { 1172 continue; 1173 } 1174 if (0) { 1175 continue; 1176 } 1177 CXFA_Node* pXFAMetaData = m_pFactory->CreateNode( 1178 XFA_XDPPACKET_Datasets, XFA_ELEMENT_DataValue); 1179 if (pXFAMetaData == NULL) { 1180 return; 1181 } 1182 pXFAMetaData->SetCData(XFA_ATTRIBUTE_Name, wsAttrName); 1183 pXFAMetaData->SetCData(XFA_ATTRIBUTE_QualifiedName, 1184 wsAttrQualifiedName); 1185 pXFAMetaData->SetCData(XFA_ATTRIBUTE_Value, wsAttrValue); 1186 pXFAMetaData->SetEnum(XFA_ATTRIBUTE_Contains, 1187 XFA_ATTRIBUTEENUM_MetaData); 1188 pXFAChild->InsertChild(pXFAMetaData); 1189 pXFAMetaData->SetXMLMappingNode(pXMLElement); 1190 pXFAMetaData->SetFlag(XFA_NODEFLAG_Initialized, TRUE, FALSE); 1191 } 1192 if (!bNeedValue) { 1193 CFX_WideString wsNilName = FX_WSTRC(L"xsi:nil"); 1194 pXMLElement->RemoveAttribute(wsNilName); 1195 } 1196 } 1197 pXFANode->InsertChild(pXFAChild); 1198 if (eNodeType == XFA_ELEMENT_DataGroup) { 1199 ParseDataGroup(pXFAChild, pXMLElement, ePacketID); 1200 } else { 1201 if (bNeedValue) { 1202 ParseDataValue(pXFAChild, pXMLChild, XFA_XDPPACKET_Datasets); 1203 } 1204 } 1205 pXFAChild->SetXMLMappingNode(pXMLElement); 1206 pXFAChild->SetFlag(XFA_NODEFLAG_Initialized, TRUE, FALSE); 1207 } 1208 continue; 1209 case FDE_XMLNODE_CharData: { 1210 IFDE_XMLCharData* pXMLCharData = (IFDE_XMLCharData*)pXMLChild; 1211 CFX_WideString wsCharData; 1212 pXMLCharData->GetCharData(wsCharData); 1213 if (XFA_FDEExtension_IsStringAllWhitespace(wsCharData)) { 1214 continue; 1215 } 1216 CXFA_Node* pXFAChild = m_pFactory->CreateNode(XFA_XDPPACKET_Datasets, 1217 XFA_ELEMENT_DataValue); 1218 if (pXFAChild == NULL) { 1219 return; 1220 } 1221 pXFAChild->SetCData(XFA_ATTRIBUTE_Value, wsCharData); 1222 pXFANode->InsertChild(pXFAChild); 1223 pXFAChild->SetXMLMappingNode(pXMLCharData); 1224 pXFAChild->SetFlag(XFA_NODEFLAG_Initialized, TRUE, FALSE); 1225 } 1226 continue; 1227 case FDE_XMLNODE_Text: { 1228 IFDE_XMLText* pXMLText = (IFDE_XMLText*)pXMLChild; 1229 CFX_WideString wsText; 1230 pXMLText->GetText(wsText); 1231 if (XFA_FDEExtension_IsStringAllWhitespace(wsText)) { 1232 continue; 1233 } 1234 CXFA_Node* pXFAChild = m_pFactory->CreateNode(XFA_XDPPACKET_Datasets, 1235 XFA_ELEMENT_DataValue); 1236 if (pXFAChild == NULL) { 1237 return; 1238 } 1239 pXFAChild->SetCData(XFA_ATTRIBUTE_Value, wsText); 1240 pXFANode->InsertChild(pXFAChild); 1241 pXFAChild->SetXMLMappingNode(pXMLText); 1242 pXFAChild->SetFlag(XFA_NODEFLAG_Initialized, TRUE, FALSE); 1243 } 1244 continue; 1245 case FDE_XMLNODE_Instruction: 1246 continue; 1247 default: 1248 continue; 1249 } 1250 } 1251 } 1252 void CXFA_SimpleParser::ParseDataValue(CXFA_Node* pXFANode, 1253 IFDE_XMLNode* pXMLNode, 1254 XFA_XDPPACKET ePacketID) { 1255 CFX_WideTextBuf wsValueTextBuf; 1256 CFX_WideTextBuf wsCurValueTextBuf; 1257 FX_BOOL bMarkAsCompound = FALSE; 1258 IFDE_XMLNode* pXMLCurValueNode = NULL; 1259 for (IFDE_XMLNode* pXMLChild = 1260 pXMLNode->GetNodeItem(IFDE_XMLNode::FirstChild); 1261 pXMLChild; 1262 pXMLChild = pXMLChild->GetNodeItem(IFDE_XMLNode::NextSibling)) { 1263 FDE_XMLNODETYPE eNodeType = pXMLChild->GetType(); 1264 if (eNodeType == FDE_XMLNODE_Instruction) { 1265 continue; 1266 } 1267 CFX_WideString wsText; 1268 if (eNodeType == FDE_XMLNODE_Text) { 1269 ((IFDE_XMLText*)pXMLChild)->GetText(wsText); 1270 if (!pXMLCurValueNode) { 1271 pXMLCurValueNode = pXMLChild; 1272 } 1273 wsCurValueTextBuf << wsText; 1274 } else if (eNodeType == FDE_XMLNODE_CharData) { 1275 ((IFDE_XMLCharData*)pXMLChild)->GetCharData(wsText); 1276 if (!pXMLCurValueNode) { 1277 pXMLCurValueNode = pXMLChild; 1278 } 1279 wsCurValueTextBuf << wsText; 1280 } else if (XFA_RecognizeRichText((IFDE_XMLElement*)pXMLChild)) { 1281 #ifdef XFA_PARSE_HAS_LINEIDENTIFIER 1282 XFA_GetPlainTextFromRichText((IFDE_XMLElement*)pXMLChild, wsText); 1283 #else 1284 XFA_ConvertRichTextToPlainText((IFDE_XMLElement*)pXMLChild, wsText); 1285 #endif 1286 if (!pXMLCurValueNode) { 1287 pXMLCurValueNode = pXMLChild; 1288 } 1289 wsCurValueTextBuf << wsText; 1290 } else { 1291 bMarkAsCompound = TRUE; 1292 if (pXMLCurValueNode) { 1293 CFX_WideStringC wsCurValue = wsCurValueTextBuf.GetWideString(); 1294 if (!wsCurValue.IsEmpty()) { 1295 CXFA_Node* pXFAChild = 1296 m_pFactory->CreateNode(ePacketID, XFA_ELEMENT_DataValue); 1297 if (pXFAChild == NULL) { 1298 return; 1299 } 1300 pXFAChild->SetCData(XFA_ATTRIBUTE_Name, FX_WSTRC(L"")); 1301 pXFAChild->SetCData(XFA_ATTRIBUTE_Value, wsCurValue); 1302 pXFANode->InsertChild(pXFAChild); 1303 pXFAChild->SetXMLMappingNode(pXMLCurValueNode); 1304 pXFAChild->SetFlag(XFA_NODEFLAG_Initialized, TRUE, FALSE); 1305 wsValueTextBuf << wsCurValue; 1306 wsCurValueTextBuf.Clear(); 1307 } 1308 pXMLCurValueNode = NULL; 1309 } 1310 CXFA_Node* pXFAChild = 1311 m_pFactory->CreateNode(ePacketID, XFA_ELEMENT_DataValue); 1312 if (pXFAChild == NULL) { 1313 return; 1314 } 1315 CFX_WideString wsNodeStr; 1316 ((IFDE_XMLElement*)pXMLChild)->GetLocalTagName(wsNodeStr); 1317 pXFAChild->SetCData(XFA_ATTRIBUTE_Name, wsNodeStr); 1318 ParseDataValue(pXFAChild, pXMLChild, ePacketID); 1319 pXFANode->InsertChild(pXFAChild); 1320 pXFAChild->SetXMLMappingNode(pXMLChild); 1321 pXFAChild->SetFlag(XFA_NODEFLAG_Initialized, TRUE, FALSE); 1322 CFX_WideStringC wsCurValue = pXFAChild->GetCData(XFA_ATTRIBUTE_Value); 1323 wsValueTextBuf << wsCurValue; 1324 } 1325 } 1326 if (pXMLCurValueNode) { 1327 CFX_WideStringC wsCurValue = wsCurValueTextBuf.GetWideString(); 1328 if (!wsCurValue.IsEmpty()) { 1329 if (bMarkAsCompound) { 1330 CXFA_Node* pXFAChild = 1331 m_pFactory->CreateNode(ePacketID, XFA_ELEMENT_DataValue); 1332 if (pXFAChild == NULL) { 1333 return; 1334 } 1335 pXFAChild->SetCData(XFA_ATTRIBUTE_Name, FX_WSTRC(L"")); 1336 pXFAChild->SetCData(XFA_ATTRIBUTE_Value, wsCurValue); 1337 pXFANode->InsertChild(pXFAChild); 1338 pXFAChild->SetXMLMappingNode(pXMLCurValueNode); 1339 pXFAChild->SetFlag(XFA_NODEFLAG_Initialized, TRUE, FALSE); 1340 } 1341 wsValueTextBuf << wsCurValue; 1342 wsCurValueTextBuf.Clear(); 1343 } 1344 pXMLCurValueNode = NULL; 1345 } 1346 CFX_WideStringC wsNodeValue = wsValueTextBuf.GetWideString(); 1347 pXFANode->SetCData(XFA_ATTRIBUTE_Value, wsNodeValue); 1348 } 1349 void CXFA_SimpleParser::ParseInstruction(CXFA_Node* pXFANode, 1350 IFDE_XMLInstruction* pXMLInstruction, 1351 XFA_XDPPACKET ePacketID) { 1352 if (!m_bDocumentParser) { 1353 return; 1354 } 1355 CFX_WideString wsTargetName; 1356 pXMLInstruction->GetTargetName(wsTargetName); 1357 if (wsTargetName == FX_WSTRC(L"originalXFAVersion")) { 1358 CFX_WideString wsData; 1359 if (pXMLInstruction->GetData(0, wsData) && 1360 (pXFANode->GetDocument()->RecognizeXFAVersionNumber(wsData) != 1361 XFA_VERSION_UNKNOWN)) { 1362 wsData.Empty(); 1363 if (pXMLInstruction->GetData(1, wsData) && 1364 wsData == FX_WSTRC(L"v2.7-scripting:1")) { 1365 pXFANode->GetDocument()->SetFlag(XFA_DOCFLAG_Scripting, TRUE); 1366 } 1367 } 1368 } else if (wsTargetName == FX_WSTRC(L"acrobat")) { 1369 CFX_WideString wsData; 1370 if (pXMLInstruction->GetData(0, wsData) && 1371 wsData == FX_WSTRC(L"JavaScript")) { 1372 if (pXMLInstruction->GetData(1, wsData) && 1373 wsData == FX_WSTRC(L"strictScoping")) { 1374 pXFANode->GetDocument()->SetFlag(XFA_DOCFLAG_StrictScoping, TRUE); 1375 } 1376 } 1377 } 1378 } 1379 void CXFA_SimpleParser::CloseParser() { 1380 if (m_pXMLDoc) { 1381 m_pXMLDoc->Release(); 1382 m_pXMLDoc = NULL; 1383 } 1384 if (m_pStream) { 1385 m_pStream->Release(); 1386 m_pStream = NULL; 1387 } 1388 } 1389 IXFA_DocParser* IXFA_DocParser::Create(IXFA_Notify* pNotify) { 1390 return new CXFA_DocumentParser(pNotify); 1391 } 1392 CXFA_DocumentParser::CXFA_DocumentParser(IXFA_Notify* pNotify) 1393 : m_nodeParser(NULL, TRUE), m_pNotify(pNotify), m_pDocument(NULL) { 1394 } 1395 CXFA_DocumentParser::~CXFA_DocumentParser() { 1396 CloseParser(); 1397 } 1398 int32_t CXFA_DocumentParser::StartParse(IFX_FileRead* pStream, 1399 XFA_XDPPACKET ePacketID) { 1400 CloseParser(); 1401 int32_t nRetStatus = m_nodeParser.StartParse(pStream, ePacketID); 1402 if (nRetStatus == XFA_PARSESTATUS_Ready) { 1403 m_pDocument = new CXFA_Document(this); 1404 m_nodeParser.SetFactory(m_pDocument); 1405 } 1406 return nRetStatus; 1407 } 1408 int32_t CXFA_DocumentParser::DoParse(IFX_Pause* pPause) { 1409 int32_t nRetStatus = m_nodeParser.DoParse(pPause); 1410 if (nRetStatus >= XFA_PARSESTATUS_Done) { 1411 FXSYS_assert(m_pDocument); 1412 m_pDocument->SetRoot(m_nodeParser.GetRootNode()); 1413 } 1414 return nRetStatus; 1415 } 1416 int32_t CXFA_DocumentParser::ParseXMLData(const CFX_WideString& wsXML, 1417 IFDE_XMLNode*& pXMLNode, 1418 IFX_Pause* pPause) { 1419 CloseParser(); 1420 int32_t nRetStatus = m_nodeParser.ParseXMLData(wsXML, pXMLNode, NULL); 1421 if (nRetStatus == XFA_PARSESTATUS_Done && pXMLNode) { 1422 m_pDocument = new CXFA_Document(this); 1423 m_nodeParser.SetFactory(m_pDocument); 1424 } 1425 return nRetStatus; 1426 } 1427 void CXFA_DocumentParser::ConstructXFANode(CXFA_Node* pXFANode, 1428 IFDE_XMLNode* pXMLNode) { 1429 if (!pXFANode || !pXMLNode) { 1430 return; 1431 } 1432 m_nodeParser.ConstructXFANode(pXFANode, pXMLNode); 1433 CXFA_Node* pRootNode = m_nodeParser.GetRootNode(); 1434 if (m_pDocument && pRootNode) { 1435 m_pDocument->SetRoot(pRootNode); 1436 } 1437 } 1438 void CXFA_DocumentParser::CloseParser() { 1439 if (m_pDocument) { 1440 delete m_pDocument; 1441 m_pDocument = NULL; 1442 } 1443 m_nodeParser.CloseParser(); 1444 } 1445 CXFA_XMLParser::CXFA_XMLParser(IFDE_XMLNode* pRoot, IFX_Stream* pStream) 1446 : 1447 #ifdef _XFA_VERIFY_Checksum_ 1448 m_nElementStart(0), 1449 m_dwCheckStatus(0), 1450 m_dwCurrentCheckStatus(0), 1451 #endif 1452 m_pRoot(pRoot), 1453 m_pStream(pStream), 1454 m_pParser(nullptr), 1455 m_pParent(pRoot), 1456 m_pChild(nullptr), 1457 m_NodeStack(16), 1458 m_dwStatus(FDE_XMLSYNTAXSTATUS_None) { 1459 ASSERT(m_pParent && m_pStream); 1460 m_NodeStack.Push(m_pParent); 1461 m_pParser = IFDE_XMLSyntaxParser::Create(); 1462 m_pParser->Init(m_pStream, 32 * 1024, 1024 * 1024); 1463 } 1464 CXFA_XMLParser::~CXFA_XMLParser() { 1465 if (m_pParser) { 1466 m_pParser->Release(); 1467 } 1468 m_NodeStack.RemoveAll(); 1469 m_ws1.Empty(); 1470 m_ws2.Empty(); 1471 } 1472 int32_t CXFA_XMLParser::DoParser(IFX_Pause* pPause) { 1473 if (m_dwStatus == FDE_XMLSYNTAXSTATUS_Error) { 1474 return -1; 1475 } 1476 if (m_dwStatus == FDE_XMLSYNTAXSTATUS_EOS) { 1477 return 100; 1478 } 1479 int32_t iCount = 0; 1480 while (TRUE) { 1481 m_dwStatus = m_pParser->DoSyntaxParse(); 1482 switch (m_dwStatus) { 1483 case FDE_XMLSYNTAXSTATUS_InstructionOpen: 1484 break; 1485 case FDE_XMLSYNTAXSTATUS_InstructionClose: 1486 if (m_pChild) { 1487 if (m_pChild->GetType() != FDE_XMLNODE_Instruction) { 1488 m_dwStatus = FDE_XMLSYNTAXSTATUS_Error; 1489 break; 1490 } 1491 } 1492 m_pChild = m_pParent; 1493 break; 1494 case FDE_XMLSYNTAXSTATUS_ElementOpen: 1495 #ifdef _XFA_VERIFY_Checksum_ 1496 if (m_dwCheckStatus != 0x03 && m_NodeStack.GetSize() == 2) { 1497 m_nElementStart = m_pParser->GetCurrentPos() - 1; 1498 } 1499 #endif 1500 break; 1501 case FDE_XMLSYNTAXSTATUS_ElementBreak: 1502 break; 1503 case FDE_XMLSYNTAXSTATUS_ElementClose: 1504 if (m_pChild->GetType() != FDE_XMLNODE_Element) { 1505 m_dwStatus = FDE_XMLSYNTAXSTATUS_Error; 1506 break; 1507 } 1508 m_pParser->GetTagName(m_ws1); 1509 ((IFDE_XMLElement*)m_pChild)->GetTagName(m_ws2); 1510 if (m_ws1.GetLength() > 0 && !m_ws1.Equal(m_ws2)) { 1511 m_dwStatus = FDE_XMLSYNTAXSTATUS_Error; 1512 break; 1513 } 1514 m_NodeStack.Pop(); 1515 if (m_NodeStack.GetSize() < 1) { 1516 m_dwStatus = FDE_XMLSYNTAXSTATUS_Error; 1517 break; 1518 } 1519 #ifdef _XFA_VERIFY_Checksum_ 1520 else if (m_dwCurrentCheckStatus != 0 && m_NodeStack.GetSize() == 2) { 1521 m_nSize[m_dwCurrentCheckStatus - 1] = 1522 m_pParser->GetCurrentBinaryPos() - 1523 m_nStart[m_dwCurrentCheckStatus - 1]; 1524 m_dwCurrentCheckStatus = 0; 1525 } 1526 #endif 1527 m_pParent = (IFDE_XMLNode*)*m_NodeStack.GetTopElement(); 1528 m_pChild = m_pParent; 1529 iCount++; 1530 break; 1531 case FDE_XMLSYNTAXSTATUS_TargetName: 1532 m_pParser->GetTargetName(m_ws1); 1533 if (m_ws1 == FX_WSTRC(L"originalXFAVersion") || 1534 m_ws1 == FX_WSTRC(L"acrobat")) { 1535 m_pChild = IFDE_XMLInstruction::Create(m_ws1); 1536 m_pParent->InsertChildNode(m_pChild); 1537 } else { 1538 m_pChild = NULL; 1539 } 1540 m_ws1.Empty(); 1541 break; 1542 case FDE_XMLSYNTAXSTATUS_TagName: 1543 m_pParser->GetTagName(m_ws1); 1544 m_pChild = IFDE_XMLElement::Create(m_ws1); 1545 m_pParent->InsertChildNode(m_pChild); 1546 m_NodeStack.Push(m_pChild); 1547 m_pParent = m_pChild; 1548 #ifdef _XFA_VERIFY_Checksum_ 1549 if (m_dwCheckStatus != 0x03 && m_NodeStack.GetSize() == 3) { 1550 CFX_WideString wsTag; 1551 ((IFDE_XMLElement*)m_pChild)->GetLocalTagName(wsTag); 1552 if (wsTag == FX_WSTRC(L"template")) { 1553 m_dwCheckStatus |= 0x01; 1554 m_dwCurrentCheckStatus = 0x01; 1555 m_nStart[0] = m_pParser->GetCurrentBinaryPos() - 1556 (m_pParser->GetCurrentPos() - m_nElementStart); 1557 } else if (wsTag == FX_WSTRC(L"datasets")) { 1558 m_dwCheckStatus |= 0x02; 1559 m_dwCurrentCheckStatus = 0x02; 1560 m_nStart[1] = m_pParser->GetCurrentBinaryPos() - 1561 (m_pParser->GetCurrentPos() - m_nElementStart); 1562 } 1563 } 1564 #endif 1565 break; 1566 case FDE_XMLSYNTAXSTATUS_AttriName: 1567 m_pParser->GetAttributeName(m_ws1); 1568 break; 1569 case FDE_XMLSYNTAXSTATUS_AttriValue: 1570 if (m_pChild) { 1571 m_pParser->GetAttributeName(m_ws2); 1572 if (m_pChild->GetType() == FDE_XMLNODE_Element) { 1573 ((IFDE_XMLElement*)m_pChild)->SetString(m_ws1, m_ws2); 1574 } 1575 } 1576 m_ws1.Empty(); 1577 break; 1578 case FDE_XMLSYNTAXSTATUS_Text: 1579 m_pParser->GetTextData(m_ws1); 1580 m_pChild = IFDE_XMLText::Create(m_ws1); 1581 m_pParent->InsertChildNode(m_pChild); 1582 m_pChild = m_pParent; 1583 break; 1584 case FDE_XMLSYNTAXSTATUS_CData: 1585 m_pParser->GetTextData(m_ws1); 1586 m_pChild = IFDE_XMLCharData::Create(m_ws1); 1587 m_pParent->InsertChildNode(m_pChild); 1588 m_pChild = m_pParent; 1589 break; 1590 case FDE_XMLSYNTAXSTATUS_TargetData: 1591 if (m_pChild) { 1592 if (m_pChild->GetType() != FDE_XMLNODE_Instruction) { 1593 m_dwStatus = FDE_XMLSYNTAXSTATUS_Error; 1594 break; 1595 } 1596 if (!m_ws1.IsEmpty()) { 1597 ((IFDE_XMLInstruction*)m_pChild)->AppendData(m_ws1); 1598 } 1599 m_pParser->GetTargetData(m_ws1); 1600 ((IFDE_XMLInstruction*)m_pChild)->AppendData(m_ws1); 1601 } 1602 m_ws1.Empty(); 1603 break; 1604 default: 1605 break; 1606 } 1607 if (m_dwStatus == FDE_XMLSYNTAXSTATUS_Error || 1608 m_dwStatus == FDE_XMLSYNTAXSTATUS_EOS) { 1609 break; 1610 } 1611 if (pPause != NULL && iCount > 500 && pPause->NeedToPauseNow()) { 1612 break; 1613 } 1614 } 1615 return (m_dwStatus == FDE_XMLSYNTAXSTATUS_Error || m_NodeStack.GetSize() != 1) 1616 ? -1 1617 : m_pParser->GetStatus(); 1618 } 1619
