Split xfa_object_imp into individual class files.

xfa/fxfa/parser/cxfa_node.cpp

-// Copyright 2014 PDFium Authors. All rights reserved.
+// 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/xfa_object.h"
 
+#include <map>
 #include <memory>
 
 #include "core/fxcrt/include/fx_ext.h"
-#include "fxjs/include/cfxjse_arguments.h"
+#include "fxjs/include/cfxjse_value.h"
 #include "third_party/base/stl_util.h"
 #include "xfa/fde/xml/fde_xml_imp.h"
 #include "xfa/fgas/crt/fgas_codepage.h"
 #include "xfa/fgas/crt/fgas_system.h"
 #include "xfa/fxfa/app/xfa_ffnotify.h"
+#include "xfa/fxfa/include/cxfa_eventparam.h"
 #include "xfa/fxfa/parser/cxfa_occur.h"
 #include "xfa/fxfa/parser/cxfa_simple_parser.h"
-#include "xfa/fxfa/parser/xfa_basic_imp.h"
-#include "xfa/fxfa/parser/xfa_doclayout.h"
+#include "xfa/fxfa/parser/xfa_basic_data.h"
 #include "xfa/fxfa/parser/xfa_document.h"
 #include "xfa/fxfa/parser/xfa_document_layout_imp.h"
-#include "xfa/fxfa/parser/xfa_localemgr.h"
-#include "xfa/fxfa/parser/xfa_script.h"
 #include "xfa/fxfa/parser/xfa_script_imp.h"
-#include "xfa/fxfa/parser/xfa_utils.h"
 
 namespace {
 
 void XFA_DeleteWideString(void* pData) {
   delete static_cast<CFX_WideString*>(pData);
 }
 
 void XFA_CopyWideString(void*& pData) {
   if (pData) {
     CFX_WideString* pNewData = new CFX_WideString(*(CFX_WideString*)pData);
     pData = pNewData;
   }
 }
 
 XFA_MAPDATABLOCKCALLBACKINFO deleteWideStringCallBack = {XFA_DeleteWideString,
                                                          XFA_CopyWideString};
 
 void XFA_DataNodeDeleteBindItem(void* pData) {
   delete static_cast<CXFA_NodeArray*>(pData);
 }
 
 XFA_MAPDATABLOCKCALLBACKINFO deleteBindItemCallBack = {
     XFA_DataNodeDeleteBindItem, nullptr};
 
+int32_t GetCount(CXFA_Node* pInstMgrNode) {
+  ASSERT(pInstMgrNode);
+  int32_t iCount = 0;
+  uint32_t dwNameHash = 0;
+  for (CXFA_Node* pNode = pInstMgrNode->GetNodeItem(XFA_NODEITEM_NextSibling);
+       pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
+    XFA_Element eCurType = pNode->GetElementType();
+    if (eCurType == XFA_Element::InstanceManager)
+      break;
+    if ((eCurType != XFA_Element::Subform) &&
+        (eCurType != XFA_Element::SubformSet)) {
+      continue;
+    }
+    if (iCount == 0) {
+      CFX_WideStringC wsName = pNode->GetCData(XFA_ATTRIBUTE_Name);
+      CFX_WideStringC wsInstName = pInstMgrNode->GetCData(XFA_ATTRIBUTE_Name);
+      if (wsInstName.GetLength() < 1 || wsInstName.GetAt(0) != '_' ||
+          wsInstName.Mid(1) != wsName) {
+        return iCount;
+      }
+      dwNameHash = pNode->GetNameHash();
+    }
+    if (dwNameHash != pNode->GetNameHash())
+      break;
+
+    iCount++;
+  }
+  return iCount;
+}
+
+void SortNodeArrayByDocumentIdx(const CXFA_NodeSet& rgNodeSet,
+                                CXFA_NodeArray& rgNodeArray,
+                                CFX_ArrayTemplate<int32_t>& rgIdxArray) {
+  int32_t iCount = pdfium::CollectionSize<int32_t>(rgNodeSet);
+  rgNodeArray.SetSize(iCount);
+  rgIdxArray.SetSize(iCount);
+  if (iCount == 0)
+    return;
+
+  int32_t iIndex = -1;
+  int32_t iTotalIndex = -1;
+  CXFA_Node* pCommonParent =
+      (*rgNodeSet.begin())->GetNodeItem(XFA_NODEITEM_Parent);
+  for (CXFA_Node* pNode = pCommonParent->GetNodeItem(XFA_NODEITEM_FirstChild);
+       pNode && iIndex < iCount;
+       pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
+    iTotalIndex++;
+    if (pdfium::ContainsValue(rgNodeSet, pNode)) {
+      iIndex++;
+      rgNodeArray[iIndex] = pNode;
+      rgIdxArray[iIndex] = iTotalIndex;
+    }
+  }
+}
+
+using CXFA_NodeSetPair = std::pair<CXFA_NodeSet, CXFA_NodeSet>;
+using CXFA_NodeSetPairMap =
+    std::map<uint32_t, std::unique_ptr<CXFA_NodeSetPair>>;
+using CXFA_NodeSetPairMapMap =
+    std::map<CXFA_Node*, std::unique_ptr<CXFA_NodeSetPairMap>>;
+
+CXFA_NodeSetPair* NodeSetPairForNode(CXFA_Node* pNode,
+                                     CXFA_NodeSetPairMapMap* pMap) {
+  CXFA_Node* pParentNode = pNode->GetNodeItem(XFA_NODEITEM_Parent);
+  uint32_t dwNameHash = pNode->GetNameHash();
+  if (!pParentNode || !dwNameHash)
+    return nullptr;
+
+  if (!(*pMap)[pParentNode])
+    (*pMap)[pParentNode].reset(new CXFA_NodeSetPairMap);
+
+  CXFA_NodeSetPairMap* pNodeSetPairMap = (*pMap)[pParentNode].get();
+  if (!(*pNodeSetPairMap)[dwNameHash])
+    (*pNodeSetPairMap)[dwNameHash].reset(new CXFA_NodeSetPair);
+
+  return (*pNodeSetPairMap)[dwNameHash].get();
+}
+
+void ReorderDataNodes(const CXFA_NodeSet& sSet1,
+                      const CXFA_NodeSet& sSet2,
+                      FX_BOOL bInsertBefore) {
+  CXFA_NodeSetPairMapMap rgMap;
+  for (CXFA_Node* pNode : sSet1) {
+    CXFA_NodeSetPair* pNodeSetPair = NodeSetPairForNode(pNode, &rgMap);
+    if (pNodeSetPair)
+      pNodeSetPair->first.insert(pNode);
+  }
+  for (CXFA_Node* pNode : sSet2) {
+    CXFA_NodeSetPair* pNodeSetPair = NodeSetPairForNode(pNode, &rgMap);
+    if (pNodeSetPair) {
+      if (pdfium::ContainsValue(pNodeSetPair->first, pNode))
+        pNodeSetPair->first.erase(pNode);
+      else
+        pNodeSetPair->second.insert(pNode);
+    }
+  }
+  for (const auto& iter1 : rgMap) {
+    CXFA_NodeSetPairMap* pNodeSetPairMap = iter1.second.get();
+    if (!pNodeSetPairMap)
+      continue;
+
+    for (const auto& iter2 : *pNodeSetPairMap) {
+      CXFA_NodeSetPair* pNodeSetPair = iter2.second.get();
+      if (!pNodeSetPair)
+        continue;
+      if (!pNodeSetPair->first.empty() && !pNodeSetPair->second.empty()) {
+        CXFA_NodeArray rgNodeArray1;
+        CXFA_NodeArray rgNodeArray2;
+        CFX_ArrayTemplate<int32_t> rgIdxArray1;
+        CFX_ArrayTemplate<int32_t> rgIdxArray2;
+        SortNodeArrayByDocumentIdx(pNodeSetPair->first, rgNodeArray1,
+                                   rgIdxArray1);
+        SortNodeArrayByDocumentIdx(pNodeSetPair->second, rgNodeArray2,
+                                   rgIdxArray2);
+        CXFA_Node* pParentNode = nullptr;
+        CXFA_Node* pBeforeNode = nullptr;
+        if (bInsertBefore) {
+          pBeforeNode = rgNodeArray2[0];
+          pParentNode = pBeforeNode->GetNodeItem(XFA_NODEITEM_Parent);
+        } else {
+          CXFA_Node* pLastNode = rgNodeArray2[rgIdxArray2.GetSize() - 1];
+          pParentNode = pLastNode->GetNodeItem(XFA_NODEITEM_Parent);
+          pBeforeNode = pLastNode->GetNodeItem(XFA_NODEITEM_NextSibling);
+        }
+        for (int32_t iIdx = 0; iIdx < rgIdxArray1.GetSize(); iIdx++) {
+          CXFA_Node* pCurNode = rgNodeArray1[iIdx];
+          pParentNode->RemoveChild(pCurNode);
+          pParentNode->InsertChild(pCurNode, pBeforeNode);
+        }
+      }
+    }
+    pNodeSetPairMap->clear();
+  }
+}
+
+CXFA_Node* GetItem(CXFA_Node* pInstMgrNode, int32_t iIndex) {
+  ASSERT(pInstMgrNode);
+  int32_t iCount = 0;
+  uint32_t dwNameHash = 0;
+  for (CXFA_Node* pNode = pInstMgrNode->GetNodeItem(XFA_NODEITEM_NextSibling);
+       pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
+    XFA_Element eCurType = pNode->GetElementType();
+    if (eCurType == XFA_Element::InstanceManager)
+      break;
+    if ((eCurType != XFA_Element::Subform) &&
+        (eCurType != XFA_Element::SubformSet)) {
+      continue;
+    }
+    if (iCount == 0) {
+      CFX_WideStringC wsName = pNode->GetCData(XFA_ATTRIBUTE_Name);
+      CFX_WideStringC wsInstName = pInstMgrNode->GetCData(XFA_ATTRIBUTE_Name);
+      if (wsInstName.GetLength() < 1 || wsInstName.GetAt(0) != '_' ||
+          wsInstName.Mid(1) != wsName) {
+        return nullptr;
+      }
+      dwNameHash = pNode->GetNameHash();
+    }
+    if (dwNameHash != pNode->GetNameHash())
+      break;
+
+    iCount++;
+    if (iCount > iIndex)
+      return pNode;
+  }
+  return nullptr;
+}
+
+void InsertItem(CXFA_Node* pInstMgrNode,
+                CXFA_Node* pNewInstance,
+                int32_t iPos,
+                int32_t iCount = -1,
+                FX_BOOL bMoveDataBindingNodes = TRUE) {
+  if (iCount < 0)
+    iCount = GetCount(pInstMgrNode);
+  if (iPos < 0)
+    iPos = iCount;
+  if (iPos == iCount) {
+    CXFA_Node* pNextSibling =
+        iCount > 0
+            ? GetItem(pInstMgrNode, iCount - 1)
+                  ->GetNodeItem(XFA_NODEITEM_NextSibling)
+            : pInstMgrNode->GetNodeItem(XFA_NODEITEM_NextSibling);
+    pInstMgrNode->GetNodeItem(XFA_NODEITEM_Parent)
+        ->InsertChild(pNewInstance, pNextSibling);
+    if (bMoveDataBindingNodes) {
+      CXFA_NodeSet sNew;
+      CXFA_NodeSet sAfter;
+      CXFA_NodeIteratorTemplate<CXFA_Node,
+                                CXFA_TraverseStrategy_XFAContainerNode>
+          sIteratorNew(pNewInstance);
+      for (CXFA_Node* pNode = sIteratorNew.GetCurrent(); pNode;
+           pNode = sIteratorNew.MoveToNext()) {
+        CXFA_Node* pDataNode = pNode->GetBindData();
+        if (!pDataNode)
+          continue;
+
+        sNew.insert(pDataNode);
+      }
+      CXFA_NodeIteratorTemplate<CXFA_Node,
+                                CXFA_TraverseStrategy_XFAContainerNode>
+          sIteratorAfter(pNextSibling);
+      for (CXFA_Node* pNode = sIteratorAfter.GetCurrent(); pNode;
+           pNode = sIteratorAfter.MoveToNext()) {
+        CXFA_Node* pDataNode = pNode->GetBindData();
+        if (!pDataNode)
+          continue;
+
+        sAfter.insert(pDataNode);
+      }
+      ReorderDataNodes(sNew, sAfter, FALSE);
+    }
+  } else {
+    CXFA_Node* pBeforeInstance = GetItem(pInstMgrNode, iPos);
+    pInstMgrNode->GetNodeItem(XFA_NODEITEM_Parent)
+        ->InsertChild(pNewInstance, pBeforeInstance);
+    if (bMoveDataBindingNodes) {
+      CXFA_NodeSet sNew;
+      CXFA_NodeSet sBefore;
+      CXFA_NodeIteratorTemplate<CXFA_Node,
+                                CXFA_TraverseStrategy_XFAContainerNode>
+          sIteratorNew(pNewInstance);
+      for (CXFA_Node* pNode = sIteratorNew.GetCurrent(); pNode;
+           pNode = sIteratorNew.MoveToNext()) {
+        CXFA_Node* pDataNode = pNode->GetBindData();
+        if (!pDataNode)
+          continue;
+
+        sNew.insert(pDataNode);
+      }
+      CXFA_NodeIteratorTemplate<CXFA_Node,
+                                CXFA_TraverseStrategy_XFAContainerNode>
+          sIteratorBefore(pBeforeInstance);
+      for (CXFA_Node* pNode = sIteratorBefore.GetCurrent(); pNode;
+           pNode = sIteratorBefore.MoveToNext()) {
+        CXFA_Node* pDataNode = pNode->GetBindData();
+        if (!pDataNode)
+          continue;
+
+        sBefore.insert(pDataNode);
+      }
+      ReorderDataNodes(sNew, sBefore, TRUE);
+    }
+  }
+}
+
+void RemoveItem(CXFA_Node* pInstMgrNode,
+                CXFA_Node* pRemoveInstance,
+                FX_BOOL bRemoveDataBinding = TRUE) {
+  pInstMgrNode->GetNodeItem(XFA_NODEITEM_Parent)->RemoveChild(pRemoveInstance);
+  if (!bRemoveDataBinding)
+    return;
+
+  CXFA_NodeIteratorTemplate<CXFA_Node, CXFA_TraverseStrategy_XFAContainerNode>
+      sIterator(pRemoveInstance);
+  for (CXFA_Node* pFormNode = sIterator.GetCurrent(); pFormNode;
+       pFormNode = sIterator.MoveToNext()) {
+    CXFA_Node* pDataNode = pFormNode->GetBindData();
+    if (!pDataNode)
+      continue;
+
+    if (pDataNode->RemoveBindItem(pFormNode) == 0) {
+      if (CXFA_Node* pDataParent =
+              pDataNode->GetNodeItem(XFA_NODEITEM_Parent)) {
+        pDataParent->RemoveChild(pDataNode);
+      }
+    }
+    pFormNode->SetObject(XFA_ATTRIBUTE_BindingNode, nullptr);
+  }
+}
+
+CXFA_Node* CreateInstance(CXFA_Node* pInstMgrNode, FX_BOOL bDataMerge) {
+  CXFA_Document* pDocument = pInstMgrNode->GetDocument();
+  CXFA_Node* pTemplateNode = pInstMgrNode->GetTemplateNode();
+  CXFA_Node* pFormParent = pInstMgrNode->GetNodeItem(XFA_NODEITEM_Parent);
+  CXFA_Node* pDataScope = nullptr;
+  for (CXFA_Node* pRootBoundNode = pFormParent;
+       pRootBoundNode && pRootBoundNode->IsContainerNode();
+       pRootBoundNode = pRootBoundNode->GetNodeItem(XFA_NODEITEM_Parent)) {
+    pDataScope = pRootBoundNode->GetBindData();
+    if (pDataScope)
+      break;
+  }
+  if (!pDataScope) {
+    pDataScope = ToNode(pDocument->GetXFAObject(XFA_HASHCODE_Record));
+    ASSERT(pDataScope);
+  }
+  CXFA_Node* pInstance = pDocument->DataMerge_CopyContainer(
+      pTemplateNode, pFormParent, pDataScope, TRUE, bDataMerge, TRUE);
+  if (pInstance) {
+    pDocument->DataMerge_UpdateBindingRelations(pInstance);
+    pFormParent->RemoveChild(pInstance);
+  }
+  return pInstance;
+}
+
+struct XFA_ExecEventParaInfo {
+ public:
+  uint32_t m_uHash;
+  const FX_WCHAR* m_lpcEventName;
+  XFA_EVENTTYPE m_eventType;
+  uint32_t m_validFlags;
+};
+static const XFA_ExecEventParaInfo gs_eventParaInfos[] = {
+    {0x02a6c55a, L"postSubmit", XFA_EVENT_PostSubmit, 0},
+    {0x0ab466bb, L"preSubmit", XFA_EVENT_PreSubmit, 0},
+    {0x109d7ce7, L"mouseEnter", XFA_EVENT_MouseEnter, 5},
+    {0x17fad373, L"postPrint", XFA_EVENT_PostPrint, 0},
+    {0x1bfc72d9, L"preOpen", XFA_EVENT_PreOpen, 7},
+    {0x2196a452, L"initialize", XFA_EVENT_Initialize, 1},
+    {0x27410f03, L"mouseExit", XFA_EVENT_MouseExit, 5},
+    {0x33c43dec, L"docClose", XFA_EVENT_DocClose, 0},
+    {0x361fa1b6, L"preSave", XFA_EVENT_PreSave, 0},
+    {0x36f1c6d8, L"preSign", XFA_EVENT_PreSign, 6},
+    {0x4731d6ba, L"exit", XFA_EVENT_Exit, 2},
+    {0x56bf456b, L"docReady", XFA_EVENT_DocReady, 0},
+    {0x7233018a, L"validate", XFA_EVENT_Validate, 1},
+    {0x8808385e, L"indexChange", XFA_EVENT_IndexChange, 3},
+    {0x891f4606, L"change", XFA_EVENT_Change, 4},
+    {0x9528a7b4, L"prePrint", XFA_EVENT_PrePrint, 0},
+    {0x9f693b21, L"mouseDown", XFA_EVENT_MouseDown, 5},
+    {0xcdce56b3, L"full", XFA_EVENT_Full, 4},
+    {0xd576d08e, L"mouseUp", XFA_EVENT_MouseUp, 5},
+    {0xd95657a6, L"click", XFA_EVENT_Click, 4},
+    {0xdbfbe02e, L"calculate", XFA_EVENT_Calculate, 1},
+    {0xe25fa7b8, L"postOpen", XFA_EVENT_PostOpen, 7},
+    {0xe28dce7e, L"enter", XFA_EVENT_Enter, 2},
+    {0xfc82d695, L"postSave", XFA_EVENT_PostSave, 0},
+    {0xfd54fbb7, L"postSign", XFA_EVENT_PostSign, 6},
+};
+
+const XFA_ExecEventParaInfo* GetEventParaInfoByName(
+    const CFX_WideStringC& wsEventName) {
+  uint32_t uHash = FX_HashCode_GetW(wsEventName, false);
+  int32_t iStart = 0;
+  int32_t iEnd = (sizeof(gs_eventParaInfos) / sizeof(gs_eventParaInfos[0])) - 1;
+  do {
+    int32_t iMid = (iStart + iEnd) / 2;
+    const XFA_ExecEventParaInfo* eventParaInfo = &gs_eventParaInfos[iMid];
+    if (uHash == eventParaInfo->m_uHash)
+      return eventParaInfo;
+    if (uHash < eventParaInfo->m_uHash)
+      iEnd = iMid - 1;
+    else
+      iStart = iMid + 1;
+  } while (iStart <= iEnd);
+  return nullptr;
+}
+
+void StrToRGB(const CFX_WideString& strRGB,
+              int32_t& r,
+              int32_t& g,
+              int32_t& b) {
+  r = 0;
+  g = 0;
+  b = 0;
+
+  FX_WCHAR zero = '0';
+  int32_t iIndex = 0;
+  int32_t iLen = strRGB.GetLength();
+  for (int32_t i = 0; i < iLen; ++i) {
+    FX_WCHAR ch = strRGB.GetAt(i);
+    if (ch == L',')
+      ++iIndex;
+    if (iIndex > 2)
+      break;
+
+    int32_t iValue = ch - zero;
+    if (iValue >= 0 && iValue <= 9) {
+      switch (iIndex) {
+        case 0:
+          r = r * 10 + iValue;
+          break;
+        case 1:
+          g = g * 10 + iValue;
+          break;
+        default:
+          b = b * 10 + iValue;
+          break;
+      }
+    }
+  }
+}
+
+enum XFA_KEYTYPE {
+  XFA_KEYTYPE_Custom,
+  XFA_KEYTYPE_Element,
+};
+
+void* GetMapKey_Custom(const CFX_WideStringC& wsKey) {
+  uint32_t dwKey = FX_HashCode_GetW(wsKey, false);
+  return (void*)(uintptr_t)((dwKey << 1) | XFA_KEYTYPE_Custom);
+}
+
+void* GetMapKey_Element(XFA_Element eType, XFA_ATTRIBUTE eAttribute) {
+  return (void*)(uintptr_t)((static_cast<int32_t>(eType) << 16) |
+                            (eAttribute << 8) | XFA_KEYTYPE_Element);
+}
+
 }  // namespace
 
