Change ThrowScriptErrorMessage() to ThrowException().

xfa/fxfa/fm2js/xfa_fm2jscontext.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/fm2js/xfa_fm2jscontext.h"
 
 #include <time.h>
 
@@ skipping 483 matching lines @@
   return false;
 }
 
 }  // namespace
 
 // static
 void CXFA_FM2JSContext::Abs(CFXJSE_Value* pThis,
                             const CFX_ByteStringC& szFuncName,
                             CFXJSE_Arguments& args) {
   if (args.GetLength() != 1) {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Abs");
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
+                                       L"Abs");
     return;
   }
 
   std::unique_ptr<CFXJSE_Value> argOne = args.GetValue(0);
   if (ValueIsNull(pThis, argOne.get())) {
     FXJSE_Value_SetNull(args.GetReturnValue());
     return;
   }
 
   FX_DOUBLE dValue = ValueToDouble(pThis, argOne.get());
@@ skipping 75 matching lines @@
   }
 
   FXJSE_Value_SetDouble(args.GetReturnValue(), dSum / uCount);
 }
 
 // static
 void CXFA_FM2JSContext::Ceil(CFXJSE_Value* pThis,
                              const CFX_ByteStringC& szFuncName,
                              CFXJSE_Arguments& args) {
   if (args.GetLength() != 1) {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Ceil");
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
+                                       L"Ceil");
     return;
   }
 
   std::unique_ptr<CFXJSE_Value> argValue = GetSimpleValue(pThis, args, 0);
   if (ValueIsNull(pThis, argValue.get())) {
     FXJSE_Value_SetNull(args.GetReturnValue());
     return;
   }
 
   FXJSE_Value_SetFloat(args.GetReturnValue(),
@@ skipping 11 matching lines @@
     std::unique_ptr<CFXJSE_Value> argValue = args.GetValue(i);
     if (FXJSE_Value_IsNull(argValue.get()))
       continue;
 
     if (FXJSE_Value_IsArray(argValue.get())) {
       std::unique_ptr<CFXJSE_Value> lengthValue(new CFXJSE_Value(pIsolate));
       FXJSE_Value_GetObjectProp(argValue.get(), "length", lengthValue.get());
 
       int32_t iLength = FXJSE_Value_ToInteger(lengthValue.get());
       if (iLength <= 2) {
-        pContext->ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
+        pContext->Throw(XFA_IDS_ARGUMENT_MISMATCH);
         return;
       }
 
       std::unique_ptr<CFXJSE_Value> propertyValue(new CFXJSE_Value(pIsolate));
       std::unique_ptr<CFXJSE_Value> jsObjectValue(new CFXJSE_Value(pIsolate));
       std::unique_ptr<CFXJSE_Value> newPropertyValue(
           new CFXJSE_Value(pIsolate));
       FXJSE_Value_GetObjectPropByIdx(argValue.get(), 1, propertyValue.get());
       FXJSE_Value_GetObjectPropByIdx(argValue.get(), 2, jsObjectValue.get());
       if (FXJSE_Value_IsNull(propertyValue.get())) {
@@ skipping 27 matching lines @@
     }
   }
   FXJSE_Value_SetInteger(args.GetReturnValue(), iCount);
 }
 
 // static
 void CXFA_FM2JSContext::Floor(CFXJSE_Value* pThis,
                               const CFX_ByteStringC& szFuncName,
                               CFXJSE_Arguments& args) {
   if (args.GetLength() != 1) {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Floor");
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
+                                       L"Floor");
     return;
   }
 
   std::unique_ptr<CFXJSE_Value> argValue = GetSimpleValue(pThis, args, 0);
   if (ValueIsNull(pThis, argValue.get())) {
     FXJSE_Value_SetNull(args.GetReturnValue());
     return;
   }
 
   FXJSE_Value_SetFloat(args.GetReturnValue(),
@@ skipping 11 matching lines @@
   for (int32_t i = 0; i < args.GetLength(); i++) {
     std::unique_ptr<CFXJSE_Value> argValue = args.GetValue(i);
     if (FXJSE_Value_IsNull(argValue.get()))
       continue;
 
     if (FXJSE_Value_IsArray(argValue.get())) {
       std::unique_ptr<CFXJSE_Value> lengthValue(new CFXJSE_Value(pIsolate));
       FXJSE_Value_GetObjectProp(argValue.get(), "length", lengthValue.get());
       int32_t iLength = FXJSE_Value_ToInteger(lengthValue.get());
       if (iLength <= 2) {
-        pContext->ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
+        pContext->Throw(XFA_IDS_ARGUMENT_MISMATCH);
         return;
       }
 
       std::unique_ptr<CFXJSE_Value> propertyValue(new CFXJSE_Value(pIsolate));
       std::unique_ptr<CFXJSE_Value> jsObjectValue(new CFXJSE_Value(pIsolate));
       std::unique_ptr<CFXJSE_Value> newPropertyValue(
           new CFXJSE_Value(pIsolate));
       FXJSE_Value_GetObjectPropByIdx(argValue.get(), 1, propertyValue.get());
       FXJSE_Value_GetObjectPropByIdx(argValue.get(), 2, jsObjectValue.get());
       if (FXJSE_Value_IsNull(propertyValue.get())) {
@@ skipping 60 matching lines @@
   for (int32_t i = 0; i < args.GetLength(); i++) {
     std::unique_ptr<CFXJSE_Value> argValue = args.GetValue(i);
     if (FXJSE_Value_IsNull(argValue.get()))
       continue;
 
     if (FXJSE_Value_IsArray(argValue.get())) {
       std::unique_ptr<CFXJSE_Value> lengthValue(new CFXJSE_Value(pIsolate));
       FXJSE_Value_GetObjectProp(argValue.get(), "length", lengthValue.get());
       int32_t iLength = FXJSE_Value_ToInteger(lengthValue.get());
       if (iLength <= 2) {
-        pContext->ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
+        pContext->Throw(XFA_IDS_ARGUMENT_MISMATCH);
         return;
       }
 
       std::unique_ptr<CFXJSE_Value> propertyValue(new CFXJSE_Value(pIsolate));
       std::unique_ptr<CFXJSE_Value> jsObjectValue(new CFXJSE_Value(pIsolate));
       std::unique_ptr<CFXJSE_Value> newPropertyValue(
           new CFXJSE_Value(pIsolate));
       FXJSE_Value_GetObjectPropByIdx(argValue.get(), 1, propertyValue.get());
       FXJSE_Value_GetObjectPropByIdx(argValue.get(), 2, jsObjectValue.get());
       if (FXJSE_Value_IsNull(propertyValue.get())) {
@@ skipping 49 matching lines @@
   FXJSE_Value_SetDouble(args.GetReturnValue(), dMinValue);
 }
 
 // static
 void CXFA_FM2JSContext::Mod(CFXJSE_Value* pThis,
                             const CFX_ByteStringC& szFuncName,
                             CFXJSE_Arguments& args) {
   CXFA_FM2JSContext* pContext = pThis->ToJSContext(nullptr);
   v8::Isolate* pIsolate = pContext->GetScriptRuntime();
   if (args.GetLength() != 2) {
-    pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                                      L"Mod");
+    pContext->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Mod");
     return;
   }
 
   std::unique_ptr<CFXJSE_Value> argOne = args.GetValue(0);
   std::unique_ptr<CFXJSE_Value> argTwo = args.GetValue(1);
   if (FXJSE_Value_IsNull(argOne.get()) || FXJSE_Value_IsNull(argTwo.get())) {
     FXJSE_Value_SetNull(args.GetReturnValue());
     return;
   }
 
   FX_DOUBLE dDividend = 0.0;
   FX_DOUBLE dDividor = 0.0;
   if (FXJSE_Value_IsArray(argOne.get())) {
     std::unique_ptr<CFXJSE_Value> lengthValue(new CFXJSE_Value(pIsolate));
     FXJSE_Value_GetObjectProp(argOne.get(), "length", lengthValue.get());
     int32_t iLength = FXJSE_Value_ToInteger(lengthValue.get());
     if (iLength <= 2) {
-      pContext->ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
+      pContext->Throw(XFA_IDS_ARGUMENT_MISMATCH);
       return;
     }
 
     std::unique_ptr<CFXJSE_Value> propertyValue(new CFXJSE_Value(pIsolate));
     std::unique_ptr<CFXJSE_Value> jsObjectValue(new CFXJSE_Value(pIsolate));
     FXJSE_Value_GetObjectPropByIdx(argOne.get(), 1, propertyValue.get());
     FXJSE_Value_GetObjectPropByIdx(argOne.get(), 2, jsObjectValue.get());
     if (FXJSE_Value_IsNull(propertyValue.get())) {
       dDividend = ValueToDouble(pThis, jsObjectValue.get());
     } else {
       CFX_ByteString propertyStr;
       FXJSE_Value_ToUTF8String(propertyValue.get(), propertyStr);
       std::unique_ptr<CFXJSE_Value> newPropertyValue(
           new CFXJSE_Value(pIsolate));
       FXJSE_Value_GetObjectProp(jsObjectValue.get(), propertyStr.AsStringC(),
                                 newPropertyValue.get());
       dDividend = ValueToDouble(pThis, newPropertyValue.get());
     }
   } else {
     dDividend = ValueToDouble(pThis, argOne.get());
   }
 
   if (FXJSE_Value_IsArray(argTwo.get())) {
     std::unique_ptr<CFXJSE_Value> lengthValue(new CFXJSE_Value(pIsolate));
     FXJSE_Value_GetObjectProp(argTwo.get(), "length", lengthValue.get());
     int32_t iLength = FXJSE_Value_ToInteger(lengthValue.get());
     if (iLength <= 2) {
-      pContext->ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
+      pContext->Throw(XFA_IDS_ARGUMENT_MISMATCH);
       return;
     }
 
     std::unique_ptr<CFXJSE_Value> propertyValue(new CFXJSE_Value(pIsolate));
     std::unique_ptr<CFXJSE_Value> jsObjectValue(new CFXJSE_Value(pIsolate));
     FXJSE_Value_GetObjectPropByIdx(argTwo.get(), 1, propertyValue.get());
     FXJSE_Value_GetObjectPropByIdx(argTwo.get(), 2, jsObjectValue.get());
     if (FXJSE_Value_IsNull(propertyValue.get())) {
       dDividor = ValueToDouble(pThis, jsObjectValue.get());
     } else {
       CFX_ByteString propertyStr;
       FXJSE_Value_ToUTF8String(propertyValue.get(), propertyStr);
       std::unique_ptr<CFXJSE_Value> newPropertyValue(
           new CFXJSE_Value(pIsolate));
       FXJSE_Value_GetObjectProp(jsObjectValue.get(), propertyStr.AsStringC(),
                                 newPropertyValue.get());
       dDividor = ValueToDouble(pThis, newPropertyValue.get());
     }
   } else {
     dDividor = ValueToDouble(pThis, argTwo.get());
   }
 
   if (dDividor == 0) {
-    pContext->ThrowScriptErrorMessage(XFA_IDS_DIVIDE_ZERO);
+    pContext->Throw(XFA_IDS_DIVIDE_ZERO);
     return;
   }
 
   FXJSE_Value_SetDouble(args.GetReturnValue(),
                         dDividend - dDividor * (int32_t)(dDividend / dDividor));
 }
 
 // static
 void CXFA_FM2JSContext::Round(CFXJSE_Value* pThis,
                               const CFX_ByteStringC& szFuncName,
                               CFXJSE_Arguments& args) {
   CXFA_FM2JSContext* pContext = pThis->ToJSContext(nullptr);
   v8::Isolate* pIsolate = pContext->GetScriptRuntime();
   int32_t argc = args.GetLength();
   uint8_t uPrecision = 0;
 
   if (argc != 1 && argc != 2) {
-    pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                                      L"Round");
+    pContext->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Round");
     return;
   }
 
   if (argc == 1) {
     std::unique_ptr<CFXJSE_Value> argOne = args.GetValue(0);
     if (FXJSE_Value_IsNull(argOne.get())) {
       FXJSE_Value_SetNull(args.GetReturnValue());
       return;
     }
 
@@ skipping 100 matching lines @@
   for (int32_t i = 0; i < argc; i++) {
     std::unique_ptr<CFXJSE_Value> argValue = args.GetValue(i);
     if (FXJSE_Value_IsNull(argValue.get()))
       continue;
 
     if (FXJSE_Value_IsArray(argValue.get())) {
       std::unique_ptr<CFXJSE_Value> lengthValue(new CFXJSE_Value(pIsolate));
       FXJSE_Value_GetObjectProp(argValue.get(), "length", lengthValue.get());
       int32_t iLength = FXJSE_Value_ToInteger(lengthValue.get());
       if (iLength <= 2) {
-        pContext->ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
+        pContext->Throw(XFA_IDS_ARGUMENT_MISMATCH);
         return;
       }
 
       std::unique_ptr<CFXJSE_Value> propertyValue(new CFXJSE_Value(pIsolate));
       FXJSE_Value_GetObjectPropByIdx(argValue.get(), 1, propertyValue.get());
       std::unique_ptr<CFXJSE_Value> jsObjectValue(new CFXJSE_Value(pIsolate));
       std::unique_ptr<CFXJSE_Value> newPropertyValue(
           new CFXJSE_Value(pIsolate));
       if (FXJSE_Value_IsNull(propertyValue.get())) {
         for (int32_t j = 2; j < iLength; j++) {
@@ skipping 42 matching lines @@
   }
 
   FXJSE_Value_SetDouble(args.GetReturnValue(), dSum);
 }
 
 // static
 void CXFA_FM2JSContext::Date(CFXJSE_Value* pThis,
                              const CFX_ByteStringC& szFuncName,
                              CFXJSE_Arguments& args) {
   if (args.GetLength() != 0) {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Date");
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
+                                       L"Date");
     return;
   }
 
   time_t currentTime;
   time(&currentTime);
   struct tm* pTmStruct = gmtime(&currentTime);
 
   CFX_ByteString bufferYear;
   CFX_ByteString bufferMon;
   CFX_ByteString bufferDay;
   bufferYear.Format("%d", pTmStruct->tm_year + 1900);
   bufferMon.Format("%02d", pTmStruct->tm_mon + 1);
   bufferDay.Format("%02d", pTmStruct->tm_mday);
 
   CFX_ByteString bufferCurrent = bufferYear + bufferMon + bufferDay;
   FXJSE_Value_SetInteger(args.GetReturnValue(),
                          DateString2Num(bufferCurrent.AsStringC()));
 }
 
 // static
 void CXFA_FM2JSContext::Date2Num(CFXJSE_Value* pThis,
                                  const CFX_ByteStringC& szFuncName,
                                  CFXJSE_Arguments& args) {
   int32_t argc = args.GetLength();
   if ((argc <= 0) || (argc >= 4)) {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Date2Num");
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
+                                       L"Date2Num");
     return;
   }
 
   std::unique_ptr<CFXJSE_Value> dateValue = GetSimpleValue(pThis, args, 0);
   if (ValueIsNull(pThis, dateValue.get())) {
     FXJSE_Value_SetNull(args.GetReturnValue());
     return;
   }
 
   CFX_ByteString dateString;
@@ skipping 29 matching lines @@
   FXJSE_Value_SetInteger(args.GetReturnValue(),
                          DateString2Num(szIsoDateString.AsStringC()));
 }
 
 // static
 void CXFA_FM2JSContext::DateFmt(CFXJSE_Value* pThis,
                                 const CFX_ByteStringC& szFuncName,
                                 CFXJSE_Arguments& args) {
   int32_t argc = args.GetLength();
   if (argc >= 3) {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Date2Num");
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
+                                       L"Date2Num");
     return;
   }
 
   int32_t iStyle = 0;
   if (argc > 0) {
     std::unique_ptr<CFXJSE_Value> argStyle = GetSimpleValue(pThis, args, 0);
     if (FXJSE_Value_IsNull(argStyle.get())) {
       FXJSE_Value_SetNull(args.GetReturnValue());
       return;
     }
@@ skipping 19 matching lines @@
     formatStr = "";
 
   FXJSE_Value_SetUTF8String(args.GetReturnValue(), formatStr.AsStringC());
 }
 
 // static
 void CXFA_FM2JSContext::IsoDate2Num(CFXJSE_Value* pThis,
                                     const CFX_ByteStringC& szFuncName,
                                     CFXJSE_Arguments& args) {
   if (args.GetLength() != 1) {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"IsoDate2Num");
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
+                                       L"IsoDate2Num");
     return;
   }
 
   std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
   if (FXJSE_Value_IsNull(argOne.get())) {
     FXJSE_Value_SetNull(args.GetReturnValue());
     return;
   }
 
   CFX_ByteString szArgString;
   ValueToUTF8String(argOne.get(), szArgString);
   FXJSE_Value_SetInteger(args.GetReturnValue(),
                          DateString2Num(szArgString.AsStringC()));
 }
 
 // static
 void CXFA_FM2JSContext::IsoTime2Num(CFXJSE_Value* pThis,
                                     const CFX_ByteStringC& szFuncName,
                                     CFXJSE_Arguments& args) {
   CXFA_FM2JSContext* pContext = pThis->ToJSContext(nullptr);
   if (args.GetLength() != 1) {
-    pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                                      L"IsoTime2Num");
+    pContext->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"IsoTime2Num");
     return;
   }
 
   std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
   if (ValueIsNull(pThis, argOne.get())) {
     FXJSE_Value_SetNull(args.GetReturnValue());
     return;
   }
 
   CXFA_Document* pDoc = pContext->GetDocument();
@@ skipping 68 matching lines @@
       CFX_ByteString formatStr;
       GetLocalDateFormat(pThis, iStyle, szLocal.AsStringC(), formatStr, FALSE);
       if (formatStr.IsEmpty()) {
         formatStr = "";
       }
       FXJSE_Value_SetUTF8String(args.GetReturnValue(), formatStr.AsStringC());
     } else {
       FXJSE_Value_SetNull(args.GetReturnValue());
     }
   } else {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"LocalDateFmt");
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
+                                       L"LocalDateFmt");
   }
 }
 
 // static
 void CXFA_FM2JSContext::LocalTimeFmt(CFXJSE_Value* pThis,
                                      const CFX_ByteStringC& szFuncName,
                                      CFXJSE_Arguments& args) {
   int32_t argc = args.GetLength();
   if (argc < 3) {
     FX_BOOL bFlags = FALSE;
@@ skipping 21 matching lines @@
       CFX_ByteString formatStr;
       GetLocalTimeFormat(pThis, iStyle, szLocal.AsStringC(), formatStr, FALSE);
       if (formatStr.IsEmpty()) {
         formatStr = "";
       }
       FXJSE_Value_SetUTF8String(args.GetReturnValue(), formatStr.AsStringC());
     } else {
       FXJSE_Value_SetNull(args.GetReturnValue());
     }
   } else {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"LocalTimeFmt");
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
+                                       L"LocalTimeFmt");
   }
 }
 
 // static
 void CXFA_FM2JSContext::Num2Date(CFXJSE_Value* pThis,
                                  const CFX_ByteStringC& szFuncName,
                                  CFXJSE_Arguments& args) {
   int32_t argc = args.GetLength();
   if ((argc > 0) && (argc < 4)) {
     FX_BOOL bFlags = FALSE;
@@ skipping 125 matching lines @@
                     szLocalDateString);
       if (szLocalDateString.IsEmpty()) {
         szLocalDateString = "";
       }
       FXJSE_Value_SetUTF8String(args.GetReturnValue(),
                                 szLocalDateString.AsStringC());
     } else {
       FXJSE_Value_SetNull(args.GetReturnValue());
     }
   } else {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Num2Date");
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
+                                       L"Num2Date");
   }
 }
 
 // static
 void CXFA_FM2JSContext::Num2GMTime(CFXJSE_Value* pThis,
                                    const CFX_ByteStringC& szFuncName,
                                    CFXJSE_Arguments& args) {
   int32_t argc = args.GetLength();
   if ((argc > 0) && (argc < 4)) {
     FX_BOOL bFlags = FALSE;
@@ skipping 32 matching lines @@
                   localString.AsStringC(), TRUE, szGMTTimeString);
       if (szGMTTimeString.IsEmpty()) {
         szGMTTimeString = "";
       }
       FXJSE_Value_SetUTF8String(args.GetReturnValue(),
                                 szGMTTimeString.AsStringC());
     } else {
       FXJSE_Value_SetNull(args.GetReturnValue());
     }
   } else {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Num2GMTime");
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
+                                       L"Num2GMTime");
   }
 }
 
 // static
 void CXFA_FM2JSContext::Num2Time(CFXJSE_Value* pThis,
                                  const CFX_ByteStringC& szFuncName,
                                  CFXJSE_Arguments& args) {
   int32_t argc = args.GetLength();
   if ((argc > 0) && (argc < 4)) {
     FX_BOOL bFlags = FALSE;
@@ skipping 32 matching lines @@
                   localString.AsStringC(), FALSE, szLocalTimeString);
       if (szLocalTimeString.IsEmpty()) {
         szLocalTimeString = "";
       }
       FXJSE_Value_SetUTF8String(args.GetReturnValue(),
                                 szLocalTimeString.AsStringC());
     } else {
       FXJSE_Value_SetNull(args.GetReturnValue());
     }
   } else {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Num2Time");
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
+                                       L"Num2Time");
   }
 }
 
 // static
 void CXFA_FM2JSContext::Time(CFXJSE_Value* pThis,
                              const CFX_ByteStringC& szFuncName,
                              CFXJSE_Arguments& args) {
   if (args.GetLength() == 0) {
     time_t now;
     time(&now);
     struct tm* pGmt = gmtime(&now);
     int32_t iGMHour = pGmt->tm_hour;
     int32_t iGMMin = pGmt->tm_min;
     int32_t iGMSec = pGmt->tm_sec;
     FXJSE_Value_SetInteger(args.GetReturnValue(),
                            ((iGMHour * 3600 + iGMMin * 60 + iGMSec) * 1000));
   } else {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Time");
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
+                                       L"Time");
   }
 }
 
 // static
 void CXFA_FM2JSContext::Time2Num(CFXJSE_Value* pThis,
                                  const CFX_ByteStringC& szFuncName,
                                  CFXJSE_Arguments& args) {
   int32_t argc = args.GetLength();
   if ((argc > 0) && (argc < 4)) {
     FX_BOOL bFlags = FALSE;
@@ skipping 72 matching lines @@
         int32_t iResult =
             hour * 3600000 + min * 60000 + second * 1000 + milSecond + 1;
         FXJSE_Value_SetInteger(args.GetReturnValue(), iResult);
       } else {
         FXJSE_Value_SetInteger(args.GetReturnValue(), 0);
       }
     } else {
       FXJSE_Value_SetNull(args.GetReturnValue());
     }
   } else {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Time2Num");
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
+                                       L"Time2Num");
   }
 }
 
 // static
 void CXFA_FM2JSContext::TimeFmt(CFXJSE_Value* pThis,
                                 const CFX_ByteStringC& szFuncName,
                                 CFXJSE_Arguments& args) {
   int32_t argc = args.GetLength();
   if (argc < 3) {
     FX_BOOL bFlags = FALSE;
@@ skipping 21 matching lines @@
       CFX_ByteString formatStr;
       GetStandardTimeFormat(pThis, iStyle, szLocal.AsStringC(), formatStr);
       if (formatStr.IsEmpty()) {
         formatStr = "";
       }
       FXJSE_Value_SetUTF8String(args.GetReturnValue(), formatStr.AsStringC());
     } else {
       FXJSE_Value_SetNull(args.GetReturnValue());
     }
   } else {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"TimeFmt");
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
+                                       L"TimeFmt");
   }
 }
 
 // static
 FX_BOOL CXFA_FM2JSContext::IsIsoDateFormat(const FX_CHAR* pData,
                                            int32_t iLength,
                                            int32_t& iStyle,
                                            int32_t& iYear,
                                            int32_t& iMonth,
                                            int32_t& iDay) {
@@ skipping 781 matching lines @@
         (ValueIsNull(pThis, argOne.get()) || ValueIsNull(pThis, argTwo.get()) ||
          ValueIsNull(pThis, argThree.get()));
     if (bFlags) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
       nPrincipal = ValueToDouble(pThis, argOne.get());
       nPayment = ValueToDouble(pThis, argTwo.get());
       nPeriods = ValueToDouble(pThis, argThree.get());
       bFlags = ((nPrincipal <= 0) || (nPayment <= 0) || (nPeriods <= 0));
       if (bFlags) {
-        pContext->ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
+        pContext->Throw(XFA_IDS_ARGUMENT_MISMATCH);
       } else {
         FX_DOUBLE r =
             2 * (nPeriods * nPayment - nPrincipal) / (nPeriods * nPrincipal);
         FX_DOUBLE nTemp = 1;
         for (int32_t i = 0; i < nPeriods; ++i) {
           nTemp *= (1 + r);
         }
         FX_DOUBLE nRet = r * nTemp / (nTemp - 1) - nPayment / nPrincipal;
         while (fabs(nRet) > kFinancialPrecision && !bFlags) {
           FX_DOUBLE nDerivative = 0;
@@ skipping 14 matching lines @@
         }
         if (bFlags) {
           FXJSE_Value_SetNull(args.GetReturnValue());
         } else {
           r = r * 12;
           FXJSE_Value_SetDouble(args.GetReturnValue(), r);
         }
       }
     }
   } else {
-    pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                                      L"Apr");
+    pContext->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Apr");
   }
 }
 
 // static
 void CXFA_FM2JSContext::CTerm(CFXJSE_Value* pThis,
                               const CFX_ByteStringC& szFuncName,
                               CFXJSE_Arguments& args) {
   CXFA_FM2JSContext* pContext = pThis->ToJSContext(nullptr);
   if (args.GetLength() == 3) {
     FX_BOOL bFlags = FALSE;
     FX_FLOAT nRate = 0;
     FX_FLOAT nFutureValue = 0;
     FX_FLOAT nInitAmount = 0;
     std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
     std::unique_ptr<CFXJSE_Value> argTwo = GetSimpleValue(pThis, args, 1);
     std::unique_ptr<CFXJSE_Value> argThree = GetSimpleValue(pThis, args, 2);
     bFlags =
         (ValueIsNull(pThis, argOne.get()) || ValueIsNull(pThis, argTwo.get()) ||
          ValueIsNull(pThis, argThree.get()));
     if (bFlags) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
       nRate = ValueToFloat(pThis, argOne.get());
       nFutureValue = ValueToFloat(pThis, argTwo.get());
       nInitAmount = ValueToFloat(pThis, argThree.get());
       bFlags = ((nRate <= 0) || (nFutureValue <= 0) || (nInitAmount <= 0));
       if (bFlags) {
-        pContext->ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
+        pContext->Throw(XFA_IDS_ARGUMENT_MISMATCH);
       } else {
         FXJSE_Value_SetFloat(args.GetReturnValue(),
                              FXSYS_log((FX_FLOAT)(nFutureValue / nInitAmount)) /
                                  FXSYS_log((FX_FLOAT)(1 + nRate)));
       }
     }
   } else {
-    pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                                      L"CTerm");
+    pContext->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"CTerm");
   }
 }
 
 // static
 void CXFA_FM2JSContext::FV(CFXJSE_Value* pThis,
                            const CFX_ByteStringC& szFuncName,
                            CFXJSE_Arguments& args) {
   CXFA_FM2JSContext* pContext = pThis->ToJSContext(nullptr);
   if (args.GetLength() == 3) {
     FX_BOOL bFlags = FALSE;
     FX_DOUBLE nAmount = 0;
     FX_DOUBLE nRate = 0;
     FX_DOUBLE nPeriod = 0;
     std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
     std::unique_ptr<CFXJSE_Value> argTwo = GetSimpleValue(pThis, args, 1);
     std::unique_ptr<CFXJSE_Value> argThree = GetSimpleValue(pThis, args, 2);
     bFlags =
         (ValueIsNull(pThis, argOne.get()) || ValueIsNull(pThis, argTwo.get()) ||
          ValueIsNull(pThis, argThree.get()));
     if (bFlags) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
       nAmount = ValueToDouble(pThis, argOne.get());
       nRate = ValueToDouble(pThis, argTwo.get());
       nPeriod = ValueToDouble(pThis, argThree.get());
       bFlags = ((nRate < 0) || (nPeriod <= 0) || (nAmount <= 0));
       if (bFlags) {
-        pContext->ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
+        pContext->Throw(XFA_IDS_ARGUMENT_MISMATCH);
       } else {
         FX_DOUBLE dResult = 0;
         if (!nRate) {
           dResult = nAmount * nPeriod;
         } else {
           FX_DOUBLE nTemp = 1;
           for (int i = 0; i < nPeriod; ++i) {
             nTemp *= 1 + nRate;
           }
           dResult = nAmount * (nTemp - 1) / nRate;
         }
         FXJSE_Value_SetDouble(args.GetReturnValue(), dResult);
       }
     }
   } else {
-    pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                                      L"FV");
+    pContext->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"FV");
   }
 }
 
 // static
 void CXFA_FM2JSContext::IPmt(CFXJSE_Value* pThis,
                              const CFX_ByteStringC& szFuncName,
                              CFXJSE_Arguments& args) {
   CXFA_FM2JSContext* pContext = pThis->ToJSContext(nullptr);
   if (args.GetLength() == 5) {
     FX_BOOL bFlags = FALSE;
@@ skipping 16 matching lines @@
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
       nPrincpalAmount = ValueToFloat(pThis, argOne.get());
       nRate = ValueToFloat(pThis, argTwo.get());
       nPayment = ValueToFloat(pThis, argThree.get());
       nFirstMonth = ValueToFloat(pThis, argFour.get());
       nNumberOfMonths = ValueToFloat(pThis, argFive.get());
       bFlags = ((nPrincpalAmount <= 0) || (nRate <= 0) || (nPayment <= 0) ||
                 (nFirstMonth < 0) || (nNumberOfMonths < 0));
       if (bFlags) {
-        pContext->ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
+        pContext->Throw(XFA_IDS_ARGUMENT_MISMATCH);
       } else {
         FX_FLOAT fResult = 0;
         FX_FLOAT nRateOfMonth = nRate / 12;
         int32_t iNums =
             (int32_t)((FXSYS_log10((FX_FLOAT)(nPayment / nPrincpalAmount)) -
                        FXSYS_log10((FX_FLOAT)(nPayment / nPrincpalAmount -
                                               nRateOfMonth))) /
                       FXSYS_log10((FX_FLOAT)(1 + nRateOfMonth)));
         int32_t iEnd = (int32_t)(nFirstMonth + nNumberOfMonths - 1);
         if (iEnd > iNums) {
@@ skipping 12 matching lines @@
           for (; i < iEnd; ++i) {
             nSum += nPrincpalAmount * nRateOfMonth;
             nPrincpalAmount -= nPayment - nPrincpalAmount * nRateOfMonth;
           }
           fResult = nSum;
         }
         FXJSE_Value_SetFloat(args.GetReturnValue(), fResult);
       }
     }
   } else {
-    pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                                      L"IPmt");
+    pContext->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"IPmt");
   }
 }
 
 // static
 void CXFA_FM2JSContext::NPV(CFXJSE_Value* pThis,
                             const CFX_ByteStringC& szFuncName,
                             CFXJSE_Arguments& args) {
   CXFA_FM2JSContext* pContext = pThis->ToJSContext(nullptr);
   int32_t argc = args.GetLength();
   if (argc > 2) {
     FX_BOOL bFlags = FALSE;
     std::vector<std::unique_ptr<CFXJSE_Value>> argValues;
     for (int32_t i = 0; i < argc; i++) {
       argValues.push_back(GetSimpleValue(pThis, args, i));
       if (ValueIsNull(pThis, argValues[i].get())) {
         bFlags = TRUE;
       }
     }
     if (!bFlags && argc > 0) {
       FX_DOUBLE nRate = 0;
       nRate = ValueToDouble(pThis, argValues[0].get());
       if (nRate <= 0) {
-        pContext->ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
+        pContext->Throw(XFA_IDS_ARGUMENT_MISMATCH);
       } else {
         FX_DOUBLE* pData = FX_Alloc(FX_DOUBLE, argc - 1);
         for (int32_t i = 1; i < argc; i++) {
           pData[i - 1] = ValueToDouble(pThis, argValues[i].get());
         }
         FX_DOUBLE nSum = 0;
         int32_t iIndex = 0;
         for (int32_t i = 0; i < argc - 1; i++) {
           FX_DOUBLE nTemp = 1;
           for (int32_t j = 0; j <= i; j++) {
             nTemp *= 1 + nRate;
           }
           FX_DOUBLE nNum = *(pData + iIndex++);
           nSum += nNum / nTemp;
         }
         FXJSE_Value_SetDouble(args.GetReturnValue(), nSum);
         FX_Free(pData);
         pData = 0;
       }
     } else {
       FXJSE_Value_SetNull(args.GetReturnValue());
     }
   } else {
-    pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                                      L"NPV");
+    pContext->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"NPV");
   }
 }
 
 // static
 void CXFA_FM2JSContext::Pmt(CFXJSE_Value* pThis,
                             const CFX_ByteStringC& szFuncName,
                             CFXJSE_Arguments& args) {
   CXFA_FM2JSContext* pContext = pThis->ToJSContext(nullptr);
   if (args.GetLength() == 3) {
     FX_BOOL bFlags = FALSE;
     FX_FLOAT nPrincipal = 0;
     FX_FLOAT nRate = 0;
     FX_FLOAT nPeriods = 0;
     std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
     std::unique_ptr<CFXJSE_Value> argTwo = GetSimpleValue(pThis, args, 1);
     std::unique_ptr<CFXJSE_Value> argThree = GetSimpleValue(pThis, args, 2);
     bFlags =
         (ValueIsNull(pThis, argOne.get()) || ValueIsNull(pThis, argTwo.get()) ||
          ValueIsNull(pThis, argThree.get()));
     if (bFlags) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
       nPrincipal = ValueToFloat(pThis, argOne.get());
       nRate = ValueToFloat(pThis, argTwo.get());
       nPeriods = ValueToFloat(pThis, argThree.get());
       bFlags = ((nPrincipal <= 0) || (nRate <= 0) || (nPeriods <= 0));
       if (bFlags) {
-        pContext->ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
+        pContext->Throw(XFA_IDS_ARGUMENT_MISMATCH);
       } else {
         FX_FLOAT nSum = 0;
         FX_FLOAT nTmp = 1 + nRate;
         nSum = nTmp;
         for (int32_t i = 0; i < nPeriods - 1; ++i) {
           nSum *= nTmp;
         }
         FXJSE_Value_SetFloat(args.GetReturnValue(),
                              (nPrincipal * nRate * nSum) / (nSum - 1));
       }
     }
   } else {
-    pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                                      L"Pmt");
+    pContext->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Pmt");
   }
 }
 
 // static
 void CXFA_FM2JSContext::PPmt(CFXJSE_Value* pThis,
                              const CFX_ByteStringC& szFuncName,
                              CFXJSE_Arguments& args) {
   CXFA_FM2JSContext* pContext = pThis->ToJSContext(nullptr);
   if (args.GetLength() == 5) {
     FX_BOOL bFlags = FALSE;
@@ skipping 16 matching lines @@
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
       nPrincpalAmount = ValueToFloat(pThis, argOne.get());
       nRate = ValueToFloat(pThis, argTwo.get());
       nPayment = ValueToFloat(pThis, argThree.get());
       nFirstMonth = ValueToFloat(pThis, argFour.get());
       nNumberOfMonths = ValueToFloat(pThis, argFive.get());
       bFlags = ((nPrincpalAmount <= 0) || (nRate <= 0) || (nPayment <= 0) ||
                 (nFirstMonth < 0) || (nNumberOfMonths < 0));
       if (bFlags) {
-        pContext->ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
+        pContext->Throw(XFA_IDS_ARGUMENT_MISMATCH);
       } else {
         int32_t iEnd = (int32_t)(nFirstMonth + nNumberOfMonths - 1);
         FX_FLOAT nSum = 0;
         FX_FLOAT nRateOfMonth = nRate / 12;
         int32_t iNums =
             (int32_t)((FXSYS_log10((FX_FLOAT)(nPayment / nPrincpalAmount)) -
                        FXSYS_log10((FX_FLOAT)(nPayment / nPrincpalAmount -
                                               nRateOfMonth))) /
                       FXSYS_log10((FX_FLOAT)(1 + nRateOfMonth)));
         if (iEnd > iNums) {
           iEnd = iNums;
         }
         if (nPayment < nPrincpalAmount * nRateOfMonth) {
           bFlags = TRUE;
         }
         if (!bFlags) {
           int32_t i = 0;
           for (i = 0; i < nFirstMonth - 1; ++i) {
             nPrincpalAmount -= nPayment - nPrincpalAmount * nRateOfMonth;
           }
           FX_FLOAT nTemp = 0;
           for (; i < iEnd; ++i) {
             nTemp = nPayment - nPrincpalAmount * nRateOfMonth;
             nSum += nTemp;
             nPrincpalAmount -= nTemp;
           }
           FXJSE_Value_SetFloat(args.GetReturnValue(), nSum);
         } else {
-          pContext->ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
+          pContext->Throw(XFA_IDS_ARGUMENT_MISMATCH);
         }
       }
     }
   } else {
-    pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                                      L"PPmt");
+    pContext->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"PPmt");
   }
 }
 
 // static
 void CXFA_FM2JSContext::PV(CFXJSE_Value* pThis,
                            const CFX_ByteStringC& szFuncName,
                            CFXJSE_Arguments& args) {
   CXFA_FM2JSContext* pContext = pThis->ToJSContext(nullptr);
   if (args.GetLength() == 3) {
     FX_BOOL bFlags = FALSE;
     FX_DOUBLE nAmount = 0;
     FX_DOUBLE nRate = 0;
     FX_DOUBLE nPeriod = 0;
     std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
     std::unique_ptr<CFXJSE_Value> argTwo = GetSimpleValue(pThis, args, 1);
     std::unique_ptr<CFXJSE_Value> argThree = GetSimpleValue(pThis, args, 2);
     bFlags =
         (ValueIsNull(pThis, argOne.get()) || ValueIsNull(pThis, argTwo.get()) ||
          ValueIsNull(pThis, argThree.get()));
     if (bFlags) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
       nAmount = ValueToDouble(pThis, argOne.get());
       nRate = ValueToDouble(pThis, argTwo.get());
       nPeriod = ValueToDouble(pThis, argThree.get());
       bFlags = ((nAmount <= 0) || (nRate < 0) || (nPeriod <= 0));
       if (bFlags) {
-        pContext->ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
+        pContext->Throw(XFA_IDS_ARGUMENT_MISMATCH);
       } else {
         FX_DOUBLE nTemp = 1;
         for (int32_t i = 0; i < nPeriod; ++i) {
           nTemp *= 1 + nRate;
         }
         nTemp = 1 / nTemp;
         FXJSE_Value_SetDouble(args.GetReturnValue(),
                               nAmount * ((1 - nTemp) / nRate));
       }
     }
   } else {
-    pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                                      L"PV");
+    pContext->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"PV");
   }
 }
 
 // static
 void CXFA_FM2JSContext::Rate(CFXJSE_Value* pThis,
                              const CFX_ByteStringC& szFuncName,
                              CFXJSE_Arguments& args) {
   CXFA_FM2JSContext* pContext = pThis->ToJSContext(nullptr);
   if (args.GetLength() == 3) {
     FX_BOOL bFlags = FALSE;
     FX_FLOAT nFuture = 0;
     FX_FLOAT nPresent = 0;
     FX_FLOAT nTotalNumber = 0;
     std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
     std::unique_ptr<CFXJSE_Value> argTwo = GetSimpleValue(pThis, args, 1);
     std::unique_ptr<CFXJSE_Value> argThree = GetSimpleValue(pThis, args, 2);
     bFlags =
         (ValueIsNull(pThis, argOne.get()) || ValueIsNull(pThis, argTwo.get()) ||
          ValueIsNull(pThis, argThree.get()));
     if (bFlags) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
       nFuture = ValueToFloat(pThis, argOne.get());
       nPresent = ValueToFloat(pThis, argTwo.get());
       nTotalNumber = ValueToFloat(pThis, argThree.get());
       bFlags = ((nFuture <= 0) || (nPresent < 0) || (nTotalNumber <= 0));
       if (bFlags) {
-        pContext->ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
+        pContext->Throw(XFA_IDS_ARGUMENT_MISMATCH);
       } else {
         FXJSE_Value_SetFloat(args.GetReturnValue(),
                              (FXSYS_pow((FX_FLOAT)(nFuture / nPresent),
                                         (FX_FLOAT)(1 / nTotalNumber)) -
                               1));
       }
     }
   } else {
-    pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                                      L"Rate");
+    pContext->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Rate");
   }
 }
 
 // static
 void CXFA_FM2JSContext::Term(CFXJSE_Value* pThis,
                              const CFX_ByteStringC& szFuncName,
                              CFXJSE_Arguments& args) {
   CXFA_FM2JSContext* pContext = pThis->ToJSContext(nullptr);
   if (args.GetLength() == 3) {
     FX_BOOL bFlags = FALSE;
     FX_FLOAT nMount = 0;
     FX_FLOAT nRate = 0;
     FX_FLOAT nFuture = 0;
     std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
     std::unique_ptr<CFXJSE_Value> argTwo = GetSimpleValue(pThis, args, 1);
     std::unique_ptr<CFXJSE_Value> argThree = GetSimpleValue(pThis, args, 2);
     bFlags =
         (ValueIsNull(pThis, argOne.get()) || ValueIsNull(pThis, argTwo.get()) ||
          ValueIsNull(pThis, argThree.get()));
     if (bFlags) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
       nMount = ValueToFloat(pThis, argOne.get());
       nRate = ValueToFloat(pThis, argTwo.get());
       nFuture = ValueToFloat(pThis, argThree.get());
       bFlags = ((nMount <= 0) || (nRate <= 0) || (nFuture <= 0));
       if (bFlags) {
-        pContext->ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
+        pContext->Throw(XFA_IDS_ARGUMENT_MISMATCH);
       } else {
         FXJSE_Value_SetFloat(
             args.GetReturnValue(),
             (FXSYS_log((FX_FLOAT)(nFuture / nMount * nRate) + 1) /
              FXSYS_log((FX_FLOAT)(1 + nRate))));
       }
     }
   } else {
-    pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                                      L"Term");
+    pContext->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Term");
   }
 }
 
 // static
 void CXFA_FM2JSContext::Choose(CFXJSE_Value* pThis,
                                const CFX_ByteStringC& szFuncName,
                                CFXJSE_Arguments& args) {
   CXFA_FM2JSContext* pContext = pThis->ToJSContext(nullptr);
   v8::Isolate* pIsolate = pContext->GetScriptRuntime();
   int32_t argc = args.GetLength();
@@ skipping 63 matching lines @@
             bFound = TRUE;
           }
         }
         iArgIndex++;
       }
       if (!bFound) {
         FXJSE_Value_SetUTF8String(args.GetReturnValue(), "");
       }
     }
   } else {
-    pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                                      L"Choose");
+    pContext->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Choose");
   }
 }
 
 // static
 void CXFA_FM2JSContext::Exists(CFXJSE_Value* pThis,
                                const CFX_ByteStringC& szFuncName,
                                CFXJSE_Arguments& args) {
   if (args.GetLength() == 1) {
     std::unique_ptr<CFXJSE_Value> argOne = args.GetValue(0);
     FXJSE_Value_SetInteger(args.GetReturnValue(),
                            FXJSE_Value_IsObject(argOne.get()));
   } else {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Exists");
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
+                                       L"Exists");
   }
 }
 
 // static
 void CXFA_FM2JSContext::HasValue(CFXJSE_Value* pThis,
                                  const CFX_ByteStringC& szFuncName,
                                  CFXJSE_Arguments& args) {
   if (args.GetLength() == 1) {
     std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
     if (FXJSE_Value_IsUTF8String(argOne.get())) {
       CFX_ByteString valueStr;
       FXJSE_Value_ToUTF8String(argOne.get(), valueStr);
       valueStr.TrimLeft();
       FXJSE_Value_SetInteger(args.GetReturnValue(), (!valueStr.IsEmpty()));
     } else if (FXJSE_Value_IsNumber(argOne.get()) ||
                FXJSE_Value_IsBoolean(argOne.get())) {
       FXJSE_Value_SetInteger(args.GetReturnValue(), TRUE);
     } else {
       FXJSE_Value_SetInteger(args.GetReturnValue(), FALSE);
     }
   } else {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"HasValue");
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
+                                       L"HasValue");
   }
 }
 
 // static
 void CXFA_FM2JSContext::Oneof(CFXJSE_Value* pThis,
                               const CFX_ByteStringC& szFuncName,
                               CFXJSE_Arguments& args) {
   if (args.GetLength() > 1) {
     FX_BOOL bFlags = FALSE;
     std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
     CFXJSE_Value** parametersValue = nullptr;
     int32_t iCount = 0;
     unfoldArgs(pThis, args, parametersValue, iCount, 1);
     for (int32_t i = 0; i < iCount; i++) {
       if (simpleValueCompare(pThis, argOne.get(), parametersValue[i])) {
         bFlags = TRUE;
         break;
       }
     }
     FXJSE_Value_SetInteger(args.GetReturnValue(), bFlags);
     for (int32_t i = 0; i < iCount; i++) {
       delete parametersValue[i];
     }
     FX_Free(parametersValue);
   } else {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Oneof");
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
+                                       L"Oneof");
   }
 }
 
 // static
 void CXFA_FM2JSContext::Within(CFXJSE_Value* pThis,
                                const CFX_ByteStringC& szFuncName,
                                CFXJSE_Arguments& args) {
   if (args.GetLength() == 3) {
     std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
     if (FXJSE_Value_IsNull(argOne.get())) {
@@ skipping 15 matching lines @@
         ValueToUTF8String(argOne.get(), oneString);
         ValueToUTF8String(argLow.get(), lowString);
         ValueToUTF8String(argHeight.get(), heightString);
         FXJSE_Value_SetInteger(
             args.GetReturnValue(),
             ((oneString.Compare(lowString.AsStringC()) >= 0) &&
              (oneString.Compare(heightString.AsStringC()) <= 0)));
       }
     }
   } else {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Within");
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
+                                       L"Within");
   }
 }
 
 // static
 void CXFA_FM2JSContext::If(CFXJSE_Value* pThis,
                            const CFX_ByteStringC& szFuncName,
                            CFXJSE_Arguments& args) {
   if (args.GetLength() == 3) {
     std::unique_ptr<CFXJSE_Value> argCondition = GetSimpleValue(pThis, args, 0);
     std::unique_ptr<CFXJSE_Value> argFirstValue =
         GetSimpleValue(pThis, args, 1);
     std::unique_ptr<CFXJSE_Value> argSecondValue =
         GetSimpleValue(pThis, args, 2);
     FX_BOOL bCondition = FXJSE_Value_ToBoolean(argCondition.get());
     FXJSE_Value_Set(args.GetReturnValue(),
                     bCondition ? argFirstValue.get() : argSecondValue.get());
   } else {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"If");
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
+                                       L"If");
   }
 }
 
 // static
 void CXFA_FM2JSContext::Eval(CFXJSE_Value* pThis,
                              const CFX_ByteStringC& szFuncName,
                              CFXJSE_Arguments& args) {
   CXFA_FM2JSContext* pContext = pThis->ToJSContext(nullptr);
   v8::Isolate* pIsolate = pContext->GetScriptRuntime();
   if (args.GetLength() == 1) {
@@ skipping 14 matching lines @@
       std::unique_ptr<CFXJSE_Value> returnValue(new CFXJSE_Value(pIsolate));
       javaScript = wsJavaScriptBuf.AsStringC();
       FXJSE_ExecuteScript(
           pTempContext,
           FX_UTF8Encode(javaScript.c_str(), javaScript.GetLength()).c_str(),
           returnValue.get());
       FXJSE_Value_Set(args.GetReturnValue(), returnValue.get());
       FXJSE_Context_Release(pTempContext);
     }
   } else {
-    pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                                      L"Eval");
+    pContext->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Eval");
   }
 }
 
 // static
 void CXFA_FM2JSContext::Ref(CFXJSE_Value* pThis,
                             const CFX_ByteStringC& szFuncName,
                             CFXJSE_Arguments& args) {
   CXFA_FM2JSContext* pContext = pThis->ToJSContext(nullptr);
   v8::Isolate* pIsolate = pContext->GetScriptRuntime();
   if (args.GetLength() == 1) {
@@ skipping 14 matching lines @@
 #ifndef NDEBUG
       std::unique_ptr<CFXJSE_Value> lengthValue(new CFXJSE_Value(pIsolate));
       FXJSE_Value_GetObjectProp(argOne.get(), "length", lengthValue.get());
       ASSERT(FXJSE_Value_ToInteger(lengthValue.get()) >= 3);
 #endif
       std::unique_ptr<CFXJSE_Value> propertyValue(new CFXJSE_Value(pIsolate));
       std::unique_ptr<CFXJSE_Value> jsObjectValue(new CFXJSE_Value(pIsolate));
       FXJSE_Value_GetObjectPropByIdx(argOne.get(), 1, propertyValue.get());
       FXJSE_Value_GetObjectPropByIdx(argOne.get(), 2, jsObjectValue.get());
       if (FXJSE_Value_IsNull(jsObjectValue.get())) {
-        pContext->ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
+        pContext->Throw(XFA_IDS_ARGUMENT_MISMATCH);
       } else if (FXJSE_Value_IsNull(propertyValue.get()) &&
                  (!FXJSE_Value_IsNull(jsObjectValue.get()))) {
         CFXJSE_Value* rgValues[3];
         for (int32_t i = 0; i < 3; i++)
           rgValues[i] = new CFXJSE_Value(pIsolate);
 
         FXJSE_Value_SetInteger(rgValues[0], 3);
         FXJSE_Value_SetNull(rgValues[1]);
         FXJSE_Value_Set(rgValues[2], jsObjectValue.get());
         FXJSE_Value_SetArray(args.GetReturnValue(), 3, rgValues);
         for (int32_t i = 0; i < 3; i++)
           delete rgValues[i];
 
       } else {
-        pContext->ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
+        pContext->Throw(XFA_IDS_ARGUMENT_MISMATCH);
       }
     } else if (FXJSE_Value_IsObject(argOne.get())) {
       CFXJSE_Value* rgValues[3];
       for (int32_t i = 0; i < 3; i++)
         rgValues[i] = new CFXJSE_Value(pIsolate);
 
       FXJSE_Value_SetInteger(rgValues[0], 3);
       FXJSE_Value_SetNull(rgValues[1]);
       FXJSE_Value_Set(rgValues[2], argOne.get());
       FXJSE_Value_SetArray(args.GetReturnValue(), 3, rgValues);
 
       for (int32_t i = 0; i < 3; i++)
         delete rgValues[i];
     } else if (FXJSE_Value_IsBoolean(argOne.get()) ||
                FXJSE_Value_IsUTF8String(argOne.get()) ||
                FXJSE_Value_IsNumber(argOne.get())) {
       FXJSE_Value_Set(args.GetReturnValue(), argOne.get());
     } else {
-      pContext->ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
+      pContext->Throw(XFA_IDS_ARGUMENT_MISMATCH);
     }
   } else {
-    pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                                      L"Ref");
+    pContext->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Ref");
   }
 }
 
 // static
 void CXFA_FM2JSContext::UnitType(CFXJSE_Value* pThis,
                                  const CFX_ByteStringC& szFuncName,
                                  CFXJSE_Arguments& args) {
   if (args.GetLength() == 1) {
     std::unique_ptr<CFXJSE_Value> unitspanValue =
         GetSimpleValue(pThis, args, 0);
@@ skipping 94 matching lines @@
           break;
         case VALUETYPE_ISMP:
           FXJSE_Value_SetUTF8String(args.GetReturnValue(), "mp");
           break;
         default:
           FXJSE_Value_SetUTF8String(args.GetReturnValue(), "in");
           break;
       }
     }
   } else {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"UnitType");
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
+                                       L"UnitType");
   }
 }
 
 // static
 void CXFA_FM2JSContext::UnitValue(CFXJSE_Value* pThis,
                                   const CFX_ByteStringC& szFuncName,
                                   CFXJSE_Arguments& args) {
   int32_t argc = args.GetLength();
   if ((argc == 1) || (argc == 2)) {
     std::unique_ptr<CFXJSE_Value> unitspanValue =
@@ skipping 134 matching lines @@
           } else {
             dResult = dFirstNumber / 72000;
           }
         }
         FXJSE_Value_SetDouble(args.GetReturnValue(), dResult);
       } else {
         FXJSE_Value_SetInteger(args.GetReturnValue(), 0);
       }
     }
   } else {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"UnitValue");
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
+                                       L"UnitValue");
   }
 }
 
 // static
 void CXFA_FM2JSContext::At(CFXJSE_Value* pThis,
                            const CFX_ByteStringC& szFuncName,
                            CFXJSE_Arguments& args) {
   if (args.GetLength() == 2) {
     std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
     std::unique_ptr<CFXJSE_Value> argTwo = GetSimpleValue(pThis, args, 1);
     if (ValueIsNull(pThis, argOne.get()) || ValueIsNull(pThis, argTwo.get())) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
       CFX_ByteString stringTwo;
       ValueToUTF8String(argTwo.get(), stringTwo);
       if (stringTwo.IsEmpty()) {
         FXJSE_Value_SetInteger(args.GetReturnValue(), 1);
       } else {
         CFX_ByteString stringOne;
         ValueToUTF8String(argOne.get(), stringOne);
         FX_STRSIZE iPosition = stringOne.Find(stringTwo.AsStringC());
         FXJSE_Value_SetInteger(args.GetReturnValue(), iPosition + 1);
       }
     }
   } else {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"At");
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
+                                       L"At");
   }
 }
 
 // static
 void CXFA_FM2JSContext::Concat(CFXJSE_Value* pThis,
                                const CFX_ByteStringC& szFuncName,
                                CFXJSE_Arguments& args) {
   int32_t argc = args.GetLength();
   if (argc >= 1) {
     CFX_ByteString resultString;
     FX_BOOL bAllNull = TRUE;
 
     for (int32_t i = 0; i < argc; i++) {
       std::unique_ptr<CFXJSE_Value> value = GetSimpleValue(pThis, args, i);
       if (!ValueIsNull(pThis, value.get())) {
         CFX_ByteString valueStr;
         ValueToUTF8String(value.get(), valueStr);
         resultString += valueStr;
         bAllNull = FALSE;
       }
     }
 
     if (bAllNull) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
       FXJSE_Value_SetUTF8String(args.GetReturnValue(),
                                 resultString.AsStringC());
     }
   } else {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Concat");
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
+                                       L"Concat");
   }
 }
 
 // static
 void CXFA_FM2JSContext::Decode(CFXJSE_Value* pThis,
                                const CFX_ByteStringC& szFuncName,
                                CFXJSE_Arguments& args) {
   int32_t argc = args.GetLength();
   if (argc == 1) {
     std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
@@ skipping 20 matching lines @@
       if (identifyString.EqualNoCase("html")) {
         DecodeHTML(toDecodeString.AsStringC(), resultBuf);
       } else if (identifyString.EqualNoCase("xml")) {
         DecodeXML(toDecodeString.AsStringC(), resultBuf);
       } else {
         DecodeURL(toDecodeString.AsStringC(), resultBuf);
       }
       FXJSE_Value_SetUTF8String(args.GetReturnValue(), resultBuf.AsStringC());
     }
   } else {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Decode");
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
+                                       L"Decode");
   }
 }
 
 // static
 void CXFA_FM2JSContext::DecodeURL(const CFX_ByteStringC& szURLString,
                                   CFX_ByteTextBuf& szResultString) {
   CFX_WideString wsURLString = CFX_WideString::FromUTF8(szURLString);
   const FX_WCHAR* pData = wsURLString.c_str();
   int32_t iLen = wsURLString.GetLength();
   int32_t i = 0;
@@ skipping 252 matching lines @@
       if (identifyString.EqualNoCase("html")) {
         EncodeHTML(toEncodeString.AsStringC(), resultBuf);
       } else if (identifyString.EqualNoCase("xml")) {
         EncodeXML(toEncodeString.AsStringC(), resultBuf);
       } else {
         EncodeURL(toEncodeString.AsStringC(), resultBuf);
       }
       FXJSE_Value_SetUTF8String(args.GetReturnValue(), resultBuf.AsStringC());
     }
   } else {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Encode");
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
+                                       L"Encode");
   }
 }
 
 // static
 void CXFA_FM2JSContext::EncodeURL(const CFX_ByteStringC& szURLString,
                                   CFX_ByteTextBuf& szResultBuf) {
   CFX_WideString wsURLString = CFX_WideString::FromUTF8(szURLString);
   CFX_WideTextBuf wsResultBuf;
   FX_WCHAR ch = 0;
   int32_t iLength = wsURLString.GetLength();
@@ skipping 354 matching lines @@
     CFX_WideString wsRet;
     if (localeValue.FormatPatterns(wsRet, wsPattern, pLocale,
                                    XFA_VALUEPICTURE_Display)) {
       FXJSE_Value_SetUTF8String(
           args.GetReturnValue(),
           FX_UTF8Encode(wsRet.c_str(), wsRet.GetLength()).AsStringC());
     } else {
       FXJSE_Value_SetUTF8String(args.GetReturnValue(), "");
     }
   } else {
-    pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                                      L"Format");
+    pContext->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Format");
   }
 }
 
 // static
 void CXFA_FM2JSContext::Left(CFXJSE_Value* pThis,
                              const CFX_ByteStringC& szFuncName,
                              CFXJSE_Arguments& args) {
   if (args.GetLength() == 2) {
     std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
     std::unique_ptr<CFXJSE_Value> argTwo = GetSimpleValue(pThis, args, 1);
     FX_BOOL argIsNull = FALSE;
     if ((ValueIsNull(pThis, argOne.get())) ||
         (ValueIsNull(pThis, argTwo.get()))) {
       argIsNull = TRUE;
     }
     if (argIsNull) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
       CFX_ByteString sourceString;
       ValueToUTF8String(argOne.get(), sourceString);
       int32_t count = ValueToInteger(pThis, argTwo.get());
       if (count < 0) {
         count = 0;
       }
       FXJSE_Value_SetUTF8String(args.GetReturnValue(),
                                 sourceString.Left(count).AsStringC());
     }
   } else {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Left");
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
+                                       L"Left");
   }
 }
 
 // static
 void CXFA_FM2JSContext::Len(CFXJSE_Value* pThis,
                             const CFX_ByteStringC& szFuncName,
                             CFXJSE_Arguments& args) {
   if (args.GetLength() == 1) {
     std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
     if (ValueIsNull(pThis, argOne.get())) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
       CFX_ByteString sourceString;
       ValueToUTF8String(argOne.get(), sourceString);
       FXJSE_Value_SetInteger(args.GetReturnValue(), sourceString.GetLength());
     }
   } else {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Len");
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
+                                       L"Len");
   }
 }
 
 // static
 void CXFA_FM2JSContext::Lower(CFXJSE_Value* pThis,
                               const CFX_ByteStringC& szFuncName,
                               CFXJSE_Arguments& args) {
   int32_t argc = args.GetLength();
   if ((argc > 0) && (argc < 3)) {
     CFX_ByteString argString;
@@ skipping 21 matching lines @@
         lowStringBuf.AppendChar(ch);
         ++i;
       }
       lowStringBuf.AppendChar(0);
       FXJSE_Value_SetUTF8String(
           args.GetReturnValue(),
           FX_UTF8Encode(lowStringBuf.GetBuffer(), lowStringBuf.GetLength())
               .AsStringC());
     }
   } else {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Lower");
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
+                                       L"Lower");
   }
 }
 
 // static
 void CXFA_FM2JSContext::Ltrim(CFXJSE_Value* pThis,
                               const CFX_ByteStringC& szFuncName,
                               CFXJSE_Arguments& args) {
   if (args.GetLength() == 1) {
     std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
     if (ValueIsNull(pThis, argOne.get())) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
       CFX_ByteString sourceString;
       ValueToUTF8String(argOne.get(), sourceString);
       sourceString.TrimLeft();
       FXJSE_Value_SetUTF8String(args.GetReturnValue(),
                                 sourceString.AsStringC());
     }
   } else {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Ltrim");
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
+                                       L"Ltrim");
   }
 }
 
 // static
 void CXFA_FM2JSContext::Parse(CFXJSE_Value* pThis,
                               const CFX_ByteStringC& szFuncName,
                               CFXJSE_Arguments& args) {
   CXFA_FM2JSContext* pContext = pThis->ToJSContext(nullptr);
   if (args.GetLength() == 2) {
     std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
@@ skipping 118 matching lines @@
                                           szParsedValue.AsStringC());
               } else {
                 FXJSE_Value_SetUTF8String(args.GetReturnValue(), "");
               }
             }
           } break;
         }
       }
     }
   } else {
-    pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                                      L"Parse");
+    pContext->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Parse");
   }
 }
 
 // static
 void CXFA_FM2JSContext::Replace(CFXJSE_Value* pThis,
                                 const CFX_ByteStringC& szFuncName,
                                 CFXJSE_Arguments& args) {
   int32_t argc = args.GetLength();
   if ((argc == 2) || (argc == 3)) {
     std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
@@ skipping 38 matching lines @@
         } else {
           resultString.AppendChar(ch);
         }
       } else {
         resultString.AppendChar(ch);
       }
     }
     resultString.AppendChar(0);
     FXJSE_Value_SetUTF8String(args.GetReturnValue(), resultString.AsStringC());
   } else {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Replace");
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
+                                       L"Replace");
   }
 }
 
 // static
 void CXFA_FM2JSContext::Right(CFXJSE_Value* pThis,
                               const CFX_ByteStringC& szFuncName,
                               CFXJSE_Arguments& args) {
   if (args.GetLength() == 2) {
     std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
     std::unique_ptr<CFXJSE_Value> argTwo = GetSimpleValue(pThis, args, 1);
     FX_BOOL argIsNull = FALSE;
     if ((ValueIsNull(pThis, argOne.get())) ||
         (ValueIsNull(pThis, argTwo.get()))) {
       argIsNull = TRUE;
     }
     if (argIsNull) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
       CFX_ByteString sourceString;
       ValueToUTF8String(argOne.get(), sourceString);
       int32_t count = ValueToInteger(pThis, argTwo.get());
       if (count < 0) {
         count = 0;
       }
       FXJSE_Value_SetUTF8String(args.GetReturnValue(),
                                 sourceString.Right(count).AsStringC());
     }
   } else {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Right");
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
+                                       L"Right");
   }
 }
 
 // static
 void CXFA_FM2JSContext::Rtrim(CFXJSE_Value* pThis,
                               const CFX_ByteStringC& szFuncName,
                               CFXJSE_Arguments& args) {
   if (args.GetLength() == 1) {
     std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
     if (ValueIsNull(pThis, argOne.get())) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
       CFX_ByteString sourceString;
       ValueToUTF8String(argOne.get(), sourceString);
       sourceString.TrimRight();
       FXJSE_Value_SetUTF8String(args.GetReturnValue(),
                                 sourceString.AsStringC());
     }
   } else {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Rtrim");
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
+                                       L"Rtrim");
   }
 }
 
 // static
 void CXFA_FM2JSContext::Space(CFXJSE_Value* pThis,
                               const CFX_ByteStringC& szFuncName,
                               CFXJSE_Arguments& args) {
   if (args.GetLength() == 1) {
     std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
     if (FXJSE_Value_IsNull(argOne.get())) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
       int32_t count = 0;
       count = ValueToInteger(pThis, argOne.get());
       count = (count < 0) ? 0 : count;
       CFX_ByteTextBuf spaceString;
       int32_t index = 0;
       while (index < count) {
         spaceString.AppendByte(' ');
         index++;
       }
       spaceString.AppendByte(0);
       FXJSE_Value_SetUTF8String(args.GetReturnValue(), spaceString.AsStringC());
     }
   } else {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Space");
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
+                                       L"Space");
   }
 }
 
 // static
 void CXFA_FM2JSContext::Str(CFXJSE_Value* pThis,
                             const CFX_ByteStringC& szFuncName,
                             CFXJSE_Arguments& args) {
   int32_t argc = args.GetLength();
   if ((argc > 0) && (argc < 4)) {
     FX_BOOL bFlags = FALSE;
@@ skipping 96 matching lines @@
             ++i;
           }
           resultBuf.AppendChar(0);
         }
       }
       FXJSE_Value_SetUTF8String(args.GetReturnValue(), resultBuf.AsStringC());
     } else {
       FXJSE_Value_SetNull(args.GetReturnValue());
     }
   } else {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Str");
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
+                                       L"Str");
   }
 }
 
 // static
 void CXFA_FM2JSContext::Stuff(CFXJSE_Value* pThis,
                               const CFX_ByteStringC& szFuncName,
                               CFXJSE_Arguments& args) {
   int32_t argc = args.GetLength();
   if ((argc == 3) || (argc == 4)) {
     CFX_ByteString sourceString;
@@ skipping 35 matching lines @@
     }
     resultString << insertString.AsStringC();
     i = iStart + iDelete;
     while (i < iLength) {
       resultString.AppendChar(sourceString.GetAt(i));
       ++i;
     }
     resultString.AppendChar(0);
     FXJSE_Value_SetUTF8String(args.GetReturnValue(), resultString.AsStringC());
   } else {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Stuff");
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
+                                       L"Stuff");
   }
 }
 
 // static
 void CXFA_FM2JSContext::Substr(CFXJSE_Value* pThis,
                                const CFX_ByteStringC& szFuncName,
                                CFXJSE_Arguments& args) {
   if (args.GetLength() == 3) {
     std::unique_ptr<CFXJSE_Value> stringValue = GetSimpleValue(pThis, args, 0);
     std::unique_ptr<CFXJSE_Value> startValue = GetSimpleValue(pThis, args, 1);
@@ skipping 21 matching lines @@
         }
         if (iCount <= 0) {
           iCount = 0;
         }
         iStart -= 1;
         FXJSE_Value_SetUTF8String(args.GetReturnValue(),
                                   szSourceStr.Mid(iStart, iCount).AsStringC());
       }
     }
   } else {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Substr");
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
+                                       L"Substr");
   }
 }
 
 // static
 void CXFA_FM2JSContext::Uuid(CFXJSE_Value* pThis,
                              const CFX_ByteStringC& szFuncName,
                              CFXJSE_Arguments& args) {
   int32_t argc = args.GetLength();
   if ((argc == 0) || (argc == 1)) {
     int32_t iNum = 0;
     if (argc == 1) {
       std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
       iNum = (int32_t)ValueToFloat(pThis, argOne.get());
     }
     FX_GUID guid;
     FX_GUID_CreateV4(&guid);
     CFX_ByteString bsUId;
     FX_GUID_ToString(&guid, bsUId, iNum);
     FXJSE_Value_SetUTF8String(args.GetReturnValue(), bsUId.AsStringC());
   } else {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Uuid");
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
+                                       L"Uuid");
   }
 }
 
 // static
 void CXFA_FM2JSContext::Upper(CFXJSE_Value* pThis,
                               const CFX_ByteStringC& szFuncName,
                               CFXJSE_Arguments& args) {
   int32_t argc = args.GetLength();
   if ((argc > 0) && (argc < 3)) {
     CFX_ByteString argString;
@@ skipping 21 matching lines @@
         upperStringBuf.AppendChar(ch);
         ++i;
       }
       upperStringBuf.AppendChar(0);
       FXJSE_Value_SetUTF8String(
           args.GetReturnValue(),
           FX_UTF8Encode(upperStringBuf.GetBuffer(), upperStringBuf.GetLength())
               .AsStringC());
     }
   } else {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Upper");
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
+                                       L"Upper");
   }
 }
 
 // static
 void CXFA_FM2JSContext::WordNum(CFXJSE_Value* pThis,
                                 const CFX_ByteStringC& szFuncName,
                                 CFXJSE_Arguments& args) {
   int32_t argc = args.GetLength();
   if ((argc > 0) && (argc < 4)) {
     FX_BOOL bFlags = FALSE;
@@ skipping 31 matching lines @@
         CFX_ByteTextBuf resultBuf;
         CFX_ByteString numberString;
         numberString.Format("%.2f", fNumber);
         WordUS(numberString.AsStringC(), iIdentifier, resultBuf);
         FXJSE_Value_SetUTF8String(args.GetReturnValue(), resultBuf.AsStringC());
       }
     } else {
       FXJSE_Value_SetNull(args.GetReturnValue());
     }
   } else {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"WordNum");
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
+                                       L"WordNum");
   }
 }
 
 // static
 void CXFA_FM2JSContext::TrillionUS(const CFX_ByteStringC& szData,
                                    CFX_ByteTextBuf& strBuf) {
   CFX_ByteStringC pUnits[] = {"zero", "one", "two",   "three", "four",
                               "five", "six", "seven", "eight", "nine"};
   CFX_ByteStringC pCapUnits[] = {"Zero", "One", "Two",   "Three", "Four",
                                  "Five", "Six", "Seven", "Eight", "Nine"};
@@ skipping 212 matching lines @@
     if (pFile) {
       int32_t size = pFile->GetSize();
       uint8_t* pData = FX_Alloc(uint8_t, size);
       pFile->ReadBlock(pData, size);
       FXJSE_Value_SetUTF8String(args.GetReturnValue(),
                                 CFX_ByteStringC(pData, size));
       FX_Free(pData);
       pFile->Release();
     }
   } else {
-    pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                                      L"Get");
+    pContext->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Get");
   }
 }
 
 // static
 void CXFA_FM2JSContext::Post(CFXJSE_Value* pThis,
                              const CFX_ByteStringC& szFuncName,
                              CFXJSE_Arguments& args) {
   CXFA_FM2JSContext* pContext = pThis->ToJSContext(nullptr);
   int32_t argc = args.GetLength();
   if ((argc >= 2) && (argc <= 5)) {
@@ skipping 33 matching lines @@
         CFX_WideString::FromUTF8(bsData.AsStringC()),
         CFX_WideString::FromUTF8(bsContentType.AsStringC()),
         CFX_WideString::FromUTF8(bsEncode.AsStringC()),
         CFX_WideString::FromUTF8(bsHeader.AsStringC()), decodedResponse);
     if (bFlags) {
       FXJSE_Value_SetUTF8String(
           args.GetReturnValue(),
           FX_UTF8Encode(decodedResponse.c_str(), decodedResponse.GetLength())
               .AsStringC());
     } else {
-      pContext->ThrowScriptErrorMessage(XFA_IDS_SERVER_DENY);
+      pContext->Throw(XFA_IDS_SERVER_DENY);
     }
   } else {
-    pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                                      L"Post");
+    pContext->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Post");
   }
 }
 
 // static
 void CXFA_FM2JSContext::Put(CFXJSE_Value* pThis,
                             const CFX_ByteStringC& szFuncName,
                             CFXJSE_Arguments& args) {
   CXFA_FM2JSContext* pContext = pThis->ToJSContext(nullptr);
   int32_t argc = args.GetLength();
   if ((argc == 2) || (argc == 3)) {
@@ skipping 17 matching lines @@
       std::unique_ptr<CFXJSE_Value> argThree = GetSimpleValue(pThis, args, 2);
       ValueToUTF8String(argThree.get(), bsEncode);
     }
     FX_BOOL bFlags = pAppProvider->PutRequestURL(
         CFX_WideString::FromUTF8(bsURL.AsStringC()),
         CFX_WideString::FromUTF8(bsData.AsStringC()),
         CFX_WideString::FromUTF8(bsEncode.AsStringC()));
     if (bFlags) {
       FXJSE_Value_SetUTF8String(args.GetReturnValue(), "");
     } else {
-      pContext->ThrowScriptErrorMessage(XFA_IDS_SERVER_DENY);
+      pContext->Throw(XFA_IDS_SERVER_DENY);
     }
   } else {
-    pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                                      L"Put");
+    pContext->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Put");
   }
 }
 
 // static
 void CXFA_FM2JSContext::assign_value_operator(CFXJSE_Value* pThis,
                                               const CFX_ByteStringC& szFuncName,
                                               CFXJSE_Arguments& args) {
   CXFA_FM2JSContext* pContext = pThis->ToJSContext(nullptr);
   v8::Isolate* pIsolate = pContext->GetScriptRuntime();
   if (args.GetLength() == 2) {
     std::unique_ptr<CFXJSE_Value> lValue = args.GetValue(0);
     std::unique_ptr<CFXJSE_Value> rValue = GetSimpleValue(pThis, args, 1);
     FX_BOOL bSetStatus = TRUE;
     if (FXJSE_Value_IsArray(lValue.get())) {
       std::unique_ptr<CFXJSE_Value> leftLengthValue(new CFXJSE_Value(pIsolate));
       FXJSE_Value_GetObjectProp(lValue.get(), "length", leftLengthValue.get());
       int32_t iLeftLength = FXJSE_Value_ToInteger(leftLengthValue.get());
       std::unique_ptr<CFXJSE_Value> jsObjectValue(new CFXJSE_Value(pIsolate));
       std::unique_ptr<CFXJSE_Value> propertyValue(new CFXJSE_Value(pIsolate));
       FXJSE_Value_GetObjectPropByIdx(lValue.get(), 1, propertyValue.get());
       if (FXJSE_Value_IsNull(propertyValue.get())) {
         for (int32_t i = 2; i < iLeftLength; i++) {
           FXJSE_Value_GetObjectPropByIdx(lValue.get(), i, jsObjectValue.get());
           bSetStatus = SetObjectDefaultValue(jsObjectValue.get(), rValue.get());
           if (!bSetStatus) {
-            pContext->ThrowScriptErrorMessage(XFA_IDS_NOT_DEFAUL_VALUE);
+            pContext->Throw(XFA_IDS_NOT_DEFAUL_VALUE);
             break;
           }
         }
       } else {
         CFX_ByteString propertyStr;
         FXJSE_Value_ToUTF8String(propertyValue.get(), propertyStr);
         for (int32_t i = 2; i < iLeftLength; i++) {
           FXJSE_Value_GetObjectPropByIdx(lValue.get(), i, jsObjectValue.get());
           FXJSE_Value_SetObjectProp(jsObjectValue.get(),
                                     propertyStr.AsStringC(), rValue.get());
         }
       }
     } else if (FXJSE_Value_IsObject(lValue.get())) {
       bSetStatus = SetObjectDefaultValue(lValue.get(), rValue.get());
       if (!bSetStatus) {
-        pContext->ThrowScriptErrorMessage(XFA_IDS_NOT_DEFAUL_VALUE);
+        pContext->Throw(XFA_IDS_NOT_DEFAUL_VALUE);
       }
     }
     FXJSE_Value_Set(args.GetReturnValue(), rValue.get());
   } else {
-    pContext->ThrowScriptErrorMessage(XFA_IDS_COMPILER_ERROR);
+    pContext->Throw(XFA_IDS_COMPILER_ERROR);
   }
 }
 
 // static
 void CXFA_FM2JSContext::logical_or_operator(CFXJSE_Value* pThis,
                                             const CFX_ByteStringC& szFuncName,
                                             CFXJSE_Arguments& args) {
   if (args.GetLength() == 2) {
     std::unique_ptr<CFXJSE_Value> argFirst = GetSimpleValue(pThis, args, 0);
     std::unique_ptr<CFXJSE_Value> argSecond = GetSimpleValue(pThis, args, 1);
     if (FXJSE_Value_IsNull(argFirst.get()) &&
         FXJSE_Value_IsNull(argSecond.get())) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
       FX_FLOAT first = ValueToFloat(pThis, argFirst.get());
       FX_FLOAT second = ValueToFloat(pThis, argSecond.get());
       FXJSE_Value_SetInteger(args.GetReturnValue(), (first || second) ? 1 : 0);
     }
   } else {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_COMPILER_ERROR);
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_COMPILER_ERROR);
   }
 }
 
 // static
 void CXFA_FM2JSContext::logical_and_operator(CFXJSE_Value* pThis,
                                              const CFX_ByteStringC& szFuncName,
                                              CFXJSE_Arguments& args) {
   if (args.GetLength() == 2) {
     std::unique_ptr<CFXJSE_Value> argFirst = GetSimpleValue(pThis, args, 0);
     std::unique_ptr<CFXJSE_Value> argSecond = GetSimpleValue(pThis, args, 1);
     if (FXJSE_Value_IsNull(argFirst.get()) &&
         FXJSE_Value_IsNull(argSecond.get())) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
       FX_FLOAT first = ValueToFloat(pThis, argFirst.get());
       FX_FLOAT second = ValueToFloat(pThis, argSecond.get());
       FXJSE_Value_SetInteger(args.GetReturnValue(), (first && second) ? 1 : 0);
     }
   } else {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_COMPILER_ERROR);
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_COMPILER_ERROR);
   }
 }
 
 // static
 void CXFA_FM2JSContext::equality_operator(CFXJSE_Value* pThis,
                                           const CFX_ByteStringC& szFuncName,
                                           CFXJSE_Arguments& args) {
   if (args.GetLength() == 2) {
     if (fm_ref_equal(pThis, args)) {
       FXJSE_Value_SetInteger(args.GetReturnValue(), 1);
@@ skipping 16 matching lines @@
         FXJSE_Value_SetInteger(args.GetReturnValue(),
                                firstOutput == secondOutput);
       } else {
         FX_DOUBLE first = ValueToDouble(pThis, argFirst.get());
         FX_DOUBLE second = ValueToDouble(pThis, argSecond.get());
         FXJSE_Value_SetInteger(args.GetReturnValue(),
                                (first == second) ? 1 : 0);
       }
     }
   } else {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_COMPILER_ERROR);
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_COMPILER_ERROR);
   }
 }
 
 // static
 void CXFA_FM2JSContext::notequality_operator(CFXJSE_Value* pThis,
                                              const CFX_ByteStringC& szFuncName,
                                              CFXJSE_Arguments& args) {
   if (args.GetLength() == 2) {
     if (fm_ref_equal(pThis, args)) {
       FXJSE_Value_SetInteger(args.GetReturnValue(), 0);
@@ skipping 15 matching lines @@
         FXJSE_Value_ToUTF8String(argSecond.get(), secondOutput);
         FXJSE_Value_SetInteger(args.GetReturnValue(),
                                firstOutput != secondOutput);
       } else {
         FX_DOUBLE first = ValueToDouble(pThis, argFirst.get());
         FX_DOUBLE second = ValueToDouble(pThis, argSecond.get());
         FXJSE_Value_SetInteger(args.GetReturnValue(), first != second);
       }
     }
   } else {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_COMPILER_ERROR);
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_COMPILER_ERROR);
   }
 }
 
 // static
 FX_BOOL CXFA_FM2JSContext::fm_ref_equal(CFXJSE_Value* pThis,
                                         CFXJSE_Arguments& args) {
   FX_BOOL bRet = FALSE;
   v8::Isolate* pIsolate = pThis->ToJSContext(nullptr)->GetScriptRuntime();
   std::unique_ptr<CFXJSE_Value> argFirst = args.GetValue(0);
   std::unique_ptr<CFXJSE_Value> argSecond = args.GetValue(1);
@@ skipping 37 matching lines @@
       FXJSE_Value_ToUTF8String(argSecond.get(), secondOutput);
       FXJSE_Value_SetInteger(
           args.GetReturnValue(),
           firstOutput.Compare(secondOutput.AsStringC()) == -1);
     } else {
       FX_DOUBLE first = ValueToDouble(pThis, argFirst.get());
       FX_DOUBLE second = ValueToDouble(pThis, argSecond.get());
       FXJSE_Value_SetInteger(args.GetReturnValue(), (first < second) ? 1 : 0);
     }
   } else {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_COMPILER_ERROR);
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_COMPILER_ERROR);
   }
 }
 
 // static
 void CXFA_FM2JSContext::lessequal_operator(CFXJSE_Value* pThis,
                                            const CFX_ByteStringC& szFuncName,
                                            CFXJSE_Arguments& args) {
   if (args.GetLength() == 2) {
     std::unique_ptr<CFXJSE_Value> argFirst = GetSimpleValue(pThis, args, 0);
     std::unique_ptr<CFXJSE_Value> argSecond = GetSimpleValue(pThis, args, 1);
@@ skipping 12 matching lines @@
       FXJSE_Value_ToUTF8String(argSecond.get(), secondOutput);
       FXJSE_Value_SetInteger(
           args.GetReturnValue(),
           firstOutput.Compare(secondOutput.AsStringC()) != 1);
     } else {
       FX_DOUBLE first = ValueToDouble(pThis, argFirst.get());
       FX_DOUBLE second = ValueToDouble(pThis, argSecond.get());
       FXJSE_Value_SetInteger(args.GetReturnValue(), (first <= second) ? 1 : 0);
     }
   } else {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_COMPILER_ERROR);
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_COMPILER_ERROR);
   }
 }
 
 // static
 void CXFA_FM2JSContext::greater_operator(CFXJSE_Value* pThis,
                                          const CFX_ByteStringC& szFuncName,
                                          CFXJSE_Arguments& args) {
   if (args.GetLength() == 2) {
     std::unique_ptr<CFXJSE_Value> argFirst = GetSimpleValue(pThis, args, 0);
     std::unique_ptr<CFXJSE_Value> argSecond = GetSimpleValue(pThis, args, 1);
     if (FXJSE_Value_IsNull(argFirst.get()) ||
         FXJSE_Value_IsNull(argSecond.get())) {
       FXJSE_Value_SetInteger(args.GetReturnValue(), 0);
     } else if (FXJSE_Value_IsUTF8String(argFirst.get()) &&
                FXJSE_Value_IsUTF8String(argSecond.get())) {
       CFX_ByteString firstOutput;
       CFX_ByteString secondOutput;
       FXJSE_Value_ToUTF8String(argFirst.get(), firstOutput);
       FXJSE_Value_ToUTF8String(argSecond.get(), secondOutput);
       FXJSE_Value_SetInteger(
           args.GetReturnValue(),
           firstOutput.Compare(secondOutput.AsStringC()) == 1);
     } else {
       FX_DOUBLE first = ValueToDouble(pThis, argFirst.get());
       FX_DOUBLE second = ValueToDouble(pThis, argSecond.get());
       FXJSE_Value_SetInteger(args.GetReturnValue(), (first > second) ? 1 : 0);
     }
   } else {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_COMPILER_ERROR);
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_COMPILER_ERROR);
   }
 }
 
 // static
 void CXFA_FM2JSContext::greaterequal_operator(CFXJSE_Value* pThis,
                                               const CFX_ByteStringC& szFuncName,
                                               CFXJSE_Arguments& args) {
   if (args.GetLength() == 2) {
     std::unique_ptr<CFXJSE_Value> argFirst = GetSimpleValue(pThis, args, 0);
     std::unique_ptr<CFXJSE_Value> argSecond = GetSimpleValue(pThis, args, 1);
@@ skipping 12 matching lines @@
       FXJSE_Value_ToUTF8String(argSecond.get(), secondOutput);
       FXJSE_Value_SetInteger(
           args.GetReturnValue(),
           firstOutput.Compare(secondOutput.AsStringC()) != -1);
     } else {
       FX_DOUBLE first = ValueToDouble(pThis, argFirst.get());
       FX_DOUBLE second = ValueToDouble(pThis, argSecond.get());
       FXJSE_Value_SetInteger(args.GetReturnValue(), (first >= second) ? 1 : 0);
     }
   } else {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_COMPILER_ERROR);
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_COMPILER_ERROR);
   }
 }
 
 // static
 void CXFA_FM2JSContext::plus_operator(CFXJSE_Value* pThis,
                                       const CFX_ByteStringC& szFuncName,
                                       CFXJSE_Arguments& args) {
   if (args.GetLength() == 2) {
     std::unique_ptr<CFXJSE_Value> argFirst = args.GetValue(0);
     std::unique_ptr<CFXJSE_Value> argSecond = args.GetValue(1);
     if (ValueIsNull(pThis, argFirst.get()) &&
         ValueIsNull(pThis, argSecond.get())) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
       FX_DOUBLE first = ValueToDouble(pThis, argFirst.get());
       FX_DOUBLE second = ValueToDouble(pThis, argSecond.get());
       FXJSE_Value_SetDouble(args.GetReturnValue(), first + second);
     }
   } else {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_COMPILER_ERROR);
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_COMPILER_ERROR);
   }
 }
 
 // static
 void CXFA_FM2JSContext::minus_operator(CFXJSE_Value* pThis,
                                        const CFX_ByteStringC& szFuncName,
                                        CFXJSE_Arguments& args) {
   if (args.GetLength() == 2) {
     std::unique_ptr<CFXJSE_Value> argFirst = GetSimpleValue(pThis, args, 0);
     std::unique_ptr<CFXJSE_Value> argSecond = GetSimpleValue(pThis, args, 1);
     if (FXJSE_Value_IsNull(argFirst.get()) &&
         FXJSE_Value_IsNull(argSecond.get())) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
       FX_DOUBLE first = ValueToDouble(pThis, argFirst.get());
       FX_DOUBLE second = ValueToDouble(pThis, argSecond.get());
       FXJSE_Value_SetDouble(args.GetReturnValue(), first - second);
     }
   } else {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_COMPILER_ERROR);
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_COMPILER_ERROR);
   }
 }
 
 // static
 void CXFA_FM2JSContext::multiple_operator(CFXJSE_Value* pThis,
                                           const CFX_ByteStringC& szFuncName,
                                           CFXJSE_Arguments& args) {
   if (args.GetLength() == 2) {
     std::unique_ptr<CFXJSE_Value> argFirst = GetSimpleValue(pThis, args, 0);
     std::unique_ptr<CFXJSE_Value> argSecond = GetSimpleValue(pThis, args, 1);
     if (FXJSE_Value_IsNull(argFirst.get()) &&
         FXJSE_Value_IsNull(argSecond.get())) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
       FX_DOUBLE first = ValueToDouble(pThis, argFirst.get());
       FX_DOUBLE second = ValueToDouble(pThis, argSecond.get());
       FXJSE_Value_SetDouble(args.GetReturnValue(), first * second);
     }
   } else {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_COMPILER_ERROR);
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_COMPILER_ERROR);
   }
 }
 
 // static
 void CXFA_FM2JSContext::divide_operator(CFXJSE_Value* pThis,
                                         const CFX_ByteStringC& szFuncName,
                                         CFXJSE_Arguments& args) {
   CXFA_FM2JSContext* pContext = pThis->ToJSContext(nullptr);
   if (args.GetLength() == 2) {
     std::unique_ptr<CFXJSE_Value> argFirst = GetSimpleValue(pThis, args, 0);
     std::unique_ptr<CFXJSE_Value> argSecond = GetSimpleValue(pThis, args, 1);
     if (FXJSE_Value_IsNull(argFirst.get()) &&
         FXJSE_Value_IsNull(argSecond.get())) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
       FX_DOUBLE first = ValueToDouble(pThis, argFirst.get());
       FX_DOUBLE second = ValueToDouble(pThis, argSecond.get());
       if (second == 0.0) {
-        pContext->ThrowScriptErrorMessage(XFA_IDS_DIVIDE_ZERO);
+        pContext->Throw(XFA_IDS_DIVIDE_ZERO);
       } else {
         FXJSE_Value_SetDouble(args.GetReturnValue(), first / second);
       }
     }
   } else {
-    pContext->ThrowScriptErrorMessage(XFA_IDS_COMPILER_ERROR);
+    pContext->Throw(XFA_IDS_COMPILER_ERROR);
   }
 }
 
 // static
 void CXFA_FM2JSContext::positive_operator(CFXJSE_Value* pThis,
                                           const CFX_ByteStringC& szFuncName,
                                           CFXJSE_Arguments& args) {
   if (args.GetLength() == 1) {
     std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
     if (FXJSE_Value_IsNull(argOne.get())) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
       FXJSE_Value_SetDouble(args.GetReturnValue(),
                             0.0 + ValueToDouble(pThis, argOne.get()));
     }
   } else {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_COMPILER_ERROR);
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_COMPILER_ERROR);
   }
 }
 
 // static
 void CXFA_FM2JSContext::negative_operator(CFXJSE_Value* pThis,
                                           const CFX_ByteStringC& szFuncName,
                                           CFXJSE_Arguments& args) {
   if (args.GetLength() == 1) {
     std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
     if (FXJSE_Value_IsNull(argOne.get())) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
       FXJSE_Value_SetDouble(args.GetReturnValue(),
                             0.0 - ValueToDouble(pThis, argOne.get()));
     }
   } else {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_COMPILER_ERROR);
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_COMPILER_ERROR);
   }
 }
 
 // static
 void CXFA_FM2JSContext::logical_not_operator(CFXJSE_Value* pThis,
                                              const CFX_ByteStringC& szFuncName,
                                              CFXJSE_Arguments& args) {
   if (args.GetLength() == 1) {
     std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
     if (FXJSE_Value_IsNull(argOne.get())) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
       FX_DOUBLE first = ValueToDouble(pThis, argOne.get());
       FXJSE_Value_SetInteger(args.GetReturnValue(), (first == 0.0) ? 1 : 0);
     }
   } else {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_COMPILER_ERROR);
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_COMPILER_ERROR);
   }
 }
 
 // static
 void CXFA_FM2JSContext::dot_accessor(CFXJSE_Value* pThis,
                                      const CFX_ByteStringC& szFuncName,
                                      CFXJSE_Arguments& args) {
   CXFA_FM2JSContext* pContext = pThis->ToJSContext(nullptr);
   v8::Isolate* pIsolate = pContext->GetScriptRuntime();
   int32_t argc = args.GetLength();
@@ skipping 58 matching lines @@
         FXJSE_Value_SetArray(args.GetReturnValue(), (iCounter + 2), rgValues);
         for (int32_t i = 0; i < (iCounter + 2); i++)
           delete rgValues[i];
 
         FX_Free(rgValues);
       } else {
         CFX_WideString wsPropertyName =
             CFX_WideString::FromUTF8(szName.AsStringC());
         CFX_WideString wsSomExpression =
             CFX_WideString::FromUTF8(szSomExp.AsStringC());
-        pContext->ThrowScriptErrorMessage(XFA_IDS_ACCESS_PROPERTY_IN_NOT_OBJECT,
-                                          wsPropertyName.c_str(),
-                                          wsSomExpression.c_str());
+        pContext->Throw(XFA_IDS_ACCESS_PROPERTY_IN_NOT_OBJECT,
+                        wsPropertyName.c_str(), wsSomExpression.c_str());
       }
       for (int32_t i = 0; i < iLength - 2; i++) {
         for (int32_t j = 0; j < iSizes[i]; j++)
           delete hResolveValues[i][j];
 
         if (iSizes[i] > 0) {
           FX_Free(hResolveValues[i]);
         }
       }
       FX_Free(hResolveValues);
