Call CXFA_Object::ToNode() rather than C-style casting.

xfa/src/fxfa/src/parser/xfa_object_imp.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #include "xfa/src/foxitlib.h"
 #include "xfa/src/fxfa/src/common/xfa_utils.h"
 #include "xfa/src/fxfa/src/common/xfa_object.h"
 #include "xfa/src/fxfa/src/common/xfa_document.h"
@@ skipping 12 matching lines @@
   ASSERT(pElement != NULL);
   wsName = pElement->pName;
 }
 uint32_t CXFA_Object::GetClassHashCode() const {
   XFA_LPCELEMENTINFO pElement = XFA_GetElementByID(GetClassID());
   ASSERT(pElement != NULL);
   return pElement->uHash;
 }
 XFA_ELEMENT CXFA_Object::GetClassID() const {
   if (IsNode()) {
-    return ((const CXFA_Node*)this)->GetClassID();
-  } else if (IsOrdinaryObject()) {
-    return ((const CXFA_OrdinaryObject*)this)->GetClassID();
-  } else if (IsNodeList()) {
-    return ((const CXFA_NodeList*)this)->GetClassID();
-  } else if (IsOrdinaryList()) {
+    return AsNode()->GetClassID();
+  }
+  if (IsOrdinaryObject()) {
+    return AsOrdinaryObject()->GetClassID();
+  }
+  if (IsNodeList()) {
+    return AsNodeList()->GetClassID();
+  }
+  if (IsOrdinaryList()) {
     return XFA_ELEMENT_List;
   }
   ASSERT(FALSE);
   return (XFA_ELEMENT)0;
 }
 void CXFA_Object::Script_ObjectClass_ClassName(FXJSE_HVALUE hValue,
                                                FX_BOOL bSetting,
                                                XFA_ATTRIBUTE eAttribute) {
   if (!bSetting) {
     CFX_WideStringC className;
@@ skipping 273 matching lines @@
   return pClone;
 }
 CXFA_Node* CXFA_Node::GetTemplateNode() {
   return m_pAuxNode;
 }
 void CXFA_Node::SetTemplateNode(CXFA_Node* pTemplateNode) {
   m_pAuxNode = pTemplateNode;
 }
 CXFA_Node* CXFA_Node::GetBindData() {
   ASSERT(GetPacketID() == XFA_XDPPACKET_Form);
-  return (CXFA_Node*)GetObject(XFA_ATTRIBUTE_BindingNode);
+  return static_cast<CXFA_Node*>(GetObject(XFA_ATTRIBUTE_BindingNode));
 }
 int32_t CXFA_Node::GetBindItems(CXFA_NodeArray& formItems) {
   if (m_uFlags & XFA_NODEFLAG_BindFormItems) {
     CXFA_NodeArray* pItems = NULL;
     TryObject(XFA_ATTRIBUTE_BindingNode, (void*&)pItems);
     formItems.Copy(*pItems);
     return formItems.GetSize();
   }
-  CXFA_Node* pFormNode = (CXFA_Node*)GetObject(XFA_ATTRIBUTE_BindingNode);
+  CXFA_Node* pFormNode =
+      static_cast<CXFA_Node*>(GetObject(XFA_ATTRIBUTE_BindingNode));
   if (pFormNode) {
     formItems.Add(pFormNode);
   }
   return formItems.GetSize();
 }
 static void XFA_DataNodeDeleteBindItem(void* pData) {
   if (pData) {
     delete ((CXFA_NodeArray*)pData);
   }
 }
 static XFA_MAPDATABLOCKCALLBACKINFO deleteBindItemCallBack = {
     XFA_DataNodeDeleteBindItem, NULL};
 int32_t CXFA_Node::AddBindItem(CXFA_Node* pFormNode) {
   ASSERT(pFormNode);
   if (m_uFlags & XFA_NODEFLAG_BindFormItems) {
     CXFA_NodeArray* pItems = NULL;
     TryObject(XFA_ATTRIBUTE_BindingNode, (void*&)pItems);
     ASSERT(pItems);
     if (pItems->Find(pFormNode) < 0) {
       pItems->Add(pFormNode);
     }
     return pItems->GetSize();
   }
-  CXFA_Node* pOldFormItem = (CXFA_Node*)GetObject(XFA_ATTRIBUTE_BindingNode);
+  CXFA_Node* pOldFormItem =
+      static_cast<CXFA_Node*>(GetObject(XFA_ATTRIBUTE_BindingNode));
   if (!pOldFormItem) {
     SetObject(XFA_ATTRIBUTE_BindingNode, pFormNode);
     return 1;
   } else if (pOldFormItem == pFormNode) {
     return 1;
   }
   CXFA_NodeArray* pItems = new CXFA_NodeArray;
   SetObject(XFA_ATTRIBUTE_BindingNode, pItems, &deleteBindItemCallBack);
   pItems->Add(pOldFormItem);
   pItems->Add(pFormNode);
@@ skipping 14 matching lines @@
       pItems->RemoveAt(iCount - 1);
       if (iCount == 2) {
         CXFA_Node* pLastFormNode = pItems->GetAt(0);
         SetObject(XFA_ATTRIBUTE_BindingNode, pLastFormNode);
         m_uFlags &= ~XFA_NODEFLAG_BindFormItems;
       }
       iCount--;
     }
     return iCount;
   }
