Change ThrowScriptErrorMessage() to ThrowException().

xfa/fxfa/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/fxfa/parser/xfa_object.h"
 
 #include <memory>
 
@@ skipping 72 matching lines @@
 void CXFA_Object::Script_ObjectClass_ClassName(CFXJSE_Value* pValue,
                                                FX_BOOL bSetting,
                                                XFA_ATTRIBUTE eAttribute) {
   if (!bSetting) {
     CFX_WideStringC className;
     GetClassName(className);
     FXJSE_Value_SetUTF8String(
         pValue,
         FX_UTF8Encode(className.c_str(), className.GetLength()).AsStringC());
   } else {
-    ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
+    ThrowException(XFA_IDS_INVAlID_PROP_SET);
   }
 }
 
-void CXFA_Object::ThrowScriptErrorMessage(int32_t iStringID, ...) {
+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(
@@ skipping 513 matching lines @@
 }
 
 void CXFA_Node::SetDataDescriptionNode(CXFA_Node* pDataDescriptionNode) {
   ASSERT(m_ePacket == XFA_XDPPACKET_Datasets);
   m_pAuxNode = pDataDescriptionNode;
 }
 
 void CXFA_Node::Script_TreeClass_ResolveNode(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength != 1) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"resolveNode");
+    ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"resolveNode");
     return;
   }
   CFX_WideString wsExpression =
       CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsStringC());
   CXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
   if (!pScriptContext)
     return;
   CXFA_Node* refNode = this;
   if (refNode->GetClassID() == XFA_ELEMENT_Xfa)
     refNode = ToNode(pScriptContext->GetThisObject());
@@ skipping 20 matching lines @@
       FXJSE_Value_Set(pArguments->GetReturnValue(), pValue.get());
     } else {
       FXJSE_Value_SetNull(pArguments->GetReturnValue());
     }
   }
 }
 
 void CXFA_Node::Script_TreeClass_ResolveNodes(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength != 1) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"resolveNodes");
+    ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"resolveNodes");
     return;
   }
   CFX_WideString wsExpression =
       CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsStringC());
   CFXJSE_Value* pValue = pArguments->GetReturnValue();
   if (!pValue)
     return;
   uint32_t dwFlag = XFA_RESOLVENODE_Children | XFA_RESOLVENODE_Attributes |
                     XFA_RESOLVENODE_Properties | XFA_RESOLVENODE_Parent |
                     XFA_RESOLVENODE_Siblings;
@@ skipping 33 matching lines @@
     }
   }
   FXJSE_Value_SetObject(pValue, (CXFA_Object*)pNodeList,
                         pScriptContext->GetJseNormalClass());
 }
 
 void CXFA_Node::Script_TreeClass_All(CFXJSE_Value* pValue,
                                      FX_BOOL bSetting,
                                      XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
-    ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
+    ThrowException(XFA_IDS_INVAlID_PROP_SET);
   } else {
     uint32_t dwFlag = XFA_RESOLVENODE_Siblings | XFA_RESOLVENODE_ALL;
     CFX_WideString wsName;
     GetAttribute(XFA_ATTRIBUTE_Name, wsName);
     CFX_WideString wsExpression = wsName + FX_WSTRC(L"[*]");
     Script_Som_ResolveNodeList(pValue, wsExpression, dwFlag);
   }
 }
 
 void CXFA_Node::Script_TreeClass_Nodes(CFXJSE_Value* pValue,
@@ skipping 14 matching lines @@
     CXFA_AttachNodeList* pNodeList = new CXFA_AttachNodeList(m_pDocument, this);
     FXJSE_Value_SetObject(pValue, (CXFA_Object*)pNodeList,
                           pScriptContext->GetJseNormalClass());
   }
 }
 
 void CXFA_Node::Script_TreeClass_ClassAll(CFXJSE_Value* pValue,
                                           FX_BOOL bSetting,
                                           XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
-    ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
+    ThrowException(XFA_IDS_INVAlID_PROP_SET);
   } else {
     uint32_t dwFlag = XFA_RESOLVENODE_Siblings | XFA_RESOLVENODE_ALL;
     CFX_WideStringC wsName;
     GetClassName(wsName);
     CFX_WideString wsExpression = FX_WSTRC(L"#") + wsName + FX_WSTRC(L"[*]");
     Script_Som_ResolveNodeList(pValue, wsExpression, dwFlag);
   }
 }
 
 void CXFA_Node::Script_TreeClass_Parent(CFXJSE_Value* pValue,
                                         FX_BOOL bSetting,
                                         XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
-    ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
+    ThrowException(XFA_IDS_INVAlID_PROP_SET);
   } else {
     CXFA_Node* pParent = GetNodeItem(XFA_NODEITEM_Parent);
     if (pParent) {
       FXJSE_Value_Set(
           pValue, m_pDocument->GetScriptContext()->GetJSValueFromMap(pParent));
     } else {
       FXJSE_Value_SetNull(pValue);
     }
   }
 }
 
 void CXFA_Node::Script_TreeClass_Index(CFXJSE_Value* pValue,
                                        FX_BOOL bSetting,
                                        XFA_ATTRIBUTE eAttribute) {
   if (bSetting)
-    ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
+    ThrowException(XFA_IDS_INVAlID_PROP_SET);
   else
     FXJSE_Value_SetInteger(pValue, GetNodeSameNameIndex());
 }
 
 void CXFA_Node::Script_TreeClass_ClassIndex(CFXJSE_Value* pValue,
                                             FX_BOOL bSetting,
                                             XFA_ATTRIBUTE eAttribute) {
   if (bSetting)
-    ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
+    ThrowException(XFA_IDS_INVAlID_PROP_SET);
   else
     FXJSE_Value_SetInteger(pValue, GetNodeSameClassIndex());
 }
 
 void CXFA_Node::Script_TreeClass_SomExpression(CFXJSE_Value* pValue,
                                                FX_BOOL bSetting,
                                                XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
-    ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
+    ThrowException(XFA_IDS_INVAlID_PROP_SET);
   } else {
     CFX_WideString wsSOMExpression;
     GetSOMExpression(wsSOMExpression);
     FXJSE_Value_SetUTF8String(pValue,
                               FX_UTF8Encode(wsSOMExpression).AsStringC());
   }
 }
 
 void CXFA_Node::Script_NodeClass_ApplyXSL(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength != 1) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"applyXSL");