-CXFA_Object::CXFA_Object(CXFA_Document* pDocument,
-                         XFA_ObjectType objectType,
-                         XFA_Element elementType,
-                         const CFX_WideStringC& elementName)
-    : m_pDocument(pDocument),
-      m_objectType(objectType),
-      m_elementType(elementType),
-      m_elementNameHash(FX_HashCode_GetW(elementName, false)),
-      m_elementName(elementName) {}
-
-CXFA_Object::~CXFA_Object() {}
-
-CFX_WideStringC CXFA_Object::GetClassName() const {
-  return m_elementName;
-}
-
-uint32_t CXFA_Object::GetClassHashCode() const {
-  return m_elementNameHash;
-}
-
-XFA_Element CXFA_Object::GetElementType() const {
-  return m_elementType;
-}
-
-void CXFA_Object::Script_ObjectClass_ClassName(CFXJSE_Value* pValue,
-                                               FX_BOOL bSetting,
-                                               XFA_ATTRIBUTE eAttribute) {
-  if (!bSetting) {
-    CFX_WideStringC className = GetClassName();
-    pValue->SetString(
-        FX_UTF8Encode(className.c_str(), className.GetLength()).AsStringC());
-  } else {
-    ThrowException(XFA_IDS_INVAlID_PROP_SET);
-  }
-}
-
-void CXFA_Object::ThrowException(int32_t iStringID, ...) {
-  IXFA_AppProvider* pAppProvider = m_pDocument->GetNotify()->GetAppProvider();
-  ASSERT(pAppProvider);
-  CFX_WideString wsFormat;
-  pAppProvider->LoadString(iStringID, wsFormat);
-  CFX_WideString wsMessage;
-  va_list arg_ptr;
-  va_start(arg_ptr, iStringID);
-  wsMessage.FormatV(wsFormat.c_str(), arg_ptr);
-  va_end(arg_ptr);
-  FXJSE_ThrowMessage(
-      FX_UTF8Encode(wsMessage.c_str(), wsMessage.GetLength()).AsStringC());
-}
+static void XFA_DefaultFreeData(void* pData) {}
+
+static XFA_MAPDATABLOCKCALLBACKINFO gs_XFADefaultFreeData = {
+    XFA_DefaultFreeData, nullptr};
 
 XFA_MAPMODULEDATA::XFA_MAPMODULEDATA() {}
 
 XFA_MAPMODULEDATA::~XFA_MAPMODULEDATA() {}
 
 CXFA_Node::CXFA_Node(CXFA_Document* pDoc,
                      uint16_t ePacket,
                      XFA_ObjectType oType,
                      XFA_Element eType,
                      const CFX_WideStringC& elementName)
@@ skipping 1075 matching lines @@
 
 void CXFA_Node::Script_ContainerClass_GetDelta(CFXJSE_Arguments* pArguments) {}
 
 void CXFA_Node::Script_ContainerClass_GetDeltas(CFXJSE_Arguments* pArguments) {
   CXFA_ArrayNodeList* pFormNodes = new CXFA_ArrayNodeList(m_pDocument);
   pArguments->GetReturnValue()->SetObject(
       pFormNodes, m_pDocument->GetScriptContext()->GetJseNormalClass());
 }
 void CXFA_Node::Script_ModelClass_ClearErrorList(CFXJSE_Arguments* pArguments) {
 }
+
 void CXFA_Node::Script_ModelClass_CreateNode(CFXJSE_Arguments* pArguments) {
   Script_Template_CreateNode(pArguments);
 }
+
 void CXFA_Node::Script_ModelClass_IsCompatibleNS(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength < 1) {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"isCompatibleNS");
     return;
   }
   CFX_WideString wsNameSpace;
   if (iLength >= 1) {
     CFX_ByteString bsNameSpace = pArguments->GetUTF8String(0);
     wsNameSpace = CFX_WideString::FromUTF8(bsNameSpace.AsStringC());
   }
   CFX_WideString wsNodeNameSpace;
   TryNamespace(wsNodeNameSpace);
   CFXJSE_Value* pValue = pArguments->GetReturnValue();
   if (pValue)
     pValue->SetBoolean(wsNodeNameSpace == wsNameSpace);
 }
+
 void CXFA_Node::Script_ModelClass_Context(CFXJSE_Value* pValue,
                                           FX_BOOL bSetting,
                                           XFA_ATTRIBUTE eAttribute) {}
+
 void CXFA_Node::Script_ModelClass_AliasNode(CFXJSE_Value* pValue,
                                             FX_BOOL bSetting,
                                             XFA_ATTRIBUTE eAttribute) {}
+
 void CXFA_Node::Script_Attribute_Integer(CFXJSE_Value* pValue,
                                          FX_BOOL bSetting,
                                          XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     SetInteger(eAttribute, pValue->ToInteger(), true);
   } else {
     pValue->SetInteger(GetInteger(eAttribute));
   }
 }
+
 void CXFA_Node::Script_Attribute_IntegerRead(CFXJSE_Value* pValue,
                                              FX_BOOL bSetting,
                                              XFA_ATTRIBUTE eAttribute) {
   if (!bSetting) {
     pValue->SetInteger(GetInteger(eAttribute));
   } else {
     ThrowException(XFA_IDS_INVAlID_PROP_SET);
   }
 }
+
 void CXFA_Node::Script_Attribute_BOOL(CFXJSE_Value* pValue,
                                       FX_BOOL bSetting,
                                       XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     SetBoolean(eAttribute, pValue->ToBoolean(), true);
   } else {
     pValue->SetString(GetBoolean(eAttribute) ? "1" : "0");
   }
 }
+
 void CXFA_Node::Script_Attribute_BOOLRead(CFXJSE_Value* pValue,
                                           FX_BOOL bSetting,
                                           XFA_ATTRIBUTE eAttribute) {
   if (!bSetting) {
     pValue->SetString(GetBoolean(eAttribute) ? "1" : "0");
   } else {
     ThrowException(XFA_IDS_INVAlID_PROP_SET);
   }
 }
 
@@ skipping 209 matching lines @@
         delete pProtoForm;
       }
     }
   } else {
     CFX_WideString wsValue;
     GetAttribute(eAttribute, wsValue);
     pValue->SetString(
         FX_UTF8Encode(wsValue.c_str(), wsValue.GetLength()).AsStringC());
   }
 }
+
 void CXFA_Node::Script_Attribute_StringRead(CFXJSE_Value* pValue,
                                             FX_BOOL bSetting,
                                             XFA_ATTRIBUTE eAttribute) {
   if (!bSetting) {
     CFX_WideString wsValue;
     GetAttribute(eAttribute, wsValue);
     pValue->SetString(
         FX_UTF8Encode(wsValue.c_str(), wsValue.GetLength()).AsStringC());
   } else {
     ThrowException(XFA_IDS_INVAlID_PROP_SET);
   }
 }
+
 void CXFA_Node::Script_WsdlConnection_Execute(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if ((argc == 0) || (argc == 1)) {
     pArguments->GetReturnValue()->SetBoolean(FALSE);
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execute");
   }
 }
+
 void CXFA_Node::Script_Delta_Restore(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"restore");
   }
 }
+
 void CXFA_Node::Script_Delta_CurrentValue(CFXJSE_Value* pValue,
                                           FX_BOOL bSetting,
                                           XFA_ATTRIBUTE eAttribute) {}
+
 void CXFA_Node::Script_Delta_SavedValue(CFXJSE_Value* pValue,
                                         FX_BOOL bSetting,
                                         XFA_ATTRIBUTE eAttribute) {}
+
 void CXFA_Node::Script_Delta_Target(CFXJSE_Value* pValue,
                                     FX_BOOL bSetting,
                                     XFA_ATTRIBUTE eAttribute) {}
+
 void CXFA_Node::Script_Som_Message(CFXJSE_Value* pValue,
                                    FX_BOOL bSetting,
                                    XFA_SOM_MESSAGETYPE iMessageType) {
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     return;
   }
   FX_BOOL bNew = FALSE;
   CXFA_Validate validate = pWidgetData->GetValidate();
   if (!validate) {
@@ skipping 32 matching lines @@
         break;
       case XFA_SOM_MandatoryMessage:
         validate.GetNullMessageText(wsMessage);
         break;
       default:
         break;
     }
     pValue->SetString(FX_UTF8Encode(wsMessage).AsStringC());
   }
 }
+
 void CXFA_Node::Script_Som_ValidationMessage(CFXJSE_Value* pValue,
                                              FX_BOOL bSetting,
                                              XFA_ATTRIBUTE eAttribute) {
   Script_Som_Message(pValue, bSetting, XFA_SOM_ValidationMessage);
 }
+
 void CXFA_Node::Script_Field_Length(CFXJSE_Value* pValue,
                                     FX_BOOL bSetting,
                                     XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     ThrowException(XFA_IDS_INVAlID_PROP_SET);
   } else {
     CXFA_WidgetData* pWidgetData = GetWidgetData();
     if (!pWidgetData) {
       pValue->SetInteger(0);
       return;
     }
     pValue->SetInteger(pWidgetData->CountChoiceListItems(TRUE));
   }
 }
+
 void CXFA_Node::Script_Som_DefaultValue(CFXJSE_Value* pValue,
                                         FX_BOOL bSetting,
                                         XFA_ATTRIBUTE eAttribute) {
   XFA_Element eType = GetElementType();
   if (eType == XFA_Element::Field) {
     Script_Field_DefaultValue(pValue, bSetting, eAttribute);
     return;
   }
   if (eType == XFA_Element::Draw) {
     Script_Draw_DefaultValue(pValue, bSetting, eAttribute);
@@ skipping 45 matching lines @@
       pValue->SetInteger(FXSYS_wtoi(content.c_str()));
     } else if (eType == XFA_Element::Float || eType == XFA_Element::Decimal) {
       CFX_Decimal decimal(content.AsStringC());
       pValue->SetFloat((FX_FLOAT)(double)decimal);
     } else {
       pValue->SetString(
           FX_UTF8Encode(content.c_str(), content.GetLength()).AsStringC());
     }
   }
 }
+
 void CXFA_Node::Script_Som_DefaultValue_Read(CFXJSE_Value* pValue,
                                              FX_BOOL bSetting,
                                              XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     ThrowException(XFA_IDS_INVAlID_PROP_SET);
     return;
   }
   CFX_WideString content = GetScriptContent(TRUE);
   if (content.IsEmpty()) {
     pValue->SetNull();
   } else {
     pValue->SetString(
         FX_UTF8Encode(content.c_str(), content.GetLength()).AsStringC());
   }
 }
+
 void CXFA_Node::Script_Boolean_Value(CFXJSE_Value* pValue,
                                      FX_BOOL bSetting,
                                      XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     CFX_ByteString newValue;
     if (!(pValue && (pValue->IsNull() || pValue->IsUndefined())))
       newValue = pValue->ToString();
 
     int32_t iValue = FXSYS_atoi(newValue.c_str());
     CFX_WideString wsNewValue(iValue == 0 ? L"0" : L"1");
     CFX_WideString wsFormatValue(wsNewValue);
     CXFA_WidgetData* pContainerWidgetData = GetContainerWidgetData();
     if (pContainerWidgetData) {
       pContainerWidgetData->GetFormatDataValue(wsNewValue, wsFormatValue);
     }
     SetScriptContent(wsNewValue, wsFormatValue, true, TRUE);
   } else {
     CFX_WideString wsValue = GetScriptContent(TRUE);
     pValue->SetBoolean(wsValue == FX_WSTRC(L"1"));
   }
 }
-struct XFA_ExecEventParaInfo {
- public:
-  uint32_t m_uHash;
-  const FX_WCHAR* m_lpcEventName;
-  XFA_EVENTTYPE m_eventType;
-  uint32_t m_validFlags;
-};
-static const XFA_ExecEventParaInfo gs_eventParaInfos[] = {
-    {0x02a6c55a, L"postSubmit", XFA_EVENT_PostSubmit, 0},
-    {0x0ab466bb, L"preSubmit", XFA_EVENT_PreSubmit, 0},
-    {0x109d7ce7, L"mouseEnter", XFA_EVENT_MouseEnter, 5},
-    {0x17fad373, L"postPrint", XFA_EVENT_PostPrint, 0},
-    {0x1bfc72d9, L"preOpen", XFA_EVENT_PreOpen, 7},
-    {0x2196a452, L"initialize", XFA_EVENT_Initialize, 1},
-    {0x27410f03, L"mouseExit", XFA_EVENT_MouseExit, 5},
-    {0x33c43dec, L"docClose", XFA_EVENT_DocClose, 0},
-    {0x361fa1b6, L"preSave", XFA_EVENT_PreSave, 0},
-    {0x36f1c6d8, L"preSign", XFA_EVENT_PreSign, 6},
-    {0x4731d6ba, L"exit", XFA_EVENT_Exit, 2},
-    {0x56bf456b, L"docReady", XFA_EVENT_DocReady, 0},
-    {0x7233018a, L"validate", XFA_EVENT_Validate, 1},
-    {0x8808385e, L"indexChange", XFA_EVENT_IndexChange, 3},
-    {0x891f4606, L"change", XFA_EVENT_Change, 4},
-    {0x9528a7b4, L"prePrint", XFA_EVENT_PrePrint, 0},
-    {0x9f693b21, L"mouseDown", XFA_EVENT_MouseDown, 5},
-    {0xcdce56b3, L"full", XFA_EVENT_Full, 4},
-    {0xd576d08e, L"mouseUp", XFA_EVENT_MouseUp, 5},
-    {0xd95657a6, L"click", XFA_EVENT_Click, 4},
-    {0xdbfbe02e, L"calculate", XFA_EVENT_Calculate, 1},
-    {0xe25fa7b8, L"postOpen", XFA_EVENT_PostOpen, 7},
-    {0xe28dce7e, L"enter", XFA_EVENT_Enter, 2},
-    {0xfc82d695, L"postSave", XFA_EVENT_PostSave, 0},
-    {0xfd54fbb7, L"postSign", XFA_EVENT_PostSign, 6},
-};
-const XFA_ExecEventParaInfo* GetEventParaInfoByName(
-    const CFX_WideStringC& wsEventName) {
-  uint32_t uHash = FX_HashCode_GetW(wsEventName, false);
-  int32_t iStart = 0;
-  int32_t iEnd = (sizeof(gs_eventParaInfos) / sizeof(gs_eventParaInfos[0])) - 1;
-  do {
-    int32_t iMid = (iStart + iEnd) / 2;
-    const XFA_ExecEventParaInfo* eventParaInfo = &gs_eventParaInfos[iMid];
-    if (uHash == eventParaInfo->m_uHash) {
-      return eventParaInfo;
-    }
-    if (uHash < eventParaInfo->m_uHash) {
-      iEnd = iMid - 1;
-    } else {
-      iStart = iMid + 1;
-    }
-  } while (iStart <= iEnd);
-  return nullptr;
-}
-void XFA_STRING_TO_RGB(const CFX_WideString& strRGB,
-                       int32_t& r,
-                       int32_t& g,
-                       int32_t& b) {
-  r = 0;
-  g = 0;
-  b = 0;
 
-  FX_WCHAR zero = '0';
-  int32_t iIndex = 0;
-  int32_t iLen = strRGB.GetLength();
-  for (int32_t i = 0; i < iLen; ++i) {
-    FX_WCHAR ch = strRGB.GetAt(i);
-    if (ch == L',') {
-      ++iIndex;
-    }
-    if (iIndex > 2) {
-      break;
-    }
-    int32_t iValue = ch - zero;
-    if (iValue >= 0 && iValue <= 9) {
-      switch (iIndex) {
-        case 0:
-          r = r * 10 + iValue;
-          break;
-        case 1:
-          g = g * 10 + iValue;
-          break;
-        default:
-          b = b * 10 + iValue;
-          break;
-      }
-    }
-  }
-}
 void CXFA_Node::Script_Som_BorderColor(CFXJSE_Value* pValue,
                                        FX_BOOL bSetting,
                                        XFA_ATTRIBUTE eAttribute) {
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     return;
   }
   CXFA_Border border = pWidgetData->GetBorder(TRUE);
   int32_t iSize = border.CountEdges();
   if (bSetting) {
     int32_t r = 0;
     int32_t g = 0;
     int32_t b = 0;
-    XFA_STRING_TO_RGB(pValue->ToWideString(), r, g, b);
+    StrToRGB(pValue->ToWideString(), r, g, b);
     FX_ARGB rgb = ArgbEncode(100, r, g, b);
     for (int32_t i = 0; i < iSize; ++i) {
       CXFA_Edge edge = border.GetEdge(i);
       edge.SetColor(rgb);
     }
   } else {
     CXFA_Edge edge = border.GetEdge(0);
     FX_ARGB color = edge.GetColor();
     int32_t a, r, g, b;
     ArgbDecode(color, a, r, g, b);
     CFX_WideString strColor;
     strColor.Format(L"%d,%d,%d", r, g, b);
     pValue->SetString(FX_UTF8Encode(strColor).AsStringC());
   }
 }