-  CXFA_Node* pOldFormItem = (CXFA_Node*)GetObject(XFA_ATTRIBUTE_BindingNode);
+  CXFA_Node* pOldFormItem =
+      static_cast<CXFA_Node*>(GetObject(XFA_ATTRIBUTE_BindingNode));
   if (pOldFormItem == pFormNode) {
     SetObject(XFA_ATTRIBUTE_BindingNode, NULL);
     pOldFormItem = NULL;
   }
   return pOldFormItem == NULL ? 0 : 1;
 }
 FX_BOOL CXFA_Node::HasBindItem() {
   return (GetPacketID() == XFA_XDPPACKET_Datasets) &&
          GetObject(XFA_ATTRIBUTE_BindingNode) != NULL;
 }
@@ skipping 62 matching lines @@
     pValueNode = (pGrandNode && pGrandNode->GetClassID() == XFA_ELEMENT_Value)
                      ? pGrandNode
                      : NULL;
   }
   CXFA_Node* pParentOfValueNode =
       pValueNode ? pValueNode->GetNodeItem(XFA_NODEITEM_Parent) : NULL;
   return pParentOfValueNode ? pParentOfValueNode->GetContainerWidgetData()
                             : NULL;
 }
 FX_BOOL CXFA_Node::GetLocaleName(CFX_WideString& wsLocaleName) {
-  CXFA_Node* pForm = (CXFA_Node*)GetDocument()->GetXFAObject(XFA_HASHCODE_Form);
+  CXFA_Node* pForm = GetDocument()->GetXFAObject(XFA_HASHCODE_Form)->AsNode();
   CXFA_Node* pTopSubform = pForm->GetFirstChildByClass(XFA_ELEMENT_Subform);
   FXSYS_assert(pTopSubform);
   CXFA_Node* pLocaleNode = this;
   FX_BOOL bLocale = FALSE;
   do {
     bLocale = pLocaleNode->TryCData(XFA_ATTRIBUTE_Locale, wsLocaleName, FALSE);
     if (!bLocale) {
       pLocaleNode = pLocaleNode->GetNodeItem(XFA_NODEITEM_Parent);
     }
   } while (pLocaleNode && pLocaleNode != pTopSubform && !bLocale);
   if (bLocale) {
     return bLocale;
   }
-  CXFA_Node* pConfig =
-      (CXFA_Node*)GetDocument()->GetXFAObject(XFA_HASHCODE_Config);
+  CXFA_Node* pConfig = ToNode(GetDocument()->GetXFAObject(XFA_HASHCODE_Config));
   wsLocaleName = GetDocument()->GetLocalMgr()->GetConfigLocaleName(pConfig);
   if (!wsLocaleName.IsEmpty()) {
     bLocale = TRUE;
   }
   if (bLocale) {
     return bLocale;
   }
   if (pTopSubform) {
     bLocale = pTopSubform->TryCData(XFA_ATTRIBUTE_Locale, wsLocaleName, FALSE);
   }
@@ skipping 109 matching lines @@
   CFX_WideString wsExpression;
   CFX_ByteString bsExpression = pArguments->GetUTF8String(0);
   wsExpression =
       CFX_WideString::FromUTF8(bsExpression, bsExpression.GetLength());
   IXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
   if (!pScriptContext) {
     return;
   }
   CXFA_Node* refNode = this;
   if (refNode->GetClassID() == XFA_ELEMENT_Xfa) {
-    refNode = (CXFA_Node*)pScriptContext->GetThisObject();
+    refNode = ToNode(pScriptContext->GetThisObject());
   }
   FX_DWORD dwFlag = XFA_RESOLVENODE_Children | XFA_RESOLVENODE_Attributes |
                     XFA_RESOLVENODE_Properties | XFA_RESOLVENODE_Parent |
                     XFA_RESOLVENODE_Siblings;
   XFA_RESOLVENODE_RS resoveNodeRS;
   int32_t iRet = pScriptContext->ResolveObjects(refNode, wsExpression,
                                                 resoveNodeRS, dwFlag);
   if (iRet < 1) {
     return FXJSE_Value_SetNull(pArguments->GetReturnValue());
   }
@@ skipping 28 matching lines @@
       CFX_WideString::FromUTF8(bsExpression, bsExpression.GetLength());
   FXJSE_HVALUE hValue = pArguments->GetReturnValue();
   if (!hValue) {
     return;
   }
   FX_DWORD dwFlag = XFA_RESOLVENODE_Children | XFA_RESOLVENODE_Attributes |
                     XFA_RESOLVENODE_Properties | XFA_RESOLVENODE_Parent |
                     XFA_RESOLVENODE_Siblings;
   CXFA_Node* refNode = this;
   if (refNode->GetClassID() == XFA_ELEMENT_Xfa) {
-    refNode = (CXFA_Node*)m_pDocument->GetScriptContext()->GetThisObject();
+    refNode = ToNode(m_pDocument->GetScriptContext()->GetThisObject());
   }
   Script_Som_ResolveNodeList(hValue, wsExpression, dwFlag, refNode);
 }
 void CXFA_Node::Script_Som_ResolveNodeList(FXJSE_HVALUE hValue,
                                            CFX_WideString wsExpression,
                                            FX_DWORD dwFlag,
                                            CXFA_Node* refNode) {
   IXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
   if (!pScriptContext) {
     return;
   }
   XFA_RESOLVENODE_RS resoveNodeRS;
   if (refNode == NULL) {
     refNode = this;
   }
   pScriptContext->ResolveObjects(refNode, wsExpression,
                                  resoveNodeRS, dwFlag);
   CXFA_ArrayNodeList* pNodeList = new CXFA_ArrayNodeList(m_pDocument);
   if (resoveNodeRS.dwFlags == XFA_RESOVENODE_RSTYPE_Nodes) {
     for (int32_t i = 0; i < resoveNodeRS.nodes.GetSize(); i++) {
-      if (resoveNodeRS.nodes[i]->IsNode()) {
-        pNodeList->Append((CXFA_Node*)resoveNodeRS.nodes[i]);
-      }
+      if (resoveNodeRS.nodes[i]->IsNode())
+        pNodeList->Append(resoveNodeRS.nodes[i]->AsNode());
     }
   } else {
     CXFA_HVALUEArray hValueArray(pScriptContext->GetRuntime());
     if (resoveNodeRS.GetAttributeResult(hValueArray) > 0) {
       CXFA_ObjArray objectArray;
       hValueArray.GetAttributeObject(objectArray);
       for (int32_t i = 0; i < objectArray.GetSize(); i++) {
-        if (objectArray[i]->IsNode()) {
-          pNodeList->Append((CXFA_Node*)objectArray[i]);
-        }
+        if (objectArray[i]->IsNode())
+          pNodeList->Append(objectArray[i]->AsNode());
       }
     }
   }
   FXJSE_Value_SetObject(hValue, (CXFA_Object*)pNodeList,
                         pScriptContext->GetJseNormalClass());
 }
 void CXFA_Node::Script_TreeClass_All(FXJSE_HVALUE hValue,
                                      FX_BOOL bSetting,
                                      XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
@@ skipping 432 matching lines @@
 }
 void CXFA_Node::Script_NodeClass_SetElement(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength != 1 && iLength != 2) {
     ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"setElement");
     return;
   }
   CXFA_Node* pNode = NULL;
   CFX_WideString wsName;
   if (iLength >= 1) {
-    pNode = (CXFA_Node*)pArguments->GetObject(0);
+    pNode = static_cast<CXFA_Node*>(pArguments->GetObject(0));
   }
   if (iLength >= 2) {
     CFX_ByteString bsName = pArguments->GetUTF8String(1);
     wsName = CFX_WideString::FromUTF8(bsName, bsName.GetLength());
   }
 }
 void CXFA_Node::Script_NodeClass_Ns(FXJSE_HVALUE hValue,
                                     FX_BOOL bSetting,
                                     XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
@@ skipping 298 matching lines @@
   if (bSetting) {
     CFX_ByteString szValue;
     FXJSE_Value_ToUTF8String(hValue, szValue);
     CFX_WideString wsValue =
         CFX_WideString::FromUTF8(szValue, szValue.GetLength());
     SetAttribute(eAttribute, wsValue, TRUE);
     if (eAttribute == XFA_ATTRIBUTE_Use &&
         this->GetClassID() == XFA_ELEMENT_Desc) {
       CFX_WideString wsUseVal = wsValue, wsID, wsSOM;
       CXFA_Node* pTemplateNode =
-          (CXFA_Node*)m_pDocument->GetXFAObject(XFA_HASHCODE_Template);
+          ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Template));
       CXFA_Node* pProtoRoot =
           pTemplateNode->GetFirstChildByClass(XFA_ELEMENT_Subform)
               ->GetFirstChildByClass(XFA_ELEMENT_Proto);
       if (!wsUseVal.IsEmpty()) {
         if (wsUseVal[0] == '#') {
           wsID = CFX_WideString((const FX_WCHAR*)wsUseVal + 1,
                                 wsUseVal.GetLength() - 1);
         } else {
           wsSOM =
               CFX_WideString((const FX_WCHAR*)wsUseVal, wsUseVal.GetLength());
         }
       }
       CXFA_Node* pProtoNode = NULL;
       if (!wsSOM.IsEmpty()) {
         FX_DWORD dwFlag = XFA_RESOLVENODE_Children |
                           XFA_RESOLVENODE_Attributes |
                           XFA_RESOLVENODE_Properties | XFA_RESOLVENODE_Parent |
                           XFA_RESOLVENODE_Siblings;
         XFA_RESOLVENODE_RS resoveNodeRS;
         int32_t iRet = m_pDocument->GetScriptContext()->ResolveObjects(
             pProtoRoot, wsSOM, resoveNodeRS, dwFlag);
         if (iRet > 0 && resoveNodeRS.nodes[0]->IsNode()) {
-          pProtoNode = (CXFA_Node*)resoveNodeRS.nodes[0];
+          pProtoNode = resoveNodeRS.nodes[0]->AsNode();
         }
       } else if (!wsID.IsEmpty()) {
         pProtoNode = m_pDocument->GetNodeByID(pProtoRoot, wsID);
       }
       if (pProtoNode) {
         CXFA_Node* pHeadChild = GetNodeItem(XFA_NODEITEM_FirstChild);
         while (pHeadChild) {
           CXFA_Node* pSibling =
               pHeadChild->GetNodeItem(XFA_NODEITEM_NextSibling);
           RemoveChild(pHeadChild);
@@ skipping 1585 matching lines @@
   for (CXFA_Node* pRootBoundNode = pFormParent;
        pRootBoundNode &&
        pRootBoundNode->GetObjectType() == XFA_OBJECTTYPE_ContainerNode;
        pRootBoundNode = pRootBoundNode->GetNodeItem(XFA_NODEITEM_Parent)) {
     pDataScope = pRootBoundNode->GetBindData();
     if (pDataScope) {
       break;
     }
   }
   if (!pDataScope) {
-    pDataScope = (CXFA_Node*)pDocument->GetXFAObject(XFA_HASHCODE_Record);
+    pDataScope = ToNode(pDocument->GetXFAObject(XFA_HASHCODE_Record));
     ASSERT(pDataScope);
   }
   CXFA_Node* pInstance = pDocument->DataMerge_CopyContainer(
       pTemplateNode, pFormParent, pDataScope, TRUE, bDataMerge);
   if (pInstance) {
     pDocument->DataMerge_UpdateBindingRelations(pInstance);
     pFormParent->RemoveChild(pInstance);
   }
   return pInstance;
 }
@@ skipping 59 matching lines @@
           pSubformInstance->GetClassID() == XFA_ELEMENT_Subform) {
         pNotify->RunSubformIndexChange(pSubformInstance);
       }
     }
   }
   CXFA_LayoutProcessor* pLayoutPro = m_pDocument->GetLayoutProcessor();
   if (!pLayoutPro) {
     return;
   }
   pLayoutPro->AddChangedContainer(
-      (CXFA_Node*)m_pDocument->GetXFAObject(XFA_HASHCODE_Form));
+      ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Form)));
 }
 void CXFA_Node::Script_InstanceManager_SetInstances(
     CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc != 1) {
     FXJSE_Value_SetUndefined(pArguments->GetReturnValue());
     return;
   }
   int32_t iDesired = pArguments->GetInt32(0);
   InstanceManager_SetInstances(iDesired);