+    ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"applyXSL");
     return;
   }
   CFX_WideString wsExpression =
       CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsStringC());
   // TODO(weili): check whether we need to implement this, pdfium:501.
   // For now, just put the variables here to avoid unused variable warning.
   (void)wsExpression;
 }
 
 void CXFA_Node::Script_NodeClass_AssignNode(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength < 1 || iLength > 3) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"assignNode");
+    ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"assignNode");
     return;
   }
   CFX_WideString wsExpression;
   CFX_WideString wsValue;
   int32_t iAction = 0;
   wsExpression =
       CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsStringC());
   if (iLength >= 2) {
     wsValue =
         CFX_WideString::FromUTF8(pArguments->GetUTF8String(1).AsStringC());
   }
   if (iLength >= 3)
     iAction = pArguments->GetInt32(2);
   // TODO(weili): check whether we need to implement this, pdfium:501.
   // For now, just put the variables here to avoid unused variable warning.
   (void)wsExpression;
   (void)wsValue;
   (void)iAction;
 }
 
 void CXFA_Node::Script_NodeClass_Clone(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength != 1) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"clone");
+    ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"clone");
     return;
   }
   bool bClone = !!pArguments->GetInt32(0);
   CXFA_Node* pCloneNode = Clone(bClone);
   FXJSE_Value_Set(
       pArguments->GetReturnValue(),
       m_pDocument->GetScriptContext()->GetJSValueFromMap(pCloneNode));
 }
 
 void CXFA_Node::Script_NodeClass_GetAttribute(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength != 1) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"getAttribute");
+    ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"getAttribute");
     return;
   }
   CFX_WideString wsExpression =
       CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsStringC());
   CFX_WideString wsValue;
   GetAttribute(wsExpression.AsStringC(), wsValue);
   CFXJSE_Value* pValue = pArguments->GetReturnValue();
   if (pValue)
     FXJSE_Value_SetUTF8String(pValue, FX_UTF8Encode(wsValue).AsStringC());
 }
 
 void CXFA_Node::Script_NodeClass_GetElement(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength < 1 || iLength > 2) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"getElement");
+    ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"getElement");
     return;
   }
   CFX_WideString wsExpression;
   int32_t iValue = 0;
   wsExpression =
       CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsStringC());
   if (iLength >= 2)
     iValue = pArguments->GetInt32(1);
   const XFA_ELEMENTINFO* pElementInfo =
       XFA_GetElementByName(wsExpression.AsStringC());
   CXFA_Node* pNode = GetProperty(iValue, pElementInfo->eName);
   FXJSE_Value_Set(pArguments->GetReturnValue(),
                   m_pDocument->GetScriptContext()->GetJSValueFromMap(pNode));
 }
 
 void CXFA_Node::Script_NodeClass_IsPropertySpecified(
     CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength < 1 || iLength > 3) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"isPropertySpecified");
+    ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"isPropertySpecified");
     return;
   }
   CFX_WideString wsExpression;
   bool bParent = true;
   int32_t iIndex = 0;
   wsExpression =
       CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsStringC());
   if (iLength >= 2)
     bParent = !!pArguments->GetInt32(1);
   if (iLength >= 3)
@@ skipping 16 matching lines @@
     }
   }
   CFXJSE_Value* pValue = pArguments->GetReturnValue();
   if (pValue)
     FXJSE_Value_SetBoolean(pValue, bHas);
 }
 
 void CXFA_Node::Script_NodeClass_LoadXML(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength < 1 || iLength > 3) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"loadXML");