+
 void CXFA_Node::Script_Som_BorderWidth(CFXJSE_Value* pValue,
                                        FX_BOOL bSetting,
                                        XFA_ATTRIBUTE eAttribute) {
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     return;
   }
   CXFA_Border border = pWidgetData->GetBorder(TRUE);
   int32_t iSize = border.CountEdges();
   CFX_WideString wsThickness;
   if (bSetting) {
     wsThickness = pValue->ToWideString();
     for (int32_t i = 0; i < iSize; ++i) {
       CXFA_Edge edge = border.GetEdge(i);
       CXFA_Measurement thickness(wsThickness.AsStringC());
       edge.SetMSThickness(thickness);
     }
   } else {
     CXFA_Edge edge = border.GetEdge(0);
     CXFA_Measurement thickness = edge.GetMSThickness();
     thickness.ToString(wsThickness);
     pValue->SetString(FX_UTF8Encode(wsThickness).AsStringC());
   }
 }
+
 void CXFA_Node::Script_Som_FillColor(CFXJSE_Value* pValue,
                                      FX_BOOL bSetting,
                                      XFA_ATTRIBUTE eAttribute) {
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     return;
   }
   CXFA_Border border = pWidgetData->GetBorder(TRUE);
   CXFA_Fill borderfill = border.GetFill(TRUE);
   CXFA_Node* pNode = borderfill.GetNode();
   if (!pNode) {
     return;
   }
   if (bSetting) {
     int32_t r;
     int32_t g;
     int32_t b;
-    XFA_STRING_TO_RGB(pValue->ToWideString(), r, g, b);
+    StrToRGB(pValue->ToWideString(), r, g, b);
     FX_ARGB color = ArgbEncode(0xff, r, g, b);
     borderfill.SetColor(color);
   } else {
     FX_ARGB color = borderfill.GetColor();
     int32_t a;
     int32_t r;
     int32_t g;
     int32_t b;
     ArgbDecode(color, a, r, g, b);
     CFX_WideString wsColor;
     wsColor.Format(L"%d,%d,%d", r, g, b);
     pValue->SetString(FX_UTF8Encode(wsColor).AsStringC());
   }
 }
+
 void CXFA_Node::Script_Som_DataNode(CFXJSE_Value* pValue,
                                     FX_BOOL bSetting,
                                     XFA_ATTRIBUTE eAttribute) {
   if (!bSetting) {
     CXFA_Node* pDataNode = GetBindData();
     if (pDataNode) {
       pValue->Assign(
           m_pDocument->GetScriptContext()->GetJSValueFromMap(pDataNode));
     } else {
       pValue->SetNull();
     }
   } else {
     ThrowException(XFA_IDS_INVAlID_PROP_SET);
   }
 }
+
 void CXFA_Node::Script_Draw_DefaultValue(CFXJSE_Value* pValue,
                                          FX_BOOL bSetting,
                                          XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     if (pValue && pValue->IsString()) {
       CXFA_WidgetData* pWidgetData = GetWidgetData();
       ASSERT(pWidgetData);
       XFA_Element uiType = pWidgetData->GetUIType();
       if (uiType == XFA_Element::Text) {
         CFX_WideString wsNewValue = pValue->ToWideString();
         CFX_WideString wsFormatValue(wsNewValue);
         SetScriptContent(wsNewValue, wsFormatValue, true, TRUE);
       }
     }
   } else {
     CFX_WideString content = GetScriptContent(TRUE);
     if (content.IsEmpty()) {
       pValue->SetNull();
     } else {
       pValue->SetString(
           FX_UTF8Encode(content.c_str(), content.GetLength()).AsStringC());
     }
   }
 }
+
 void CXFA_Node::Script_Field_DefaultValue(CFXJSE_Value* pValue,
                                           FX_BOOL bSetting,
                                           XFA_ATTRIBUTE eAttribute) {
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     return;
   }
   if (bSetting) {
     if (pValue && pValue->IsNull()) {
       pWidgetData->m_bPreNull = pWidgetData->m_bIsNull;
@@ skipping 45 matching lines @@
       } else if (pNode && pNode->GetElementType() == XFA_Element::Float) {
         CFX_Decimal decimal(content.AsStringC());
         pValue->SetFloat((FX_FLOAT)(double)decimal);
       } else {
         pValue->SetString(
             FX_UTF8Encode(content.c_str(), content.GetLength()).AsStringC());
       }
     }
   }
 }
+
 void CXFA_Node::Script_Field_EditValue(CFXJSE_Value* pValue,
                                        FX_BOOL bSetting,
                                        XFA_ATTRIBUTE eAttribute) {
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     return;
   }
   if (bSetting) {
     pWidgetData->SetValue(pValue->ToWideString(), XFA_VALUEPICTURE_Edit);
   } else {
     CFX_WideString wsValue;
     pWidgetData->GetValue(wsValue, XFA_VALUEPICTURE_Edit);
     pValue->SetString(FX_UTF8Encode(wsValue).AsStringC());
   }
 }
+
 void CXFA_Node::Script_Som_FontColor(CFXJSE_Value* pValue,
                                      FX_BOOL bSetting,
                                      XFA_ATTRIBUTE eAttribute) {
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     return;
   }
   CXFA_Font font = pWidgetData->GetFont(TRUE);
   CXFA_Node* pNode = font.GetNode();
   if (!pNode) {
     return;
   }
   if (bSetting) {
     int32_t r;
     int32_t g;
     int32_t b;
-    XFA_STRING_TO_RGB(pValue->ToWideString(), r, g, b);
+    StrToRGB(pValue->ToWideString(), r, g, b);
     FX_ARGB color = ArgbEncode(0xff, r, g, b);
     font.SetColor(color);
   } else {
     FX_ARGB color = font.GetColor();
     int32_t a;
     int32_t r;
     int32_t g;
     int32_t b;
     ArgbDecode(color, a, r, g, b);
     CFX_WideString wsColor;
     wsColor.Format(L"%d,%d,%d", r, g, b);
     pValue->SetString(FX_UTF8Encode(wsColor).AsStringC());
   }
 }
+
 void CXFA_Node::Script_Field_FormatMessage(CFXJSE_Value* pValue,
                                            FX_BOOL bSetting,
                                            XFA_ATTRIBUTE eAttribute) {
   Script_Som_Message(pValue, bSetting, XFA_SOM_FormatMessage);
 }
+
 void CXFA_Node::Script_Field_FormattedValue(CFXJSE_Value* pValue,
                                             FX_BOOL bSetting,
                                             XFA_ATTRIBUTE eAttribute) {
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     return;
   }
   if (bSetting) {
     pWidgetData->SetValue(pValue->ToWideString(), XFA_VALUEPICTURE_Display);
   } else {
     CFX_WideString wsValue;
     pWidgetData->GetValue(wsValue, XFA_VALUEPICTURE_Display);
     pValue->SetString(FX_UTF8Encode(wsValue).AsStringC());
   }
 }
+
 void CXFA_Node::Script_Som_Mandatory(CFXJSE_Value* pValue,
                                      FX_BOOL bSetting,
                                      XFA_ATTRIBUTE eAttribute) {
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     return;
   }
   CXFA_Validate validate = pWidgetData->GetValidate(TRUE);
   if (bSetting) {
     validate.SetNullTest(pValue->ToWideString());
   } else {
     int32_t iValue = validate.GetNullTest();
     const XFA_ATTRIBUTEENUMINFO* pInfo =
         XFA_GetAttributeEnumByID((XFA_ATTRIBUTEENUM)iValue);
     CFX_WideString wsValue;
     if (pInfo)
       wsValue = pInfo->pName;
     pValue->SetString(FX_UTF8Encode(wsValue).AsStringC());
   }
 }
+
 void CXFA_Node::Script_Som_MandatoryMessage(CFXJSE_Value* pValue,
                                             FX_BOOL bSetting,
                                             XFA_ATTRIBUTE eAttribute) {
   Script_Som_Message(pValue, bSetting, XFA_SOM_MandatoryMessage);
 }
+
 void CXFA_Node::Script_Field_ParentSubform(CFXJSE_Value* pValue,
                                            FX_BOOL bSetting,
                                            XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     ThrowException(XFA_IDS_INVAlID_PROP_SET);
   } else {
     pValue->SetNull();
   }
 }
+
 void CXFA_Node::Script_Field_SelectedIndex(CFXJSE_Value* pValue,
                                            FX_BOOL bSetting,
                                            XFA_ATTRIBUTE eAttribute) {
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     return;
   }
   if (bSetting) {
     int32_t iIndex = pValue->ToInteger();
     if (iIndex == -1) {
       pWidgetData->ClearAllSelections();
       return;
     }
     pWidgetData->SetItemState(iIndex, TRUE, true, TRUE, TRUE);
   } else {
     pValue->SetInteger(pWidgetData->GetSelectedItem());
   }
 }
+
 void CXFA_Node::Script_Field_ClearItems(CFXJSE_Arguments* pArguments) {
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     return;
   }
   pWidgetData->DeleteItem(-1, TRUE);
 }
+
 void CXFA_Node::Script_Field_ExecEvent(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 1) {
     CFX_ByteString eventString = pArguments->GetUTF8String(0);
     int32_t iRet = execSingleEventByName(
         CFX_WideString::FromUTF8(eventString.AsStringC()).AsStringC(),
         XFA_Element::Field);
     if (eventString == "validate") {
       pArguments->GetReturnValue()->SetBoolean(
           (iRet == XFA_EVENTERROR_Error) ? FALSE : TRUE);
     }
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execEvent");
   }
 }
+
 void CXFA_Node::Script_Field_ExecInitialize(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
     CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
     if (!pNotify) {
       return;
     }
     pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Initialize, FALSE, FALSE);
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execInitialize");
   }
 }
+
 void CXFA_Node::Script_Field_DeleteItem(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength != 1) {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"deleteItem");
     return;
   }
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     return;
   }
   int32_t iIndex = pArguments->GetInt32(0);
   FX_BOOL bValue = pWidgetData->DeleteItem(iIndex, TRUE, TRUE);
   CFXJSE_Value* pValue = pArguments->GetReturnValue();
   if (pValue)
     pValue->SetBoolean(bValue);
 }
+
 void CXFA_Node::Script_Field_GetSaveItem(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength != 1) {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"getSaveItem");
     return;
   }
   int32_t iIndex = pArguments->GetInt32(0);
   if (iIndex < 0) {
     pArguments->GetReturnValue()->SetNull();
     return;
   }
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     pArguments->GetReturnValue()->SetNull();
     return;
   }
   CFX_WideString wsValue;
   FX_BOOL bHasItem = pWidgetData->GetChoiceListItem(wsValue, iIndex, TRUE);
   if (bHasItem) {
     pArguments->GetReturnValue()->SetString(
         FX_UTF8Encode(wsValue.c_str(), wsValue.GetLength()).AsStringC());
   } else {
     pArguments->GetReturnValue()->SetNull();
   }
 }
+
 void CXFA_Node::Script_Field_BoundItem(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength != 1) {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"boundItem");
     return;
   }
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     return;
   }
   CFX_ByteString bsValue = pArguments->GetUTF8String(0);
   CFX_WideString wsValue = CFX_WideString::FromUTF8(bsValue.AsStringC());
   CFX_WideString wsBoundValue;
   pWidgetData->GetItemValue(wsValue.AsStringC(), wsBoundValue);
   CFXJSE_Value* pValue = pArguments->GetReturnValue();
   if (pValue)
     pValue->SetString(FX_UTF8Encode(wsBoundValue).AsStringC());
 }
+
 void CXFA_Node::Script_Field_GetItemState(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength != 1) {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"getItemState");
     return;
   }
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     return;
   }
   int32_t iIndex = pArguments->GetInt32(0);
   FX_BOOL bValue = pWidgetData->GetItemState(iIndex);
   CFXJSE_Value* pValue = pArguments->GetReturnValue();
   if (pValue)
     pValue->SetBoolean(bValue);
 }
+
 void CXFA_Node::Script_Field_ExecCalculate(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
     CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
     if (!pNotify) {
       return;
     }
     pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Calculate, FALSE, FALSE);
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execCalculate");
   }
 }
+
 void CXFA_Node::Script_Field_SetItems(CFXJSE_Arguments* pArguments) {}
+
 void CXFA_Node::Script_Field_GetDisplayItem(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength != 1) {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"getDisplayItem");
     return;
   }
   int32_t iIndex = pArguments->GetInt32(0);
   if (iIndex < 0) {
     pArguments->GetReturnValue()->SetNull();
     return;
   }
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     pArguments->GetReturnValue()->SetNull();
     return;
   }
   CFX_WideString wsValue;
   FX_BOOL bHasItem = pWidgetData->GetChoiceListItem(wsValue, iIndex, FALSE);
   if (bHasItem) {
     pArguments->GetReturnValue()->SetString(
         FX_UTF8Encode(wsValue.c_str(), wsValue.GetLength()).AsStringC());
   } else {
     pArguments->GetReturnValue()->SetNull();
   }
 }
+
 void CXFA_Node::Script_Field_SetItemState(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength != 2) {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"setItemState");
     return;
   }
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData)
     return;
 
   int32_t iIndex = pArguments->GetInt32(0);
   if (pArguments->GetInt32(1) != 0) {
     pWidgetData->SetItemState(iIndex, TRUE, true, TRUE, TRUE);
   } else {
     if (pWidgetData->GetItemState(iIndex))
       pWidgetData->SetItemState(iIndex, FALSE, true, TRUE, TRUE);
   }
 }
+
 void CXFA_Node::Script_Field_AddItem(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength < 1 || iLength > 2) {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"addItem");
     return;
   }
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     return;
   }
   CFX_WideString wsLabel;
   CFX_WideString wsValue;
   if (iLength >= 1) {
     CFX_ByteString bsLabel = pArguments->GetUTF8String(0);
     wsLabel = CFX_WideString::FromUTF8(bsLabel.AsStringC());
   }
   if (iLength >= 2) {
     CFX_ByteString bsValue = pArguments->GetUTF8String(1);
     wsValue = CFX_WideString::FromUTF8(bsValue.AsStringC());
   }
   pWidgetData->InsertItem(wsLabel, wsValue, -1, TRUE);
 }
+
 void CXFA_Node::Script_Field_ExecValidate(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
     CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
     if (!pNotify) {
       pArguments->GetReturnValue()->SetBoolean(FALSE);
     } else {
       int32_t iRet =
           pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Validate, FALSE, FALSE);
       pArguments->GetReturnValue()->SetBoolean(
           (iRet == XFA_EVENTERROR_Error) ? FALSE : TRUE);
     }
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execValidate");
   }
 }
+
 void CXFA_Node::Script_ExclGroup_ErrorText(CFXJSE_Value* pValue,
                                            FX_BOOL bSetting,
                                            XFA_ATTRIBUTE eAttribute) {
   if (!bSetting) {
   } else {
     ThrowException(XFA_IDS_INVAlID_PROP_SET);
   }
 }
+
 void CXFA_Node::Script_ExclGroup_DefaultAndRawValue(CFXJSE_Value* pValue,
                                                     FX_BOOL bSetting,
                                                     XFA_ATTRIBUTE eAttribute) {
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     return;
   }
   if (bSetting) {
     pWidgetData->SetSelectedMemberByValue(pValue->ToWideString().AsStringC(),
                                           true, TRUE, TRUE);
   } else {
     CFX_WideString wsValue = GetScriptContent(TRUE);
     XFA_VERSION curVersion = GetDocument()->GetCurVersionMode();
     if (wsValue.IsEmpty() && curVersion >= XFA_VERSION_300) {
       pValue->SetNull();
     } else {
       pValue->SetString(FX_UTF8Encode(wsValue).AsStringC());
     }
   }
 }
+
 void CXFA_Node::Script_ExclGroup_Transient(CFXJSE_Value* pValue,
                                            FX_BOOL bSetting,
                                            XFA_ATTRIBUTE eAttribute) {}
+
 void CXFA_Node::Script_ExclGroup_ExecEvent(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 1) {
     CFX_ByteString eventString = pArguments->GetUTF8String(0);
     execSingleEventByName(
         CFX_WideString::FromUTF8(eventString.AsStringC()).AsStringC(),
         XFA_Element::ExclGroup);
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execEvent");
   }
@@ skipping 34 matching lines @@
   if (argc == 0) {
     CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
     if (!pNotify) {
       return;
     }
     pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Initialize);
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execInitialize");
   }
 }
+
 void CXFA_Node::Script_ExclGroup_ExecCalculate(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
     CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
     if (!pNotify) {
       return;
     }
     pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Calculate);
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execCalculate");
   }
 }
+
 void CXFA_Node::Script_ExclGroup_ExecValidate(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
     CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
     if (!pNotify) {
       pArguments->GetReturnValue()->SetBoolean(FALSE);
     } else {
       int32_t iRet = pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Validate);
       pArguments->GetReturnValue()->SetBoolean(
           (iRet == XFA_EVENTERROR_Error) ? FALSE : TRUE);
     }
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execValidate");
   }
 }
