blob: dd602d1c37a575e0150ba9bffa5c5a42fa5b3447 [file] [log] [blame]
// Copyright 2016 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 "xfa/fxfa/parser/cxfa_document_builder.h"
#include <utility>
#include <vector>
#include "core/fxcrt/autorestorer.h"
#include "core/fxcrt/cfx_readonlymemorystream.h"
#include "core/fxcrt/cfx_widetextbuf.h"
#include "core/fxcrt/fx_codepage.h"
#include "core/fxcrt/fx_extension.h"
#include "core/fxcrt/xml/cfx_xmlchardata.h"
#include "core/fxcrt/xml/cfx_xmldocument.h"
#include "core/fxcrt/xml/cfx_xmlelement.h"
#include "core/fxcrt/xml/cfx_xmlinstruction.h"
#include "core/fxcrt/xml/cfx_xmlnode.h"
#include "core/fxcrt/xml/cfx_xmltext.h"
#include "fxjs/xfa/cjx_object.h"
#include "third_party/base/check.h"
#include "third_party/base/notreached.h"
#include "third_party/base/optional.h"
#include "xfa/fxfa/fxfa.h"
#include "xfa/fxfa/parser/cxfa_document.h"
#include "xfa/fxfa/parser/cxfa_node.h"
#include "xfa/fxfa/parser/cxfa_subform.h"
#include "xfa/fxfa/parser/cxfa_template.h"
#include "xfa/fxfa/parser/xfa_basic_data.h"
#include "xfa/fxfa/parser/xfa_utils.h"
namespace {
CFX_XMLNode* GetDocumentNode(CFX_XMLNode* pRootNode) {
for (CFX_XMLNode* pXMLNode = pRootNode->GetFirstChild(); pXMLNode;
pXMLNode = pXMLNode->GetNextSibling()) {
if (pXMLNode->GetType() == CFX_XMLNode::Type::kElement)
return pXMLNode;
}
return nullptr;
}
bool MatchNodeName(CFX_XMLNode* pNode,
WideStringView wsLocalTagName,
WideStringView wsNamespaceURIPrefix,
uint32_t eMatchFlags = XFA_XDPPACKET_FLAGS_NOMATCH) {
CFX_XMLElement* pElement = ToXMLElement(pNode);
if (!pElement)
return false;
WideString wsNodeStr = pElement->GetLocalTagName();
if (wsNodeStr != wsLocalTagName)
return false;
wsNodeStr = pElement->GetNamespaceURI();
if (eMatchFlags & XFA_XDPPACKET_FLAGS_NOMATCH)
return true;
if (eMatchFlags & XFA_XDPPACKET_FLAGS_PREFIXMATCH) {
return wsNodeStr.First(wsNamespaceURIPrefix.GetLength()) ==
wsNamespaceURIPrefix;
}
return wsNodeStr == wsNamespaceURIPrefix;
}
bool GetAttributeLocalName(WideStringView wsAttributeName,
WideString& wsLocalAttrName) {
WideString wsAttrName(wsAttributeName);
auto pos = wsAttrName.Find(L':', 0);
if (!pos.has_value()) {
wsLocalAttrName = std::move(wsAttrName);
return false;
}
wsLocalAttrName = wsAttrName.Last(wsAttrName.GetLength() - pos.value() - 1);
return true;
}
bool ResolveAttribute(CFX_XMLElement* pElement,
const WideString& wsAttrName,
WideString& wsLocalAttrName,
WideString& wsNamespaceURI) {
WideString wsNSPrefix;
if (GetAttributeLocalName(wsAttrName.AsStringView(), wsLocalAttrName)) {
wsNSPrefix = wsAttrName.First(wsAttrName.GetLength() -
wsLocalAttrName.GetLength() - 1);
}
if (wsLocalAttrName.EqualsASCII("xmlns") || wsNSPrefix.EqualsASCII("xmlns") ||
wsNSPrefix.EqualsASCII("xml")) {
return false;
}
if (!XFA_FDEExtension_ResolveNamespaceQualifier(pElement, wsNSPrefix,
&wsNamespaceURI)) {
wsNamespaceURI.clear();
return false;
}
return true;
}
Optional<WideString> FindAttributeWithNS(CFX_XMLElement* pElement,
WideStringView wsLocalAttributeName,
WideStringView wsNamespaceURIPrefix) {
WideString wsAttrNS;
for (auto it : pElement->GetAttributes()) {
auto pos = it.first.Find(L':', 0);
WideString wsNSPrefix;
if (!pos.has_value()) {
if (wsLocalAttributeName != it.first)
continue;
} else {
if (wsLocalAttributeName !=
it.first.Last(it.first.GetLength() - pos.value() - 1)) {
continue;
}
wsNSPrefix = it.first.First(pos.value());
}
if (!XFA_FDEExtension_ResolveNamespaceQualifier(pElement, wsNSPrefix,
&wsAttrNS) ||
wsAttrNS != wsNamespaceURIPrefix) {
continue;
}
return it.second;
}
return {};
}
CFX_XMLNode* GetDataSetsFromXDP(CFX_XMLNode* pXMLDocumentNode) {
XFA_PACKETINFO datasets_packet =
XFA_GetPacketByIndex(XFA_PacketType::Datasets);
if (MatchNodeName(pXMLDocumentNode, datasets_packet.name, datasets_packet.uri,
datasets_packet.flags)) {
return pXMLDocumentNode;
}
XFA_PACKETINFO xdp_packet = XFA_GetPacketByIndex(XFA_PacketType::Xdp);
if (!MatchNodeName(pXMLDocumentNode, xdp_packet.name, xdp_packet.uri,
xdp_packet.flags)) {
return nullptr;
}
for (CFX_XMLNode* pDatasetsNode = pXMLDocumentNode->GetFirstChild();
pDatasetsNode; pDatasetsNode = pDatasetsNode->GetNextSibling()) {
if (MatchNodeName(pDatasetsNode, datasets_packet.name, datasets_packet.uri,
datasets_packet.flags)) {
return pDatasetsNode;
}
}
return nullptr;
}
bool IsStringAllWhitespace(WideString wsText) {
wsText.TrimRight(L"\x20\x9\xD\xA");
return wsText.IsEmpty();
}
void ConvertXMLToPlainText(CFX_XMLElement* pRootXMLNode, WideString& wsOutput) {
for (CFX_XMLNode* pXMLChild = pRootXMLNode->GetFirstChild(); pXMLChild;
pXMLChild = pXMLChild->GetNextSibling()) {
switch (pXMLChild->GetType()) {
case CFX_XMLNode::Type::kElement: {
WideString wsTextData = ToXMLElement(pXMLChild)->GetTextData();
wsTextData += L"\n";
wsOutput += wsTextData;
break;
}
case CFX_XMLNode::Type::kText:
case CFX_XMLNode::Type::kCharData: {
WideString wsText = ToXMLText(pXMLChild)->GetText();
if (IsStringAllWhitespace(wsText))
continue;
wsOutput = std::move(wsText);
break;
}
default:
NOTREACHED();
break;
}
}
}
WideString GetPlainTextFromRichText(CFX_XMLNode* pXMLNode) {
if (!pXMLNode)
return WideString();
WideString wsPlainText;
switch (pXMLNode->GetType()) {
case CFX_XMLNode::Type::kElement: {
CFX_XMLElement* pXMLElement = static_cast<CFX_XMLElement*>(pXMLNode);
WideString wsTag = pXMLElement->GetLocalTagName();
uint32_t uTag = FX_HashCode_GetW(wsTag.AsStringView(), true);
if (uTag == 0x0001f714) {
wsPlainText += L"\n";
} else if (uTag == 0x00000070) {
if (!wsPlainText.IsEmpty()) {
wsPlainText += L"\n";
}
} else if (uTag == 0xa48ac63) {
if (!wsPlainText.IsEmpty() && wsPlainText.Back() != '\n') {
wsPlainText += L"\n";
}
}
break;
}
case CFX_XMLNode::Type::kText:
case CFX_XMLNode::Type::kCharData: {
WideString wsContent = ToXMLText(pXMLNode)->GetText();
wsPlainText += wsContent;
break;
}
default:
break;
}
for (CFX_XMLNode* pChildXML = pXMLNode->GetFirstChild(); pChildXML;
pChildXML = pChildXML->GetNextSibling()) {
wsPlainText += GetPlainTextFromRichText(pChildXML);
}
return wsPlainText;
}
} // namespace
bool XFA_RecognizeRichText(CFX_XMLElement* pRichTextXMLNode) {
return pRichTextXMLNode && pRichTextXMLNode->GetNamespaceURI().EqualsASCII(
"http://www.w3.org/1999/xhtml");
}
CXFA_DocumentBuilder::CXFA_DocumentBuilder(CXFA_Document* pNodeFactory)
: node_factory_(pNodeFactory) {}
CXFA_DocumentBuilder::~CXFA_DocumentBuilder() = default;
bool CXFA_DocumentBuilder::BuildDocument(CFX_XMLDocument* pXML,
XFA_PacketType ePacketID) {
CFX_XMLNode* root = Build(pXML);
if (!root)
return false;
root_node_ = ParseAsXDPPacket(root, ePacketID);
return !!root_node_;
}
CFX_XMLNode* CXFA_DocumentBuilder::Build(CFX_XMLDocument* pXML) {
if (!pXML)
return nullptr;
xml_doc_ = pXML;
xml_doc_->GetRoot()->InsertChildNode(
xml_doc_->CreateNode<CFX_XMLInstruction>(L"xml"), 0);
return GetDocumentNode(xml_doc_->GetRoot());
}
void CXFA_DocumentBuilder::ConstructXFANode(CXFA_Node* pXFANode,
CFX_XMLNode* pXMLNode) {
XFA_PacketType ePacketID = pXFANode->GetPacketType();
if (ePacketID == XFA_PacketType::Datasets) {
if (pXFANode->GetElementType() == XFA_Element::DataValue) {
for (CFX_XMLNode* pXMLChild = pXMLNode->GetFirstChild(); pXMLChild;
pXMLChild = pXMLChild->GetNextSibling()) {
CFX_XMLNode::Type eNodeType = pXMLChild->GetType();
if (eNodeType == CFX_XMLNode::Type::kInstruction)
continue;
if (eNodeType == CFX_XMLNode::Type::kElement) {
CXFA_Node* pXFAChild = node_factory_->CreateNode(
XFA_PacketType::Datasets, XFA_Element::DataValue);
if (!pXFAChild)
return;
CFX_XMLElement* child = static_cast<CFX_XMLElement*>(pXMLChild);
WideString wsNodeStr = child->GetLocalTagName();
pXFAChild->JSObject()->SetCData(XFA_Attribute::Name, wsNodeStr);
WideString wsChildValue = GetPlainTextFromRichText(child);
if (!wsChildValue.IsEmpty())
pXFAChild->JSObject()->SetCData(XFA_Attribute::Value, wsChildValue);
pXFANode->InsertChildAndNotify(pXFAChild, nullptr);
pXFAChild->SetXMLMappingNode(pXMLChild);
pXFAChild->SetFlag(XFA_NodeFlag_Initialized);
break;
}
}
root_node_ = pXFANode;
} else {
root_node_ = DataLoader(pXFANode, pXMLNode, true);
}
} else if (pXFANode->IsContentNode()) {
ParseContentNode(pXFANode, pXMLNode, ePacketID);
root_node_ = pXFANode;
} else {
root_node_ = NormalLoader(pXFANode, pXMLNode, ePacketID, true);
}
}
CXFA_Node* CXFA_DocumentBuilder::GetRootNode() const {
return root_node_;
}
CXFA_Node* CXFA_DocumentBuilder::ParseAsXDPPacket(CFX_XMLNode* pXMLDocumentNode,
XFA_PacketType ePacketID) {
switch (ePacketID) {
case XFA_PacketType::Xdp:
return ParseAsXDPPacket_XDP(pXMLDocumentNode);
case XFA_PacketType::Config:
return ParseAsXDPPacket_Config(pXMLDocumentNode);
case XFA_PacketType::Template:
return ParseAsXDPPacket_Template(pXMLDocumentNode);
case XFA_PacketType::Form:
return ParseAsXDPPacket_Form(pXMLDocumentNode);
case XFA_PacketType::Datasets:
return ParseAsXDPPacket_Data(pXMLDocumentNode);
case XFA_PacketType::Xdc:
return ParseAsXDPPacket_Xdc(pXMLDocumentNode);
case XFA_PacketType::LocaleSet:
return ParseAsXDPPacket_LocaleConnectionSourceSet(
pXMLDocumentNode, XFA_PacketType::LocaleSet, XFA_Element::LocaleSet);
case XFA_PacketType::ConnectionSet:
return ParseAsXDPPacket_LocaleConnectionSourceSet(
pXMLDocumentNode, XFA_PacketType::ConnectionSet,
XFA_Element::ConnectionSet);
case XFA_PacketType::SourceSet:
return ParseAsXDPPacket_LocaleConnectionSourceSet(
pXMLDocumentNode, XFA_PacketType::SourceSet, XFA_Element::SourceSet);
default:
return ParseAsXDPPacket_User(pXMLDocumentNode);
}
}
CXFA_Node* CXFA_DocumentBuilder::ParseAsXDPPacket_XDP(
CFX_XMLNode* pXMLDocumentNode) {
XFA_PACKETINFO packet = XFA_GetPacketByIndex(XFA_PacketType::Xdp);
if (!MatchNodeName(pXMLDocumentNode, packet.name, packet.uri, packet.flags))
return nullptr;
CXFA_Node* pXFARootNode =
node_factory_->CreateNode(XFA_PacketType::Xdp, XFA_Element::Xfa);
if (!pXFARootNode)
return nullptr;
root_node_ = pXFARootNode;
pXFARootNode->JSObject()->SetCData(XFA_Attribute::Name, L"xfa");
for (auto it : ToXMLElement(pXMLDocumentNode)->GetAttributes()) {
if (it.first.EqualsASCII("uuid"))
pXFARootNode->JSObject()->SetCData(XFA_Attribute::Uuid, it.second);
else if (it.first.EqualsASCII("timeStamp"))
pXFARootNode->JSObject()->SetCData(XFA_Attribute::TimeStamp, it.second);
}
CFX_XMLNode* pXMLConfigDOMRoot = nullptr;
CXFA_Node* pXFAConfigDOMRoot = nullptr;
XFA_PACKETINFO config_packet = XFA_GetPacketByIndex(XFA_PacketType::Config);
for (CFX_XMLNode* pChildItem = pXMLDocumentNode->GetFirstChild(); pChildItem;
pChildItem = pChildItem->GetNextSibling()) {
if (!MatchNodeName(pChildItem, config_packet.name, config_packet.uri,
config_packet.flags)) {
continue;
}
// TODO(tsepez): make GetFirstChildByName() take a name.
uint32_t hash = FX_HashCode_GetW(config_packet.name, false);
if (pXFARootNode->GetFirstChildByName(hash))
return nullptr;
pXMLConfigDOMRoot = pChildItem;
pXFAConfigDOMRoot = ParseAsXDPPacket_Config(pXMLConfigDOMRoot);
if (pXFAConfigDOMRoot)
pXFARootNode->InsertChildAndNotify(pXFAConfigDOMRoot, nullptr);
}
CFX_XMLNode* pXMLDatasetsDOMRoot = nullptr;
CFX_XMLNode* pXMLFormDOMRoot = nullptr;
CFX_XMLNode* pXMLTemplateDOMRoot = nullptr;
for (CFX_XMLNode* pChildItem = pXMLDocumentNode->GetFirstChild(); pChildItem;
pChildItem = pChildItem->GetNextSibling()) {
CFX_XMLElement* pElement = ToXMLElement(pChildItem);
if (!pElement || pElement == pXMLConfigDOMRoot)
continue;
WideString wsPacketName = pElement->GetLocalTagName();
Optional<XFA_PACKETINFO> packet_info =
XFA_GetPacketByName(wsPacketName.AsStringView());
if (packet_info.has_value() && packet_info.value().uri &&
!MatchNodeName(pElement, packet_info.value().name,
packet_info.value().uri, packet_info.value().flags)) {
packet_info = {};
}
XFA_PacketType ePacket = XFA_PacketType::User;
if (packet_info.has_value())
ePacket = packet_info.value().packet_type;
if (ePacket == XFA_PacketType::Xdp)
continue;
if (ePacket == XFA_PacketType::Datasets) {
if (pXMLDatasetsDOMRoot)
return nullptr;
pXMLDatasetsDOMRoot = pElement;
} else if (ePacket == XFA_PacketType::Form) {
if (pXMLFormDOMRoot)
return nullptr;
pXMLFormDOMRoot = pElement;
} else if (ePacket == XFA_PacketType::Template) {
// Found a duplicate template packet.
if (pXMLTemplateDOMRoot)
return nullptr;
CXFA_Node* pPacketNode = ParseAsXDPPacket_Template(pElement);
if (pPacketNode) {
pXMLTemplateDOMRoot = pElement;
pXFARootNode->InsertChildAndNotify(pPacketNode, nullptr);
}
} else {
CXFA_Node* pPacketNode = ParseAsXDPPacket(pElement, ePacket);
if (pPacketNode) {
if (packet_info.has_value() &&
(packet_info.value().flags & XFA_XDPPACKET_FLAGS_SUPPORTONE) &&
pXFARootNode->GetFirstChildByName(
FX_HashCode_GetW(packet_info.value().name, false))) {
return nullptr;
}
pXFARootNode->InsertChildAndNotify(pPacketNode, nullptr);
}
}
}
// No template is found.
if (!pXMLTemplateDOMRoot)
return nullptr;
if (pXMLDatasetsDOMRoot) {
CXFA_Node* pPacketNode =
ParseAsXDPPacket(pXMLDatasetsDOMRoot, XFA_PacketType::Datasets);
if (pPacketNode)
pXFARootNode->InsertChildAndNotify(pPacketNode, nullptr);
}
if (pXMLFormDOMRoot) {
CXFA_Node* pPacketNode =
ParseAsXDPPacket(pXMLFormDOMRoot, XFA_PacketType::Form);
if (pPacketNode)
pXFARootNode->InsertChildAndNotify(pPacketNode, nullptr);
}
pXFARootNode->SetXMLMappingNode(pXMLDocumentNode);
return pXFARootNode;
}
CXFA_Node* CXFA_DocumentBuilder::ParseAsXDPPacket_Config(
CFX_XMLNode* pXMLDocumentNode) {
XFA_PACKETINFO packet = XFA_GetPacketByIndex(XFA_PacketType::Config);
if (!MatchNodeName(pXMLDocumentNode, packet.name, packet.uri, packet.flags))
return nullptr;
CXFA_Node* pNode =
node_factory_->CreateNode(XFA_PacketType::Config, XFA_Element::Config);
if (!pNode)
return nullptr;
pNode->JSObject()->SetCData(XFA_Attribute::Name, packet.name);
if (!NormalLoader(pNode, pXMLDocumentNode, XFA_PacketType::Config, true))
return nullptr;
pNode->SetXMLMappingNode(pXMLDocumentNode);
return pNode;
}
CXFA_Node* CXFA_DocumentBuilder::ParseAsXDPPacket_Template(
CFX_XMLNode* pXMLDocumentNode) {
XFA_PACKETINFO packet = XFA_GetPacketByIndex(XFA_PacketType::Template);
if (!MatchNodeName(pXMLDocumentNode, packet.name, packet.uri, packet.flags))
return nullptr;
CXFA_Node* pNode = node_factory_->CreateNode(XFA_PacketType::Template,
XFA_Element::Template);
if (!pNode)
return nullptr;
pNode->JSObject()->SetCData(XFA_Attribute::Name, packet.name);
CFX_XMLElement* pXMLDocumentElement = ToXMLElement(pXMLDocumentNode);
WideString wsNamespaceURI = pXMLDocumentElement->GetNamespaceURI();
if (wsNamespaceURI.IsEmpty())
wsNamespaceURI = pXMLDocumentElement->GetAttribute(L"xmlns:xfa");
pNode->GetDocument()->RecognizeXFAVersionNumber(wsNamespaceURI);
if (!NormalLoader(pNode, pXMLDocumentNode, XFA_PacketType::Template, true))
return nullptr;
pNode->SetXMLMappingNode(pXMLDocumentNode);
return pNode;
}
CXFA_Node* CXFA_DocumentBuilder::ParseAsXDPPacket_Form(
CFX_XMLNode* pXMLDocumentNode) {
XFA_PACKETINFO packet = XFA_GetPacketByIndex(XFA_PacketType::Form);
if (!MatchNodeName(pXMLDocumentNode, packet.name, packet.uri, packet.flags))
return nullptr;
CXFA_Node* pNode =
node_factory_->CreateNode(XFA_PacketType::Form, XFA_Element::Form);
if (!pNode)
return nullptr;
pNode->JSObject()->SetCData(XFA_Attribute::Name, packet.name);
CXFA_Template* pTemplateRoot =
root_node_->GetFirstChildByClass<CXFA_Template>(XFA_Element::Template);
CXFA_Subform* pTemplateChosen =
pTemplateRoot ? pTemplateRoot->GetFirstChildByClass<CXFA_Subform>(
XFA_Element::Subform)
: nullptr;
bool bUseAttribute = true;
if (pTemplateChosen &&
pTemplateChosen->JSObject()->GetEnum(XFA_Attribute::RestoreState) !=
XFA_AttributeValue::Auto) {
bUseAttribute = false;
}
if (!NormalLoader(pNode, pXMLDocumentNode, XFA_PacketType::Form,
bUseAttribute))
return nullptr;
pNode->SetXMLMappingNode(pXMLDocumentNode);
return pNode;
}
CXFA_Node* CXFA_DocumentBuilder::ParseAsXDPPacket_Data(
CFX_XMLNode* pXMLDocumentNode) {
XFA_PACKETINFO packet = XFA_GetPacketByIndex(XFA_PacketType::Datasets);
CFX_XMLNode* pDatasetsXMLNode = GetDataSetsFromXDP(pXMLDocumentNode);
if (pDatasetsXMLNode) {
CXFA_Node* pNode = node_factory_->CreateNode(XFA_PacketType::Datasets,
XFA_Element::DataModel);
if (!pNode)
return nullptr;
pNode->JSObject()->SetCData(XFA_Attribute::Name, packet.name);
if (!DataLoader(pNode, pDatasetsXMLNode, false))
return nullptr;
pNode->SetXMLMappingNode(pDatasetsXMLNode);
return pNode;
}
CFX_XMLNode* pDataXMLNode = nullptr;
if (MatchNodeName(pXMLDocumentNode, L"data", packet.uri, packet.flags)) {
ToXMLElement(pXMLDocumentNode)->RemoveAttribute(L"xmlns:xfa");
pDataXMLNode = pXMLDocumentNode;
} else {
auto* pDataElement = xml_doc_->CreateNode<CFX_XMLElement>(L"xfa:data");
pXMLDocumentNode->RemoveSelfIfParented();
CFX_XMLElement* pElement = ToXMLElement(pXMLDocumentNode);
pElement->RemoveAttribute(L"xmlns:xfa");
// The node was either removed from the parent above, or already has no
// parent so we can take ownership.
pDataElement->AppendLastChild(pXMLDocumentNode);
pDataXMLNode = pDataElement;
}
if (!pDataXMLNode)
return nullptr;
CXFA_Node* pNode = node_factory_->CreateNode(XFA_PacketType::Datasets,
XFA_Element::DataGroup);
if (!pNode)
return nullptr;
WideString wsLocalName = ToXMLElement(pDataXMLNode)->GetLocalTagName();
pNode->JSObject()->SetCData(XFA_Attribute::Name, wsLocalName);
if (!DataLoader(pNode, pDataXMLNode, true))
return nullptr;
pNode->SetXMLMappingNode(pDataXMLNode);
return pNode;
}
CXFA_Node* CXFA_DocumentBuilder::ParseAsXDPPacket_LocaleConnectionSourceSet(
CFX_XMLNode* pXMLDocumentNode,
XFA_PacketType packet_type,
XFA_Element element) {
XFA_PACKETINFO packet = XFA_GetPacketByIndex(packet_type);
if (!MatchNodeName(pXMLDocumentNode, packet.name, packet.uri, packet.flags))
return nullptr;
CXFA_Node* pNode = node_factory_->CreateNode(packet_type, element);
if (!pNode)
return nullptr;
pNode->JSObject()->SetCData(XFA_Attribute::Name, packet.name);
if (!NormalLoader(pNode, pXMLDocumentNode, packet_type, true))
return nullptr;
pNode->SetXMLMappingNode(pXMLDocumentNode);
return pNode;
}
CXFA_Node* CXFA_DocumentBuilder::ParseAsXDPPacket_Xdc(
CFX_XMLNode* pXMLDocumentNode) {
XFA_PACKETINFO packet = XFA_GetPacketByIndex(XFA_PacketType::Xdc);
if (!MatchNodeName(pXMLDocumentNode, packet.name, packet.uri, packet.flags))
return nullptr;
CXFA_Node* pNode =
node_factory_->CreateNode(XFA_PacketType::Xdc, XFA_Element::Xdc);
if (!pNode)
return nullptr;
pNode->JSObject()->SetCData(XFA_Attribute::Name, packet.name);
pNode->SetXMLMappingNode(pXMLDocumentNode);
return pNode;
}
CXFA_Node* CXFA_DocumentBuilder::ParseAsXDPPacket_User(
CFX_XMLNode* pXMLDocumentNode) {
CXFA_Node* pNode =
node_factory_->CreateNode(XFA_PacketType::Xdp, XFA_Element::Packet);
if (!pNode)
return nullptr;
WideString wsName = ToXMLElement(pXMLDocumentNode)->GetLocalTagName();
pNode->JSObject()->SetCData(XFA_Attribute::Name, wsName);
pNode->SetXMLMappingNode(pXMLDocumentNode);
return pNode;
}
CXFA_Node* CXFA_DocumentBuilder::DataLoader(CXFA_Node* pXFANode,
CFX_XMLNode* pXMLDoc,
bool bDoTransform) {
ParseDataGroup(pXFANode, pXMLDoc, XFA_PacketType::Datasets);
return pXFANode;
}
CXFA_Node* CXFA_DocumentBuilder::NormalLoader(CXFA_Node* pXFANode,
CFX_XMLNode* pXMLDoc,
XFA_PacketType ePacketID,
bool bUseAttribute) {
constexpr size_t kMaxExecuteRecursion = 1000;
if (execute_recursion_depth_ > kMaxExecuteRecursion)
return nullptr;
AutoRestorer<size_t> restorer(&execute_recursion_depth_);
++execute_recursion_depth_;
bool bOneOfPropertyFound = false;
for (CFX_XMLNode* pXMLChild = pXMLDoc->GetFirstChild(); pXMLChild;
pXMLChild = pXMLChild->GetNextSibling()) {
switch (pXMLChild->GetType()) {
case CFX_XMLNode::Type::kElement: {
CFX_XMLElement* pXMLElement = static_cast<CFX_XMLElement*>(pXMLChild);
WideString wsTagName = pXMLElement->GetLocalTagName();
XFA_Element eType = XFA_GetElementByName(wsTagName.AsStringView());
if (eType == XFA_Element::Unknown)
continue;
if (pXFANode->HasPropertyFlags(
eType,
XFA_PROPERTYFLAG_OneOf | XFA_PROPERTYFLAG_DefaultOneOf)) {
if (bOneOfPropertyFound)
break;
bOneOfPropertyFound = true;
}
CXFA_Node* pXFAChild = node_factory_->CreateNode(ePacketID, eType);
if (!pXFAChild)
return nullptr;
if (ePacketID == XFA_PacketType::Config) {
pXFAChild->JSObject()->SetAttributeByEnum(XFA_Attribute::Name,
wsTagName, false);
}
bool IsNeedValue = true;
for (auto it : pXMLElement->GetAttributes()) {
WideString wsAttrName;
GetAttributeLocalName(it.first.AsStringView(), wsAttrName);
if (wsAttrName.EqualsASCII("nil") && it.second.EqualsASCII("true"))
IsNeedValue = false;
Optional<XFA_ATTRIBUTEINFO> attr =
XFA_GetAttributeByName(wsAttrName.AsStringView());
if (!attr.has_value())
continue;
if (!bUseAttribute && attr.value().attribute != XFA_Attribute::Name &&
attr.value().attribute != XFA_Attribute::Save) {
continue;
}
pXFAChild->JSObject()->SetAttributeByEnum(attr.value().attribute,
it.second, false);
}
pXFANode->InsertChildAndNotify(pXFAChild, nullptr);
if (eType == XFA_Element::Validate || eType == XFA_Element::Locale) {
if (ePacketID == XFA_PacketType::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 CFX_XMLNode::Type::kInstruction:
ParseInstruction(pXFANode, ToXMLInstruction(pXMLChild), ePacketID);
break;
default:
break;
}
}
return pXFANode;
}
void CXFA_DocumentBuilder::ParseContentNode(CXFA_Node* pXFANode,
CFX_XMLNode* pXMLNode,
XFA_PacketType ePacketID) {
XFA_Element element = XFA_Element::Sharptext;
if (pXFANode->GetElementType() == XFA_Element::ExData) {
WideString wsContentType =
pXFANode->JSObject()->GetCData(XFA_Attribute::ContentType);
if (wsContentType.EqualsASCII("text/html"))
element = XFA_Element::SharpxHTML;
else if (wsContentType.EqualsASCII("text/xml"))
element = XFA_Element::Sharpxml;
}
if (element == XFA_Element::SharpxHTML)
pXFANode->SetXMLMappingNode(pXMLNode);
WideString wsValue;
for (CFX_XMLNode* pXMLChild = pXMLNode->GetFirstChild(); pXMLChild;
pXMLChild = pXMLChild->GetNextSibling()) {
CFX_XMLNode::Type eNodeType = pXMLChild->GetType();
if (eNodeType == CFX_XMLNode::Type::kInstruction)
continue;
CFX_XMLElement* pElement = ToXMLElement(pXMLChild);
if (element == XFA_Element::SharpxHTML) {
if (!pElement)
break;
if (XFA_RecognizeRichText(pElement))
wsValue += GetPlainTextFromRichText(pElement);
} else if (element == XFA_Element::Sharpxml) {
if (!pElement)
break;
ConvertXMLToPlainText(pElement, wsValue);
} else {
if (pElement)
break;
CFX_XMLText* pText = ToXMLText(pXMLChild);
if (pText)
wsValue = pText->GetText();
}
break;
}
if (!wsValue.IsEmpty()) {
if (pXFANode->IsContentNode()) {
CXFA_Node* pContentRawDataNode =
node_factory_->CreateNode(ePacketID, element);
DCHECK(pContentRawDataNode);
pContentRawDataNode->JSObject()->SetCData(XFA_Attribute::Value, wsValue);
pXFANode->InsertChildAndNotify(pContentRawDataNode, nullptr);
} else {
pXFANode->JSObject()->SetCData(XFA_Attribute::Value, wsValue);
}
}
}
void CXFA_DocumentBuilder::ParseDataGroup(CXFA_Node* pXFANode,
CFX_XMLNode* pXMLNode,
XFA_PacketType ePacketID) {
for (CFX_XMLNode* pXMLChild = pXMLNode->GetFirstChild(); pXMLChild;
pXMLChild = pXMLChild->GetNextSibling()) {
switch (pXMLChild->GetType()) {
case CFX_XMLNode::Type::kElement: {
CFX_XMLElement* pXMLElement = static_cast<CFX_XMLElement*>(pXMLChild);
WideString wsNamespaceURI = pXMLElement->GetNamespaceURI();
if (wsNamespaceURI.EqualsASCII(
"http://www.xfa.com/schema/xfa-package/") ||
wsNamespaceURI.EqualsASCII(
"http://www.xfa.org/schema/xfa-package/") ||
wsNamespaceURI.EqualsASCII(
"http://www.w3.org/2001/XMLSchema-instance")) {
continue;
}
XFA_Element eNodeType = XFA_Element::DataModel;
if (eNodeType == XFA_Element::DataModel) {
Optional<WideString> wsDataNodeAttr =
FindAttributeWithNS(pXMLElement, L"dataNode",
L"http://www.xfa.org/schema/xfa-data/1.0/");
if (wsDataNodeAttr.has_value()) {
if (wsDataNodeAttr.value().EqualsASCII("dataGroup"))
eNodeType = XFA_Element::DataGroup;
else if (wsDataNodeAttr.value().EqualsASCII("dataValue"))
eNodeType = XFA_Element::DataValue;
}
}
if (eNodeType == XFA_Element::DataModel) {
Optional<WideString> wsContentType =
FindAttributeWithNS(pXMLElement, L"contentType",
L"http://www.xfa.org/schema/xfa-data/1.0/");
if (wsContentType.has_value() && !wsContentType.value().IsEmpty())
eNodeType = XFA_Element::DataValue;
}
if (eNodeType == XFA_Element::DataModel) {
for (CFX_XMLNode* pXMLDataChild = pXMLElement->GetFirstChild();
pXMLDataChild; pXMLDataChild = pXMLDataChild->GetNextSibling()) {
CFX_XMLElement* pElement = ToXMLElement(pXMLDataChild);
if (pElement && !XFA_RecognizeRichText(pElement)) {
eNodeType = XFA_Element::DataGroup;
break;
}
}
}
if (eNodeType == XFA_Element::DataModel)
eNodeType = XFA_Element::DataValue;
CXFA_Node* pXFAChild =
node_factory_->CreateNode(XFA_PacketType::Datasets, eNodeType);
if (!pXFAChild)
return;
pXFAChild->JSObject()->SetCData(XFA_Attribute::Name,
pXMLElement->GetLocalTagName());
bool bNeedValue = true;
for (auto it : pXMLElement->GetAttributes()) {
WideString wsName;
WideString wsNS;
if (!ResolveAttribute(pXMLElement, it.first, wsName, wsNS)) {
continue;
}
if (wsName.EqualsASCII("nil") && it.second.EqualsASCII("true")) {
bNeedValue = false;
continue;
}
if (wsNS.EqualsASCII("http://www.xfa.com/schema/xfa-package/") ||
wsNS.EqualsASCII("http://www.xfa.org/schema/xfa-package/") ||
wsNS.EqualsASCII("http://www.w3.org/2001/XMLSchema-instance") ||
wsNS.EqualsASCII("http://www.xfa.org/schema/xfa-data/1.0/")) {
continue;
}
CXFA_Node* pXFAMetaData = node_factory_->CreateNode(
XFA_PacketType::Datasets, XFA_Element::DataValue);
if (!pXFAMetaData)
return;
pXFAMetaData->JSObject()->SetCData(XFA_Attribute::Name, wsName);
pXFAMetaData->JSObject()->SetCData(XFA_Attribute::QualifiedName,
it.first);
pXFAMetaData->JSObject()->SetCData(XFA_Attribute::Value, it.second);
pXFAMetaData->JSObject()->SetEnum(
XFA_Attribute::Contains, XFA_AttributeValue::MetaData, false);
pXFAChild->InsertChildAndNotify(pXFAMetaData, nullptr);
pXFAMetaData->SetXMLMappingNode(pXMLElement);
pXFAMetaData->SetFlag(XFA_NodeFlag_Initialized);
}
if (!bNeedValue)
pXMLElement->RemoveAttribute(L"xsi:nil");
pXFANode->InsertChildAndNotify(pXFAChild, nullptr);
if (eNodeType == XFA_Element::DataGroup)
ParseDataGroup(pXFAChild, pXMLElement, ePacketID);
else if (bNeedValue)
ParseDataValue(pXFAChild, pXMLChild, XFA_PacketType::Datasets);
pXFAChild->SetXMLMappingNode(pXMLElement);
pXFAChild->SetFlag(XFA_NodeFlag_Initialized);
continue;
}
case CFX_XMLNode::Type::kCharData:
case CFX_XMLNode::Type::kText: {
CFX_XMLText* pXMLText = ToXMLText(pXMLChild);
WideString wsText = pXMLText->GetText();
if (IsStringAllWhitespace(wsText))
continue;
CXFA_Node* pXFAChild = node_factory_->CreateNode(
XFA_PacketType::Datasets, XFA_Element::DataValue);
if (!pXFAChild)
return;
pXFAChild->JSObject()->SetCData(XFA_Attribute::Value, wsText);
pXFANode->InsertChildAndNotify(pXFAChild, nullptr);
pXFAChild->SetXMLMappingNode(pXMLText);
pXFAChild->SetFlag(XFA_NodeFlag_Initialized);
continue;
}
default:
continue;
}
}
}
void CXFA_DocumentBuilder::ParseDataValue(CXFA_Node* pXFANode,
CFX_XMLNode* pXMLNode,
XFA_PacketType ePacketID) {
CFX_WideTextBuf wsValueTextBuf;
CFX_WideTextBuf wsCurValueTextBuf;
bool bMarkAsCompound = false;
CFX_XMLNode* pXMLCurValueNode = nullptr;
for (CFX_XMLNode* pXMLChild = pXMLNode->GetFirstChild(); pXMLChild;
pXMLChild = pXMLChild->GetNextSibling()) {
CFX_XMLNode::Type eNodeType = pXMLChild->GetType();
if (eNodeType == CFX_XMLNode::Type::kInstruction)
continue;
CFX_XMLText* pText = ToXMLText(pXMLChild);
if (pText) {
WideString wsText = pText->GetText();
if (!pXMLCurValueNode)
pXMLCurValueNode = pXMLChild;
wsCurValueTextBuf << wsText;
continue;
}
if (XFA_RecognizeRichText(ToXMLElement(pXMLChild))) {
WideString wsText = GetPlainTextFromRichText(ToXMLElement(pXMLChild));
if (!pXMLCurValueNode)
pXMLCurValueNode = pXMLChild;
wsCurValueTextBuf << wsText;
continue;
}
bMarkAsCompound = true;
if (pXMLCurValueNode) {
WideString wsCurValue = wsCurValueTextBuf.MakeString();
if (!wsCurValue.IsEmpty()) {
CXFA_Node* pXFAChild =
node_factory_->CreateNode(ePacketID, XFA_Element::DataValue);
if (!pXFAChild)
return;
pXFAChild->JSObject()->SetCData(XFA_Attribute::Name, WideString());
pXFAChild->JSObject()->SetCData(XFA_Attribute::Value, wsCurValue);
pXFANode->InsertChildAndNotify(pXFAChild, nullptr);
pXFAChild->SetXMLMappingNode(pXMLCurValueNode);
pXFAChild->SetFlag(XFA_NodeFlag_Initialized);
wsValueTextBuf << wsCurValue;
wsCurValueTextBuf.Clear();
}
pXMLCurValueNode = nullptr;
}
CXFA_Node* pXFAChild =
node_factory_->CreateNode(ePacketID, XFA_Element::DataValue);
if (!pXFAChild)
return;
WideString wsNodeStr = ToXMLElement(pXMLChild)->GetLocalTagName();
pXFAChild->JSObject()->SetCData(XFA_Attribute::Name, wsNodeStr);
ParseDataValue(pXFAChild, pXMLChild, ePacketID);
pXFANode->InsertChildAndNotify(pXFAChild, nullptr);
pXFAChild->SetXMLMappingNode(pXMLChild);
pXFAChild->SetFlag(XFA_NodeFlag_Initialized);
WideString wsCurValue =
pXFAChild->JSObject()->GetCData(XFA_Attribute::Value);
wsValueTextBuf << wsCurValue;
}
if (pXMLCurValueNode) {
WideString wsCurValue = wsCurValueTextBuf.MakeString();
if (!wsCurValue.IsEmpty()) {
if (bMarkAsCompound) {
CXFA_Node* pXFAChild =
node_factory_->CreateNode(ePacketID, XFA_Element::DataValue);
if (!pXFAChild)
return;
pXFAChild->JSObject()->SetCData(XFA_Attribute::Name, WideString());
pXFAChild->JSObject()->SetCData(XFA_Attribute::Value, wsCurValue);
pXFANode->InsertChildAndNotify(pXFAChild, nullptr);
pXFAChild->SetXMLMappingNode(pXMLCurValueNode);
pXFAChild->SetFlag(XFA_NodeFlag_Initialized);
}
wsValueTextBuf << wsCurValue;
wsCurValueTextBuf.Clear();
}
pXMLCurValueNode = nullptr;
}
WideString wsNodeValue = wsValueTextBuf.MakeString();
pXFANode->JSObject()->SetCData(XFA_Attribute::Value, wsNodeValue);
}
void CXFA_DocumentBuilder::ParseInstruction(CXFA_Node* pXFANode,
CFX_XMLInstruction* pXMLInstruction,
XFA_PacketType ePacketID) {
const std::vector<WideString>& target_data = pXMLInstruction->GetTargetData();
if (pXMLInstruction->IsOriginalXFAVersion()) {
if (target_data.size() > 1 &&
(pXFANode->GetDocument()->RecognizeXFAVersionNumber(target_data[0]) !=
XFA_VERSION_UNKNOWN) &&
target_data[1].EqualsASCII("v2.7-scripting:1")) {
pXFANode->GetDocument()->set_is_scripting();
}
return;
}
if (pXMLInstruction->IsAcrobat()) {
if (target_data.size() > 1 && target_data[0].EqualsASCII("JavaScript") &&
target_data[1].EqualsASCII("strictScoping")) {
pXFANode->GetDocument()->set_is_strict_scoping();
}
}
}