+    ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"loadXML");
     return;
   }
   CFX_WideString wsExpression;
   bool bIgnoreRoot = true;
   bool bOverwrite = 0;
   wsExpression =
       CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsStringC());
   if (wsExpression.IsEmpty())
     return;
   if (iLength >= 2)
@@ skipping 101 matching lines @@
   }
 }
 
 void CXFA_Node::Script_NodeClass_SaveFilteredXML(CFXJSE_Arguments* pArguments) {
   // TODO(weili): Check whether we need to implement this, pdfium:501.
 }
 
 void CXFA_Node::Script_NodeClass_SaveXML(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength < 0 || iLength > 1) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"saveXML");
+    ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"saveXML");
     return;
   }
   bool bPrettyMode = false;
   if (iLength == 1) {
     if (pArguments->GetUTF8String(0) != "pretty") {
-      ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
+      ThrowException(XFA_IDS_ARGUMENT_MISMATCH);
       return;
     }
     bPrettyMode = true;
   }
   CFX_ByteStringC bsXMLHeader = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
   if (GetPacketID() == XFA_XDPPACKET_Form ||
       GetPacketID() == XFA_XDPPACKET_Datasets) {
     CFDE_XMLNode* pElement = nullptr;
     if (GetPacketID() == XFA_XDPPACKET_Datasets) {
       pElement = GetXMLMappingNode();
@@ skipping 27 matching lines @@
         pArguments->GetReturnValue(),
         CFX_ByteStringC(pMemoryStream->GetBuffer(), pMemoryStream->GetSize()));
     return;
   }
   FXJSE_Value_SetUTF8String(pArguments->GetReturnValue(), "");
 }
 
 void CXFA_Node::Script_NodeClass_SetAttribute(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength != 2) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"setAttribute");
+    ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"setAttribute");
     return;
   }
   CFX_WideString wsAttributeValue =
       CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsStringC());
   CFX_WideString wsAttribute =
       CFX_WideString::FromUTF8(pArguments->GetUTF8String(1).AsStringC());
   SetAttribute(wsAttribute.AsStringC(), wsAttributeValue.AsStringC(), true);
 }
 
 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");
+    ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"setElement");
     return;
   }
   CXFA_Node* pNode = nullptr;
   CFX_WideString wsName;
   pNode = static_cast<CXFA_Node*>(pArguments->GetObject(0));
   if (iLength == 2)
     wsName = CFX_WideString::FromUTF8(pArguments->GetUTF8String(1).AsStringC());
   // TODO(weili): check whether we need to implement this, pdfium:501.
   // For now, just put the variables here to avoid unused variable warning.
   (void)pNode;
   (void)wsName;
 }
 
 void CXFA_Node::Script_NodeClass_Ns(CFXJSE_Value* pValue,
                                     FX_BOOL bSetting,
                                     XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
-    ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
+    ThrowException(XFA_IDS_INVAlID_PROP_SET);
   } else {
     CFX_WideString wsNameSpace;
     TryNamespace(wsNameSpace);
     FXJSE_Value_SetUTF8String(pValue, FX_UTF8Encode(wsNameSpace).AsStringC());
   }
 }
 
 void CXFA_Node::Script_NodeClass_Model(CFXJSE_Value* pValue,
                                        FX_BOOL bSetting,
                                        XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
-    ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
+    ThrowException(XFA_IDS_INVAlID_PROP_SET);
   } else {
     FXJSE_Value_Set(pValue, m_pDocument->GetScriptContext()->GetJSValueFromMap(
                                 GetModelNode()));
   }
 }
 
 void CXFA_Node::Script_NodeClass_IsContainer(CFXJSE_Value* pValue,
                                              FX_BOOL bSetting,
                                              XFA_ATTRIBUTE eAttribute) {
   if (bSetting)
-    ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
+    ThrowException(XFA_IDS_INVAlID_PROP_SET);
   else
     FXJSE_Value_SetBoolean(pValue, IsContainerNode());
 }
 
 void CXFA_Node::Script_NodeClass_IsNull(CFXJSE_Value* pValue,
                                         FX_BOOL bSetting,
                                         XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
-    ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
+    ThrowException(XFA_IDS_INVAlID_PROP_SET);
   } else {
     if (GetClassID() == XFA_ELEMENT_Subform) {
       FXJSE_Value_SetBoolean(pValue, FALSE);
       return;
     }
     CFX_WideString strValue;
     FXJSE_Value_SetBoolean(pValue, !TryContent(strValue) || strValue.IsEmpty());
   }
 }
 
 void CXFA_Node::Script_NodeClass_OneOfChild(CFXJSE_Value* pValue,
                                             FX_BOOL bSetting,
                                             XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
-    ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
+    ThrowException(XFA_IDS_INVAlID_PROP_SET);
   } else {
     CXFA_NodeArray properts;
     int32_t iSize = GetNodeList(properts, XFA_NODEFILTER_OneOfProperty);
     if (iSize > 0) {
       FXJSE_Value_Set(
           pValue,
           m_pDocument->GetScriptContext()->GetJSValueFromMap(properts[0]));
     }
   }
 }
 
 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);
   FXJSE_Value_SetObject(pArguments->GetReturnValue(), (CXFA_Object*)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) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"isCompatibleNS");