-static CXFA_Node* XFA_ScriptInstanceManager_GetItem(CXFA_Node* pInstMgrNode,
-                                                    int32_t iIndex) {
-  ASSERT(pInstMgrNode);
-  int32_t iCount = 0;
-  uint32_t dwNameHash = 0;
-  for (CXFA_Node* pNode = pInstMgrNode->GetNodeItem(XFA_NODEITEM_NextSibling);
-       pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    XFA_Element eCurType = pNode->GetElementType();
-    if (eCurType == XFA_Element::InstanceManager) {
-      break;
-    }
-    if ((eCurType != XFA_Element::Subform) &&
-        (eCurType != XFA_Element::SubformSet)) {
-      continue;
-    }
-    if (iCount == 0) {
-      CFX_WideStringC wsName = pNode->GetCData(XFA_ATTRIBUTE_Name);
-      CFX_WideStringC wsInstName = pInstMgrNode->GetCData(XFA_ATTRIBUTE_Name);
-      if (wsInstName.GetLength() < 1 || wsInstName.GetAt(0) != '_' ||
-          wsInstName.Mid(1) != wsName) {
-        return nullptr;
-      }
-      dwNameHash = pNode->GetNameHash();
-    }
-    if (dwNameHash != pNode->GetNameHash()) {
-      break;
-    }
-    iCount++;
-    if (iCount > iIndex) {
-      return pNode;
-    }
-  }
-  return nullptr;
-}
+
 void CXFA_Node::Script_Som_InstanceIndex(CFXJSE_Value* pValue,
                                          FX_BOOL bSetting,
                                          XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     int32_t iTo = pValue->ToInteger();
     int32_t iFrom = Subform_and_SubformSet_InstanceIndex();
     CXFA_Node* pManagerNode = nullptr;
     for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_PrevSibling); pNode;
          pNode = pNode->GetNodeItem(XFA_NODEITEM_PrevSibling)) {
       if (pNode->GetElementType() == XFA_Element::InstanceManager) {
         pManagerNode = pNode;
         break;
       }
     }
     if (pManagerNode) {
       pManagerNode->InstanceManager_MoveInstance(iTo, iFrom);
       CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
       if (!pNotify) {
         return;
       }
-      CXFA_Node* pToInstance =
-          XFA_ScriptInstanceManager_GetItem(pManagerNode, iTo);
+      CXFA_Node* pToInstance = GetItem(pManagerNode, iTo);
       if (pToInstance &&
           pToInstance->GetElementType() == XFA_Element::Subform) {
         pNotify->RunSubformIndexChange(pToInstance);
       }
-      CXFA_Node* pFromInstance =
-          XFA_ScriptInstanceManager_GetItem(pManagerNode, iFrom);
+      CXFA_Node* pFromInstance = GetItem(pManagerNode, iFrom);
       if (pFromInstance &&
           pFromInstance->GetElementType() == XFA_Element::Subform) {
         pNotify->RunSubformIndexChange(pFromInstance);
       }
     }
   } else {
     pValue->SetInteger(Subform_and_SubformSet_InstanceIndex());
   }
 }
+
 void CXFA_Node::Script_Subform_InstanceManager(CFXJSE_Value* pValue,
                                                FX_BOOL bSetting,
                                                XFA_ATTRIBUTE eAttribute) {
   if (!bSetting) {
     CFX_WideStringC wsName = GetCData(XFA_ATTRIBUTE_Name);
     CXFA_Node* pInstanceMgr = nullptr;
     for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_PrevSibling); pNode;
          pNode = pNode->GetNodeItem(XFA_NODEITEM_PrevSibling)) {
       if (pNode->GetElementType() == XFA_Element::InstanceManager) {
         CFX_WideStringC wsInstMgrName = pNode->GetCData(XFA_ATTRIBUTE_Name);
         if (wsInstMgrName.GetLength() >= 1 && wsInstMgrName.GetAt(0) == '_' &&
             wsInstMgrName.Mid(1) == wsName) {
           pInstanceMgr = pNode;
         }
         break;
       }
     }
     if (pInstanceMgr) {
       pValue->Assign(
           m_pDocument->GetScriptContext()->GetJSValueFromMap(pInstanceMgr));
     } else {
       pValue->SetNull();
     }
   } else {
     ThrowException(XFA_IDS_INVAlID_PROP_SET);
   }
 }
+
 void CXFA_Node::Script_Subform_Locale(CFXJSE_Value* pValue,
                                       FX_BOOL bSetting,
                                       XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     SetCData(XFA_ATTRIBUTE_Locale, pValue->ToWideString(), true, TRUE);
   } else {
     CFX_WideString wsLocaleName;
     GetLocaleName(wsLocaleName);
     pValue->SetString(
         FX_UTF8Encode(wsLocaleName.c_str(), wsLocaleName.GetLength())
             .AsStringC());
   }
 }
+
 void CXFA_Node::Script_Subform_ExecEvent(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 1) {
     CFX_ByteString eventString = pArguments->GetUTF8String(0);
     execSingleEventByName(
         CFX_WideString::FromUTF8(eventString.AsStringC()).AsStringC(),
         XFA_Element::Subform);
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execEvent");
   }
 }
+
 void CXFA_Node::Script_Subform_ExecInitialize(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
     CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
     if (!pNotify) {
       return;
     }
     pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Initialize);
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execInitialize");
   }
 }
+
 void CXFA_Node::Script_Subform_ExecCalculate(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
     CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
     if (!pNotify) {
       return;
     }
     pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Calculate);
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execCalculate");
   }
 }
+
 void CXFA_Node::Script_Subform_ExecValidate(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
     CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
     if (!pNotify) {
       pArguments->GetReturnValue()->SetBoolean(FALSE);
     } else {
       int32_t iRet = pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Validate);
       pArguments->GetReturnValue()->SetBoolean(
           (iRet == XFA_EVENTERROR_Error) ? FALSE : TRUE);
     }
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execValidate");
   }
 }
+
 void CXFA_Node::Script_Subform_GetInvalidObjects(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"getInvalidObjects");
   }
 }
+
 int32_t CXFA_Node::Subform_and_SubformSet_InstanceIndex() {
   int32_t index = 0;
   for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_PrevSibling); pNode;
        pNode = pNode->GetNodeItem(XFA_NODEITEM_PrevSibling)) {
     if ((pNode->GetElementType() == XFA_Element::Subform) ||
         (pNode->GetElementType() == XFA_Element::SubformSet)) {
       index++;
     } else {
       break;
     }
   }
   return index;
 }
+
 void CXFA_Node::Script_Template_FormNodes(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 1) {
     pArguments->GetReturnValue()->SetBoolean(TRUE);
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"formNodes");
   }
 }
+
 void CXFA_Node::Script_Template_Remerge(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
     m_pDocument->DoDataRemerge(TRUE);
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"remerge");
   }
 }
+
 void CXFA_Node::Script_Template_ExecInitialize(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
     CXFA_WidgetData* pWidgetData = GetWidgetData();
     if (!pWidgetData) {
       pArguments->GetReturnValue()->SetBoolean(FALSE);
     } else {
       pArguments->GetReturnValue()->SetBoolean(TRUE);
     }
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execInitialize");
   }
 }
+
 void CXFA_Node::Script_Template_CreateNode(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if ((argc > 0) && (argc < 4)) {
     CFX_WideString strTagName;
     CFX_WideString strName;
     CFX_WideString strNameSpace;
     CFX_ByteString bsTagName = pArguments->GetUTF8String(0);
     strTagName = CFX_WideString::FromUTF8(bsTagName.AsStringC());
     if (argc > 1) {
       CFX_ByteString bsName = pArguments->GetUTF8String(1);
@@ skipping 23 matching lines @@
         }
       } else {
         pArguments->GetReturnValue()->Assign(
             m_pDocument->GetScriptContext()->GetJSValueFromMap(pNewNode));
       }
     }
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"createNode");
   }
 }
+
 void CXFA_Node::Script_Template_Recalculate(CFXJSE_Arguments* pArguments) {
   if (pArguments->GetLength() == 1) {
     pArguments->GetReturnValue()->SetBoolean(TRUE);
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"recalculate");
   }
 }
+
 void CXFA_Node::Script_Template_ExecCalculate(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
     CXFA_WidgetData* pWidgetData = GetWidgetData();
     if (!pWidgetData) {
       pArguments->GetReturnValue()->SetBoolean(FALSE);
     } else {
       pArguments->GetReturnValue()->SetBoolean(TRUE);
     }
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execCalculate");
   }
 }
+
 void CXFA_Node::Script_Template_ExecValidate(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
     CXFA_WidgetData* pWidgetData = GetWidgetData();
     if (!pWidgetData) {
       pArguments->GetReturnValue()->SetBoolean(FALSE);
     } else {
       pArguments->GetReturnValue()->SetBoolean(TRUE);
     }
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execValidate");
   }
 }
+
 void CXFA_Node::Script_Manifest_Evaluate(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
     CXFA_WidgetData* pWidgetData = GetWidgetData();
     if (!pWidgetData) {
       pArguments->GetReturnValue()->SetBoolean(FALSE);
     } else {
       pArguments->GetReturnValue()->SetBoolean(TRUE);
     }
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"evaluate");
   }
 }
+
 void CXFA_Node::Script_InstanceManager_Max(CFXJSE_Value* pValue,
                                            FX_BOOL bSetting,
                                            XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     ThrowException(XFA_IDS_INVAlID_PROP_SET);
     return;
   }
   CXFA_Occur nodeOccur(GetOccurNode());
   pValue->SetInteger(nodeOccur.GetMax());
 }
+
 void CXFA_Node::Script_InstanceManager_Min(CFXJSE_Value* pValue,
                                            FX_BOOL bSetting,
                                            XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     ThrowException(XFA_IDS_INVAlID_PROP_SET);
     return;
   }
   CXFA_Occur nodeOccur(GetOccurNode());
   pValue->SetInteger(nodeOccur.GetMin());
 }
-static int32_t XFA_ScriptInstanceManager_GetCount(CXFA_Node* pInstMgrNode) {
-  ASSERT(pInstMgrNode);
-  int32_t iCount = 0;
-  uint32_t dwNameHash = 0;
-  for (CXFA_Node* pNode = pInstMgrNode->GetNodeItem(XFA_NODEITEM_NextSibling);
-       pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    XFA_Element eCurType = pNode->GetElementType();
-    if (eCurType == XFA_Element::InstanceManager) {
-      break;
-    }
-    if ((eCurType != XFA_Element::Subform) &&
-        (eCurType != XFA_Element::SubformSet)) {
-      continue;
-    }
-    if (iCount == 0) {
-      CFX_WideStringC wsName = pNode->GetCData(XFA_ATTRIBUTE_Name);
-      CFX_WideStringC wsInstName = pInstMgrNode->GetCData(XFA_ATTRIBUTE_Name);
-      if (wsInstName.GetLength() < 1 || wsInstName.GetAt(0) != '_' ||
-          wsInstName.Mid(1) != wsName) {
-        return iCount;
-      }
-      dwNameHash = pNode->GetNameHash();
-    }
-    if (dwNameHash != pNode->GetNameHash()) {
-      break;
-    }
-    iCount++;
-  }
-  return iCount;
-}
-static void
-XFA_ScriptInstanceManager_ReorderDataNodes_SortNodeArrayByDocumentIdx(
-    const CXFA_NodeSet& rgNodeSet,
-    CXFA_NodeArray& rgNodeArray,
-    CFX_ArrayTemplate<int32_t>& rgIdxArray) {
-  int32_t iCount = pdfium::CollectionSize<int32_t>(rgNodeSet);
-  rgNodeArray.SetSize(iCount);
-  rgIdxArray.SetSize(iCount);
-  if (iCount == 0)
-    return;
 
-  int32_t iIndex = -1;
-  int32_t iTotalIndex = -1;
-  CXFA_Node* pCommonParent =
-      (*rgNodeSet.begin())->GetNodeItem(XFA_NODEITEM_Parent);
-  for (CXFA_Node* pNode = pCommonParent->GetNodeItem(XFA_NODEITEM_FirstChild);
-       pNode && iIndex < iCount;
-       pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    iTotalIndex++;
-    if (pdfium::ContainsValue(rgNodeSet, pNode)) {
-      iIndex++;
-      rgNodeArray[iIndex] = pNode;
-      rgIdxArray[iIndex] = iTotalIndex;
-    }
-  }
-}
-
-using CXFA_NodeSetPair = std::pair<CXFA_NodeSet, CXFA_NodeSet>;
-using CXFA_NodeSetPairMap =
-    std::map<uint32_t, std::unique_ptr<CXFA_NodeSetPair>>;
-using CXFA_NodeSetPairMapMap =
-    std::map<CXFA_Node*, std::unique_ptr<CXFA_NodeSetPairMap>>;
-
-static CXFA_NodeSetPair* NodeSetPairForNode(CXFA_Node* pNode,
-                                            CXFA_NodeSetPairMapMap* pMap) {
-  CXFA_Node* pParentNode = pNode->GetNodeItem(XFA_NODEITEM_Parent);
-  uint32_t dwNameHash = pNode->GetNameHash();
-  if (!pParentNode || !dwNameHash)
-    return nullptr;
-
-  if (!(*pMap)[pParentNode])
-    (*pMap)[pParentNode].reset(new CXFA_NodeSetPairMap);
-
-  CXFA_NodeSetPairMap* pNodeSetPairMap = (*pMap)[pParentNode].get();
-  if (!(*pNodeSetPairMap)[dwNameHash])
-    (*pNodeSetPairMap)[dwNameHash].reset(new CXFA_NodeSetPair);
-
-  return (*pNodeSetPairMap)[dwNameHash].get();
-}
-
-static void XFA_ScriptInstanceManager_ReorderDataNodes(
-    const CXFA_NodeSet& sSet1,
-    const CXFA_NodeSet& sSet2,
-    FX_BOOL bInsertBefore) {
-  CXFA_NodeSetPairMapMap rgMap;
-  for (CXFA_Node* pNode : sSet1) {
-    CXFA_NodeSetPair* pNodeSetPair = NodeSetPairForNode(pNode, &rgMap);
-    if (pNodeSetPair)
-      pNodeSetPair->first.insert(pNode);
-  }
-  for (CXFA_Node* pNode : sSet2) {
-    CXFA_NodeSetPair* pNodeSetPair = NodeSetPairForNode(pNode, &rgMap);
-    if (pNodeSetPair) {
-      if (pdfium::ContainsValue(pNodeSetPair->first, pNode))
-        pNodeSetPair->first.erase(pNode);
-      else
-        pNodeSetPair->second.insert(pNode);
-    }
-  }
-  for (const auto& iter1 : rgMap) {
-    CXFA_NodeSetPairMap* pNodeSetPairMap = iter1.second.get();
-    if (!pNodeSetPairMap) {
-      continue;
-    }
-    for (const auto& iter2 : *pNodeSetPairMap) {
-      CXFA_NodeSetPair* pNodeSetPair = iter2.second.get();
-      if (!pNodeSetPair) {
-        continue;
-      }
-      if (!pNodeSetPair->first.empty() && !pNodeSetPair->second.empty()) {
-        CXFA_NodeArray rgNodeArray1;
-        CXFA_NodeArray rgNodeArray2;
-        CFX_ArrayTemplate<int32_t> rgIdxArray1;
-        CFX_ArrayTemplate<int32_t> rgIdxArray2;
-        XFA_ScriptInstanceManager_ReorderDataNodes_SortNodeArrayByDocumentIdx(
-            pNodeSetPair->first, rgNodeArray1, rgIdxArray1);
-        XFA_ScriptInstanceManager_ReorderDataNodes_SortNodeArrayByDocumentIdx(
-            pNodeSetPair->second, rgNodeArray2, rgIdxArray2);
-        CXFA_Node* pParentNode = nullptr;
-        CXFA_Node* pBeforeNode = nullptr;
-        if (bInsertBefore) {
-          pBeforeNode = rgNodeArray2[0];
-          pParentNode = pBeforeNode->GetNodeItem(XFA_NODEITEM_Parent);
-        } else {
-          CXFA_Node* pLastNode = rgNodeArray2[rgIdxArray2.GetSize() - 1];
-          pParentNode = pLastNode->GetNodeItem(XFA_NODEITEM_Parent);
-          pBeforeNode = pLastNode->GetNodeItem(XFA_NODEITEM_NextSibling);
-        }
-        for (int32_t iIdx = 0; iIdx < rgIdxArray1.GetSize(); iIdx++) {
-          CXFA_Node* pCurNode = rgNodeArray1[iIdx];
-          pParentNode->RemoveChild(pCurNode);
-          pParentNode->InsertChild(pCurNode, pBeforeNode);
-        }
-      }
-    }
-    pNodeSetPairMap->clear();
-  }
-}
-
-static void XFA_ScriptInstanceManager_InsertItem(
-    CXFA_Node* pInstMgrNode,
-    CXFA_Node* pNewInstance,
-    int32_t iPos,
-    int32_t iCount = -1,
-    FX_BOOL bMoveDataBindingNodes = TRUE) {
-  if (iCount < 0) {
-    iCount = XFA_ScriptInstanceManager_GetCount(pInstMgrNode);
-  }
-  if (iPos < 0) {
-    iPos = iCount;
-  }
-  if (iPos == iCount) {
-    CXFA_Node* pNextSibling =
-        iCount > 0
-            ? XFA_ScriptInstanceManager_GetItem(pInstMgrNode, iCount - 1)
-                  ->GetNodeItem(XFA_NODEITEM_NextSibling)
-            : pInstMgrNode->GetNodeItem(XFA_NODEITEM_NextSibling);
-    pInstMgrNode->GetNodeItem(XFA_NODEITEM_Parent)
-        ->InsertChild(pNewInstance, pNextSibling);
-    if (bMoveDataBindingNodes) {
-      CXFA_NodeSet sNew;
-      CXFA_NodeSet sAfter;
-      CXFA_NodeIteratorTemplate<CXFA_Node,
-                                CXFA_TraverseStrategy_XFAContainerNode>
-          sIteratorNew(pNewInstance);
-      for (CXFA_Node* pNode = sIteratorNew.GetCurrent(); pNode;
-           pNode = sIteratorNew.MoveToNext()) {
-        CXFA_Node* pDataNode = pNode->GetBindData();
-        if (!pDataNode) {
-          continue;
-        }
-        sNew.insert(pDataNode);
-      }
-      CXFA_NodeIteratorTemplate<CXFA_Node,
-                                CXFA_TraverseStrategy_XFAContainerNode>
-          sIteratorAfter(pNextSibling);
-      for (CXFA_Node* pNode = sIteratorAfter.GetCurrent(); pNode;
-           pNode = sIteratorAfter.MoveToNext()) {
-        CXFA_Node* pDataNode = pNode->GetBindData();
-        if (!pDataNode) {
-          continue;
-        }
-        sAfter.insert(pDataNode);
-      }
-      XFA_ScriptInstanceManager_ReorderDataNodes(sNew, sAfter, FALSE);
-    }
-  } else {
-    CXFA_Node* pBeforeInstance =
-        XFA_ScriptInstanceManager_GetItem(pInstMgrNode, iPos);
-    pInstMgrNode->GetNodeItem(XFA_NODEITEM_Parent)
-        ->InsertChild(pNewInstance, pBeforeInstance);
-    if (bMoveDataBindingNodes) {
-      CXFA_NodeSet sNew;
-      CXFA_NodeSet sBefore;
-      CXFA_NodeIteratorTemplate<CXFA_Node,
-                                CXFA_TraverseStrategy_XFAContainerNode>
-          sIteratorNew(pNewInstance);
-      for (CXFA_Node* pNode = sIteratorNew.GetCurrent(); pNode;
-           pNode = sIteratorNew.MoveToNext()) {
-        CXFA_Node* pDataNode = pNode->GetBindData();
-        if (!pDataNode) {
-          continue;
-        }
-        sNew.insert(pDataNode);
-      }
-      CXFA_NodeIteratorTemplate<CXFA_Node,
-                                CXFA_TraverseStrategy_XFAContainerNode>
-          sIteratorBefore(pBeforeInstance);
-      for (CXFA_Node* pNode = sIteratorBefore.GetCurrent(); pNode;
-           pNode = sIteratorBefore.MoveToNext()) {
-        CXFA_Node* pDataNode = pNode->GetBindData();
-        if (!pDataNode) {
-          continue;
-        }
-        sBefore.insert(pDataNode);
-      }
-      XFA_ScriptInstanceManager_ReorderDataNodes(sNew, sBefore, TRUE);
-    }
-  }
-}
-static void XFA_ScriptInstanceManager_RemoveItem(
-    CXFA_Node* pInstMgrNode,
-    CXFA_Node* pRemoveInstance,
-    FX_BOOL bRemoveDataBinding = TRUE) {
-  pInstMgrNode->GetNodeItem(XFA_NODEITEM_Parent)->RemoveChild(pRemoveInstance);
-  if (!bRemoveDataBinding) {
-    return;
-  }
-  CXFA_NodeIteratorTemplate<CXFA_Node, CXFA_TraverseStrategy_XFAContainerNode>
-      sIterator(pRemoveInstance);
-  for (CXFA_Node* pFormNode = sIterator.GetCurrent(); pFormNode;
-       pFormNode = sIterator.MoveToNext()) {
-    CXFA_Node* pDataNode = pFormNode->GetBindData();
-    if (!pDataNode) {
-      continue;
-    }
-    if (pDataNode->RemoveBindItem(pFormNode) == 0) {
-      if (CXFA_Node* pDataParent =
-              pDataNode->GetNodeItem(XFA_NODEITEM_Parent)) {
-        pDataParent->RemoveChild(pDataNode);
-      }
-    }
-    pFormNode->SetObject(XFA_ATTRIBUTE_BindingNode, nullptr);
-  }
-}
-static CXFA_Node* XFA_ScriptInstanceManager_CreateInstance(
-    CXFA_Node* pInstMgrNode,
-    FX_BOOL bDataMerge) {
-  CXFA_Document* pDocument = pInstMgrNode->GetDocument();
-  CXFA_Node* pTemplateNode = pInstMgrNode->GetTemplateNode();
-  CXFA_Node* pFormParent = pInstMgrNode->GetNodeItem(XFA_NODEITEM_Parent);
-  CXFA_Node* pDataScope = nullptr;
-  for (CXFA_Node* pRootBoundNode = pFormParent;
-       pRootBoundNode && pRootBoundNode->IsContainerNode();
-       pRootBoundNode = pRootBoundNode->GetNodeItem(XFA_NODEITEM_Parent)) {
-    pDataScope = pRootBoundNode->GetBindData();
-    if (pDataScope) {
-      break;
-    }
-  }
-  if (!pDataScope) {
-    pDataScope = ToNode(pDocument->GetXFAObject(XFA_HASHCODE_Record));
-    ASSERT(pDataScope);
-  }
-  CXFA_Node* pInstance = pDocument->DataMerge_CopyContainer(
-      pTemplateNode, pFormParent, pDataScope, TRUE, bDataMerge, TRUE);
-  if (pInstance) {
-    pDocument->DataMerge_UpdateBindingRelations(pInstance);
-    pFormParent->RemoveChild(pInstance);
-  }
-  return pInstance;
-}
 void CXFA_Node::Script_InstanceManager_Count(CFXJSE_Value* pValue,
                                              FX_BOOL bSetting,
                                              XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     int32_t iDesired = pValue->ToInteger();
     InstanceManager_SetInstances(iDesired);
   } else {
-    pValue->SetInteger(XFA_ScriptInstanceManager_GetCount(this));
+    pValue->SetInteger(GetCount(this));
   }
 }