@@ skipping 40 matching lines @@
         FX_Free(rgValues);
         for (int32_t i = 0; i < iSize; i++)
           delete hResolveValues[i];
 
         FX_Free(hResolveValues);
       } else {
         CFX_WideString wsPropertyName =
             CFX_WideString::FromUTF8(szName.AsStringC());
         CFX_WideString wsSomExpression =
             CFX_WideString::FromUTF8(szSomExp.AsStringC());
-        pContext->ThrowScriptErrorMessage(XFA_IDS_ACCESS_PROPERTY_IN_NOT_OBJECT,
-                                          wsPropertyName.c_str(),
-                                          wsSomExpression.c_str());
+        pContext->Throw(XFA_IDS_ACCESS_PROPERTY_IN_NOT_OBJECT,
+                        wsPropertyName.c_str(), wsSomExpression.c_str());
       }
     }
   } else {
-    pContext->ThrowScriptErrorMessage(XFA_IDS_COMPILER_ERROR);
+    pContext->Throw(XFA_IDS_COMPILER_ERROR);
   }
 }
 
 // static
 void CXFA_FM2JSContext::dotdot_accessor(CFXJSE_Value* pThis,
                                         const CFX_ByteStringC& szFuncName,
                                         CFXJSE_Arguments& args) {
   CXFA_FM2JSContext* pContext = pThis->ToJSContext(nullptr);
   v8::Isolate* pIsolate = pContext->GetScriptRuntime();
   int32_t argc = args.GetLength();
@@ skipping 55 matching lines @@
         FXJSE_Value_SetArray(args.GetReturnValue(), (iCounter + 2), rgValues);
         for (int32_t i = 0; i < (iCounter + 2); i++)
           delete rgValues[i];
 
         FX_Free(rgValues);
       } else {
         CFX_WideString wsPropertyName =
             CFX_WideString::FromUTF8(szName.AsStringC());
         CFX_WideString wsSomExpression =
             CFX_WideString::FromUTF8(szSomExp.AsStringC());
-        pContext->ThrowScriptErrorMessage(XFA_IDS_ACCESS_PROPERTY_IN_NOT_OBJECT,
-                                          wsPropertyName.c_str(),
-                                          wsSomExpression.c_str());
+        pContext->Throw(XFA_IDS_ACCESS_PROPERTY_IN_NOT_OBJECT,
+                        wsPropertyName.c_str(), wsSomExpression.c_str());
       }
       for (int32_t i = 0; i < iLength - 2; i++) {
         for (int32_t j = 0; j < iSizes[i]; j++)
           delete hResolveValues[i][j];
 
         FX_Free(hResolveValues[i]);
       }
       FX_Free(hResolveValues);
       FX_Free(iSizes);
     } else {
@@ skipping 38 matching lines @@
         FX_Free(rgValues);
         for (int32_t i = 0; i < iSize; i++)
           delete hResolveValues[i];
 
         FX_Free(hResolveValues);
       } else {
         CFX_WideString wsPropertyName =
             CFX_WideString::FromUTF8(szName.AsStringC());
         CFX_WideString wsSomExpression =
             CFX_WideString::FromUTF8(szSomExp.AsStringC());
-        pContext->ThrowScriptErrorMessage(XFA_IDS_ACCESS_PROPERTY_IN_NOT_OBJECT,
-                                          wsPropertyName.c_str(),
-                                          wsSomExpression.c_str());
+        pContext->Throw(XFA_IDS_ACCESS_PROPERTY_IN_NOT_OBJECT,
+                        wsPropertyName.c_str(), wsSomExpression.c_str());
       }
     }
   } else {
-    pContext->ThrowScriptErrorMessage(XFA_IDS_COMPILER_ERROR);
+    pContext->Throw(XFA_IDS_COMPILER_ERROR);
   }
 }
 
 // static
 void CXFA_FM2JSContext::eval_translation(CFXJSE_Value* pThis,
                                          const CFX_ByteStringC& szFuncName,
                                          CFXJSE_Arguments& args) {
   CXFA_FM2JSContext* pContext = pThis->ToJSContext(nullptr);
   if (args.GetLength() == 1) {
     std::unique_ptr<CFXJSE_Value> argOne = GetSimpleValue(pThis, args, 0);
     CFX_ByteString argString;
     ValueToUTF8String(argOne.get(), argString);
     if (argString.IsEmpty()) {
-      pContext->ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
+      pContext->Throw(XFA_IDS_ARGUMENT_MISMATCH);
     } else {
       CFX_WideString scriptString =
           CFX_WideString::FromUTF8(argString.AsStringC());
       CFX_WideTextBuf wsJavaScriptBuf;
       CFX_WideString wsError;
       CXFA_FM2JSContext::Translate(scriptString.AsStringC(), wsJavaScriptBuf,
                                    wsError);
       if (wsError.IsEmpty()) {
         CFX_WideString javaScript = wsJavaScriptBuf.MakeString();
         FXJSE_Value_SetUTF8String(
             args.GetReturnValue(),
             FX_UTF8Encode(javaScript.c_str(), javaScript.GetLength())
                 .AsStringC());
       } else {
-        pContext->ThrowScriptErrorMessage(XFA_IDS_COMPILER_ERROR);
+        pContext->Throw(XFA_IDS_COMPILER_ERROR);
       }
     }
   } else {
-    pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
-                                      L"Eval");
+    pContext->Throw(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"Eval");
   }
 }
 
 // static
 void CXFA_FM2JSContext::is_fm_object(CFXJSE_Value* pThis,
                                      const CFX_ByteStringC& szFuncName,
                                      CFXJSE_Arguments& args) {
   if (args.GetLength() == 1) {
     std::unique_ptr<CFXJSE_Value> argOne = args.GetValue(0);
     FXJSE_Value_SetBoolean(args.GetReturnValue(),
@@ skipping 36 matching lines @@
         FXJSE_Value_ToUTF8String(propertyValue.get(), propertyStr);
         FXJSE_Value_GetObjectProp(jsObjectValue.get(), propertyStr.AsStringC(),
                                   args.GetReturnValue());
       }
     } else if (FXJSE_Value_IsObject(argOne.get())) {
       GetObjectDefaultValue(argOne.get(), args.GetReturnValue());
     } else {
       FXJSE_Value_Set(args.GetReturnValue(), argOne.get());
     }
   } else {
-    pContext->ThrowScriptErrorMessage(XFA_IDS_COMPILER_ERROR);
+    pContext->Throw(XFA_IDS_COMPILER_ERROR);
   }
 }
 
 // static
 void CXFA_FM2JSContext::get_fm_jsobj(CFXJSE_Value* pThis,
                                      const CFX_ByteStringC& szFuncName,
                                      CFXJSE_Arguments& args) {
   if (args.GetLength() == 1) {
     std::unique_ptr<CFXJSE_Value> argOne = args.GetValue(0);
     if (FXJSE_Value_IsArray(argOne.get())) {
 #ifndef NDEBUG
       v8::Isolate* pIsolate = pThis->ToJSContext(nullptr)->GetScriptRuntime();
       std::unique_ptr<CFXJSE_Value> lengthValue(new CFXJSE_Value(pIsolate));
       FXJSE_Value_GetObjectProp(argOne.get(), "length", lengthValue.get());
       ASSERT(FXJSE_Value_ToInteger(lengthValue.get()) >= 3);
 #endif
       FXJSE_Value_GetObjectPropByIdx(argOne.get(), 2, args.GetReturnValue());
     } else {
       FXJSE_Value_Set(args.GetReturnValue(), argOne.get());
     }
   } else {
-    pThis->ToJSContext(nullptr)->ThrowScriptErrorMessage(
-        XFA_IDS_COMPILER_ERROR);
+    pThis->ToJSContext(nullptr)->Throw(XFA_IDS_COMPILER_ERROR);
   }
 }
 
 // static
 void CXFA_FM2JSContext::fm_var_filter(CFXJSE_Value* pThis,
                                       const CFX_ByteStringC& szFuncName,
                                       CFXJSE_Arguments& args) {
   CXFA_FM2JSContext* pContext = pThis->ToJSContext(nullptr);
   v8::Isolate* pIsolate = pContext->GetScriptRuntime();
   if (args.GetLength() == 1) {
@@ skipping 17 matching lines @@
         FXJSE_Value_SetNull(rgValues[2]);
         FXJSE_Value_SetArray(args.GetReturnValue(), 3, rgValues);
         for (int32_t i = 0; i < 3; i++)
           delete rgValues[i];
       } else if (iFlags == 3) {
         std::unique_ptr<CFXJSE_Value> objectValue(new CFXJSE_Value(pIsolate));
         FXJSE_Value_GetObjectPropByIdx(argOne.get(), 2, objectValue.get());
         if (!FXJSE_Value_IsNull(objectValue.get())) {
           FXJSE_Value_Set(args.GetReturnValue(), argOne.get());
         } else {
-          pContext->ThrowScriptErrorMessage(XFA_IDS_COMPILER_ERROR);
+          pContext->Throw(XFA_IDS_COMPILER_ERROR);
         }
       } else {
         std::unique_ptr<CFXJSE_Value> simpleValue =
             GetSimpleValue(pThis, args, 0);
         FXJSE_Value_Set(args.GetReturnValue(), simpleValue.get());
       }
     } else {
       std::unique_ptr<CFXJSE_Value> simpleValue =
           GetSimpleValue(pThis, args, 0);
       FXJSE_Value_Set(args.GetReturnValue(), simpleValue.get());
     }
   } else {
-    pContext->ThrowScriptErrorMessage(XFA_IDS_COMPILER_ERROR);
+    pContext->Throw(XFA_IDS_COMPILER_ERROR);
   }
 }
 
 // static
 void CXFA_FM2JSContext::concat_fm_object(CFXJSE_Value* pThis,
                                          const CFX_ByteStringC& szFuncName,
                                          CFXJSE_Arguments& args) {
   v8::Isolate* pIsolate = pThis->ToJSContext(nullptr)->GetScriptRuntime();
   uint32_t iLength = 0;
   int32_t argc = args.GetLength();
@@ skipping 554 matching lines @@
   FXJSE_Value_SetNull(m_pValue.get());
   FXJSE_Value_SetObject(m_pValue.get(), this, m_pFMClass);
 }
 
 CXFA_FM2JSContext::~CXFA_FM2JSContext() {}
 
 void CXFA_FM2JSContext::GlobalPropertyGetter(CFXJSE_Value* pValue) {
   FXJSE_Value_Set(pValue, m_pValue.get());
 }
 
-void CXFA_FM2JSContext::ThrowScriptErrorMessage(int32_t iStringID, ...) {
+void CXFA_FM2JSContext::Throw(int32_t iStringID, ...) {
   IXFA_AppProvider* pAppProvider = m_pDocument->GetNotify()->GetAppProvider();
   ASSERT(pAppProvider);
   CFX_WideString wsFormat;
   pAppProvider->LoadString(iStringID, wsFormat);
   CFX_WideString wsMessage;
   va_list arg_ptr;
   va_start(arg_ptr, iStringID);
   wsMessage.FormatV(wsFormat.c_str(), arg_ptr);
   va_end(arg_ptr);
   FXJSE_ThrowMessage(
       "", FX_UTF8Encode(wsMessage.c_str(), wsMessage.GetLength()).AsStringC());
 }