+    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();
@@ skipping 15 matching lines @@
   } else {
     FXJSE_Value_SetInteger(pValue, GetInteger(eAttribute));
   }
 }
 void CXFA_Node::Script_Attribute_IntegerRead(CFXJSE_Value* pValue,
                                              FX_BOOL bSetting,
                                              XFA_ATTRIBUTE eAttribute) {
   if (!bSetting) {
     FXJSE_Value_SetInteger(pValue, GetInteger(eAttribute));
   } else {
-    ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
+    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, FXJSE_Value_ToBoolean(pValue), true);
   } else {
     FXJSE_Value_SetUTF8String(pValue, GetBoolean(eAttribute) ? "1" : "0");
   }
 }
 void CXFA_Node::Script_Attribute_BOOLRead(CFXJSE_Value* pValue,
                                           FX_BOOL bSetting,
                                           XFA_ATTRIBUTE eAttribute) {
   if (!bSetting) {
     FXJSE_Value_SetUTF8String(pValue, GetBoolean(eAttribute) ? "1" : "0");
   } else {
-    ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
+    ThrowException(XFA_IDS_INVAlID_PROP_SET);
   }
 }
 
 void CXFA_Node::Script_Attribute_SendAttributeChangeMessage(
     XFA_ATTRIBUTE eAttribute,
     FX_BOOL bScriptModify) {
   CXFA_LayoutProcessor* pLayoutPro = m_pDocument->GetLayoutProcessor();
   if (!pLayoutPro)
     return;
 
@@ skipping 213 matching lines @@
 void CXFA_Node::Script_Attribute_StringRead(CFXJSE_Value* pValue,
                                             FX_BOOL bSetting,
                                             XFA_ATTRIBUTE eAttribute) {
   if (!bSetting) {
     CFX_WideString wsValue;
     GetAttribute(eAttribute, wsValue);
     FXJSE_Value_SetUTF8String(
         pValue,
         FX_UTF8Encode(wsValue.c_str(), wsValue.GetLength()).AsStringC());
   } else {
-    ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
+    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)) {
     FXJSE_Value_SetBoolean(pArguments->GetReturnValue(), FALSE);
   } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execute");
+    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 {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"restore");
+    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,
@@ skipping 57 matching lines @@
 }
 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) {
-    ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
+    ThrowException(XFA_IDS_INVAlID_PROP_SET);
   } else {
     CXFA_WidgetData* pWidgetData = GetWidgetData();
     if (!pWidgetData) {
       FXJSE_Value_SetInteger(pValue, 0);
       return;
     }
     FXJSE_Value_SetInteger(pValue, pWidgetData->CountChoiceListItems(TRUE));
   }
 }
 void CXFA_Node::Script_Som_DefaultValue(CFXJSE_Value* pValue,
@@ skipping 58 matching lines @@
       FXJSE_Value_SetUTF8String(
           pValue,
           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) {
-    ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
+    ThrowException(XFA_IDS_INVAlID_PROP_SET);
     return;
   }
   CFX_WideString content = GetScriptContent(TRUE);
   if (content.IsEmpty()) {
     FXJSE_Value_SetNull(pValue);
   } else {
     FXJSE_Value_SetUTF8String(
         pValue,
         FX_UTF8Encode(content.c_str(), content.GetLength()).AsStringC());
   }
@@ skipping 198 matching lines @@
   if (!bSetting) {
     CXFA_Node* pDataNode = GetBindData();
     if (pDataNode) {
       FXJSE_Value_Set(
           pValue,
           m_pDocument->GetScriptContext()->GetJSValueFromMap(pDataNode));
     } else {
       FXJSE_Value_SetNull(pValue);
     }
   } else {
-    ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
+    ThrowException(XFA_IDS_INVAlID_PROP_SET);
   }
 }
 void CXFA_Node::Script_Draw_DefaultValue(CFXJSE_Value* pValue,
                                          FX_BOOL bSetting,
                                          XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     if (FXJSE_Value_IsUTF8String(pValue)) {
       CXFA_WidgetData* pWidgetData = GetWidgetData();
       ASSERT(pWidgetData);
       XFA_ELEMENT uiType = pWidgetData->GetUIType();
@@ skipping 184 matching lines @@
 }
 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) {
-    ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
+    ThrowException(XFA_IDS_INVAlID_PROP_SET);
   } else {
     FXJSE_Value_SetNull(pValue);
   }
 }
 void CXFA_Node::Script_Field_SelectedIndex(CFXJSE_Value* pValue,
                                            FX_BOOL bSetting,
                                            XFA_ATTRIBUTE eAttribute) {
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     return;
@@ skipping 21 matching lines @@
   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") {
       FXJSE_Value_SetBoolean(pArguments->GetReturnValue(),
                              ((iRet == XFA_EVENTERROR_Error) ? FALSE : TRUE));
     }
   } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execEvent");