+
 void CXFA_Node::Script_InstanceManager_MoveInstance(
     CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc != 2) {
     pArguments->GetReturnValue()->SetUndefined();
     return;
   }
   int32_t iFrom = pArguments->GetInt32(0);
   int32_t iTo = pArguments->GetInt32(1);
   InstanceManager_MoveInstance(iTo, iFrom);
   CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
   if (!pNotify) {
     return;
   }
-  CXFA_Node* pToInstance = XFA_ScriptInstanceManager_GetItem(this, iTo);
+  CXFA_Node* pToInstance = GetItem(this, iTo);
   if (pToInstance && pToInstance->GetElementType() == XFA_Element::Subform) {
     pNotify->RunSubformIndexChange(pToInstance);
   }
-  CXFA_Node* pFromInstance = XFA_ScriptInstanceManager_GetItem(this, iFrom);
+  CXFA_Node* pFromInstance = GetItem(this, iFrom);
   if (pFromInstance &&
       pFromInstance->GetElementType() == XFA_Element::Subform) {
     pNotify->RunSubformIndexChange(pFromInstance);
   }
 }
+
 void CXFA_Node::Script_InstanceManager_RemoveInstance(
     CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc != 1) {
     pArguments->GetReturnValue()->SetUndefined();
     return;
   }
   int32_t iIndex = pArguments->GetInt32(0);
-  int32_t iCount = XFA_ScriptInstanceManager_GetCount(this);
+  int32_t iCount = GetCount(this);
   if (iIndex < 0 || iIndex >= iCount) {
     ThrowException(XFA_IDS_INDEX_OUT_OF_BOUNDS);
     return;
   }
   CXFA_Occur nodeOccur(GetOccurNode());
   int32_t iMin = nodeOccur.GetMin();
   if (iCount - 1 < iMin) {
     ThrowException(XFA_IDS_VIOLATE_BOUNDARY, L"min");
     return;
   }
-  CXFA_Node* pRemoveInstance = XFA_ScriptInstanceManager_GetItem(this, iIndex);
-  XFA_ScriptInstanceManager_RemoveItem(this, pRemoveInstance);
+  CXFA_Node* pRemoveInstance = GetItem(this, iIndex);
+  RemoveItem(this, pRemoveInstance);
   CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
   if (pNotify) {
     for (int32_t i = iIndex; i < iCount - 1; i++) {
-      CXFA_Node* pSubformInstance = XFA_ScriptInstanceManager_GetItem(this, i);
+      CXFA_Node* pSubformInstance = GetItem(this, i);
       if (pSubformInstance &&
           pSubformInstance->GetElementType() == XFA_Element::Subform) {
         pNotify->RunSubformIndexChange(pSubformInstance);
       }
     }
   }
   CXFA_LayoutProcessor* pLayoutPro = m_pDocument->GetLayoutProcessor();
   if (!pLayoutPro) {
     return;
   }
   pLayoutPro->AddChangedContainer(
       ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Form)));
 }
+
 void CXFA_Node::Script_InstanceManager_SetInstances(
     CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc != 1) {
     pArguments->GetReturnValue()->SetUndefined();
     return;
   }
   int32_t iDesired = pArguments->GetInt32(0);
   InstanceManager_SetInstances(iDesired);
 }
+
 void CXFA_Node::Script_InstanceManager_AddInstance(
     CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if ((argc != 0) && (argc != 1)) {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"addInstance");
     return;
   }
   FX_BOOL fFlags = TRUE;
   if (argc == 1) {
     fFlags = pArguments->GetInt32(0) == 0 ? FALSE : TRUE;
   }
-  int32_t iCount = XFA_ScriptInstanceManager_GetCount(this);
+  int32_t iCount = GetCount(this);
   CXFA_Occur nodeOccur(GetOccurNode());
   int32_t iMax = nodeOccur.GetMax();
   if (iMax >= 0 && iCount >= iMax) {
     ThrowException(XFA_IDS_VIOLATE_BOUNDARY, L"max");
     return;
   }
-  CXFA_Node* pNewInstance =
-      XFA_ScriptInstanceManager_CreateInstance(this, fFlags);
-  XFA_ScriptInstanceManager_InsertItem(this, pNewInstance, iCount, iCount,
-                                       FALSE);
+  CXFA_Node* pNewInstance = CreateInstance(this, fFlags);
+  InsertItem(this, pNewInstance, iCount, iCount, FALSE);
   pArguments->GetReturnValue()->Assign(
       m_pDocument->GetScriptContext()->GetJSValueFromMap(pNewInstance));
   CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
   if (!pNotify) {
     return;
   }
   pNotify->RunNodeInitialize(pNewInstance);
   CXFA_LayoutProcessor* pLayoutPro = m_pDocument->GetLayoutProcessor();
   if (!pLayoutPro) {
     return;
   }
   pLayoutPro->AddChangedContainer(
       ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Form)));
 }
+
 void CXFA_Node::Script_InstanceManager_InsertInstance(
     CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if ((argc != 1) && (argc != 2)) {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"insertInstance");
     return;
   }
   int32_t iIndex = pArguments->GetInt32(0);
   FX_BOOL bBind = FALSE;
   if (argc == 2) {
     bBind = pArguments->GetInt32(1) == 0 ? FALSE : TRUE;
   }
   CXFA_Occur nodeOccur(GetOccurNode());
-  int32_t iCount = XFA_ScriptInstanceManager_GetCount(this);
+  int32_t iCount = GetCount(this);
   if (iIndex < 0 || iIndex > iCount) {
     ThrowException(XFA_IDS_INDEX_OUT_OF_BOUNDS);
     return;
   }
   int32_t iMax = nodeOccur.GetMax();
   if (iMax >= 0 && iCount >= iMax) {
     ThrowException(XFA_IDS_VIOLATE_BOUNDARY, L"max");
     return;
   }
-  CXFA_Node* pNewInstance =
-      XFA_ScriptInstanceManager_CreateInstance(this, bBind);
-  XFA_ScriptInstanceManager_InsertItem(this, pNewInstance, iIndex, iCount,
-                                       TRUE);
+  CXFA_Node* pNewInstance = CreateInstance(this, bBind);
+  InsertItem(this, pNewInstance, iIndex, iCount, TRUE);
   pArguments->GetReturnValue()->Assign(
       m_pDocument->GetScriptContext()->GetJSValueFromMap(pNewInstance));
   CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
   if (!pNotify) {
     return;
   }
   pNotify->RunNodeInitialize(pNewInstance);
   CXFA_LayoutProcessor* pLayoutPro = m_pDocument->GetLayoutProcessor();
   if (!pLayoutPro) {
     return;
   }
   pLayoutPro->AddChangedContainer(
       ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Form)));
 }
+
 int32_t CXFA_Node::InstanceManager_SetInstances(int32_t iDesired) {
   CXFA_Occur nodeOccur(GetOccurNode());
   int32_t iMax = nodeOccur.GetMax();
   int32_t iMin = nodeOccur.GetMin();
   if (iDesired < iMin) {
     ThrowException(XFA_IDS_VIOLATE_BOUNDARY, L"min");
     return 1;
   }
   if ((iMax >= 0) && (iDesired > iMax)) {
     ThrowException(XFA_IDS_VIOLATE_BOUNDARY, L"max");
     return 2;
   }
-  int32_t iCount = XFA_ScriptInstanceManager_GetCount(this);
+  int32_t iCount = GetCount(this);
   if (iDesired == iCount) {
     return 0;
   }
   if (iDesired < iCount) {
     CFX_WideStringC wsInstManagerName = GetCData(XFA_ATTRIBUTE_Name);
     CFX_WideString wsInstanceName =
         CFX_WideString(wsInstManagerName.IsEmpty() ? wsInstManagerName
                                                    : wsInstManagerName.Mid(1));
     uint32_t dInstanceNameHash =
         FX_HashCode_GetW(wsInstanceName.AsStringC(), false);
     CXFA_Node* pPrevSibling =
-        (iDesired == 0) ? this
-                        : XFA_ScriptInstanceManager_GetItem(this, iDesired - 1);
+        (iDesired == 0) ? this : GetItem(this, iDesired - 1);
     while (iCount > iDesired) {
       CXFA_Node* pRemoveInstance =
           pPrevSibling->GetNodeItem(XFA_NODEITEM_NextSibling);
       if (pRemoveInstance->GetElementType() != XFA_Element::Subform &&
           pRemoveInstance->GetElementType() != XFA_Element::SubformSet) {
         continue;
       }
       if (pRemoveInstance->GetElementType() == XFA_Element::InstanceManager) {
         ASSERT(FALSE);
         break;
       }
       if (pRemoveInstance->GetNameHash() == dInstanceNameHash) {
-        XFA_ScriptInstanceManager_RemoveItem(this, pRemoveInstance);
+        RemoveItem(this, pRemoveInstance);
         iCount--;
       }
     }
   } else if (iDesired > iCount) {
     while (iCount < iDesired) {
-      CXFA_Node* pNewInstance =
-          XFA_ScriptInstanceManager_CreateInstance(this, TRUE);
-      XFA_ScriptInstanceManager_InsertItem(this, pNewInstance, iCount, iCount,
-                                           FALSE);
+      CXFA_Node* pNewInstance = CreateInstance(this, TRUE);
+      InsertItem(this, pNewInstance, iCount, iCount, FALSE);
       iCount++;
       CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
       if (!pNotify) {
         return 0;
       }
       pNotify->RunNodeInitialize(pNewInstance);
     }
   }
   CXFA_LayoutProcessor* pLayoutPro = m_pDocument->GetLayoutProcessor();
   if (pLayoutPro) {
     pLayoutPro->AddChangedContainer(
         ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Form)));
   }
   return 0;
 }
+
 int32_t CXFA_Node::InstanceManager_MoveInstance(int32_t iTo, int32_t iFrom) {
-  int32_t iCount = XFA_ScriptInstanceManager_GetCount(this);
+  int32_t iCount = GetCount(this);
   if (iFrom > iCount || iTo > iCount - 1) {
     ThrowException(XFA_IDS_INDEX_OUT_OF_BOUNDS);
     return 1;
   }
   if (iFrom < 0 || iTo < 0 || iFrom == iTo) {
     return 0;
   }
-  CXFA_Node* pMoveInstance = XFA_ScriptInstanceManager_GetItem(this, iFrom);
-  XFA_ScriptInstanceManager_RemoveItem(this, pMoveInstance, FALSE);
-  XFA_ScriptInstanceManager_InsertItem(this, pMoveInstance, iTo, iCount - 1,
-                                       TRUE);
+  CXFA_Node* pMoveInstance = GetItem(this, iFrom);
+  RemoveItem(this, pMoveInstance, FALSE);
+  InsertItem(this, pMoveInstance, iTo, iCount - 1, TRUE);
   CXFA_LayoutProcessor* pLayoutPro = m_pDocument->GetLayoutProcessor();
   if (pLayoutPro) {
     pLayoutPro->AddChangedContainer(
         ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Form)));
   }
   return 0;
 }
+
 void CXFA_Node::Script_Occur_Max(CFXJSE_Value* pValue,
                                  FX_BOOL bSetting,
                                  XFA_ATTRIBUTE eAttribute) {
   CXFA_Occur occur(this);
   if (bSetting) {
     int32_t iMax = pValue->ToInteger();
     occur.SetMax(iMax);
   } else {
     pValue->SetInteger(occur.GetMax());
   }
 }
+
 void CXFA_Node::Script_Occur_Min(CFXJSE_Value* pValue,
                                  FX_BOOL bSetting,
                                  XFA_ATTRIBUTE eAttribute) {
   CXFA_Occur occur(this);
   if (bSetting) {
     int32_t iMin = pValue->ToInteger();
     occur.SetMin(iMin);
   } else {
     pValue->SetInteger(occur.GetMin());
   }
 }
+
 void CXFA_Node::Script_Desc_Metadata(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if ((argc == 0) || (argc == 1)) {
     pArguments->GetReturnValue()->SetString("");
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"metadata");
   }
 }
+
 void CXFA_Node::Script_Form_FormNodes(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 1) {
     CXFA_Node* pDataNode = static_cast<CXFA_Node*>(pArguments->GetObject(0));
     if (pDataNode) {
       CXFA_NodeArray formItems;
       CXFA_ArrayNodeList* pFormNodes = new CXFA_ArrayNodeList(m_pDocument);
       pFormNodes->SetArrayNodeList(formItems);
       pArguments->GetReturnValue()->SetObject(
           pFormNodes, m_pDocument->GetScriptContext()->GetJseNormalClass());
     } else {
       ThrowException(XFA_IDS_ARGUMENT_MISMATCH);
     }
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"formNodes");
   }
 }
+
 void CXFA_Node::Script_Form_Remerge(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
     m_pDocument->DoDataRemerge(TRUE);
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"remerge");
   }
 }
+
 void CXFA_Node::Script_Form_ExecInitialize(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
     CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
     if (!pNotify) {
       return;
     }
     pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Initialize);
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execInitialize");
   }
 }