@@ skipping 26 matching lines @@
   IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
   if (!pNotify) {
     return;
   }
   pNotify->RunNodeInitialize(pNewInstance);
   CXFA_LayoutProcessor* pLayoutPro = m_pDocument->GetLayoutProcessor();
   if (!pLayoutPro) {
     return;
   }
   pLayoutPro->AddChangedContainer(
-      (CXFA_Node*)m_pDocument->GetXFAObject(XFA_HASHCODE_Form));
+      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)) {
     ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                             L"insertInstance");
     return;
   }
   int32_t iIndex = pArguments->GetInt32(0);
@@ skipping 22 matching lines @@
   IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
   if (!pNotify) {
     return;
   }
   pNotify->RunNodeInitialize(pNewInstance);
   CXFA_LayoutProcessor* pLayoutPro = m_pDocument->GetLayoutProcessor();
   if (!pLayoutPro) {
     return;
   }
   pLayoutPro->AddChangedContainer(
-      (CXFA_Node*)m_pDocument->GetXFAObject(XFA_HASHCODE_Form));
+      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) {
     ThrowScriptErrorMessage(XFA_IDS_VIOLATE_BOUNDARY, L"min");
     return 1;
   }
   if ((iMax >= 0) && (iDesired > iMax)) {
@@ skipping 40 matching lines @@
                                            FALSE);
       iCount++;
       IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
       if (!pNotify) {
         return 0;
       }
       pNotify->RunNodeInitialize(pNewInstance);
     }
   }
   CXFA_LayoutProcessor* pLayoutPro = m_pDocument->GetLayoutProcessor();