+    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->GetParser()->GetNotify();
     if (!pNotify) {
       return;
     }
     pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Initialize, FALSE, FALSE);
   } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"execInitialize");
+    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) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"deleteItem");
+    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) {
     FXJSE_Value_SetBoolean(pValue, bValue);
   }
 }
 void CXFA_Node::Script_Field_GetSaveItem(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength != 1) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"getSaveItem");
+    ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"getSaveItem");
     return;
   }
   int32_t iIndex = pArguments->GetInt32(0);
   if (iIndex < 0) {
     FXJSE_Value_SetNull(pArguments->GetReturnValue());
     return;
   }
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     FXJSE_Value_SetNull(pArguments->GetReturnValue());
     return;
   }
   CFX_WideString wsValue;
   FX_BOOL bHasItem = pWidgetData->GetChoiceListItem(wsValue, iIndex, TRUE);
   if (bHasItem) {
     FXJSE_Value_SetUTF8String(
         pArguments->GetReturnValue(),
         FX_UTF8Encode(wsValue.c_str(), wsValue.GetLength()).AsStringC());
   } else {
     FXJSE_Value_SetNull(pArguments->GetReturnValue());
   }
 }
 void CXFA_Node::Script_Field_BoundItem(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength != 1) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"boundItem");
+    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) {
     FXJSE_Value_SetUTF8String(pValue, FX_UTF8Encode(wsBoundValue).AsStringC());
   }
 }
 void CXFA_Node::Script_Field_GetItemState(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength != 1) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"getItemState");
+    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) {
     FXJSE_Value_SetBoolean(pValue, bValue);
   }
 }
 void CXFA_Node::Script_Field_ExecCalculate(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
     CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
     if (!pNotify) {
       return;
     }
     pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Calculate, FALSE, FALSE);
   } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"execCalculate");
+    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) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"getDisplayItem");
+    ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"getDisplayItem");
     return;
   }
   int32_t iIndex = pArguments->GetInt32(0);
   if (iIndex < 0) {
     FXJSE_Value_SetNull(pArguments->GetReturnValue());
     return;
   }
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     FXJSE_Value_SetNull(pArguments->GetReturnValue());
     return;
   }
   CFX_WideString wsValue;
   FX_BOOL bHasItem = pWidgetData->GetChoiceListItem(wsValue, iIndex, FALSE);
   if (bHasItem) {
     FXJSE_Value_SetUTF8String(
         pArguments->GetReturnValue(),
         FX_UTF8Encode(wsValue.c_str(), wsValue.GetLength()).AsStringC());
   } else {
     FXJSE_Value_SetNull(pArguments->GetReturnValue());
   }
 }
 void CXFA_Node::Script_Field_SetItemState(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength != 2) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"setItemState");
+    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) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"addItem");
+    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);
@@ skipping 11 matching lines @@
     CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
     if (!pNotify) {
       FXJSE_Value_SetBoolean(pArguments->GetReturnValue(), FALSE);
     } else {
       int32_t iRet =
           pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Validate, FALSE, FALSE);
       FXJSE_Value_SetBoolean(pArguments->GetReturnValue(),
                              ((iRet == XFA_EVENTERROR_Error) ? FALSE : TRUE));
     }
   } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"execValidate");
+    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 {
-    ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
+    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) {
@@ skipping 16 matching lines @@
                                            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 {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execEvent");
+    ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execEvent");
   }
 }
 
 void CXFA_Node::Script_ExclGroup_SelectedMember(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc < 0 || argc > 1) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"selectedMember");
+    ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"selectedMember");
     return;
   }
 
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     FXJSE_Value_SetNull(pArguments->GetReturnValue());
     return;
   }
 
   CXFA_Node* pReturnNode = nullptr;
@@ skipping 16 matching lines @@
 
 void CXFA_Node::Script_ExclGroup_ExecInitialize(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
     CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
     if (!pNotify) {
       return;
     }
     pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Initialize);
   } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"execInitialize");
+    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->GetParser()->GetNotify();
     if (!pNotify) {
       return;
     }
     pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Calculate);
   } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"execCalculate");
+    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->GetParser()->GetNotify();
     if (!pNotify) {
       FXJSE_Value_SetBoolean(pArguments->GetReturnValue(), FALSE);
     } else {
       int32_t iRet = pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Validate);
       FXJSE_Value_SetBoolean(pArguments->GetReturnValue(),
                              ((iRet == XFA_EVENTERROR_Error) ? FALSE : TRUE));
     }
   } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"execValidate");