+
 void CXFA_Node::Script_Form_Recalculate(CFXJSE_Arguments* pArguments) {
   CXFA_EventParam* pEventParam =
       m_pDocument->GetScriptContext()->GetEventParam();
   if (pEventParam->m_eType == XFA_EVENT_Calculate ||
       pEventParam->m_eType == XFA_EVENT_InitCalculate) {
     return;
   }
   int32_t argc = pArguments->GetLength();
   if (argc == 1) {
     const bool bScriptFlags = pArguments->GetInt32(0) != 0;
     CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
     if (!pNotify) {
       return;
     }
     if (bScriptFlags) {
       pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Calculate);
       pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Validate);
       pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Ready, TRUE);
     } else {
     }
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"recalculate");
   }
 }
+
 void CXFA_Node::Script_Form_ExecCalculate(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
     CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
     if (!pNotify) {
       return;
     }
     pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Calculate);
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execCalculate");
   }
 }
+
 void CXFA_Node::Script_Form_ExecValidate(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
     CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
     if (!pNotify) {
       pArguments->GetReturnValue()->SetBoolean(FALSE);
     } else {
       int32_t iRet = pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Validate);
       pArguments->GetReturnValue()->SetBoolean(
           (iRet == XFA_EVENTERROR_Error) ? FALSE : TRUE);
     }
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execValidate");
   }
 }
+
 void CXFA_Node::Script_Form_Checksum(CFXJSE_Value* pValue,
                                      FX_BOOL bSetting,
                                      XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     SetAttribute(XFA_ATTRIBUTE_Checksum, pValue->ToWideString().AsStringC());
   } else {
     CFX_WideString wsChecksum;
     GetAttribute(XFA_ATTRIBUTE_Checksum, wsChecksum, FALSE);
     pValue->SetString(
         FX_UTF8Encode(wsChecksum.c_str(), wsChecksum.GetLength()).AsStringC());
   }
 }
+
 void CXFA_Node::Script_Packet_GetAttribute(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 1) {
     CFX_ByteString bsAttributeName = pArguments->GetUTF8String(0);
     CFX_WideString wsAttributeValue;
     CFDE_XMLNode* pXMLNode = GetXMLMappingNode();
     if (pXMLNode && pXMLNode->GetType() == FDE_XMLNODE_Element) {
       static_cast<CFDE_XMLElement*>(pXMLNode)->GetString(
           CFX_WideString::FromUTF8(bsAttributeName.AsStringC()).c_str(),
           wsAttributeValue);
     }
     pArguments->GetReturnValue()->SetString(
         FX_UTF8Encode(wsAttributeValue.c_str(), wsAttributeValue.GetLength())
             .AsStringC());
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"getAttribute");
   }
 }
+
 void CXFA_Node::Script_Packet_SetAttribute(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 2) {
     CFX_ByteString bsValue = pArguments->GetUTF8String(0);
     CFX_ByteString bsName = pArguments->GetUTF8String(1);
     CFDE_XMLNode* pXMLNode = GetXMLMappingNode();
     if (pXMLNode && pXMLNode->GetType() == FDE_XMLNODE_Element) {
-      static_cast<CFDE_XMLElement*>(pXMLNode)
-          ->SetString(CFX_WideString::FromUTF8(bsName.AsStringC()),
-                      CFX_WideString::FromUTF8(bsValue.AsStringC()));
+      static_cast<CFDE_XMLElement*>(pXMLNode)->SetString(
+          CFX_WideString::FromUTF8(bsName.AsStringC()),
+          CFX_WideString::FromUTF8(bsValue.AsStringC()));
     }
     pArguments->GetReturnValue()->SetNull();
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"setAttribute");
   }
 }
+
 void CXFA_Node::Script_Packet_RemoveAttribute(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 1) {
     CFX_ByteString bsName = pArguments->GetUTF8String(0);
     CFX_WideString wsName = CFX_WideString::FromUTF8(bsName.AsStringC());
     CFDE_XMLNode* pXMLNode = GetXMLMappingNode();
     if (pXMLNode && pXMLNode->GetType() == FDE_XMLNODE_Element) {
       CFDE_XMLElement* pXMLElement = static_cast<CFDE_XMLElement*>(pXMLNode);
       if (pXMLElement->HasAttribute(wsName.c_str())) {
         pXMLElement->RemoveAttribute(wsName.c_str());
       }
     }
     pArguments->GetReturnValue()->SetNull();
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"removeAttribute");
   }
 }
+
 void CXFA_Node::Script_Packet_Content(CFXJSE_Value* pValue,
                                       FX_BOOL bSetting,
                                       XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     CFDE_XMLNode* pXMLNode = GetXMLMappingNode();
     if (pXMLNode && pXMLNode->GetType() == FDE_XMLNODE_Element) {
       CFDE_XMLElement* pXMLElement = static_cast<CFDE_XMLElement*>(pXMLNode);
       pXMLElement->SetTextData(pValue->ToWideString());
     }
   } else {
     CFX_WideString wsTextData;
     CFDE_XMLNode* pXMLNode = GetXMLMappingNode();
     if (pXMLNode && pXMLNode->GetType() == FDE_XMLNODE_Element) {
       CFDE_XMLElement* pXMLElement = static_cast<CFDE_XMLElement*>(pXMLNode);
       pXMLElement->GetTextData(wsTextData);
     }
     pValue->SetString(
         FX_UTF8Encode(wsTextData.c_str(), wsTextData.GetLength()).AsStringC());
   }
 }
+
 void CXFA_Node::Script_Source_Next(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"next");
   }
 }
+
 void CXFA_Node::Script_Source_CancelBatch(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"cancelBatch");
   }
 }
+
 void CXFA_Node::Script_Source_First(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"first");
   }
 }
+
 void CXFA_Node::Script_Source_UpdateBatch(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"updateBatch");
   }
 }
+
 void CXFA_Node::Script_Source_Previous(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"previous");
   }
 }
+
 void CXFA_Node::Script_Source_IsBOF(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"isBOF");
   }
 }
+
 void CXFA_Node::Script_Source_IsEOF(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"isEOF");
   }
 }
+
 void CXFA_Node::Script_Source_Cancel(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"cancel");
   }
 }
+
 void CXFA_Node::Script_Source_Update(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"update");
   }
 }
+
 void CXFA_Node::Script_Source_Open(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"open");
   }
 }
+
 void CXFA_Node::Script_Source_Delete(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"delete");
   }
 }
+
 void CXFA_Node::Script_Source_AddNew(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"addNew");
   }
 }
+
 void CXFA_Node::Script_Source_Requery(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"requery");
   }
 }
+
 void CXFA_Node::Script_Source_Resync(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"resync");
   }
 }
+
 void CXFA_Node::Script_Source_Close(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"close");
   }
 }
+
 void CXFA_Node::Script_Source_Last(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"last");
   }
 }
+
 void CXFA_Node::Script_Source_HasDataChanged(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"hasDataChanged");
   }
 }
+
 void CXFA_Node::Script_Source_Db(CFXJSE_Value* pValue,
                                  FX_BOOL bSetting,
                                  XFA_ATTRIBUTE eAttribute) {}
+
 void CXFA_Node::Script_Xfa_This(CFXJSE_Value* pValue,
                                 FX_BOOL bSetting,
                                 XFA_ATTRIBUTE eAttribute) {
   if (!bSetting) {
     CXFA_Object* pThis = m_pDocument->GetScriptContext()->GetThisObject();
     ASSERT(pThis);
     pValue->Assign(m_pDocument->GetScriptContext()->GetJSValueFromMap(pThis));
   }
 }
+
 void CXFA_Node::Script_Handler_Version(CFXJSE_Value* pValue,
                                        FX_BOOL bSetting,
                                        XFA_ATTRIBUTE eAttribute) {}
+
 void CXFA_Node::Script_SubmitFormat_Mode(CFXJSE_Value* pValue,
                                          FX_BOOL bSetting,
                                          XFA_ATTRIBUTE eAttribute) {}
+
 void CXFA_Node::Script_Extras_Type(CFXJSE_Value* pValue,
                                    FX_BOOL bSetting,
                                    XFA_ATTRIBUTE eAttribute) {}
+
 void CXFA_Node::Script_Script_Stateless(CFXJSE_Value* pValue,
                                         FX_BOOL bSetting,
                                         XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     ThrowException(XFA_IDS_INVAlID_PROP_SET);
     return;
   }
   pValue->SetString(FX_UTF8Encode(FX_WSTRC(L"0")).AsStringC());
 }
+
 void CXFA_Node::Script_Encrypt_Format(CFXJSE_Value* pValue,
                                       FX_BOOL bSetting,
                                       XFA_ATTRIBUTE eAttribute) {}
-enum XFA_KEYTYPE {
-  XFA_KEYTYPE_Custom,
-  XFA_KEYTYPE_Element,
-};
-void* XFA_GetMapKey_Custom(const CFX_WideStringC& wsKey) {
-  uint32_t dwKey = FX_HashCode_GetW(wsKey, false);
-  return (void*)(uintptr_t)((dwKey << 1) | XFA_KEYTYPE_Custom);
-}
-void* XFA_GetMapKey_Element(XFA_Element eType, XFA_ATTRIBUTE eAttribute) {
-  return (void*)(uintptr_t)((static_cast<int32_t>(eType) << 16) |
-                            (eAttribute << 8) | XFA_KEYTYPE_Element);
-}
+
 FX_BOOL CXFA_Node::HasAttribute(XFA_ATTRIBUTE eAttr, FX_BOOL bCanInherit) {
-  void* pKey = XFA_GetMapKey_Element(GetElementType(), eAttr);
+  void* pKey = GetMapKey_Element(GetElementType(), eAttr);
   return HasMapModuleKey(pKey, bCanInherit);
 }
+
 FX_BOOL CXFA_Node::SetAttribute(XFA_ATTRIBUTE eAttr,
                                 const CFX_WideStringC& wsValue,
                                 bool bNotify) {
   const XFA_ATTRIBUTEINFO* pAttr = XFA_GetAttributeByID(eAttr);
   if (!pAttr)
     return FALSE;
 
   XFA_ATTRIBUTETYPE eType = pAttr->eType;
   if (eType == XFA_ATTRIBUTETYPE_NOTSURE) {
     const XFA_NOTSUREATTRIBUTE* pNotsure =
@@ skipping 17 matching lines @@
           pAttr->eName,
           FXSYS_round(FX_wcstof(wsValue.c_str(), wsValue.GetLength(), nullptr)),
           bNotify);
     case XFA_ATTRIBUTETYPE_Measure:
       return SetMeasure(pAttr->eName, CXFA_Measurement(wsValue), bNotify);
     default:
       break;
   }
   return FALSE;
 }
+
 FX_BOOL CXFA_Node::GetAttribute(XFA_ATTRIBUTE eAttr,
                                 CFX_WideString& wsValue,
                                 FX_BOOL bUseDefault) {
   const XFA_ATTRIBUTEINFO* pAttr = XFA_GetAttributeByID(eAttr);
   if (!pAttr) {
     return FALSE;
   }
   XFA_ATTRIBUTETYPE eType = pAttr->eType;
   if (eType == XFA_ATTRIBUTETYPE_NOTSURE) {
     const XFA_NOTSUREATTRIBUTE* pNotsure =
@@ skipping 39 matching lines @@
         return FALSE;
       }
       mValue.ToString(wsValue);
       return TRUE;
     } break;
     default:
       break;
   }
   return FALSE;
 }
+
 FX_BOOL CXFA_Node::SetAttribute(const CFX_WideStringC& wsAttr,
                                 const CFX_WideStringC& wsValue,
                                 bool bNotify) {
   const XFA_ATTRIBUTEINFO* pAttributeInfo = XFA_GetAttributeByName(wsValue);
   if (pAttributeInfo) {
     return SetAttribute(pAttributeInfo->eName, wsValue, bNotify);
   }
-  void* pKey = XFA_GetMapKey_Custom(wsAttr);
+  void* pKey = GetMapKey_Custom(wsAttr);
   SetMapModuleString(pKey, wsValue);
   return TRUE;
 }
+
 FX_BOOL CXFA_Node::GetAttribute(const CFX_WideStringC& wsAttr,
                                 CFX_WideString& wsValue,
                                 FX_BOOL bUseDefault) {
   const XFA_ATTRIBUTEINFO* pAttributeInfo = XFA_GetAttributeByName(wsAttr);
   if (pAttributeInfo) {
     return GetAttribute(pAttributeInfo->eName, wsValue, bUseDefault);
   }
-  void* pKey = XFA_GetMapKey_Custom(wsAttr);
+  void* pKey = GetMapKey_Custom(wsAttr);
   CFX_WideStringC wsValueC;
   if (GetMapModuleString(pKey, wsValueC)) {
     wsValue = wsValueC;
   }
   return TRUE;
 }
+
 FX_BOOL CXFA_Node::RemoveAttribute(const CFX_WideStringC& wsAttr) {
-  void* pKey = XFA_GetMapKey_Custom(wsAttr);
+  void* pKey = GetMapKey_Custom(wsAttr);
   RemoveMapModuleKey(pKey);
   return TRUE;
 }
+
 FX_BOOL CXFA_Node::TryBoolean(XFA_ATTRIBUTE eAttr,
                               FX_BOOL& bValue,
                               FX_BOOL bUseDefault) {
   void* pValue = nullptr;
   if (!GetValue(eAttr, XFA_ATTRIBUTETYPE_Boolean, bUseDefault, pValue))
     return FALSE;
   bValue = (FX_BOOL)(uintptr_t)pValue;
   return TRUE;
 }
+
 FX_BOOL CXFA_Node::TryInteger(XFA_ATTRIBUTE eAttr,
                               int32_t& iValue,
                               FX_BOOL bUseDefault) {
   void* pValue = nullptr;
   if (!GetValue(eAttr, XFA_ATTRIBUTETYPE_Integer, bUseDefault, pValue))
     return FALSE;
   iValue = (int32_t)(uintptr_t)pValue;
   return TRUE;
 }