-  if (!pLayoutPro) {
-    return 0;
+  if (pLayoutPro) {
+    pLayoutPro->AddChangedContainer(
+        ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Form)));
   }
-  pLayoutPro->AddChangedContainer(
-      (CXFA_Node*)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);
   if (iFrom > iCount || iTo > iCount - 1) {
     ThrowScriptErrorMessage(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_LayoutProcessor* pLayoutPro = m_pDocument->GetLayoutProcessor();
-  if (!pLayoutPro) {
-    return 0;
+  if (pLayoutPro) {
+    pLayoutPro->AddChangedContainer(
+        ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Form)));
   }
-  pLayoutPro->AddChangedContainer(
-      (CXFA_Node*)m_pDocument->GetXFAObject(XFA_HASHCODE_Form));
   return 0;
 }
 void CXFA_Node::Script_Occur_Max(FXJSE_HVALUE hValue,
                                  FX_BOOL bSetting,
                                  XFA_ATTRIBUTE eAttribute) {
   CXFA_Occur occur(this);
   if (bSetting) {
     int32_t iMax = FXJSE_Value_ToInteger(hValue);
     occur.SetMax(iMax);
   } else {
@@ skipping 15 matching lines @@
   int32_t argc = pArguments->GetLength();
   if ((argc == 0) || (argc == 1)) {
     FXJSE_Value_SetUTF8String(pArguments->GetReturnValue(), "");
   } else {
     ThrowScriptErrorMessage(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 = (CXFA_Node*)pArguments->GetObject(0);
+    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);
       FXJSE_Value_SetObject(
           pArguments->GetReturnValue(), (CXFA_Object*)pFormNodes,
           m_pDocument->GetScriptContext()->GetJseNormalClass());
     } else {
       ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
     }
@@ skipping 1062 matching lines @@
     }
     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 (CXFA_Node*)m_pDocument->GetXFAObject(XFA_HASHCODE_Config);
+      return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Config));
     case XFA_XDPPACKET_Template:
-      return (CXFA_Node*)m_pDocument->GetXFAObject(XFA_HASHCODE_Template);
+      return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Template));
     case XFA_XDPPACKET_Form:
-      return (CXFA_Node*)m_pDocument->GetXFAObject(XFA_HASHCODE_Form);
+      return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Form));
     case XFA_XDPPACKET_Datasets:
-      return (CXFA_Node*)m_pDocument->GetXFAObject(XFA_HASHCODE_Datasets);
+      return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Datasets));
     case XFA_XDPPACKET_LocaleSet:
-      return (CXFA_Node*)m_pDocument->GetXFAObject(XFA_HASHCODE_LocaleSet);
+      return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_LocaleSet));
     case XFA_XDPPACKET_ConnectionSet:
-      return (CXFA_Node*)m_pDocument->GetXFAObject(XFA_HASHCODE_ConnectionSet);
+      return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_ConnectionSet));
     case XFA_XDPPACKET_SourceSet:
-      return (CXFA_Node*)m_pDocument->GetXFAObject(XFA_HASHCODE_SourceSet);
+      return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_SourceSet));
     case XFA_XDPPACKET_Xdc:
-      return (CXFA_Node*)m_pDocument->GetXFAObject(XFA_HASHCODE_Xdc);
+      return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Xdc));
     default:
       return this;
   }
 }
 FX_BOOL CXFA_Node::TryNamespace(CFX_WideString& wsNamespace) {
   wsNamespace.Empty();
   if (this->GetObjectType() == XFA_OBJECTTYPE_ModelNode ||
       this->GetClassID() == XFA_ELEMENT_Packet) {
     IFDE_XMLNode* pXMLNode = this->GetXMLMappingNode();
     if (!pXMLNode || pXMLNode->GetType() != FDE_XMLNODE_Element) {
@@ skipping 303 matching lines @@
       return pNode;
     }
   }
   return NULL;
 }
 int32_t CXFA_Node::GetNodeSameNameIndex() const {
   IXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
   if (!pScriptContext) {
     return -1;
   }
-  return pScriptContext->GetIndexByName((CXFA_Node*)this);
+  return pScriptContext->GetIndexByName(const_cast<CXFA_Node*>(this));
 }
 int32_t CXFA_Node::GetNodeSameClassIndex() const {
   IXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
   if (!pScriptContext) {
     return -1;
   }
-  return pScriptContext->GetIndexByClassName((CXFA_Node*)this);
+  return pScriptContext->GetIndexByClassName(const_cast<CXFA_Node*>(this));
 }
 void CXFA_Node::GetSOMExpression(CFX_WideString& wsSOMExpression) {
   IXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
   if (!pScriptContext) {
     return;
   }
   pScriptContext->GetSomExpression(this, wsSOMExpression);
 }
 CXFA_Node* CXFA_Node::GetInstanceMgrOfSubform() {
   CXFA_Node* pInstanceMgr = NULL;
@@ skipping 314 matching lines @@
     pMoudle->m_BufferMap.RemoveAll();
     pMoudle->m_ValueMap.RemoveAll();
     if (pMoudle) {
       delete pMoudle;
       pMoudle = NULL;
     }
   }
 }
 void CXFA_Node::MergeAllData(void* pDstModule, FX_BOOL bUseSrcAttr) {
   XFA_LPMAPMODULEDATA pDstModuleData =
-      ((CXFA_Node*)pDstModule)->GetMapModuleData(TRUE);
+      static_cast<CXFA_Node*>(pDstModule)->GetMapModuleData(TRUE);
   if (!pDstModuleData) {
     return;
   }
   XFA_LPMAPMODULEDATA pSrcModuleData = this->GetMapModuleData(FALSE);
   if (!pSrcModuleData) {
     return;
   }
   FX_POSITION psValue = pSrcModuleData->m_ValueMap.GetStartPosition();
   while (psValue) {
     void* pKey;
@@ skipping 115 matching lines @@
     CXFA_Node* ret = Item(i);
     if (dwHashCode == ret->GetNameHash()) {
       return ret;
     }
   }
   return NULL;
 }
 void CXFA_NodeList::Script_ListClass_Append(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 1) {
-    CXFA_Node* pNode = (CXFA_Node*)pArguments->GetObject(0);
+    CXFA_Node* pNode = static_cast<CXFA_Node*>(pArguments->GetObject(0));
     if (pNode) {
       Append(pNode);
     } else {
       ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
     }
   } else {
     ThrowScriptErrorMessage(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 = (CXFA_Node*)pArguments->GetObject(0);
-    CXFA_Node* pBeforeNode = (CXFA_Node*)pArguments->GetObject(1);
+    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 {
       ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
     }
   } else {
     ThrowScriptErrorMessage(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 = (CXFA_Node*)pArguments->GetObject(0);
+    CXFA_Node* pNode = static_cast<CXFA_Node*>(pArguments->GetObject(0));
     if (pNode) {
       Remove(pNode);
     } else {
       ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
     }
   } else {
     ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"remove");
   }
 }
 void CXFA_NodeList::Script_ListClass_Item(CFXJSE_Arguments* pArguments) {
@@ skipping 107 matching lines @@
   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->GetClassID() == XFA_ELEMENT_Subform);
 }