+    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->GetClassID();
@@ skipping 76 matching lines @@
       }
     }
     if (pInstanceMgr) {
       FXJSE_Value_Set(
           pValue,
           m_pDocument->GetScriptContext()->GetJSValueFromMap(pInstanceMgr));
     } else {
       FXJSE_Value_SetNull(pValue);
     }
   } else {
-    ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
+    ThrowException(XFA_IDS_INVAlID_PROP_SET);
   }
 }
 void CXFA_Node::Script_Subform_Locale(CFXJSE_Value* pValue,
                                       FX_BOOL bSetting,
                                       XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     CFX_ByteString bsLocaleName;
     FXJSE_Value_ToUTF8String(pValue, bsLocaleName);
     SetCData(XFA_ATTRIBUTE_Locale,
              CFX_WideString::FromUTF8(bsLocaleName.AsStringC()), true, TRUE);
   } else {
     CFX_WideString wsLocaleName;
     GetLocaleName(wsLocaleName);
     FXJSE_Value_SetUTF8String(
         pValue, 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 {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execEvent");
+    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->GetParser()->GetNotify();
     if (!pNotify) {
       return;
     }
     pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Initialize);
   } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"execInitialize");
+    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->GetParser()->GetNotify();
     if (!pNotify) {
       return;
     }
     pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Calculate);
   } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"execCalculate");
+    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->GetParser()->GetNotify();
     if (!pNotify) {
       FXJSE_Value_SetBoolean(pArguments->GetReturnValue(), FALSE);
     } else {
       int32_t iRet = pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Validate);
       FXJSE_Value_SetBoolean(pArguments->GetReturnValue(),
                              ((iRet == XFA_EVENTERROR_Error) ? FALSE : TRUE));
     }
   } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"execValidate");
+    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 {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"getInvalidObjects");
+    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->GetClassID() == XFA_ELEMENT_Subform) ||
         (pNode->GetClassID() == 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) {
     FXJSE_Value_SetBoolean(pArguments->GetReturnValue(), TRUE);
   } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"formNodes");
+    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 {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"remerge");
+    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) {
       FXJSE_Value_SetBoolean(pArguments->GetReturnValue(), FALSE);
     } else {
       FXJSE_Value_SetBoolean(pArguments->GetReturnValue(), TRUE);
     }
   } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"execInitialize");
+    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());
@@ skipping 15 matching lines @@
         if (XFA_GetAttributeOfElement(pElement->eName, XFA_ATTRIBUTE_Name,
                                       XFA_XDPPACKET_UNKNOWN)) {
           pNewNode->SetAttribute(XFA_ATTRIBUTE_Name, strName.AsStringC(), true);
           if (pNewNode->GetPacketID() == XFA_XDPPACKET_Datasets) {
             pNewNode->CreateXMLMappingNode();
           }
           FXJSE_Value_Set(
               pArguments->GetReturnValue(),
               m_pDocument->GetScriptContext()->GetJSValueFromMap(pNewNode));
         } else {
-          ThrowScriptErrorMessage(XFA_IDS_NOT_HAVE_PROPERTY, strTagName.c_str(),
-                                  L"name");
+          ThrowException(XFA_IDS_NOT_HAVE_PROPERTY, strTagName.c_str(),
+                         L"name");
         }
       } else {
         FXJSE_Value_Set(
             pArguments->GetReturnValue(),
             m_pDocument->GetScriptContext()->GetJSValueFromMap(pNewNode));
       }
     }
   } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"createNode");
+    ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"createNode");
   }
 }
 void CXFA_Node::Script_Template_Recalculate(CFXJSE_Arguments* pArguments) {
   if (pArguments->GetLength() == 1) {
     FXJSE_Value_SetBoolean(pArguments->GetReturnValue(), TRUE);
   } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"recalculate");
+    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) {
       FXJSE_Value_SetBoolean(pArguments->GetReturnValue(), FALSE);
     } else {
       FXJSE_Value_SetBoolean(pArguments->GetReturnValue(), TRUE);
     }
   } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"execCalculate");
+    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) {
       FXJSE_Value_SetBoolean(pArguments->GetReturnValue(), FALSE);
     } else {
       FXJSE_Value_SetBoolean(pArguments->GetReturnValue(), TRUE);
     }
   } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"execValidate");
+    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) {
       FXJSE_Value_SetBoolean(pArguments->GetReturnValue(), FALSE);
     } else {
       FXJSE_Value_SetBoolean(pArguments->GetReturnValue(), TRUE);
     }
   } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"evaluate");
+    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) {
-    ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
+    ThrowException(XFA_IDS_INVAlID_PROP_SET);
     return;
   }
   CXFA_Occur nodeOccur(GetOccurNode());
   FXJSE_Value_SetInteger(pValue, nodeOccur.GetMax());
 }
 void CXFA_Node::Script_InstanceManager_Min(CFXJSE_Value* pValue,
                                            FX_BOOL bSetting,
                                            XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
-    ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
+    ThrowException(XFA_IDS_INVAlID_PROP_SET);
     return;
   }
   CXFA_Occur nodeOccur(GetOccurNode());
   FXJSE_Value_SetInteger(pValue, 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);