+
 FX_BOOL CXFA_Node::TryEnum(XFA_ATTRIBUTE eAttr,
                            XFA_ATTRIBUTEENUM& eValue,
                            FX_BOOL bUseDefault) {
   void* pValue = nullptr;
   if (!GetValue(eAttr, XFA_ATTRIBUTETYPE_Enum, bUseDefault, pValue))
     return FALSE;
   eValue = (XFA_ATTRIBUTEENUM)(uintptr_t)pValue;
   return TRUE;
 }
 
 FX_BOOL CXFA_Node::SetMeasure(XFA_ATTRIBUTE eAttr,
                               CXFA_Measurement mValue,
                               bool bNotify) {
-  void* pKey = XFA_GetMapKey_Element(GetElementType(), eAttr);
+  void* pKey = GetMapKey_Element(GetElementType(), eAttr);
   OnChanging(eAttr, bNotify);
   SetMapModuleBuffer(pKey, &mValue, sizeof(CXFA_Measurement));
   OnChanged(eAttr, bNotify, FALSE);
   return TRUE;
 }
 
 FX_BOOL CXFA_Node::TryMeasure(XFA_ATTRIBUTE eAttr,
                               CXFA_Measurement& mValue,
                               FX_BOOL bUseDefault) const {
-  void* pKey = XFA_GetMapKey_Element(GetElementType(), eAttr);
+  void* pKey = GetMapKey_Element(GetElementType(), eAttr);
   void* pValue;
   int32_t iBytes;
   if (GetMapModuleBuffer(pKey, pValue, iBytes) && iBytes == sizeof(mValue)) {
     FXSYS_memcpy(&mValue, pValue, sizeof(mValue));
     return TRUE;
   }
   if (bUseDefault &&
       XFA_GetAttributeDefaultValue(pValue, GetElementType(), eAttr,
                                    XFA_ATTRIBUTETYPE_Measure, m_ePacket)) {
     FXSYS_memcpy(&mValue, pValue, sizeof(mValue));
     return TRUE;
   }
   return FALSE;
 }
 
 CXFA_Measurement CXFA_Node::GetMeasure(XFA_ATTRIBUTE eAttr) const {
   CXFA_Measurement mValue;
   return TryMeasure(eAttr, mValue, TRUE) ? mValue : CXFA_Measurement();
 }
 
 FX_BOOL CXFA_Node::SetCData(XFA_ATTRIBUTE eAttr,
                             const CFX_WideString& wsValue,
                             bool bNotify,
                             FX_BOOL bScriptModify) {
-  void* pKey = XFA_GetMapKey_Element(GetElementType(), eAttr);
+  void* pKey = GetMapKey_Element(GetElementType(), eAttr);
   OnChanging(eAttr, bNotify);
   if (eAttr == XFA_ATTRIBUTE_Value) {
     CFX_WideString* pClone = new CFX_WideString(wsValue);
     SetUserData(pKey, pClone, &deleteWideStringCallBack);
   } else {
     SetMapModuleString(pKey, wsValue.AsStringC());
     if (eAttr == XFA_ATTRIBUTE_Name)
       UpdateNameHash();
   }
   OnChanged(eAttr, bNotify, bScriptModify);
@@ skipping 55 matching lines @@
     }
     static_cast<CFDE_XMLElement*>(m_pXMLNode)->SetString(wsAttrName, wsValue);
   }
   return TRUE;
 }
 
 FX_BOOL CXFA_Node::SetAttributeValue(const CFX_WideString& wsValue,
                                      const CFX_WideString& wsXMLValue,
                                      bool bNotify,
                                      FX_BOOL bScriptModify) {
-  void* pKey = XFA_GetMapKey_Element(GetElementType(), XFA_ATTRIBUTE_Value);
+  void* pKey = GetMapKey_Element(GetElementType(), XFA_ATTRIBUTE_Value);
   OnChanging(XFA_ATTRIBUTE_Value, bNotify);
   CFX_WideString* pClone = new CFX_WideString(wsValue);
   SetUserData(pKey, pClone, &deleteWideStringCallBack);
   OnChanged(XFA_ATTRIBUTE_Value, bNotify, bScriptModify);
   if (IsNeedSavingXMLNode()) {
     FDE_XMLNODETYPE eXMLType = m_pXMLNode->GetType();
     switch (eXMLType) {
       case FDE_XMLNODE_Element:
         if (IsAttributeInXML()) {
           static_cast<CFDE_XMLElement*>(m_pXMLNode)
@@ skipping 21 matching lines @@
         break;
       case FDE_XMLNODE_Text:
         static_cast<CFDE_XMLText*>(m_pXMLNode)->SetText(wsXMLValue);
         break;
       default:
         ASSERT(0);
     }
   }
   return TRUE;
 }
+
 FX_BOOL CXFA_Node::TryCData(XFA_ATTRIBUTE eAttr,
                             CFX_WideString& wsValue,
                             FX_BOOL bUseDefault,
                             FX_BOOL bProto) {
-  void* pKey = XFA_GetMapKey_Element(GetElementType(), eAttr);
+  void* pKey = GetMapKey_Element(GetElementType(), eAttr);
   if (eAttr == XFA_ATTRIBUTE_Value) {
     CFX_WideString* pStr = (CFX_WideString*)GetUserData(pKey, bProto);
     if (pStr) {
       wsValue = *pStr;
       return TRUE;
     }
   } else {
     CFX_WideStringC wsValueC;
     if (GetMapModuleString(pKey, wsValueC)) {
       wsValue = wsValueC;
       return TRUE;
     }
   }
   if (!bUseDefault) {
     return FALSE;
   }
   void* pValue = nullptr;
   if (XFA_GetAttributeDefaultValue(pValue, GetElementType(), eAttr,
                                    XFA_ATTRIBUTETYPE_Cdata, m_ePacket)) {
     wsValue = (const FX_WCHAR*)pValue;
     return TRUE;
   }
   return FALSE;
 }
+
 FX_BOOL CXFA_Node::TryCData(XFA_ATTRIBUTE eAttr,
                             CFX_WideStringC& wsValue,
                             FX_BOOL bUseDefault,
                             FX_BOOL bProto) {
-  void* pKey = XFA_GetMapKey_Element(GetElementType(), eAttr);
+  void* pKey = GetMapKey_Element(GetElementType(), eAttr);
   if (eAttr == XFA_ATTRIBUTE_Value) {
     CFX_WideString* pStr = (CFX_WideString*)GetUserData(pKey, bProto);
     if (pStr) {
       wsValue = pStr->AsStringC();
       return TRUE;
     }
   } else {
     if (GetMapModuleString(pKey, wsValue)) {
       return TRUE;
     }
   }
   if (!bUseDefault) {
     return FALSE;
   }
   void* pValue = nullptr;
   if (XFA_GetAttributeDefaultValue(pValue, GetElementType(), eAttr,
                                    XFA_ATTRIBUTETYPE_Cdata, m_ePacket)) {
     wsValue = (CFX_WideStringC)(const FX_WCHAR*)pValue;
     return TRUE;
   }
   return FALSE;
 }
+
 FX_BOOL CXFA_Node::SetObject(XFA_ATTRIBUTE eAttr,
                              void* pData,
                              XFA_MAPDATABLOCKCALLBACKINFO* pCallbackInfo) {
-  void* pKey = XFA_GetMapKey_Element(GetElementType(), eAttr);
+  void* pKey = GetMapKey_Element(GetElementType(), eAttr);
   return SetUserData(pKey, pData, pCallbackInfo);
 }
+
 FX_BOOL CXFA_Node::TryObject(XFA_ATTRIBUTE eAttr, void*& pData) {
-  void* pKey = XFA_GetMapKey_Element(GetElementType(), eAttr);
+  void* pKey = GetMapKey_Element(GetElementType(), eAttr);
   pData = GetUserData(pKey);
   return !!pData;
 }
+
 FX_BOOL CXFA_Node::SetValue(XFA_ATTRIBUTE eAttr,
                             XFA_ATTRIBUTETYPE eType,
                             void* pValue,
                             bool bNotify) {
-  void* pKey = XFA_GetMapKey_Element(GetElementType(), eAttr);
+  void* pKey = GetMapKey_Element(GetElementType(), eAttr);
   OnChanging(eAttr, bNotify);
   SetMapModuleValue(pKey, pValue);
   OnChanged(eAttr, bNotify, FALSE);
   if (IsNeedSavingXMLNode()) {
     ASSERT(m_pXMLNode->GetType() == FDE_XMLNODE_Element);
     const XFA_ATTRIBUTEINFO* pInfo = XFA_GetAttributeByID(eAttr);
     if (pInfo) {
       switch (eType) {
         case XFA_ATTRIBUTETYPE_Enum:
           static_cast<CFDE_XMLElement*>(m_pXMLNode)
@@ skipping 10 matching lines @@
           static_cast<CFDE_XMLElement*>(m_pXMLNode)
               ->SetInteger(pInfo->pName, (int32_t)(uintptr_t)pValue);
           break;
         default:
           ASSERT(0);
       }
     }
   }
   return TRUE;
 }
+
 FX_BOOL CXFA_Node::GetValue(XFA_ATTRIBUTE eAttr,
                             XFA_ATTRIBUTETYPE eType,
                             FX_BOOL bUseDefault,
                             void*& pValue) {
-  void* pKey = XFA_GetMapKey_Element(GetElementType(), eAttr);
+  void* pKey = GetMapKey_Element(GetElementType(), eAttr);
   if (GetMapModuleValue(pKey, pValue)) {
     return TRUE;
   }
   if (!bUseDefault) {
     return FALSE;
   }
   return XFA_GetAttributeDefaultValue(pValue, GetElementType(), eAttr, eType,
                                       m_ePacket);
 }
-static void XFA_DefaultFreeData(void* pData) {}
-static XFA_MAPDATABLOCKCALLBACKINFO gs_XFADefaultFreeData = {
-    XFA_DefaultFreeData, nullptr};
+
 FX_BOOL CXFA_Node::SetUserData(void* pKey,
                                void* pData,
                                XFA_MAPDATABLOCKCALLBACKINFO* pCallbackInfo) {
   SetMapModuleBuffer(pKey, &pData, sizeof(void*),
                      pCallbackInfo ? pCallbackInfo : &gs_XFADefaultFreeData);
   return TRUE;
 }
+
 FX_BOOL CXFA_Node::TryUserData(void* pKey, void*& pData, FX_BOOL bProtoAlso) {
   int32_t iBytes = 0;
   if (!GetMapModuleBuffer(pKey, pData, iBytes, bProtoAlso)) {
     return FALSE;
   }
   return iBytes == sizeof(void*) && FXSYS_memcpy(&pData, pData, iBytes);
 }
+
 FX_BOOL CXFA_Node::SetScriptContent(const CFX_WideString& wsContent,
                                     const CFX_WideString& wsXMLValue,
                                     bool bNotify,
                                     FX_BOOL bScriptModify,
                                     FX_BOOL bSyncData) {
   CXFA_Node* pNode = nullptr;
   CXFA_Node* pBindNode = nullptr;
   switch (GetObjectType()) {
     case XFA_ObjectType::ContainerNode: {
       if (XFA_FieldIsMultiListBox(this)) {
@@ skipping 152 matching lines @@
       pBindNode->GetBindItems(nodeArray);
       for (int32_t i = 0; i < nodeArray.GetSize(); i++) {
         nodeArray[i]->SetScriptContent(wsContent, wsContent, bNotify,
                                        bScriptModify, FALSE);
       }
     }
     return TRUE;
   }
   return FALSE;
 }
+
 FX_BOOL CXFA_Node::SetContent(const CFX_WideString& wsContent,
                               const CFX_WideString& wsXMLValue,
                               bool bNotify,
                               FX_BOOL bScriptModify,
                               FX_BOOL bSyncData) {
   return SetScriptContent(wsContent, wsXMLValue, bNotify, bScriptModify,
                           bSyncData);
 }
+
 CFX_WideString CXFA_Node::GetScriptContent(FX_BOOL bScriptModify) {
   CFX_WideString wsContent;
   return TryContent(wsContent, bScriptModify) ? wsContent : CFX_WideString();
 }
+
 CFX_WideString CXFA_Node::GetContent() {
   return GetScriptContent();
 }
+
 FX_BOOL CXFA_Node::TryContent(CFX_WideString& wsContent,
                               FX_BOOL bScriptModify,
                               FX_BOOL bProto) {
   CXFA_Node* pNode = nullptr;
   switch (GetObjectType()) {
     case XFA_ObjectType::ContainerNode:
       if (GetElementType() == XFA_Element::ExclGroup) {
         pNode = this;
       } else {
         CXFA_Node* pValue = GetChild(0, XFA_Element::Value);
@@ skipping 42 matching lines @@
     if (bScriptModify) {
       CXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
       if (pScriptContext) {
         m_pDocument->GetScriptContext()->AddNodesOfRunScript(this);
       }
     }
     return TryCData(XFA_ATTRIBUTE_Value, wsContent, FALSE, bProto);
   }
   return FALSE;
 }
+
 CXFA_Node* CXFA_Node::GetModelNode() {
   switch (GetPacketID()) {
     case XFA_XDPPACKET_XDP:
       return m_pDocument->GetRoot();
     case XFA_XDPPACKET_Config:
       return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Config));
     case XFA_XDPPACKET_Template:
       return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Template));
     case XFA_XDPPACKET_Form:
       return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Form));
     case XFA_XDPPACKET_Datasets:
       return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Datasets));
     case XFA_XDPPACKET_LocaleSet:
       return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_LocaleSet));
     case XFA_XDPPACKET_ConnectionSet:
       return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_ConnectionSet));
     case XFA_XDPPACKET_SourceSet:
       return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_SourceSet));
     case XFA_XDPPACKET_Xdc:
       return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Xdc));
     default:
       return this;
   }
 }
+
 FX_BOOL CXFA_Node::TryNamespace(CFX_WideString& wsNamespace) {
   wsNamespace.clear();
   if (IsModelNode() || GetElementType() == XFA_Element::Packet) {
     CFDE_XMLNode* pXMLNode = GetXMLMappingNode();
     if (!pXMLNode || pXMLNode->GetType() != FDE_XMLNODE_Element) {
       return FALSE;
     }
     static_cast<CFDE_XMLElement*>(pXMLNode)->GetNamespaceURI(wsNamespace);
     return TRUE;
   } else if (GetPacketID() == XFA_XDPPACKET_Datasets) {
@@ skipping 10 matching lines @@
           static_cast<CFDE_XMLElement*>(pXMLNode),
           GetCData(XFA_ATTRIBUTE_QualifiedName), wsNamespace);
     }
     static_cast<CFDE_XMLElement*>(pXMLNode)->GetNamespaceURI(wsNamespace);
     return TRUE;
   } else {
     CXFA_Node* pModelNode = GetModelNode();
     return pModelNode->TryNamespace(wsNamespace);
   }
 }
+
 CXFA_Node* CXFA_Node::GetProperty(int32_t index,
                                   XFA_Element eProperty,
                                   FX_BOOL bCreateProperty) {
   XFA_Element eType = GetElementType();
   uint32_t dwPacket = GetPacketID();
   const XFA_PROPERTY* pProperty =
       XFA_GetPropertyOfElement(eType, eProperty, dwPacket);
   if (!pProperty || index >= pProperty->uOccur)
     return nullptr;
 
@@ skipping 24 matching lines @@
   CXFA_Node* pNewNode = nullptr;
   for (; iCount <= index; iCount++) {
     pNewNode = m_pDocument->CreateNode(pPacket, eProperty);
     if (!pNewNode)
       return nullptr;
     InsertChild(pNewNode, nullptr);
     pNewNode->SetFlag(XFA_NodeFlag_Initialized, true);
   }
   return pNewNode;
 }
+
 int32_t CXFA_Node::CountChildren(XFA_Element eType, FX_BOOL bOnlyChild) {
   CXFA_Node* pNode = m_pChild;
   int32_t iCount = 0;
   for (; pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     if (pNode->GetElementType() == eType || eType == XFA_Element::Unknown) {
       if (bOnlyChild) {
         const XFA_PROPERTY* pProperty = XFA_GetPropertyOfElement(
             GetElementType(), pNode->GetElementType(), XFA_XDPPACKET_UNKNOWN);
         if (pProperty) {
           continue;
         }
       }
       iCount++;
     }
   }
   return iCount;
 }
+
 CXFA_Node* CXFA_Node::GetChild(int32_t index,
                                XFA_Element eType,
                                FX_BOOL bOnlyChild) {
   ASSERT(index > -1);
   CXFA_Node* pNode = m_pChild;
   int32_t iCount = 0;
   for (; pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     if (pNode->GetElementType() == eType || eType == XFA_Element::Unknown) {
       if (bOnlyChild) {
         const XFA_PROPERTY* pProperty = XFA_GetPropertyOfElement(
             GetElementType(), pNode->GetElementType(), XFA_XDPPACKET_UNKNOWN);
         if (pProperty) {
           continue;
         }
       }
       iCount++;
       if (iCount > index) {
         return pNode;
       }
     }
   }
   return nullptr;
 }
+
 int32_t CXFA_Node::InsertChild(int32_t index, CXFA_Node* pNode) {
   ASSERT(!pNode->m_pNext);
   pNode->m_pParent = this;
   FX_BOOL ret = m_pDocument->RemovePurgeNode(pNode);
   ASSERT(ret);
   (void)ret;  // Avoid unused variable warning.
 
   if (!m_pChild || index == 0) {
     if (index > 0) {
       return -1;
@@ skipping 73 matching lines @@
   if (pNotify)
     pNotify->OnChildAdded(this);
 
   if (IsNeedSavingXMLNode() && pNode->m_pXMLNode) {
     ASSERT(!pNode->m_pXMLNode->GetNodeItem(CFDE_XMLNode::Parent));
     m_pXMLNode->InsertChildNode(pNode->m_pXMLNode, nIndex);
     pNode->ClearFlag(XFA_NodeFlag_OwnXMLNode);
   }
   return TRUE;
 }
+
 CXFA_Node* CXFA_Node::Deprecated_GetPrevSibling() {
   if (!m_pParent) {
     return nullptr;
   }
   for (CXFA_Node* pSibling = m_pParent->m_pChild; pSibling;
        pSibling = pSibling->m_pNext) {
     if (pSibling->m_pNext == this) {
       return pSibling;
     }
   }
   return nullptr;
 }
+
 FX_BOOL CXFA_Node::RemoveChild(CXFA_Node* pNode, bool bNotify) {
   if (!pNode || pNode->m_pParent != this) {
     ASSERT(FALSE);
     return FALSE;
   }
   if (m_pChild == pNode) {
     m_pChild = pNode->m_pNext;
     if (m_pLastChild == pNode) {
       m_pLastChild = pNode->m_pNext;
     }
@@ skipping 32 matching lines @@
       }
       pNode->m_pXMLNode = pNewXMLElement;
       pNode->SetEnum(XFA_ATTRIBUTE_Contains, XFA_ATTRIBUTEENUM_Unknown);
     } else {
       m_pXMLNode->RemoveChildNode(pNode->m_pXMLNode);
     }
     pNode->SetFlag(XFA_NodeFlag_OwnXMLNode, false);
   }
   return TRUE;
 }
+
 CXFA_Node* CXFA_Node::GetFirstChildByName(const CFX_WideStringC& wsName) const {
   return GetFirstChildByName(FX_HashCode_GetW(wsName, false));
 }
+
 CXFA_Node* CXFA_Node::GetFirstChildByName(uint32_t dwNameHash) const {
   for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_FirstChild); pNode;
        pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     if (pNode->GetNameHash() == dwNameHash) {
       return pNode;
     }
   }
   return nullptr;
 }
+
 CXFA_Node* CXFA_Node::GetFirstChildByClass(XFA_Element eType) const {
   for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_FirstChild); pNode;
        pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     if (pNode->GetElementType() == eType) {
       return pNode;
     }
   }
   return nullptr;
 }
+
 CXFA_Node* CXFA_Node::GetNextSameNameSibling(uint32_t dwNameHash) const {
   for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_NextSibling); pNode;
        pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     if (pNode->GetNameHash() == dwNameHash) {
       return pNode;
     }
   }
   return nullptr;
 }
+
 CXFA_Node* CXFA_Node::GetNextSameNameSibling(
     const CFX_WideStringC& wsNodeName) const {
   return GetNextSameNameSibling(FX_HashCode_GetW(wsNodeName, false));
 }
+
 CXFA_Node* CXFA_Node::GetNextSameClassSibling(XFA_Element eType) const {
   for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_NextSibling); pNode;
        pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     if (pNode->GetElementType() == eType) {
       return pNode;
     }
   }
   return nullptr;
 }
+
 int32_t CXFA_Node::GetNodeSameNameIndex() const {
   CXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
   if (!pScriptContext) {
     return -1;
   }
   return pScriptContext->GetIndexByName(const_cast<CXFA_Node*>(this));
 }
+
 int32_t CXFA_Node::GetNodeSameClassIndex() const {
   CXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
   if (!pScriptContext) {
     return -1;
   }
   return pScriptContext->GetIndexByClassName(const_cast<CXFA_Node*>(this));
 }
+
 void CXFA_Node::GetSOMExpression(CFX_WideString& wsSOMExpression) {
   CXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
   if (!pScriptContext) {
     return;
   }
   pScriptContext->GetSomExpression(this, wsSOMExpression);
 }
+
 CXFA_Node* CXFA_Node::GetInstanceMgrOfSubform() {
   CXFA_Node* pInstanceMgr = nullptr;
   if (m_ePacket == XFA_XDPPACKET_Form) {
     CXFA_Node* pParentNode = GetNodeItem(XFA_NODEITEM_Parent);
     if (!pParentNode || pParentNode->GetElementType() == XFA_Element::Area) {
       return pInstanceMgr;
     }
     for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_PrevSibling); pNode;
          pNode = pNode->GetNodeItem(XFA_NODEITEM_PrevSibling)) {
       XFA_Element eType = pNode->GetElementType();
       if ((eType == XFA_Element::Subform || eType == XFA_Element::SubformSet) &&
           pNode->m_dwNameHash != m_dwNameHash) {
         break;
       }
       if (eType == XFA_Element::InstanceManager) {
         CFX_WideStringC wsName = GetCData(XFA_ATTRIBUTE_Name);
         CFX_WideStringC wsInstName = pNode->GetCData(XFA_ATTRIBUTE_Name);
         if (wsInstName.GetLength() > 0 && wsInstName.GetAt(0) == '_' &&
             wsInstName.Mid(1) == wsName) {
           pInstanceMgr = pNode;
         }
         break;
       }
     }
   }
   return pInstanceMgr;
 }
+
 CXFA_Node* CXFA_Node::GetOccurNode() {
   return GetFirstChildByClass(XFA_Element::Occur);
 }