@@ skipping 301 matching lines @@
 void CXFA_Node::Script_InstanceManager_RemoveInstance(
     CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc != 1) {
     FXJSE_Value_SetUndefined(pArguments->GetReturnValue());
     return;
   }
   int32_t iIndex = pArguments->GetInt32(0);
   int32_t iCount = XFA_ScriptInstanceManager_GetCount(this);
   if (iIndex < 0 || iIndex >= iCount) {
-    ThrowScriptErrorMessage(XFA_IDS_INDEX_OUT_OF_BOUNDS);
+    ThrowException(XFA_IDS_INDEX_OUT_OF_BOUNDS);
     return;
   }
   CXFA_Occur nodeOccur(GetOccurNode());
   int32_t iMin = nodeOccur.GetMin();
   if (iCount - 1 < iMin) {
-    ThrowScriptErrorMessage(XFA_IDS_VIOLATE_BOUNDARY, L"min");
+    ThrowException(XFA_IDS_VIOLATE_BOUNDARY, L"min");
     return;
   }
   CXFA_Node* pRemoveInstance = XFA_ScriptInstanceManager_GetItem(this, iIndex);
   XFA_ScriptInstanceManager_RemoveItem(this, pRemoveInstance);
   CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
   if (pNotify) {
     for (int32_t i = iIndex; i < iCount - 1; i++) {
       CXFA_Node* pSubformInstance = XFA_ScriptInstanceManager_GetItem(this, i);
       if (pSubformInstance &&
           pSubformInstance->GetClassID() == XFA_ELEMENT_Subform) {
@@ skipping 15 matching lines @@
     FXJSE_Value_SetUndefined(pArguments->GetReturnValue());
     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)) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"addInstance");
+    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);
   CXFA_Occur nodeOccur(GetOccurNode());
   int32_t iMax = nodeOccur.GetMax();
   if (iMax >= 0 && iCount >= iMax) {
-    ThrowScriptErrorMessage(XFA_IDS_VIOLATE_BOUNDARY, L"max");
+    ThrowException(XFA_IDS_VIOLATE_BOUNDARY, L"max");
     return;
   }
   CXFA_Node* pNewInstance =
       XFA_ScriptInstanceManager_CreateInstance(this, fFlags);
   XFA_ScriptInstanceManager_InsertItem(this, pNewInstance, iCount, iCount,
                                        FALSE);
   FXJSE_Value_Set(
       pArguments->GetReturnValue(),
       m_pDocument->GetScriptContext()->GetJSValueFromMap(pNewInstance));
   CXFA_FFNotify* pNotify = m_pDocument->GetParser()->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)) {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"insertInstance");
+    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);
   if (iIndex < 0 || iIndex > iCount) {
-    ThrowScriptErrorMessage(XFA_IDS_INDEX_OUT_OF_BOUNDS);
+    ThrowException(XFA_IDS_INDEX_OUT_OF_BOUNDS);
     return;
   }
   int32_t iMax = nodeOccur.GetMax();
   if (iMax >= 0 && iCount >= iMax) {
-    ThrowScriptErrorMessage(XFA_IDS_VIOLATE_BOUNDARY, L"max");
+    ThrowException(XFA_IDS_VIOLATE_BOUNDARY, L"max");
     return;
   }
   CXFA_Node* pNewInstance =
       XFA_ScriptInstanceManager_CreateInstance(this, bBind);
   XFA_ScriptInstanceManager_InsertItem(this, pNewInstance, iIndex, iCount,
                                        TRUE);
   FXJSE_Value_Set(
       pArguments->GetReturnValue(),
       m_pDocument->GetScriptContext()->GetJSValueFromMap(pNewInstance));
   CXFA_FFNotify* pNotify = m_pDocument->GetParser()->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) {
-    ThrowScriptErrorMessage(XFA_IDS_VIOLATE_BOUNDARY, L"min");
+    ThrowException(XFA_IDS_VIOLATE_BOUNDARY, L"min");
     return 1;
   }
   if ((iMax >= 0) && (iDesired > iMax)) {
-    ThrowScriptErrorMessage(XFA_IDS_VIOLATE_BOUNDARY, L"max");
+    ThrowException(XFA_IDS_VIOLATE_BOUNDARY, L"max");
     return 2;
   }
   int32_t iCount = XFA_ScriptInstanceManager_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
@@ skipping 36 matching lines @@
   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);
   if (iFrom > iCount || iTo > iCount - 1) {
-    ThrowScriptErrorMessage(XFA_IDS_INDEX_OUT_OF_BOUNDS);
+    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_LayoutProcessor* pLayoutPro = m_pDocument->GetLayoutProcessor();
@@ skipping 23 matching lines @@
     occur.SetMin(iMin);
   } else {
     FXJSE_Value_SetInteger(pValue, occur.GetMin());
   }
 }
 void CXFA_Node::Script_Desc_Metadata(CFXJSE_Arguments* pArguments) {
   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");
+    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);
       FXJSE_Value_SetObject(
           pArguments->GetReturnValue(), (CXFA_Object*)pFormNodes,
           m_pDocument->GetScriptContext()->GetJseNormalClass());
     } else {
-      ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
+      ThrowException(XFA_IDS_ARGUMENT_MISMATCH);
     }
   } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"formNodes");
+    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 {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"remerge");
+    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->GetParser()->GetNotify();
     if (!pNotify) {
       return;
     }
     pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Initialize);
   } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"execInitialize");
+    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->GetParser()->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 {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"recalculate");
+    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->GetParser()->GetNotify();
     if (!pNotify) {
       return;
     }
     pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Calculate);
   } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"execCalculate");
+    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->GetParser()->GetNotify();
     if (!pNotify) {
       FXJSE_Value_SetBoolean(pArguments->GetReturnValue(), FALSE);
     } else {
       int32_t iRet = pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Validate);
       FXJSE_Value_SetBoolean(pArguments->GetReturnValue(),
                              ((iRet == XFA_EVENTERROR_Error) ? FALSE : TRUE));
     }
   } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"execValidate");
+    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) {
     CFX_ByteString bsChecksum;
     FXJSE_Value_ToUTF8String(pValue, bsChecksum);
     SetAttribute(XFA_ATTRIBUTE_Checksum,
                  CFX_WideString::FromUTF8(bsChecksum.AsStringC()).AsStringC());
@@ skipping 14 matching lines @@
     if (pXMLNode && pXMLNode->GetType() == FDE_XMLNODE_Element) {
       static_cast<CFDE_XMLElement*>(pXMLNode)->GetString(
           CFX_WideString::FromUTF8(bsAttributeName.AsStringC()).c_str(),
           wsAttributeValue);
     }
     FXJSE_Value_SetUTF8String(
         pArguments->GetReturnValue(),
         FX_UTF8Encode(wsAttributeValue.c_str(), wsAttributeValue.GetLength())
             .AsStringC());
   } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"getAttribute");
+    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()));
     }
     FXJSE_Value_SetNull(pArguments->GetReturnValue());
   } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"setAttribute");
+    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());
       }
     }
     FXJSE_Value_SetNull(pArguments->GetReturnValue());
   } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"removeAttribute");
+    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) {
     CFX_ByteString bsNewContent;
     FXJSE_Value_ToUTF8String(pValue, bsNewContent);
     CFDE_XMLNode* pXMLNode = GetXMLMappingNode();
     if (pXMLNode && pXMLNode->GetType() == FDE_XMLNODE_Element) {
@@ skipping 10 matching lines @@
     }
     FXJSE_Value_SetUTF8String(
         pValue,
         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 {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"next");
+    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 {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"cancelBatch");
+    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 {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"first");
+    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 {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"updateBatch");
+    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 {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"previous");
+    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 {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"isBOF");
+    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 {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"isEOF");
+    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 {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"cancel");
+    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 {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"update");
+    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 {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"open");
+    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 {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"delete");
+    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 {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"addNew");
+    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 {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"requery");
+    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 {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"resync");
+    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 {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"close");
+    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 {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"last");
+    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 {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                            L"hasDataChanged");
+    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);
     FXJSE_Value_Set(pValue,
                     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) {
-    ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
+    ThrowException(XFA_IDS_INVAlID_PROP_SET);
     return;
   }
   FXJSE_Value_SetUTF8String(pValue, 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,
@@ skipping 1503 matching lines @@
   }
   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 {
-      ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
+      ThrowException(XFA_IDS_ARGUMENT_MISMATCH);
     }
   } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"append");
+    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 {
-      ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
+      ThrowException(XFA_IDS_ARGUMENT_MISMATCH);
     }
   } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"insert");
+    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 {
-      ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
+      ThrowException(XFA_IDS_ARGUMENT_MISMATCH);
     }
   } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"remove");
+    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())) {
       FXJSE_Value_Set(
           pArguments->GetReturnValue(),
           m_pDocument->GetScriptContext()->GetJSValueFromMap(Item(iIndex)));
     } else {
-      ThrowScriptErrorMessage(XFA_IDS_INDEX_OUT_OF_BOUNDS);
+      ThrowException(XFA_IDS_INDEX_OUT_OF_BOUNDS);
     }
   } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"item");
+    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;
     }
     FXJSE_Value_Set(pArguments->GetReturnValue(),
                     m_pDocument->GetScriptContext()->GetJSValueFromMap(pNode));
   } else {
-    ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"namedItem");
+    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) {
     FXJSE_Value_SetInteger(pValue, GetLength());
   } else {
-    ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
+    ThrowException(XFA_IDS_INVAlID_PROP_SET);
   }
 }
 CXFA_ArrayNodeList::CXFA_ArrayNodeList(CXFA_Document* pDocument)
     : CXFA_NodeList(pDocument) {}
 void CXFA_ArrayNodeList::SetArrayNodeList(const CXFA_NodeArray& srcArray) {
   if (srcArray.GetSize() > 0) {
     m_array.Copy(srcArray);
   }
 }
 int32_t CXFA_ArrayNodeList::GetLength() {
@@ skipping 60 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);
 }