+
 bool CXFA_Node::HasFlag(XFA_NodeFlag dwFlag) const {
   if (m_uNodeFlags & dwFlag)
     return true;
   if (dwFlag == XFA_NodeFlag_HasRemovedChildren)
     return m_pParent && m_pParent->HasFlag(dwFlag);
   return false;
 }
 
 void CXFA_Node::SetFlag(uint32_t dwFlag, bool bNotify) {
   if (dwFlag == XFA_NodeFlag_Initialized && bNotify && !IsInitialized()) {
@@ skipping 92 matching lines @@
         if ((pUINode->m_elementType == XFA_Element::ChoiceList) &&
             (!pWidgetData->IsListBox())) {
           iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType,
                                                FALSE, FALSE);
         }
       }
     }
   }
   return iRet;
 }
+
 void CXFA_Node::UpdateNameHash() {
   const XFA_NOTSUREATTRIBUTE* pNotsure =
       XFA_GetNotsureAttribute(GetElementType(), XFA_ATTRIBUTE_Name);
   CFX_WideStringC wsName;
   if (!pNotsure || pNotsure->eType == XFA_ATTRIBUTETYPE_Cdata) {
     wsName = GetCData(XFA_ATTRIBUTE_Name);
     m_dwNameHash = FX_HashCode_GetW(wsName, false);
   } else if (pNotsure->eType == XFA_ATTRIBUTETYPE_Enum) {
     wsName = XFA_GetAttributeEnumByID(GetEnum(XFA_ATTRIBUTE_Name))->pName;
     m_dwNameHash = FX_HashCode_GetW(wsName, false);
   }
 }
+
 CFDE_XMLNode* CXFA_Node::CreateXMLMappingNode() {
   if (!m_pXMLNode) {
     CFX_WideString wsTag(GetCData(XFA_ATTRIBUTE_Name));
     m_pXMLNode = new CFDE_XMLElement(wsTag);
     SetFlag(XFA_NodeFlag_OwnXMLNode, false);
   }
   return m_pXMLNode;
 }
+
 FX_BOOL CXFA_Node::IsNeedSavingXMLNode() {
   return m_pXMLNode && (GetPacketID() == XFA_XDPPACKET_Datasets ||
                         GetElementType() == XFA_Element::Xfa);
 }
 
 XFA_MAPMODULEDATA* CXFA_Node::CreateMapModuleData() {
   if (!m_pMapModuleData)
     m_pMapModuleData = new XFA_MAPMODULEDATA;
   return m_pMapModuleData;
 }
@@ skipping 13 matching lines @@
     XFA_MAPMODULEDATA* pModule = pNode->GetMapModuleData();
     if (pModule && pModule->m_ValueMap.Lookup(pKey, pValue)) {
       return TRUE;
     }
     pNode = pNode->GetPacketID() != XFA_XDPPACKET_Datasets
                 ? pNode->GetTemplateNode()
                 : nullptr;
   }
   return FALSE;
 }
+
 void CXFA_Node::SetMapModuleString(void* pKey, const CFX_WideStringC& wsValue) {
   SetMapModuleBuffer(pKey, (void*)wsValue.c_str(),
                      wsValue.GetLength() * sizeof(FX_WCHAR));
 }
+
 FX_BOOL CXFA_Node::GetMapModuleString(void* pKey, CFX_WideStringC& wsValue) {
   void* pValue;
   int32_t iBytes;
   if (!GetMapModuleBuffer(pKey, pValue, iBytes)) {
     return FALSE;
   }
   wsValue = CFX_WideStringC((const FX_WCHAR*)pValue, iBytes / sizeof(FX_WCHAR));
   return TRUE;
 }
+
 void CXFA_Node::SetMapModuleBuffer(
     void* pKey,
     void* pValue,
     int32_t iBytes,
     XFA_MAPDATABLOCKCALLBACKINFO* pCallbackInfo) {
   XFA_MAPMODULEDATA* pModule = CreateMapModuleData();
   XFA_MAPDATABLOCK*& pBuffer = pModule->m_BufferMap[pKey];
   if (!pBuffer) {
     pBuffer =
         (XFA_MAPDATABLOCK*)FX_Alloc(uint8_t, sizeof(XFA_MAPDATABLOCK) + iBytes);
   } else if (pBuffer->iBytes != iBytes) {
     if (pBuffer->pCallbackInfo && pBuffer->pCallbackInfo->pFree) {
       pBuffer->pCallbackInfo->pFree(*(void**)pBuffer->GetData());
     }
     pBuffer = (XFA_MAPDATABLOCK*)FX_Realloc(uint8_t, pBuffer,
                                             sizeof(XFA_MAPDATABLOCK) + iBytes);
   } else if (pBuffer->pCallbackInfo && pBuffer->pCallbackInfo->pFree) {
     pBuffer->pCallbackInfo->pFree(*(void**)pBuffer->GetData());
   }
   if (!pBuffer)
     return;
 
   pBuffer->pCallbackInfo = pCallbackInfo;
   pBuffer->iBytes = iBytes;
   FXSYS_memcpy(pBuffer->GetData(), pValue, iBytes);
 }
+
 FX_BOOL CXFA_Node::GetMapModuleBuffer(void* pKey,
                                       void*& pValue,
                                       int32_t& iBytes,
                                       FX_BOOL bProtoAlso) const {
   XFA_MAPDATABLOCK* pBuffer = nullptr;
   const CXFA_Node* pNode = this;
   while (pNode) {
     XFA_MAPMODULEDATA* pModule = pNode->GetMapModuleData();
     if (pModule && pModule->m_BufferMap.Lookup(pKey, pBuffer)) {
       break;
     }
     pNode = (bProtoAlso && pNode->GetPacketID() != XFA_XDPPACKET_Datasets)
                 ? pNode->GetTemplateNode()
                 : nullptr;
   }
   if (!pBuffer) {
     return FALSE;
   }
   pValue = pBuffer->GetData();
   iBytes = pBuffer->iBytes;
   return TRUE;
 }
+
 FX_BOOL CXFA_Node::HasMapModuleKey(void* pKey, FX_BOOL bProtoAlso) {
   CXFA_Node* pNode = this;
   while (pNode) {
     void* pVal;
     XFA_MAPMODULEDATA* pModule = pNode->GetMapModuleData();
     if (pModule &&
         (pModule->m_ValueMap.Lookup(pKey, pVal) ||
          pModule->m_BufferMap.Lookup(pKey, (XFA_MAPDATABLOCK*&)pVal))) {
       return TRUE;
     }
     pNode = (bProtoAlso && pNode->GetPacketID() != XFA_XDPPACKET_Datasets)
                 ? pNode->GetTemplateNode()
                 : nullptr;
   }
   return FALSE;
 }
+
 void CXFA_Node::RemoveMapModuleKey(void* pKey) {
   XFA_MAPMODULEDATA* pModule = GetMapModuleData();
   if (!pModule)
     return;
 
   if (pKey) {
     XFA_MAPDATABLOCK* pBuffer = nullptr;
     pModule->m_BufferMap.Lookup(pKey, pBuffer);
     if (pBuffer) {
       if (pBuffer->pCallbackInfo && pBuffer->pCallbackInfo->pFree) {
@@ skipping 13 matching lines @@
           pBuffer->pCallbackInfo->pFree(*(void**)pBuffer->GetData());
         }
         FX_Free(pBuffer);
       }
     }
     pModule->m_BufferMap.RemoveAll();
     pModule->m_ValueMap.RemoveAll();
     delete pModule;
   }
 }
+
 void CXFA_Node::MergeAllData(void* pDstModule, FX_BOOL bUseSrcAttr) {
   XFA_MAPMODULEDATA* pDstModuleData =
       static_cast<CXFA_Node*>(pDstModule)->CreateMapModuleData();
   XFA_MAPMODULEDATA* pSrcModuleData = GetMapModuleData();
   if (!pSrcModuleData) {
     return;
   }
   FX_POSITION psValue = pSrcModuleData->m_ValueMap.GetStartPosition();
   while (psValue) {
     void* pKey;
@@ skipping 36 matching lines @@
       continue;
     }
     pBuffer->pCallbackInfo = pSrcBuffer->pCallbackInfo;
     pBuffer->iBytes = pSrcBuffer->iBytes;
     FXSYS_memcpy(pBuffer->GetData(), pSrcBuffer->GetData(), pSrcBuffer->iBytes);
     if (pBuffer->pCallbackInfo && pBuffer->pCallbackInfo->pCopy) {
       pBuffer->pCallbackInfo->pCopy(*(void**)pBuffer->GetData());
     }
   }
 }
+
 void CXFA_Node::MoveBufferMapData(CXFA_Node* pDstModule, void* pKey) {
   if (!pDstModule) {
     return;
   }
   FX_BOOL bNeedMove = TRUE;
   if (!pKey) {
     bNeedMove = FALSE;
   }
   if (pDstModule->GetElementType() != GetElementType()) {
     bNeedMove = FALSE;
@@ skipping 19 matching lines @@
   if (pDstModule->IsNodeV()) {
     CFX_WideString wsValue = pDstModule->GetScriptContent(FALSE);
     CFX_WideString wsFormatValue(wsValue);
     CXFA_WidgetData* pWidgetData = pDstModule->GetContainerWidgetData();
     if (pWidgetData) {
       pWidgetData->GetFormatDataValue(wsValue, wsFormatValue);
     }
     pDstModule->SetScriptContent(wsValue, wsFormatValue, true, TRUE);
   }
 }
+
 void CXFA_Node::MoveBufferMapData(CXFA_Node* pSrcModule,
                                   CXFA_Node* pDstModule,
                                   void* pKey,
                                   FX_BOOL bRecursive) {
   if (!pSrcModule || !pDstModule || !pKey) {
     return;
   }
   if (bRecursive) {
     CXFA_Node* pSrcChild = pSrcModule->GetNodeItem(XFA_NODEITEM_FirstChild);
     CXFA_Node* pDstChild = pDstModule->GetNodeItem(XFA_NODEITEM_FirstChild);
     for (; pSrcChild && pDstChild;
          pSrcChild = pSrcChild->GetNodeItem(XFA_NODEITEM_NextSibling),
          pDstChild = pDstChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {
       MoveBufferMapData(pSrcChild, pDstChild, pKey, TRUE);
     }
   }
   pSrcModule->MoveBufferMapData(pDstModule, pKey);
 }
-
-CXFA_ThisProxy::CXFA_ThisProxy(CXFA_Node* pThisNode, CXFA_Node* pScriptNode)
-    : CXFA_Object(pThisNode->GetDocument(),
-                  XFA_ObjectType::VariablesThis,
-                  XFA_Element::Unknown,
-                  CFX_WideStringC()),
-      m_pThisNode(nullptr),
-      m_pScriptNode(nullptr) {
-  m_pThisNode = pThisNode;
-  m_pScriptNode = pScriptNode;
-}
-
-CXFA_ThisProxy::~CXFA_ThisProxy() {}
-
-CXFA_Node* CXFA_ThisProxy::GetThisNode() const {
-  return m_pThisNode;
-}
-
-CXFA_Node* CXFA_ThisProxy::GetScriptNode() const {
-  return m_pScriptNode;
-}
-
-CXFA_NodeList::CXFA_NodeList(CXFA_Document* pDocument)
-    : CXFA_Object(pDocument,
-                  XFA_ObjectType::NodeList,
-                  XFA_Element::NodeList,
-                  CFX_WideStringC(L"nodeList")) {
-  m_pDocument->GetScriptContext()->AddToCacheList(
-      std::unique_ptr<CXFA_NodeList>(this));
-}
-
-CXFA_NodeList::~CXFA_NodeList() {}
-
-CXFA_Node* CXFA_NodeList::NamedItem(const CFX_WideStringC& wsName) {
-  uint32_t dwHashCode = FX_HashCode_GetW(wsName, false);
-  int32_t iCount = GetLength();
-  for (int32_t i = 0; i < iCount; i++) {
-    CXFA_Node* ret = Item(i);
-    if (dwHashCode == ret->GetNameHash())
-      return ret;
-  }
-  return nullptr;
-}
-void CXFA_NodeList::Script_ListClass_Append(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 1) {
-    CXFA_Node* pNode = static_cast<CXFA_Node*>(pArguments->GetObject(0));
-    if (pNode) {
-      Append(pNode);
-    } else {
-      ThrowException(XFA_IDS_ARGUMENT_MISMATCH);
-    }
-  } else {
-    ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"append");
-  }
-}
-void CXFA_NodeList::Script_ListClass_Insert(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 2) {
-    CXFA_Node* pNewNode = static_cast<CXFA_Node*>(pArguments->GetObject(0));
-    CXFA_Node* pBeforeNode = static_cast<CXFA_Node*>(pArguments->GetObject(1));
-    if (pNewNode) {
-      Insert(pNewNode, pBeforeNode);
-    } else {
-      ThrowException(XFA_IDS_ARGUMENT_MISMATCH);
-    }
-  } else {
-    ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"insert");
-  }
-}
-void CXFA_NodeList::Script_ListClass_Remove(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 1) {
-    CXFA_Node* pNode = static_cast<CXFA_Node*>(pArguments->GetObject(0));
-    if (pNode) {
-      Remove(pNode);
-    } else {
-      ThrowException(XFA_IDS_ARGUMENT_MISMATCH);
-    }
-  } else {
-    ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"remove");
-  }
-}
-void CXFA_NodeList::Script_ListClass_Item(CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 1) {
-    int32_t iIndex = pArguments->GetInt32(0);
-    if ((iIndex >= 0) && (iIndex + 1 <= GetLength())) {
-      pArguments->GetReturnValue()->Assign(
-          m_pDocument->GetScriptContext()->GetJSValueFromMap(Item(iIndex)));
-    } else {
-      ThrowException(XFA_IDS_INDEX_OUT_OF_BOUNDS);
-    }
-  } else {
-    ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"item");
-  }
-}
-void CXFA_NodeList::Script_TreelistClass_NamedItem(
-    CFXJSE_Arguments* pArguments) {
-  int32_t argc = pArguments->GetLength();
-  if (argc == 1) {
-    CFX_ByteString szName = pArguments->GetUTF8String(0);
-    CXFA_Node* pNode =
-        NamedItem(CFX_WideString::FromUTF8(szName.AsStringC()).AsStringC());
-    if (!pNode) {
-      return;
-    }
-    pArguments->GetReturnValue()->Assign(
-        m_pDocument->GetScriptContext()->GetJSValueFromMap(pNode));
-  } else {
-    ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"namedItem");
-  }
-}
-void CXFA_NodeList::Script_ListClass_Length(CFXJSE_Value* pValue,
-                                            FX_BOOL bSetting,
-                                            XFA_ATTRIBUTE eAttribute) {
-  if (!bSetting) {
-    pValue->SetInteger(GetLength());
-  } else {
-    ThrowException(XFA_IDS_INVAlID_PROP_SET);
-  }
-}
-CXFA_ArrayNodeList::CXFA_ArrayNodeList(CXFA_Document* pDocument)
-    : CXFA_NodeList(pDocument) {}
-
-CXFA_ArrayNodeList::~CXFA_ArrayNodeList() {}
-
-void CXFA_ArrayNodeList::SetArrayNodeList(const CXFA_NodeArray& srcArray) {
-  if (srcArray.GetSize() > 0) {
-    m_array.Copy(srcArray);
-  }
-}
-int32_t CXFA_ArrayNodeList::GetLength() {
-  return m_array.GetSize();
-}
-FX_BOOL CXFA_ArrayNodeList::Append(CXFA_Node* pNode) {
-  m_array.Add(pNode);
-  return TRUE;
-}
-FX_BOOL CXFA_ArrayNodeList::Insert(CXFA_Node* pNewNode,
-                                   CXFA_Node* pBeforeNode) {
-  if (!pBeforeNode) {
-    m_array.Add(pNewNode);
-  } else {
-    int32_t iSize = m_array.GetSize();
-    for (int32_t i = 0; i < iSize; ++i) {
-      if (m_array[i] == pBeforeNode) {
-        m_array.InsertAt(i, pNewNode);
-        break;
-      }
-    }
-  }
-  return TRUE;
-}
-FX_BOOL CXFA_ArrayNodeList::Remove(CXFA_Node* pNode) {
-  int32_t iSize = m_array.GetSize();
-  for (int32_t i = 0; i < iSize; ++i) {
-    if (m_array[i] == pNode) {
-      m_array.RemoveAt(i);
-      break;
-    }
-  }
-  return TRUE;
-}
-CXFA_Node* CXFA_ArrayNodeList::Item(int32_t iIndex) {
-  int32_t iSize = m_array.GetSize();
-  if (iIndex >= 0 && iIndex < iSize) {
-    return m_array[iIndex];
-  }
-  return nullptr;
-}
-CXFA_AttachNodeList::CXFA_AttachNodeList(CXFA_Document* pDocument,
-                                         CXFA_Node* pAttachNode)
-    : CXFA_NodeList(pDocument) {
-  m_pAttachNode = pAttachNode;
-}
-int32_t CXFA_AttachNodeList::GetLength() {
-  return m_pAttachNode->CountChildren(
-      XFA_Element::Unknown,
-      m_pAttachNode->GetElementType() == XFA_Element::Subform);
-}
-FX_BOOL CXFA_AttachNodeList::Append(CXFA_Node* pNode) {
-  CXFA_Node* pParent = pNode->GetNodeItem(XFA_NODEITEM_Parent);
-  if (pParent) {
-    pParent->RemoveChild(pNode);
-  }
-  return m_pAttachNode->InsertChild(pNode);
-}
-FX_BOOL CXFA_AttachNodeList::Insert(CXFA_Node* pNewNode,
-                                    CXFA_Node* pBeforeNode) {
-  CXFA_Node* pParent = pNewNode->GetNodeItem(XFA_NODEITEM_Parent);
-  if (pParent) {
-    pParent->RemoveChild(pNewNode);
-  }
-  return m_pAttachNode->InsertChild(pNewNode, pBeforeNode);
-}
-FX_BOOL CXFA_AttachNodeList::Remove(CXFA_Node* pNode) {
-  return m_pAttachNode->RemoveChild(pNode);
-}
-CXFA_Node* CXFA_AttachNodeList::Item(int32_t iIndex) {
-  return m_pAttachNode->GetChild(
-      iIndex, XFA_Element::Unknown,
-      m_pAttachNode->GetElementType() == XFA_Element::Subform);
-}