Remove FXJSE_HOBJECT and FXJSE_HVALUE for CFXJSE_Value*

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 280 matching lines @@
         wsPattern.SetAt(i, wsAltSymbols[nAlt]);
       }
     }
     i++;
     bEscape = FALSE;
   }
 }
 
 }  // namespace
 
-void CXFA_FM2JSContext::Abs(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::Abs(CFXJSE_Value* pThis,
                             const CFX_ByteStringC& szFuncName,
                             CFXJSE_Arguments& args) {
   if (args.GetLength() == 1) {
-    FXJSE_HVALUE argOne = args.GetValue(0);
-    if (HValueIsNull(hThis, argOne)) {
+    CFXJSE_Value* argOne = args.GetValue(0);
+    if (ValueIsNull(pThis, argOne)) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
-      FX_DOUBLE dValue = HValueToDouble(hThis, argOne);
+      FX_DOUBLE dValue = ValueToDouble(pThis, argOne);
       if (dValue < 0) {
         dValue = -dValue;
       }
       FXJSE_Value_SetDouble(args.GetReturnValue(), dValue);
     }
     FXJSE_Value_Release(argOne);
   } else {
     CXFA_FM2JSContext* pContext =
-        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"Abs");
   }
 }
-void CXFA_FM2JSContext::Avg(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::Avg(CFXJSE_Value* pThis,
                             const CFX_ByteStringC& szFuncName,
                             CFXJSE_Arguments& args) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   v8::Isolate* pIsolate = pContext->GetScriptRuntime();
   int32_t argc = args.GetLength();
   uint32_t uCount = 0;
   FX_DOUBLE dSum = 0.0;
   if (argc >= 1) {
-    FXJSE_HVALUE argValue = 0;
+    CFXJSE_Value* argValue = nullptr;
     for (int32_t i = 0; i < argc; i++) {
       argValue = args.GetValue(i);
       if (FXJSE_Value_IsNull(argValue)) {
         FXJSE_Value_Release(argValue);
         continue;
       } else if (FXJSE_Value_IsArray(argValue)) {
-        FXJSE_HVALUE lengthValue = FXJSE_Value_Create(pIsolate);
+        CFXJSE_Value* lengthValue = FXJSE_Value_Create(pIsolate);
         FXJSE_Value_GetObjectProp(argValue, "length", lengthValue);
         int32_t iLength = FXJSE_Value_ToInteger(lengthValue);
         FXJSE_Value_Release(lengthValue);
         if (iLength > 2) {
-          FXJSE_HVALUE propertyValue = FXJSE_Value_Create(pIsolate);
+          CFXJSE_Value* propertyValue = FXJSE_Value_Create(pIsolate);
           FXJSE_Value_GetObjectPropByIdx(argValue, 1, propertyValue);
-          FXJSE_HVALUE jsObjectValue = FXJSE_Value_Create(pIsolate);
+          CFXJSE_Value* jsObjectValue = FXJSE_Value_Create(pIsolate);
           if (FXJSE_Value_IsNull(propertyValue)) {
             for (int32_t j = 2; j < iLength; j++) {
               FXJSE_Value_GetObjectPropByIdx(argValue, j, jsObjectValue);
-              FXJSE_HVALUE defaultPropValue = FXJSE_Value_Create(pIsolate);
+              CFXJSE_Value* defaultPropValue = FXJSE_Value_Create(pIsolate);
               GetObjectDefaultValue(jsObjectValue, defaultPropValue);
               if (!FXJSE_Value_IsNull(defaultPropValue)) {
-                dSum += HValueToDouble(hThis, defaultPropValue);
+                dSum += ValueToDouble(pThis, defaultPropValue);
                 uCount++;
               }
               FXJSE_Value_Release(defaultPropValue);
             }
           } else {
             CFX_ByteString propertyStr;
             FXJSE_Value_ToUTF8String(propertyValue, propertyStr);
-            FXJSE_HVALUE newPropertyValue = FXJSE_Value_Create(pIsolate);
+            CFXJSE_Value* newPropertyValue = FXJSE_Value_Create(pIsolate);
             for (int32_t j = 2; j < iLength; j++) {
               FXJSE_Value_GetObjectPropByIdx(argValue, j, jsObjectValue);
               FXJSE_Value_GetObjectProp(jsObjectValue, propertyStr.AsStringC(),
                                         newPropertyValue);
               if (!FXJSE_Value_IsNull(newPropertyValue)) {
-                dSum += HValueToDouble(hThis, newPropertyValue);
+                dSum += ValueToDouble(pThis, newPropertyValue);
                 uCount++;
               }
             }
             FXJSE_Value_Release(newPropertyValue);
           }
           FXJSE_Value_Release(jsObjectValue);
           FXJSE_Value_Release(propertyValue);
         }
       } else {
-        dSum += HValueToDouble(hThis, argValue);
+        dSum += ValueToDouble(pThis, argValue);
         uCount++;
       }
       FXJSE_Value_Release(argValue);
     }
-    argValue = 0;
+    argValue = nullptr;
   }
   if (0 == uCount) {
     FXJSE_Value_SetNull(args.GetReturnValue());
   } else {
     FXJSE_Value_SetDouble(args.GetReturnValue(), dSum / uCount);
   }
 }
-void CXFA_FM2JSContext::Ceil(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::Ceil(CFXJSE_Value* pThis,
                              const CFX_ByteStringC& szFuncName,
                              CFXJSE_Arguments& args) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   if (args.GetLength() == 1) {
-    FXJSE_HVALUE argValue = GetSimpleHValue(hThis, args, 0);
-    if (HValueIsNull(hThis, argValue)) {
+    CFXJSE_Value* argValue = GetSimpleValue(pThis, args, 0);
+    if (ValueIsNull(pThis, argValue)) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
       FXJSE_Value_SetFloat(args.GetReturnValue(),
-                           FXSYS_ceil(HValueToFloat(hThis, argValue)));
+                           FXSYS_ceil(ValueToFloat(pThis, argValue)));
     }
     FXJSE_Value_Release(argValue);
   } else {
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"Ceil");
   }
 }
-void CXFA_FM2JSContext::Count(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::Count(CFXJSE_Value* pThis,
                               const CFX_ByteStringC& szFuncName,
                               CFXJSE_Arguments& args) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   v8::Isolate* pIsolate = pContext->GetScriptRuntime();
   int32_t argc = args.GetLength();
   uint32_t uCount = 0;
-  FXJSE_HVALUE argValue = 0;
+  CFXJSE_Value* argValue = nullptr;
   for (int32_t i = 0; i < argc; i++) {
     argValue = args.GetValue(i);
     if (FXJSE_Value_IsNull(argValue)) {
       FXJSE_Value_Release(argValue);
       continue;
     } else if (FXJSE_Value_IsArray(argValue)) {
-      FXJSE_HVALUE lengthValue = FXJSE_Value_Create(pIsolate);
+      CFXJSE_Value* lengthValue = FXJSE_Value_Create(pIsolate);
       FXJSE_Value_GetObjectProp(argValue, "length", lengthValue);
       int32_t iLength = FXJSE_Value_ToInteger(lengthValue);
       FXJSE_Value_Release(lengthValue);
       if (iLength > 2) {
-        FXJSE_HVALUE propertyValue = FXJSE_Value_Create(pIsolate);
-        FXJSE_HVALUE jsObjectValue = FXJSE_Value_Create(pIsolate);
-        FXJSE_HVALUE newPropertyValue = FXJSE_Value_Create(pIsolate);
+        CFXJSE_Value* propertyValue = FXJSE_Value_Create(pIsolate);
+        CFXJSE_Value* jsObjectValue = FXJSE_Value_Create(pIsolate);
+        CFXJSE_Value* newPropertyValue = FXJSE_Value_Create(pIsolate);
         FXJSE_Value_GetObjectPropByIdx(argValue, 1, propertyValue);
         FXJSE_Value_GetObjectPropByIdx(argValue, 2, jsObjectValue);
         if (FXJSE_Value_IsNull(propertyValue)) {
           for (int32_t i = 2; i < iLength; i++) {
             FXJSE_Value_GetObjectPropByIdx(argValue, i, jsObjectValue);
             GetObjectDefaultValue(jsObjectValue, newPropertyValue);
             if (!FXJSE_Value_IsNull(newPropertyValue)) {
               uCount++;
             }
           }
         } else {
           CFX_ByteString propertyStr;
           FXJSE_Value_ToUTF8String(propertyValue, propertyStr);
           for (int32_t i = 2; i < iLength; i++) {
             FXJSE_Value_GetObjectPropByIdx(argValue, i, jsObjectValue);
             FXJSE_Value_GetObjectProp(jsObjectValue, propertyStr.AsStringC(),
                                       newPropertyValue);
             uCount += (FXJSE_Value_IsNull(newPropertyValue) ? 0 : 1);
           }
         }
         FXJSE_Value_Release(propertyValue);
         FXJSE_Value_Release(jsObjectValue);
         FXJSE_Value_Release(newPropertyValue);
       } else {
         pContext->ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
       }
     } else if (FXJSE_Value_IsObject(argValue)) {
-      FXJSE_HVALUE newPropertyValue = FXJSE_Value_Create(pIsolate);
+      CFXJSE_Value* newPropertyValue = FXJSE_Value_Create(pIsolate);
       GetObjectDefaultValue(argValue, newPropertyValue);
       if (!FXJSE_Value_IsNull(newPropertyValue)) {
         uCount++;
       }
       FXJSE_Value_Release(newPropertyValue);
     } else {
       uCount++;
     }
     FXJSE_Value_Release(argValue);
   }
-  argValue = 0;
+  argValue = nullptr;
   FXJSE_Value_SetInteger(args.GetReturnValue(), (int32_t)uCount);
 }
-void CXFA_FM2JSContext::Floor(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::Floor(CFXJSE_Value* pThis,
                               const CFX_ByteStringC& szFuncName,
                               CFXJSE_Arguments& args) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   if (args.GetLength() == 1) {
-    FXJSE_HVALUE argValue = GetSimpleHValue(hThis, args, 0);
-    if (HValueIsNull(hThis, argValue)) {
+    CFXJSE_Value* argValue = GetSimpleValue(pThis, args, 0);
+    if (ValueIsNull(pThis, argValue)) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
       FXJSE_Value_SetFloat(args.GetReturnValue(),
-                           FXSYS_floor(HValueToFloat(hThis, argValue)));
+                           FXSYS_floor(ValueToFloat(pThis, argValue)));
     }
     FXJSE_Value_Release(argValue);
   } else {
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"Floor");
   }
 }
-void CXFA_FM2JSContext::Max(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::Max(CFXJSE_Value* pThis,
                             const CFX_ByteStringC& szFuncName,
                             CFXJSE_Arguments& args) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   v8::Isolate* pIsolate = pContext->GetScriptRuntime();
   int32_t argc = args.GetLength();
   uint32_t uCount = 0;
   FX_DOUBLE dMaxValue = 0.0;
-  FXJSE_HVALUE argValue = 0;
+  CFXJSE_Value* argValue = nullptr;
   for (int32_t i = 0; i < argc; i++) {
     argValue = args.GetValue(i);
     if (FXJSE_Value_IsNull(argValue)) {
       FXJSE_Value_Release(argValue);
       continue;
     } else if (FXJSE_Value_IsArray(argValue)) {
-      FXJSE_HVALUE lengthValue = FXJSE_Value_Create(pIsolate);
+      CFXJSE_Value* lengthValue = FXJSE_Value_Create(pIsolate);
       FXJSE_Value_GetObjectProp(argValue, "length", lengthValue);
       int32_t iLength = FXJSE_Value_ToInteger(lengthValue);
       FXJSE_Value_Release(lengthValue);
       if (iLength > 2) {
-        FXJSE_HVALUE propertyValue = FXJSE_Value_Create(pIsolate);
-        FXJSE_HVALUE jsObjectValue = FXJSE_Value_Create(pIsolate);
-        FXJSE_HVALUE newPropertyValue = FXJSE_Value_Create(pIsolate);
+        CFXJSE_Value* propertyValue = FXJSE_Value_Create(pIsolate);
+        CFXJSE_Value* jsObjectValue = FXJSE_Value_Create(pIsolate);
+        CFXJSE_Value* newPropertyValue = FXJSE_Value_Create(pIsolate);
         FXJSE_Value_GetObjectPropByIdx(argValue, 1, propertyValue);
         FXJSE_Value_GetObjectPropByIdx(argValue, 2, jsObjectValue);
         if (FXJSE_Value_IsNull(propertyValue)) {
           for (int32_t i = 2; i < iLength; i++) {
             FXJSE_Value_GetObjectPropByIdx(argValue, i, jsObjectValue);
             GetObjectDefaultValue(jsObjectValue, newPropertyValue);
             if (!FXJSE_Value_IsNull(newPropertyValue)) {
               uCount++;
               if (uCount == 1) {
-                dMaxValue = HValueToDouble(hThis, newPropertyValue);
+                dMaxValue = ValueToDouble(pThis, newPropertyValue);
               } else {
-                FX_DOUBLE dValue = HValueToDouble(hThis, newPropertyValue);
+                FX_DOUBLE dValue = ValueToDouble(pThis, newPropertyValue);
                 if (dMaxValue < dValue) {
                   dMaxValue = dValue;
                 }
               }
             }
           }
         } else {
           CFX_ByteString propertyStr;
           FXJSE_Value_ToUTF8String(propertyValue, propertyStr);
           for (int32_t i = 2; i < iLength; i++) {
             FXJSE_Value_GetObjectPropByIdx(argValue, i, jsObjectValue);
             FXJSE_Value_GetObjectProp(jsObjectValue, propertyStr.AsStringC(),
                                       newPropertyValue);
             if (!FXJSE_Value_IsNull(newPropertyValue)) {
               uCount++;
               if (uCount == 1) {
-                dMaxValue = HValueToDouble(hThis, newPropertyValue);
+                dMaxValue = ValueToDouble(pThis, newPropertyValue);
               } else {
-                FX_DOUBLE dValue = HValueToDouble(hThis, newPropertyValue);
+                FX_DOUBLE dValue = ValueToDouble(pThis, newPropertyValue);
                 if (dMaxValue < dValue) {
                   dMaxValue = dValue;
                 }
               }
             }
           }
         }
         FXJSE_Value_Release(propertyValue);
         FXJSE_Value_Release(jsObjectValue);
         FXJSE_Value_Release(newPropertyValue);
       } else {
         pContext->ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
       }
     } else if (FXJSE_Value_IsObject(argValue)) {
-      FXJSE_HVALUE newPropertyValue = FXJSE_Value_Create(pIsolate);
+      CFXJSE_Value* newPropertyValue = FXJSE_Value_Create(pIsolate);
       GetObjectDefaultValue(argValue, newPropertyValue);
       if (!FXJSE_Value_IsNull(newPropertyValue)) {
         uCount++;
         if (uCount == 1) {
-          dMaxValue = HValueToDouble(hThis, newPropertyValue);
+          dMaxValue = ValueToDouble(pThis, newPropertyValue);
         } else {
-          FX_DOUBLE dValue = HValueToDouble(hThis, newPropertyValue);
+          FX_DOUBLE dValue = ValueToDouble(pThis, newPropertyValue);
           if (dMaxValue < dValue) {
             dMaxValue = dValue;
           }
         }
       }
       FXJSE_Value_Release(newPropertyValue);
     } else {
       uCount++;
       if (uCount == 1) {
-        dMaxValue = HValueToDouble(hThis, argValue);
+        dMaxValue = ValueToDouble(pThis, argValue);
       } else {
-        FX_DOUBLE dValue = HValueToDouble(hThis, argValue);
+        FX_DOUBLE dValue = ValueToDouble(pThis, argValue);
         if (dMaxValue < dValue) {
           dMaxValue = dValue;
         }
       }
     }
     FXJSE_Value_Release(argValue);
   }
-  argValue = 0;
+  argValue = nullptr;
   if (uCount) {
     FXJSE_Value_SetDouble(args.GetReturnValue(), dMaxValue);
   } else {
     FXJSE_Value_SetNull(args.GetReturnValue());
   }
 }
-void CXFA_FM2JSContext::Min(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::Min(CFXJSE_Value* pThis,
                             const CFX_ByteStringC& szFuncName,
                             CFXJSE_Arguments& args) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   v8::Isolate* pIsolate = pContext->GetScriptRuntime();
   int32_t argc = args.GetLength();
   uint32_t uCount = 0;
   FX_DOUBLE dMinValue = 0.0;
-  FXJSE_HVALUE argValue = 0;
+  CFXJSE_Value* argValue = nullptr;
   for (int32_t i = 0; i < argc; i++) {
     argValue = args.GetValue(i);
     if (FXJSE_Value_IsNull(argValue)) {
       FXJSE_Value_Release(argValue);
       continue;
     } else if (FXJSE_Value_IsArray(argValue)) {
-      FXJSE_HVALUE lengthValue = FXJSE_Value_Create(pIsolate);
+      CFXJSE_Value* lengthValue = FXJSE_Value_Create(pIsolate);
       FXJSE_Value_GetObjectProp(argValue, "length", lengthValue);
       int32_t iLength = FXJSE_Value_ToInteger(lengthValue);
       FXJSE_Value_Release(lengthValue);
       if (iLength > 2) {
-        FXJSE_HVALUE propertyValue = FXJSE_Value_Create(pIsolate);
-        FXJSE_HVALUE jsObjectValue = FXJSE_Value_Create(pIsolate);
-        FXJSE_HVALUE newPropertyValue = FXJSE_Value_Create(pIsolate);
+        CFXJSE_Value* propertyValue = FXJSE_Value_Create(pIsolate);
+        CFXJSE_Value* jsObjectValue = FXJSE_Value_Create(pIsolate);
+        CFXJSE_Value* newPropertyValue = FXJSE_Value_Create(pIsolate);
         FXJSE_Value_GetObjectPropByIdx(argValue, 1, propertyValue);
         FXJSE_Value_GetObjectPropByIdx(argValue, 2, jsObjectValue);
         if (FXJSE_Value_IsNull(propertyValue)) {
           for (int32_t i = 2; i < iLength; i++) {
             FXJSE_Value_GetObjectPropByIdx(argValue, i, jsObjectValue);
             GetObjectDefaultValue(jsObjectValue, newPropertyValue);
             if (!FXJSE_Value_IsNull(newPropertyValue)) {
               uCount++;
               if (uCount == 1) {
-                dMinValue = HValueToDouble(hThis, newPropertyValue);
+                dMinValue = ValueToDouble(pThis, newPropertyValue);
               } else {
-                FX_DOUBLE dValue = HValueToDouble(hThis, newPropertyValue);
+                FX_DOUBLE dValue = ValueToDouble(pThis, newPropertyValue);
                 if (dMinValue > dValue) {
                   dMinValue = dValue;
                 }
               }
             }
           }
         } else {
           CFX_ByteString propertyStr;
           FXJSE_Value_ToUTF8String(propertyValue, propertyStr);
           for (int32_t i = 2; i < iLength; i++) {
             FXJSE_Value_GetObjectPropByIdx(argValue, i, jsObjectValue);
             FXJSE_Value_GetObjectProp(jsObjectValue, propertyStr.AsStringC(),
                                       newPropertyValue);
             if (!FXJSE_Value_IsNull(newPropertyValue)) {
               uCount++;
               if (uCount == 1) {
-                dMinValue = HValueToDouble(hThis, newPropertyValue);
+                dMinValue = ValueToDouble(pThis, newPropertyValue);
               } else {
-                FX_DOUBLE dValue = HValueToDouble(hThis, newPropertyValue);
+                FX_DOUBLE dValue = ValueToDouble(pThis, newPropertyValue);
                 if (dMinValue > dValue) {
                   dMinValue = dValue;
                 }
               }
             }
           }
         }
         FXJSE_Value_Release(propertyValue);
         FXJSE_Value_Release(jsObjectValue);
         FXJSE_Value_Release(newPropertyValue);
       } else {
         pContext->ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
       }
     } else if (FXJSE_Value_IsObject(argValue)) {
-      FXJSE_HVALUE newPropertyValue = FXJSE_Value_Create(pIsolate);
+      CFXJSE_Value* newPropertyValue = FXJSE_Value_Create(pIsolate);
       GetObjectDefaultValue(argValue, newPropertyValue);
       if (!FXJSE_Value_IsNull(newPropertyValue)) {
         uCount++;
         if (uCount == 1) {
-          dMinValue = HValueToDouble(hThis, newPropertyValue);
+          dMinValue = ValueToDouble(pThis, newPropertyValue);
         } else {
-          FX_DOUBLE dValue = HValueToDouble(hThis, newPropertyValue);
+          FX_DOUBLE dValue = ValueToDouble(pThis, newPropertyValue);
           if (dMinValue > dValue) {
             dMinValue = dValue;
           }
         }
       }
       FXJSE_Value_Release(newPropertyValue);
     } else {
       uCount++;
       if (uCount == 1) {
-        dMinValue = HValueToDouble(hThis, argValue);
+        dMinValue = ValueToDouble(pThis, argValue);
       } else {
-        FX_DOUBLE dValue = HValueToDouble(hThis, argValue);
+        FX_DOUBLE dValue = ValueToDouble(pThis, argValue);
         if (dMinValue > dValue) {
           dMinValue = dValue;
         }
       }
     }
     FXJSE_Value_Release(argValue);
   }
-  argValue = 0;
+  argValue = nullptr;
   if (uCount) {
     FXJSE_Value_SetDouble(args.GetReturnValue(), dMinValue);
   } else {
     FXJSE_Value_SetNull(args.GetReturnValue());
   }
 }
-void CXFA_FM2JSContext::Mod(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::Mod(CFXJSE_Value* pThis,
                             const CFX_ByteStringC& szFuncName,
                             CFXJSE_Arguments& args) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   v8::Isolate* pIsolate = pContext->GetScriptRuntime();
   if (args.GetLength() == 2) {
-    FXJSE_HVALUE argOne = args.GetValue(0);
-    FXJSE_HVALUE argTwo = args.GetValue(1);
+    CFXJSE_Value* argOne = args.GetValue(0);
+    CFXJSE_Value* argTwo = args.GetValue(1);
     if (FXJSE_Value_IsNull(argOne) || FXJSE_Value_IsNull(argTwo)) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
       FX_DOUBLE dDividend = 0.0;
       FX_DOUBLE dDividor = 0.0;
       if (FXJSE_Value_IsArray(argOne)) {
-        FXJSE_HVALUE lengthValue = FXJSE_Value_Create(pIsolate);
+        CFXJSE_Value* lengthValue = FXJSE_Value_Create(pIsolate);
         FXJSE_Value_GetObjectProp(argOne, "length", lengthValue);
         int32_t iLength = FXJSE_Value_ToInteger(lengthValue);
         FXJSE_Value_Release(lengthValue);
         if (iLength > 2) {
-          FXJSE_HVALUE propertyValue = FXJSE_Value_Create(pIsolate);
-          FXJSE_HVALUE jsObjectValue = FXJSE_Value_Create(pIsolate);
+          CFXJSE_Value* propertyValue = FXJSE_Value_Create(pIsolate);
+          CFXJSE_Value* jsObjectValue = FXJSE_Value_Create(pIsolate);
           FXJSE_Value_GetObjectPropByIdx(argOne, 1, propertyValue);
           FXJSE_Value_GetObjectPropByIdx(argOne, 2, jsObjectValue);
           if (FXJSE_Value_IsNull(propertyValue)) {
-            dDividend = HValueToDouble(hThis, jsObjectValue);
+            dDividend = ValueToDouble(pThis, jsObjectValue);
           } else {
             CFX_ByteString propertyStr;
             FXJSE_Value_ToUTF8String(propertyValue, propertyStr);
-            FXJSE_HVALUE newPropertyValue = FXJSE_Value_Create(pIsolate);
+            CFXJSE_Value* newPropertyValue = FXJSE_Value_Create(pIsolate);
             FXJSE_Value_GetObjectProp(jsObjectValue, propertyStr.AsStringC(),
                                       newPropertyValue);
-            dDividend = HValueToDouble(hThis, newPropertyValue);
+            dDividend = ValueToDouble(pThis, newPropertyValue);
             FXJSE_Value_Release(newPropertyValue);
           }
           FXJSE_Value_Release(propertyValue);
           FXJSE_Value_Release(jsObjectValue);
         } else {
           pContext->ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
         }
       } else {
-        dDividend = HValueToDouble(hThis, argOne);
+        dDividend = ValueToDouble(pThis, argOne);
       }
       if (FXJSE_Value_IsArray(argTwo)) {
-        FXJSE_HVALUE lengthValue = FXJSE_Value_Create(pIsolate);
+        CFXJSE_Value* lengthValue = FXJSE_Value_Create(pIsolate);
         FXJSE_Value_GetObjectProp(argTwo, "length", lengthValue);
         int32_t iLength = FXJSE_Value_ToInteger(lengthValue);
         FXJSE_Value_Release(lengthValue);
         if (iLength > 2) {
-          FXJSE_HVALUE propertyValue = FXJSE_Value_Create(pIsolate);
-          FXJSE_HVALUE jsObjectValue = FXJSE_Value_Create(pIsolate);
+          CFXJSE_Value* propertyValue = FXJSE_Value_Create(pIsolate);
+          CFXJSE_Value* jsObjectValue = FXJSE_Value_Create(pIsolate);
           FXJSE_Value_GetObjectPropByIdx(argTwo, 1, propertyValue);
           FXJSE_Value_GetObjectPropByIdx(argTwo, 2, jsObjectValue);
           if (FXJSE_Value_IsNull(propertyValue)) {
-            dDividor = HValueToDouble(hThis, jsObjectValue);
+            dDividor = ValueToDouble(pThis, jsObjectValue);
           } else {
             CFX_ByteString propertyStr;
             FXJSE_Value_ToUTF8String(propertyValue, propertyStr);
-            FXJSE_HVALUE newPropertyValue = FXJSE_Value_Create(pIsolate);
+            CFXJSE_Value* newPropertyValue = FXJSE_Value_Create(pIsolate);
             FXJSE_Value_GetObjectProp(jsObjectValue, propertyStr.AsStringC(),
                                       newPropertyValue);
-            dDividor = HValueToDouble(hThis, newPropertyValue);
+            dDividor = ValueToDouble(pThis, newPropertyValue);
             FXJSE_Value_Release(newPropertyValue);
           }
           FXJSE_Value_Release(propertyValue);
           FXJSE_Value_Release(jsObjectValue);
         } else {
           pContext->ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
         }
       } else {
-        dDividor = HValueToDouble(hThis, argTwo);
+        dDividor = ValueToDouble(pThis, argTwo);
       }
       if (dDividor) {
         FXJSE_Value_SetDouble(
             args.GetReturnValue(),
             dDividend - dDividor * (int32_t)(dDividend / dDividor));
       } else {
         pContext->ThrowScriptErrorMessage(XFA_IDS_DIVIDE_ZERO);
       }
     }
     FXJSE_Value_Release(argOne);
     FXJSE_Value_Release(argTwo);
   } else {
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"Mod");
   }
 }
-void CXFA_FM2JSContext::Round(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::Round(CFXJSE_Value* pThis,
                               const CFX_ByteStringC& szFuncName,
                               CFXJSE_Arguments& args) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   v8::Isolate* pIsolate = pContext->GetScriptRuntime();
   int32_t argc = args.GetLength();
   uint8_t uPrecision = 0;
   if (argc == 1) {
-    FXJSE_HVALUE argOne = args.GetValue(0);
+    CFXJSE_Value* argOne = args.GetValue(0);
     if (FXJSE_Value_IsNull(argOne)) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
       FX_DOUBLE dValue = 0.0;
       if (FXJSE_Value_IsArray(argOne)) {
-        FXJSE_HVALUE propertyValue = FXJSE_Value_Create(pIsolate);
-        FXJSE_HVALUE jsObjectValue = FXJSE_Value_Create(pIsolate);
+        CFXJSE_Value* propertyValue = FXJSE_Value_Create(pIsolate);
+        CFXJSE_Value* jsObjectValue = FXJSE_Value_Create(pIsolate);
         FXJSE_Value_GetObjectPropByIdx(argOne, 1, propertyValue);
         FXJSE_Value_GetObjectPropByIdx(argOne, 2, jsObjectValue);
         if (FXJSE_Value_IsNull(propertyValue)) {
-          dValue = HValueToDouble(hThis, jsObjectValue);
+          dValue = ValueToDouble(pThis, jsObjectValue);
         } else {
           CFX_ByteString propertyStr;
           FXJSE_Value_ToUTF8String(propertyValue, propertyStr);
-          FXJSE_HVALUE newPropertyValue = FXJSE_Value_Create(pIsolate);
+          CFXJSE_Value* newPropertyValue = FXJSE_Value_Create(pIsolate);
           FXJSE_Value_GetObjectProp(jsObjectValue, propertyStr.AsStringC(),
                                     newPropertyValue);
-          dValue = HValueToDouble(hThis, newPropertyValue);
+          dValue = ValueToDouble(pThis, newPropertyValue);
           FXJSE_Value_Release(newPropertyValue);
         }
         FXJSE_Value_Release(propertyValue);
         FXJSE_Value_Release(jsObjectValue);
       } else {
-        dValue = HValueToDouble(hThis, argOne);
+        dValue = ValueToDouble(pThis, argOne);
       }
       CFX_Decimal decimalValue((FX_FLOAT)dValue, uPrecision);
       CFX_WideString wsValue = decimalValue;
       FXJSE_Value_SetUTF8String(args.GetReturnValue(),
                                 wsValue.UTF8Encode().AsStringC());
     }
     FXJSE_Value_Release(argOne);
   } else if (argc == 2) {
-    FXJSE_HVALUE argOne = args.GetValue(0);
-    FXJSE_HVALUE argTwo = args.GetValue(1);
+    CFXJSE_Value* argOne = args.GetValue(0);
+    CFXJSE_Value* argTwo = args.GetValue(1);
     if (FXJSE_Value_IsNull(argOne) || FXJSE_Value_IsNull(argTwo)) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
       FX_DOUBLE dValue = 0.0;
       if (FXJSE_Value_IsArray(argOne)) {
-        FXJSE_HVALUE propertyValue = FXJSE_Value_Create(pIsolate);
-        FXJSE_HVALUE jsObjectValue = FXJSE_Value_Create(pIsolate);
+        CFXJSE_Value* propertyValue = FXJSE_Value_Create(pIsolate);
+        CFXJSE_Value* jsObjectValue = FXJSE_Value_Create(pIsolate);
         FXJSE_Value_GetObjectPropByIdx(argOne, 1, propertyValue);
         FXJSE_Value_GetObjectPropByIdx(argOne, 2, jsObjectValue);
         if (FXJSE_Value_IsNull(propertyValue)) {
-          dValue = HValueToDouble(hThis, jsObjectValue);
+          dValue = ValueToDouble(pThis, jsObjectValue);
         } else {
           CFX_ByteString propertyStr;
           FXJSE_Value_ToUTF8String(propertyValue, propertyStr);
-          FXJSE_HVALUE newPropertyValue = FXJSE_Value_Create(pIsolate);
+          CFXJSE_Value* newPropertyValue = FXJSE_Value_Create(pIsolate);
           FXJSE_Value_GetObjectProp(jsObjectValue, propertyStr.AsStringC(),
                                     newPropertyValue);
-          dValue = HValueToDouble(hThis, newPropertyValue);
+          dValue = ValueToDouble(pThis, newPropertyValue);
           FXJSE_Value_Release(newPropertyValue);
         }
         FXJSE_Value_Release(propertyValue);
         FXJSE_Value_Release(jsObjectValue);
       } else {
-        dValue = HValueToDouble(hThis, argOne);
+        dValue = ValueToDouble(pThis, argOne);
       }
       FX_DOUBLE dPrecision = 0.0;
       if (FXJSE_Value_IsArray(argTwo)) {
-        FXJSE_HVALUE propertyValue = FXJSE_Value_Create(pIsolate);
-        FXJSE_HVALUE jsObjectValue = FXJSE_Value_Create(pIsolate);
+        CFXJSE_Value* propertyValue = FXJSE_Value_Create(pIsolate);
+        CFXJSE_Value* jsObjectValue = FXJSE_Value_Create(pIsolate);
         FXJSE_Value_GetObjectPropByIdx(argTwo, 1, propertyValue);
         FXJSE_Value_GetObjectPropByIdx(argTwo, 2, jsObjectValue);
         if (FXJSE_Value_IsNull(propertyValue)) {
-          dPrecision = HValueToDouble(hThis, jsObjectValue);
+          dPrecision = ValueToDouble(pThis, jsObjectValue);
         } else {
           CFX_ByteString propertyStr;
           FXJSE_Value_ToUTF8String(propertyValue, propertyStr);
-          FXJSE_HVALUE newPropertyValue = FXJSE_Value_Create(pIsolate);
+          CFXJSE_Value* newPropertyValue = FXJSE_Value_Create(pIsolate);
           FXJSE_Value_GetObjectProp(jsObjectValue, propertyStr.AsStringC(),
                                     newPropertyValue);
-          dPrecision = HValueToDouble(hThis, newPropertyValue);
+          dPrecision = ValueToDouble(pThis, newPropertyValue);
           FXJSE_Value_Release(newPropertyValue);
         }
         FXJSE_Value_Release(propertyValue);
         FXJSE_Value_Release(jsObjectValue);
       } else {
-        dPrecision = HValueToDouble(hThis, argTwo);
+        dPrecision = ValueToDouble(pThis, argTwo);
       }
       if (dPrecision < 0) {
         uPrecision = 0;
       } else if (dPrecision > 12.0) {
         uPrecision = 12;
       } else {
         uPrecision = (uint8_t)dPrecision;
       }
       CFX_Decimal decimalValue((FX_FLOAT)dValue, uPrecision);
       CFX_WideString wsValue = decimalValue;
       FXJSE_Value_SetUTF8String(args.GetReturnValue(),
                                 wsValue.UTF8Encode().AsStringC());
     }
     FXJSE_Value_Release(argOne);
     FXJSE_Value_Release(argTwo);
   } else {
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"Round");
   }
 }
-void CXFA_FM2JSContext::Sum(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::Sum(CFXJSE_Value* pThis,
                             const CFX_ByteStringC& szFuncName,
                             CFXJSE_Arguments& args) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   v8::Isolate* pIsolate = pContext->GetScriptRuntime();
   int32_t argc = args.GetLength();
   uint32_t uCount = 0;
   FX_DOUBLE dSum = 0.0;
   if (argc) {
-    FXJSE_HVALUE argValue = 0;
+    CFXJSE_Value* argValue = nullptr;
     for (int32_t i = 0; i < argc; i++) {
       argValue = args.GetValue(i);
       if (FXJSE_Value_IsNull(argValue)) {
         FXJSE_Value_Release(argValue);
         continue;
       } else if (FXJSE_Value_IsArray(argValue)) {
-        FXJSE_HVALUE lengthValue = FXJSE_Value_Create(pIsolate);
+        CFXJSE_Value* lengthValue = FXJSE_Value_Create(pIsolate);
         FXJSE_Value_GetObjectProp(argValue, "length", lengthValue);
         int32_t iLength = FXJSE_Value_ToInteger(lengthValue);
         FXJSE_Value_Release(lengthValue);
         if (iLength > 2) {
-          FXJSE_HVALUE propertyValue = FXJSE_Value_Create(pIsolate);
+          CFXJSE_Value* propertyValue = FXJSE_Value_Create(pIsolate);
           FXJSE_Value_GetObjectPropByIdx(argValue, 1, propertyValue);
-          FXJSE_HVALUE jsObjectValue = FXJSE_Value_Create(pIsolate);
-          FXJSE_HVALUE newPropertyValue = FXJSE_Value_Create(pIsolate);
+          CFXJSE_Value* jsObjectValue = FXJSE_Value_Create(pIsolate);
+          CFXJSE_Value* newPropertyValue = FXJSE_Value_Create(pIsolate);
           if (FXJSE_Value_IsNull(propertyValue)) {
             for (int32_t j = 2; j < iLength; j++) {
               FXJSE_Value_GetObjectPropByIdx(argValue, j, jsObjectValue);
               GetObjectDefaultValue(jsObjectValue, newPropertyValue);
               if (!FXJSE_Value_IsNull(newPropertyValue)) {
-                dSum += HValueToDouble(hThis, jsObjectValue);
+                dSum += ValueToDouble(pThis, jsObjectValue);
                 uCount++;
               }
             }
           } else {
             CFX_ByteString propertyStr;
             FXJSE_Value_ToUTF8String(propertyValue, propertyStr);
             for (int32_t j = 2; j < iLength; j++) {
               FXJSE_Value_GetObjectPropByIdx(argValue, j, jsObjectValue);
               FXJSE_Value_GetObjectProp(jsObjectValue, propertyStr.AsStringC(),
                                         newPropertyValue);
               if (!FXJSE_Value_IsNull(newPropertyValue)) {
-                dSum += HValueToDouble(hThis, newPropertyValue);
+                dSum += ValueToDouble(pThis, newPropertyValue);
                 uCount++;
               }
             }
           }
           FXJSE_Value_Release(newPropertyValue);
           FXJSE_Value_Release(jsObjectValue);
           FXJSE_Value_Release(propertyValue);
         } else {
           pContext->ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
         }
       } else if (FXJSE_Value_IsObject(argValue)) {
-        FXJSE_HVALUE newPropertyValue = FXJSE_Value_Create(pIsolate);
+        CFXJSE_Value* newPropertyValue = FXJSE_Value_Create(pIsolate);
         GetObjectDefaultValue(argValue, newPropertyValue);
         if (!FXJSE_Value_IsNull(newPropertyValue)) {
-          dSum += HValueToDouble(hThis, argValue);
+          dSum += ValueToDouble(pThis, argValue);
           uCount++;
         }
         FXJSE_Value_Release(newPropertyValue);
       } else {
-        dSum += HValueToDouble(hThis, argValue);
+        dSum += ValueToDouble(pThis, argValue);
         uCount++;
       }
       FXJSE_Value_Release(argValue);
     }
-    argValue = 0;
+    argValue = nullptr;
   }
   if (uCount < 1) {
     FXJSE_Value_SetNull(args.GetReturnValue());
   } else {
     FXJSE_Value_SetDouble(args.GetReturnValue(), dSum);
   }
 }
-void CXFA_FM2JSContext::Date(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::Date(CFXJSE_Value* pThis,
                              const CFX_ByteStringC& szFuncName,
                              CFXJSE_Arguments& args) {
   if (args.GetLength() == 0) {
     struct tm* pTmStruct = 0;
     time_t currentTime;
     time(&currentTime);
     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;
     int32_t dDays = DateString2Num(bufferCurrent.AsStringC());
     FXJSE_Value_SetInteger(args.GetReturnValue(), dDays);
   } else {
     CXFA_FM2JSContext* pContext =
-        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"Date");
   }
 }
-void CXFA_FM2JSContext::Date2Num(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::Date2Num(CFXJSE_Value* pThis,
                                  const CFX_ByteStringC& szFuncName,
                                  CFXJSE_Arguments& args) {
   int32_t argc = args.GetLength();
   if ((argc > 0) && (argc < 4)) {
     FX_BOOL bFlags = FALSE;
     CFX_ByteString dateString;
     CFX_ByteString formatString;
     CFX_ByteString localString;
-    FXJSE_HVALUE dateValue = GetSimpleHValue(hThis, args, 0);
-    FXJSE_HVALUE formatValue = 0;
-    FXJSE_HVALUE localValue = 0;
-    if (HValueIsNull(hThis, dateValue)) {
+    CFXJSE_Value* dateValue = GetSimpleValue(pThis, args, 0);
+    CFXJSE_Value* formatValue = nullptr;
+    CFXJSE_Value* localValue = nullptr;
+    if (ValueIsNull(pThis, dateValue)) {
       bFlags = TRUE;
     } else {
-      HValueToUTF8String(dateValue, dateString);
+      ValueToUTF8String(dateValue, dateString);
     }
     if (argc > 1) {
-      formatValue = GetSimpleHValue(hThis, args, 1);
-      if (HValueIsNull(hThis, formatValue)) {
+      formatValue = GetSimpleValue(pThis, args, 1);
+      if (ValueIsNull(pThis, formatValue)) {
         bFlags = TRUE;
       } else {
-        HValueToUTF8String(formatValue, formatString);
+        ValueToUTF8String(formatValue, formatString);
       }
     }
     if (argc == 3) {
-      localValue = GetSimpleHValue(hThis, args, 2);
-      if (HValueIsNull(hThis, localValue)) {
+      localValue = GetSimpleValue(pThis, args, 2);
+      if (ValueIsNull(pThis, localValue)) {
         bFlags = TRUE;
       } else {
-        HValueToUTF8String(localValue, localString);
+        ValueToUTF8String(localValue, localString);
       }
     }
     if (!bFlags) {
       CFX_ByteString szIsoDateString;
       FX_BOOL bRet =
-          Local2IsoDate(hThis, dateString.AsStringC(), formatString.AsStringC(),
+          Local2IsoDate(pThis, dateString.AsStringC(), formatString.AsStringC(),
                         localString.AsStringC(), szIsoDateString);
       if (bRet) {
         FXJSE_Value_SetInteger(args.GetReturnValue(),
                                DateString2Num(szIsoDateString.AsStringC()));
       } else {
         FXJSE_Value_SetInteger(args.GetReturnValue(), 0);
       }
     } else {
       FXJSE_Value_SetNull(args.GetReturnValue());
     }
     FXJSE_Value_Release(dateValue);
     if (argc > 1) {
       FXJSE_Value_Release(formatValue);
       if (argc == 3) {
         FXJSE_Value_Release(localValue);
       }
     }
   } else {
     CXFA_FM2JSContext* pContext =
-        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"Date2Num");
   }
 }
-void CXFA_FM2JSContext::DateFmt(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::DateFmt(CFXJSE_Value* pThis,
                                 const CFX_ByteStringC& szFuncName,
                                 CFXJSE_Arguments& args) {
   int32_t argc = args.GetLength();
   if (argc < 3) {
     FX_BOOL bFlags = FALSE;
     int32_t iStyle = 0;
     CFX_ByteString szLocal;
-    FXJSE_HVALUE argStyle = 0;
-    FXJSE_HVALUE argLocal = 0;
+    CFXJSE_Value* argStyle = nullptr;
+    CFXJSE_Value* argLocal = nullptr;
     if (argc > 0) {
-      argStyle = GetSimpleHValue(hThis, args, 0);
+      argStyle = GetSimpleValue(pThis, args, 0);
       if (FXJSE_Value_IsNull(argStyle)) {
         bFlags = TRUE;
       }
-      iStyle = (int32_t)HValueToFloat(hThis, argStyle);
+      iStyle = (int32_t)ValueToFloat(pThis, argStyle);
       if (iStyle > 4 || iStyle < 0) {
         iStyle = 0;
       }
     }
     if (argc == 2) {
-      argLocal = GetSimpleHValue(hThis, args, 1);
+      argLocal = GetSimpleValue(pThis, args, 1);
       if (FXJSE_Value_IsNull(argLocal)) {
         bFlags = TRUE;
       } else {
-        HValueToUTF8String(argLocal, szLocal);
+        ValueToUTF8String(argLocal, szLocal);
       }
     }
     if (!bFlags) {
       CFX_ByteString formatStr;
-      GetStandardDateFormat(hThis, iStyle, szLocal.AsStringC(), formatStr);
+      GetStandardDateFormat(pThis, iStyle, szLocal.AsStringC(), formatStr);
       if (formatStr.IsEmpty()) {
         formatStr = "";
       }
       FXJSE_Value_SetUTF8String(args.GetReturnValue(), formatStr.AsStringC());
     } else {
       FXJSE_Value_SetNull(args.GetReturnValue());
     }
     if (argc > 0) {
       FXJSE_Value_Release(argStyle);
       if (argc == 2) {
         FXJSE_Value_Release(argLocal);
       }
     }
   } else {
     CXFA_FM2JSContext* pContext =
-        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"Date2Num");
   }
 }
-void CXFA_FM2JSContext::IsoDate2Num(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::IsoDate2Num(CFXJSE_Value* pThis,
                                     const CFX_ByteStringC& szFuncName,
                                     CFXJSE_Arguments& args) {
   if (args.GetLength() == 1) {
-    FXJSE_HVALUE argOne = GetSimpleHValue(hThis, args, 0);
+    CFXJSE_Value* argOne = GetSimpleValue(pThis, args, 0);
     if (FXJSE_Value_IsNull(argOne)) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
       CFX_ByteString szArgString;
-      HValueToUTF8String(argOne, szArgString);
+      ValueToUTF8String(argOne, szArgString);
       int32_t dDays = DateString2Num(szArgString.AsStringC());
       FXJSE_Value_SetInteger(args.GetReturnValue(), (int32_t)dDays);
     }
     FXJSE_Value_Release(argOne);
   } else {
     CXFA_FM2JSContext* pContext =
-        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"IsoDate2Num");
   }
 }
-void CXFA_FM2JSContext::IsoTime2Num(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::IsoTime2Num(CFXJSE_Value* pThis,
                                     const CFX_ByteStringC& szFuncName,
                                     CFXJSE_Arguments& args) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   if (args.GetLength() == 1) {
-    FXJSE_HVALUE argOne = GetSimpleHValue(hThis, args, 0);
-    if (HValueIsNull(hThis, argOne)) {
+    CFXJSE_Value* argOne = GetSimpleValue(pThis, args, 0);
+    if (ValueIsNull(pThis, argOne)) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
       CXFA_Document* pDoc = pContext->GetDocument();
       ASSERT(pDoc);
       IFX_LocaleMgr* pMgr = (IFX_LocaleMgr*)pDoc->GetLocalMgr();
       CFX_ByteString szArgString;
-      HValueToUTF8String(argOne, szArgString);
+      ValueToUTF8String(argOne, szArgString);
       szArgString = szArgString.Mid(szArgString.Find('T', 0) + 1);
       if (szArgString.IsEmpty()) {
         FXJSE_Value_SetInteger(args.GetReturnValue(), 0);
         FXJSE_Value_Release(argOne);
         return;
       }
       CXFA_LocaleValue timeValue(
           XFA_VT_TIME, CFX_WideString::FromUTF8(szArgString.AsStringC()),
           (CXFA_LocaleMgr*)pMgr);
       if (timeValue.IsValid()) {
@@ skipping 22 matching lines @@
       } else {
         FXJSE_Value_SetInteger(args.GetReturnValue(), 0);
       }
     }
     FXJSE_Value_Release(argOne);
   } else {
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"IsoTime2Num");
   }
 }
-void CXFA_FM2JSContext::LocalDateFmt(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::LocalDateFmt(CFXJSE_Value* pThis,
                                      const CFX_ByteStringC& szFuncName,
                                      CFXJSE_Arguments& args) {
   int32_t argc = args.GetLength();
   if (argc < 3) {
     FX_BOOL bFlags = FALSE;
     int32_t iStyle = 0;
     CFX_ByteString szLocal;
-    FXJSE_HVALUE argStyle = 0;
-    FXJSE_HVALUE argLocal = 0;
+    CFXJSE_Value* argStyle = nullptr;
+    CFXJSE_Value* argLocal = nullptr;
     if (argc > 0) {
-      argStyle = GetSimpleHValue(hThis, args, 0);
+      argStyle = GetSimpleValue(pThis, args, 0);
       if (FXJSE_Value_IsNull(argStyle)) {
         bFlags = TRUE;
       }
-      iStyle = (int32_t)HValueToFloat(hThis, argStyle);
+      iStyle = (int32_t)ValueToFloat(pThis, argStyle);
       if (iStyle > 4 || iStyle < 0) {
         iStyle = 0;
       }
     }
     if (argc == 2) {
-      argLocal = GetSimpleHValue(hThis, args, 1);
+      argLocal = GetSimpleValue(pThis, args, 1);
       if (FXJSE_Value_IsNull(argLocal)) {
         bFlags = TRUE;
       } else {
-        HValueToUTF8String(argLocal, szLocal);
+        ValueToUTF8String(argLocal, szLocal);
       }
     }
     if (!bFlags) {
       CFX_ByteString formatStr;
-      GetLocalDateFormat(hThis, iStyle, szLocal.AsStringC(), formatStr, FALSE);
+      GetLocalDateFormat(pThis, iStyle, szLocal.AsStringC(), formatStr, FALSE);
       if (formatStr.IsEmpty()) {
         formatStr = "";
       }
       FXJSE_Value_SetUTF8String(args.GetReturnValue(), formatStr.AsStringC());
     } else {
       FXJSE_Value_SetNull(args.GetReturnValue());
     }
     if (argc > 0) {
       FXJSE_Value_Release(argStyle);
       if (argc == 2) {
         FXJSE_Value_Release(argLocal);
       }
     }
   } else {
     CXFA_FM2JSContext* pContext =
-        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"LocalDateFmt");
   }
 }
-void CXFA_FM2JSContext::LocalTimeFmt(FXJSE_HOBJECT hThis,
+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;
     int32_t iStyle = 0;
     CFX_ByteString szLocal;
-    FXJSE_HVALUE argStyle = 0;
-    FXJSE_HVALUE argLocal = 0;
+    CFXJSE_Value* argStyle = nullptr;
+    CFXJSE_Value* argLocal = nullptr;
     if (argc > 0) {
-      argStyle = GetSimpleHValue(hThis, args, 0);
+      argStyle = GetSimpleValue(pThis, args, 0);
       if (FXJSE_Value_IsNull(argStyle)) {
         bFlags = TRUE;
       }
-      iStyle = (int32_t)HValueToFloat(hThis, argStyle);
+      iStyle = (int32_t)ValueToFloat(pThis, argStyle);
       if (iStyle > 4 || iStyle < 0) {
         iStyle = 0;
       }
     }
     if (argc == 2) {
-      argLocal = GetSimpleHValue(hThis, args, 1);
+      argLocal = GetSimpleValue(pThis, args, 1);
       if (FXJSE_Value_IsNull(argLocal)) {
         bFlags = TRUE;
       } else {
-        HValueToUTF8String(argLocal, szLocal);
+        ValueToUTF8String(argLocal, szLocal);
       }
     }
     if (!bFlags) {
       CFX_ByteString formatStr;
-      GetLocalTimeFormat(hThis, iStyle, szLocal.AsStringC(), formatStr, FALSE);
+      GetLocalTimeFormat(pThis, iStyle, szLocal.AsStringC(), formatStr, FALSE);
       if (formatStr.IsEmpty()) {
         formatStr = "";
       }
       FXJSE_Value_SetUTF8String(args.GetReturnValue(), formatStr.AsStringC());
     } else {
       FXJSE_Value_SetNull(args.GetReturnValue());
     }
     if (argc > 0) {
       FXJSE_Value_Release(argStyle);
       if (argc == 2) {
         FXJSE_Value_Release(argLocal);
       }
     }
   } else {
     CXFA_FM2JSContext* pContext =
-        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"LocalTimeFmt");
   }
 }
-void CXFA_FM2JSContext::Num2Date(FXJSE_HOBJECT hThis,
+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;
     int32_t dDate = 0;
     CFX_ByteString formatString;
     CFX_ByteString localString;
-    FXJSE_HVALUE dateValue = GetSimpleHValue(hThis, args, 0);
-    FXJSE_HVALUE formatValue = 0;
-    FXJSE_HVALUE localValue = 0;
-    if (HValueIsNull(hThis, dateValue)) {
+    CFXJSE_Value* dateValue = GetSimpleValue(pThis, args, 0);
+    CFXJSE_Value* formatValue = nullptr;
+    CFXJSE_Value* localValue = nullptr;
+    if (ValueIsNull(pThis, dateValue)) {
       bFlags = TRUE;
     } else {
-      dDate = (int32_t)HValueToFloat(hThis, dateValue);
+      dDate = (int32_t)ValueToFloat(pThis, dateValue);
       bFlags = dDate < 1;
     }
     if (argc > 1) {
-      formatValue = GetSimpleHValue(hThis, args, 1);
-      if (HValueIsNull(hThis, formatValue)) {
+      formatValue = GetSimpleValue(pThis, args, 1);
+      if (ValueIsNull(pThis, formatValue)) {
         bFlags = TRUE;
       } else {
-        HValueToUTF8String(formatValue, formatString);
+        ValueToUTF8String(formatValue, formatString);
       }
     }
     if (argc == 3) {
-      localValue = GetSimpleHValue(hThis, args, 2);
-      if (HValueIsNull(hThis, localValue)) {
+      localValue = GetSimpleValue(pThis, args, 2);
+      if (ValueIsNull(pThis, localValue)) {
         bFlags = TRUE;
       } else {
-        HValueToUTF8String(localValue, localString);
+        ValueToUTF8String(localValue, localString);
       }
     }
     if (!bFlags) {
       int32_t iYear = 1900;
       int32_t iMonth = 1;
       int32_t iDay = 1;
       int32_t i = 0;
       while (dDate > 0) {
         if (iMonth == 2) {
           if ((!((iYear + i) % 4) && ((iYear + i) % 100)) ||
@@ skipping 78 matching lines @@
             } else {
               iDay += static_cast<int32_t>(dDate) - 1;
               dDate = 0;
             }
           }
         }
       }
       CFX_ByteString szIsoDateString;
       szIsoDateString.Format("%d%02d%02d", iYear + i, iMonth, iDay);
       CFX_ByteString szLocalDateString;
-      IsoDate2Local(hThis, szIsoDateString.AsStringC(),
+      IsoDate2Local(pThis, szIsoDateString.AsStringC(),
                     formatString.AsStringC(), localString.AsStringC(),
                     szLocalDateString);
       if (szLocalDateString.IsEmpty()) {
         szLocalDateString = "";
       }
       FXJSE_Value_SetUTF8String(args.GetReturnValue(),
                                 szLocalDateString.AsStringC());
     } else {
       FXJSE_Value_SetNull(args.GetReturnValue());
     }
     FXJSE_Value_Release(dateValue);
     if (argc > 1) {
       FXJSE_Value_Release(formatValue);
       if (argc == 3) {
         FXJSE_Value_Release(localValue);
       }
     }
   } else {
     CXFA_FM2JSContext* pContext =
-        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"Num2Date");
   }
 }
-void CXFA_FM2JSContext::Num2GMTime(FXJSE_HOBJECT hThis,
+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;
     int32_t iTime = 0;
     CFX_ByteString formatString;
     CFX_ByteString localString;
-    FXJSE_HVALUE timeValue = GetSimpleHValue(hThis, args, 0);
-    FXJSE_HVALUE formatValue = 0;
-    FXJSE_HVALUE localValue = 0;
+    CFXJSE_Value* timeValue = GetSimpleValue(pThis, args, 0);
+    CFXJSE_Value* formatValue = nullptr;
+    CFXJSE_Value* localValue = nullptr;
     if (FXJSE_Value_IsNull(timeValue)) {
       bFlags = TRUE;
     } else {
-      iTime = (int32_t)HValueToFloat(hThis, timeValue);
+      iTime = (int32_t)ValueToFloat(pThis, timeValue);
       if (FXSYS_abs(iTime) < 1.0) {
         bFlags = TRUE;
       }
     }
     if (argc > 1) {
-      formatValue = GetSimpleHValue(hThis, args, 1);
+      formatValue = GetSimpleValue(pThis, args, 1);
       if (FXJSE_Value_IsNull(formatValue)) {
         bFlags = TRUE;
       } else {
-        HValueToUTF8String(formatValue, formatString);
+        ValueToUTF8String(formatValue, formatString);
       }
     }
     if (argc == 3) {
-      localValue = GetSimpleHValue(hThis, args, 2);
+      localValue = GetSimpleValue(pThis, args, 2);
       if (FXJSE_Value_IsNull(localValue)) {
         bFlags = TRUE;
       } else {
-        HValueToUTF8String(localValue, localString);
+        ValueToUTF8String(localValue, localString);
       }
     }
     if (!bFlags) {
       CFX_ByteString szGMTTimeString;
-      Num2AllTime(hThis, iTime, formatString.AsStringC(),
+      Num2AllTime(pThis, iTime, formatString.AsStringC(),
                   localString.AsStringC(), TRUE, szGMTTimeString);
       if (szGMTTimeString.IsEmpty()) {
         szGMTTimeString = "";
       }
       FXJSE_Value_SetUTF8String(args.GetReturnValue(),
                                 szGMTTimeString.AsStringC());
     } else {
       FXJSE_Value_SetNull(args.GetReturnValue());
     }
     FXJSE_Value_Release(timeValue);
     if (argc > 1) {
       FXJSE_Value_Release(formatValue);
       if (argc == 3) {
         FXJSE_Value_Release(localValue);
       }
     }
   } else {
     CXFA_FM2JSContext* pContext =
-        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"Num2GMTime");
   }
 }
-void CXFA_FM2JSContext::Num2Time(FXJSE_HOBJECT hThis,
+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;
     FX_FLOAT fTime = 0.0f;
     CFX_ByteString formatString;
     CFX_ByteString localString;
-    FXJSE_HVALUE timeValue = GetSimpleHValue(hThis, args, 0);
-    FXJSE_HVALUE formatValue = 0;
-    FXJSE_HVALUE localValue = 0;
+    CFXJSE_Value* timeValue = GetSimpleValue(pThis, args, 0);
+    CFXJSE_Value* formatValue = nullptr;
+    CFXJSE_Value* localValue = nullptr;
     if (FXJSE_Value_IsNull(timeValue)) {
       bFlags = TRUE;
     } else {
-      fTime = HValueToFloat(hThis, timeValue);
+      fTime = ValueToFloat(pThis, timeValue);
       if (FXSYS_fabs(fTime) < 1.0) {
         bFlags = TRUE;
       }
     }
     if (argc > 1) {
-      formatValue = GetSimpleHValue(hThis, args, 1);
+      formatValue = GetSimpleValue(pThis, args, 1);
       if (FXJSE_Value_IsNull(formatValue)) {
         bFlags = TRUE;
       } else {
-        HValueToUTF8String(formatValue, formatString);
+        ValueToUTF8String(formatValue, formatString);
       }
     }
     if (argc == 3) {
-      localValue = GetSimpleHValue(hThis, args, 2);
+      localValue = GetSimpleValue(pThis, args, 2);
       if (FXJSE_Value_IsNull(localValue)) {
         bFlags = TRUE;
       } else {
-        HValueToUTF8String(localValue, localString);
+        ValueToUTF8String(localValue, localString);
       }
     }
     if (!bFlags) {
       CFX_ByteString szLocalTimeString;
-      Num2AllTime(hThis, (int32_t)fTime, formatString.AsStringC(),
+      Num2AllTime(pThis, (int32_t)fTime, formatString.AsStringC(),
                   localString.AsStringC(), FALSE, szLocalTimeString);
       if (szLocalTimeString.IsEmpty()) {
         szLocalTimeString = "";
       }
       FXJSE_Value_SetUTF8String(args.GetReturnValue(),
                                 szLocalTimeString.AsStringC());
     } else {
       FXJSE_Value_SetNull(args.GetReturnValue());
     }
     FXJSE_Value_Release(timeValue);
     if (argc > 1) {
       FXJSE_Value_Release(formatValue);
       if (argc == 3) {
         FXJSE_Value_Release(localValue);
       }
     }
   } else {
     CXFA_FM2JSContext* pContext =
-        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"Num2Time");
   }
 }
-void CXFA_FM2JSContext::Time(FXJSE_HOBJECT hThis,
+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 {
     CXFA_FM2JSContext* pContext =
-        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"Time");
   }
 }
-void CXFA_FM2JSContext::Time2Num(FXJSE_HOBJECT hThis,
+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;
     CFX_ByteString timeString;
     CFX_ByteString formatString;
     CFX_ByteString localString;
-    FXJSE_HVALUE timeValue = GetSimpleHValue(hThis, args, 0);
-    FXJSE_HVALUE formatValue = 0;
-    FXJSE_HVALUE localValue = 0;
-    if (HValueIsNull(hThis, timeValue)) {
+    CFXJSE_Value* timeValue = GetSimpleValue(pThis, args, 0);
+    CFXJSE_Value* formatValue = nullptr;
+    CFXJSE_Value* localValue = nullptr;
+    if (ValueIsNull(pThis, timeValue)) {
       bFlags = TRUE;
     } else {
-      HValueToUTF8String(timeValue, timeString);
+      ValueToUTF8String(timeValue, timeString);
     }
     if (argc > 1) {
-      formatValue = GetSimpleHValue(hThis, args, 1);
-      if (HValueIsNull(hThis, formatValue)) {
+      formatValue = GetSimpleValue(pThis, args, 1);
+      if (ValueIsNull(pThis, formatValue)) {
         bFlags = TRUE;
       } else {
-        HValueToUTF8String(formatValue, formatString);
+        ValueToUTF8String(formatValue, formatString);
       }
     }
     if (argc == 3) {
-      localValue = GetSimpleHValue(hThis, args, 2);
-      if (HValueIsNull(hThis, localValue)) {
+      localValue = GetSimpleValue(pThis, args, 2);
+      if (ValueIsNull(pThis, localValue)) {
         bFlags = TRUE;
       } else {
-        HValueToUTF8String(localValue, localString);
+        ValueToUTF8String(localValue, localString);
       }
     }
     if (!bFlags) {
       CXFA_FM2JSContext* pContext =
-          (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+          (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
       CXFA_Document* pDoc = pContext->GetDocument();
       IFX_LocaleMgr* pMgr = (IFX_LocaleMgr*)pDoc->GetLocalMgr();
       IFX_Locale* pLocale = NULL;
       if (localString.IsEmpty()) {
         CXFA_Node* pThisNode =
             ToNode(pDoc->GetScriptContext()->GetThisObject());
         ASSERT(pThisNode);
         CXFA_WidgetData widgetData(pThisNode);
         pLocale = widgetData.GetLocal();
       } else {
@@ skipping 43 matching lines @@
     }
     FXJSE_Value_Release(timeValue);
     if (argc > 1) {
       FXJSE_Value_Release(formatValue);
       if (argc == 3) {
         FXJSE_Value_Release(localValue);
       }
     }
   } else {
     CXFA_FM2JSContext* pContext =
-        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"Time2Num");
   }
 }
-void CXFA_FM2JSContext::TimeFmt(FXJSE_HOBJECT hThis,
+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;
     int32_t iStyle = 0;
     CFX_ByteString szLocal;
-    FXJSE_HVALUE argStyle = 0;
-    FXJSE_HVALUE argLocal = 0;
+    CFXJSE_Value* argStyle = nullptr;
+    CFXJSE_Value* argLocal = nullptr;
     if (argc > 0) {
-      argStyle = GetSimpleHValue(hThis, args, 0);
+      argStyle = GetSimpleValue(pThis, args, 0);
       if (FXJSE_Value_IsNull(argStyle)) {
         bFlags = TRUE;
       }
-      iStyle = (int32_t)HValueToFloat(hThis, argStyle);
+      iStyle = (int32_t)ValueToFloat(pThis, argStyle);
       if (iStyle > 4 || iStyle < 0) {
         iStyle = 0;
       }
     }
     if (argc == 2) {
-      argLocal = GetSimpleHValue(hThis, args, 1);
+      argLocal = GetSimpleValue(pThis, args, 1);
       if (FXJSE_Value_IsNull(argLocal)) {
         bFlags = TRUE;
       } else {
-        HValueToUTF8String(argLocal, szLocal);
+        ValueToUTF8String(argLocal, szLocal);
       }
     }
     if (!bFlags) {
       CFX_ByteString formatStr;
-      GetStandardTimeFormat(hThis, iStyle, szLocal.AsStringC(), formatStr);
+      GetStandardTimeFormat(pThis, iStyle, szLocal.AsStringC(), formatStr);
       if (formatStr.IsEmpty()) {
         formatStr = "";
       }
       FXJSE_Value_SetUTF8String(args.GetReturnValue(), formatStr.AsStringC());
     } else {
       FXJSE_Value_SetNull(args.GetReturnValue());
     }
     if (argc > 0) {
       FXJSE_Value_Release(argStyle);
       if (argc == 2) {
         FXJSE_Value_Release(argLocal);
       }
     }
   } else {
     CXFA_FM2JSContext* pContext =
-        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"TimeFmt");
   }
 }
 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 303 matching lines @@
     return iRet;
   }
   iRet = IsIsoTimeFormat(pData + iIndex, iLength - iIndex, iHour, iMinute,
                          iSecond, iMillionSecond, iZoneHour, iZoneMinute);
   if (!iRet) {
     return iRet;
   }
   iRet = TRUE;
   return iRet;
 }
-FX_BOOL CXFA_FM2JSContext::Local2IsoDate(FXJSE_HOBJECT hThis,
+FX_BOOL CXFA_FM2JSContext::Local2IsoDate(CFXJSE_Value* pThis,
                                          const CFX_ByteStringC& szDate,
                                          const CFX_ByteStringC& szFormat,
                                          const CFX_ByteStringC& szLocale,
                                          CFX_ByteString& strIsoDate) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   CXFA_Document* pDoc = pContext->GetDocument();
   if (!pDoc) {
     return FALSE;
   }
   IFX_LocaleMgr* pMgr = (IFX_LocaleMgr*)pDoc->GetLocalMgr();
   IFX_Locale* pLocale = NULL;
   if (szLocale.IsEmpty()) {
     CXFA_Node* pThisNode = ToNode(pDoc->GetScriptContext()->GetThisObject());
     ASSERT(pThisNode);
     CXFA_WidgetData widgetData(pThisNode);
     pLocale = widgetData.GetLocal();
   } else {
     pLocale = pMgr->GetLocaleByName(CFX_WideString::FromUTF8(szLocale));
   }
   if (!pLocale) {
     return FALSE;
   }
   CFX_WideString wsFormat;
   if (szFormat.IsEmpty()) {
     pLocale->GetDatePattern(FX_LOCALEDATETIMESUBCATEGORY_Default, wsFormat);
   } else {
     wsFormat = CFX_WideString::FromUTF8(szFormat);
   }
   CXFA_LocaleValue widgetValue(XFA_VT_DATE, CFX_WideString::FromUTF8(szDate),
                                wsFormat, pLocale, (CXFA_LocaleMgr*)pMgr);
   CFX_Unitime dt = widgetValue.GetDate();
   strIsoDate.Format("%4d-%02d-%02d", dt.GetYear(), dt.GetMonth(), dt.GetDay());
   return TRUE;
 }
-FX_BOOL CXFA_FM2JSContext::Local2IsoTime(FXJSE_HOBJECT hThis,
+FX_BOOL CXFA_FM2JSContext::Local2IsoTime(CFXJSE_Value* pThis,
                                          const CFX_ByteStringC& szTime,
                                          const CFX_ByteStringC& szFormat,
                                          const CFX_ByteStringC& szLocale,
                                          CFX_ByteString& strIsoTime) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   CXFA_Document* pDoc = pContext->GetDocument();
   if (!pDoc) {
     return FALSE;
   }
   IFX_LocaleMgr* pMgr = (IFX_LocaleMgr*)pDoc->GetLocalMgr();
   IFX_Locale* pLocale = NULL;
   if (szLocale.IsEmpty()) {
     CXFA_Node* pThisNode = ToNode(pDoc->GetScriptContext()->GetThisObject());
     ASSERT(pThisNode);
     CXFA_WidgetData widgetData(pThisNode);
@@ skipping 12 matching lines @@
   }
   wsFormat = FX_WSTRC(L"time{") + wsFormat;
   wsFormat += FX_WSTRC(L"}");
   CXFA_LocaleValue widgetValue(XFA_VT_TIME, CFX_WideString::FromUTF8(szTime),
                                wsFormat, pLocale, (CXFA_LocaleMgr*)pMgr);
   CFX_Unitime utime = widgetValue.GetTime();
   strIsoTime.Format("%02d:%02d:%02d.%03d", utime.GetHour(), utime.GetMinute(),
                     utime.GetSecond(), utime.GetMillisecond());
   return TRUE;
 }
-FX_BOOL CXFA_FM2JSContext::IsoDate2Local(FXJSE_HOBJECT hThis,
+FX_BOOL CXFA_FM2JSContext::IsoDate2Local(CFXJSE_Value* pThis,
                                          const CFX_ByteStringC& szDate,
                                          const CFX_ByteStringC& szFormat,
                                          const CFX_ByteStringC& szLocale,
                                          CFX_ByteString& strLocalDate) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   CXFA_Document* pDoc = pContext->GetDocument();
   if (!pDoc) {
     return FALSE;
   }
   IFX_LocaleMgr* pMgr = (IFX_LocaleMgr*)pDoc->GetLocalMgr();
   IFX_Locale* pLocale = NULL;
   if (szLocale.IsEmpty()) {
     CXFA_Node* pThisNode = ToNode(pDoc->GetScriptContext()->GetThisObject());
     ASSERT(pThisNode);
     CXFA_WidgetData widgetData(pThisNode);
@@ skipping 11 matching lines @@
     wsFormat = CFX_WideString::FromUTF8(szFormat);
   }
   CXFA_LocaleValue widgetValue(XFA_VT_DATE, CFX_WideString::FromUTF8(szDate),
                                (CXFA_LocaleMgr*)pMgr);
   CFX_WideString wsRet;
   widgetValue.FormatPatterns(wsRet, wsFormat, pLocale,
                              XFA_VALUEPICTURE_Display);
   strLocalDate = FX_UTF8Encode(wsRet.c_str(), wsRet.GetLength());
   return TRUE;
 }
-FX_BOOL CXFA_FM2JSContext::IsoTime2Local(FXJSE_HOBJECT hThis,
+FX_BOOL CXFA_FM2JSContext::IsoTime2Local(CFXJSE_Value* pThis,
                                          const CFX_ByteStringC& szTime,
                                          const CFX_ByteStringC& szFormat,
                                          const CFX_ByteStringC& szLocale,
                                          CFX_ByteString& strLocalTime) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   CXFA_Document* pDoc = pContext->GetDocument();
   if (!pDoc) {
     return FALSE;
   }
   IFX_LocaleMgr* pMgr = (IFX_LocaleMgr*)pDoc->GetLocalMgr();
   IFX_Locale* pLocale = NULL;
   if (szLocale.IsEmpty()) {
     CXFA_Node* pThisNode = ToNode(pDoc->GetScriptContext()->GetThisObject());
     ASSERT(pThisNode);
     CXFA_WidgetData widgetData(pThisNode);
@@ skipping 13 matching lines @@
   wsFormat = FX_WSTRC(L"time{") + wsFormat;
   wsFormat += FX_WSTRC(L"}");
   CXFA_LocaleValue widgetValue(XFA_VT_TIME, CFX_WideString::FromUTF8(szTime),
                                (CXFA_LocaleMgr*)pMgr);
   CFX_WideString wsRet;
   widgetValue.FormatPatterns(wsRet, wsFormat, pLocale,
                              XFA_VALUEPICTURE_Display);
   strLocalTime = FX_UTF8Encode(wsRet.c_str(), wsRet.GetLength());
   return TRUE;
 }
-FX_BOOL CXFA_FM2JSContext::GetGMTTime(FXJSE_HOBJECT hThis,
+FX_BOOL CXFA_FM2JSContext::GetGMTTime(CFXJSE_Value* pThis,
                                       const CFX_ByteStringC& szTime,
                                       const CFX_ByteStringC& szFormat,
                                       const CFX_ByteStringC& szLocale,
                                       CFX_ByteString& strGMTTime) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   CXFA_Document* pDoc = pContext->GetDocument();
   if (!pDoc) {
     return FALSE;
   }
   IFX_LocaleMgr* pMgr = (IFX_LocaleMgr*)pDoc->GetLocalMgr();
   IFX_Locale* pLocale = NULL;
   if (szLocale.IsEmpty()) {
     CXFA_Node* pThisNode = ToNode(pDoc->GetScriptContext()->GetThisObject());
     ASSERT(pThisNode);
     CXFA_WidgetData widgetData(pThisNode);
@@ skipping 86 matching lines @@
     while (iDay - i > 0) {
       dDays += 1;
       ++i;
     }
   } else {
     dDays = 0;
   }
   return (int32_t)dDays;
 }
 
-void CXFA_FM2JSContext::GetLocalDateFormat(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::GetLocalDateFormat(CFXJSE_Value* pThis,
                                            int32_t iStyle,
                                            const CFX_ByteStringC& szLocalStr,
                                            CFX_ByteString& strFormat,
                                            FX_BOOL bStandard) {
   FX_LOCALEDATETIMESUBCATEGORY strStyle;
   switch (iStyle) {
     case 0:
       strStyle = FX_LOCALEDATETIMESUBCATEGORY_Medium;
       break;
     case 1:
       strStyle = FX_LOCALEDATETIMESUBCATEGORY_Short;
       break;
     case 2:
       strStyle = FX_LOCALEDATETIMESUBCATEGORY_Medium;
       break;
     case 3:
       strStyle = FX_LOCALEDATETIMESUBCATEGORY_Long;
       break;
     case 4:
       strStyle = FX_LOCALEDATETIMESUBCATEGORY_Full;
       break;
     default:
       strStyle = FX_LOCALEDATETIMESUBCATEGORY_Medium;
       break;
   }
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   CXFA_Document* pDoc = pContext->GetDocument();
   if (!pDoc) {
     return;
   }
   IFX_LocaleMgr* pMgr = (IFX_LocaleMgr*)pDoc->GetLocalMgr();
   IFX_Locale* pLocale = NULL;
   if (szLocalStr.IsEmpty()) {
     CXFA_Node* pThisNode = ToNode(pDoc->GetScriptContext()->GetThisObject());
     ASSERT(pThisNode);
     CXFA_WidgetData widgetData(pThisNode);
     pLocale = widgetData.GetLocal();
   } else {
     pLocale = pMgr->GetLocaleByName(CFX_WideString::FromUTF8(szLocalStr));
   }
   if (!pLocale) {
     return;
   }
   CFX_WideString strRet;
   pLocale->GetDatePattern(strStyle, strRet);
   if (!bStandard) {
     CFX_WideString wsSymbols;
     pLocale->GetDateTimeSymbols(wsSymbols);
     AlternateDateTimeSymbols(strRet, wsSymbols, g_sAltTable_Date);
   }
   strFormat = FX_UTF8Encode(strRet.c_str(), strRet.GetLength());
 }
-void CXFA_FM2JSContext::GetLocalTimeFormat(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::GetLocalTimeFormat(CFXJSE_Value* pThis,
                                            int32_t iStyle,
                                            const CFX_ByteStringC& szLocalStr,
                                            CFX_ByteString& strFormat,
                                            FX_BOOL bStandard) {
   FX_LOCALEDATETIMESUBCATEGORY strStyle;
   switch (iStyle) {
     case 0:
       strStyle = FX_LOCALEDATETIMESUBCATEGORY_Medium;
       break;
     case 1:
       strStyle = FX_LOCALEDATETIMESUBCATEGORY_Short;
       break;
     case 2:
       strStyle = FX_LOCALEDATETIMESUBCATEGORY_Medium;
       break;
     case 3:
       strStyle = FX_LOCALEDATETIMESUBCATEGORY_Long;
       break;
     case 4:
       strStyle = FX_LOCALEDATETIMESUBCATEGORY_Full;
       break;
     default:
       strStyle = FX_LOCALEDATETIMESUBCATEGORY_Medium;
       break;
   }
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   CXFA_Document* pDoc = pContext->GetDocument();
   if (!pDoc) {
     return;
   }
   IFX_LocaleMgr* pMgr = (IFX_LocaleMgr*)pDoc->GetLocalMgr();
   IFX_Locale* pLocale = NULL;
   if (szLocalStr.IsEmpty()) {
     CXFA_Node* pThisNode = ToNode(pDoc->GetScriptContext()->GetThisObject());
     ASSERT(pThisNode);
     CXFA_WidgetData widgetData(pThisNode);
     pLocale = widgetData.GetLocal();
   } else {
     pLocale = pMgr->GetLocaleByName(CFX_WideString::FromUTF8(szLocalStr));
   }
   if (!pLocale) {
     return;
   }
   CFX_WideString strRet;
   pLocale->GetTimePattern(strStyle, strRet);
   if (!bStandard) {
     CFX_WideString wsSymbols;
     pLocale->GetDateTimeSymbols(wsSymbols);
     AlternateDateTimeSymbols(strRet, wsSymbols, g_sAltTable_Time);
   }
   strFormat = FX_UTF8Encode(strRet.c_str(), strRet.GetLength());
 }
-void CXFA_FM2JSContext::GetStandardDateFormat(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::GetStandardDateFormat(CFXJSE_Value* pThis,
                                               int32_t iStyle,
                                               const CFX_ByteStringC& szLocalStr,
                                               CFX_ByteString& strFormat) {
-  GetLocalDateFormat(hThis, iStyle, szLocalStr, strFormat, TRUE);
+  GetLocalDateFormat(pThis, iStyle, szLocalStr, strFormat, TRUE);
 }
-void CXFA_FM2JSContext::GetStandardTimeFormat(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::GetStandardTimeFormat(CFXJSE_Value* pThis,
                                               int32_t iStyle,
                                               const CFX_ByteStringC& szLocalStr,
                                               CFX_ByteString& strFormat) {
-  GetLocalTimeFormat(hThis, iStyle, szLocalStr, strFormat, TRUE);
+  GetLocalTimeFormat(pThis, iStyle, szLocalStr, strFormat, TRUE);
 }
-void CXFA_FM2JSContext::Num2AllTime(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::Num2AllTime(CFXJSE_Value* pThis,
                                     int32_t iTime,
                                     const CFX_ByteStringC& szFormat,
                                     const CFX_ByteStringC& szLocale,
                                     FX_BOOL bGM,
                                     CFX_ByteString& strTime) {
   int32_t iHour = 0;
   int32_t iMin = 0;
   int32_t iSec = 0;
   int32_t iZoneHour = 0;
   int32_t iZoneMin = 0;
   int32_t iZoneSec = 0;
   iHour = static_cast<int>(iTime) / 3600000;
   iMin = (static_cast<int>(iTime) - iHour * 3600000) / 60000;
   iSec = (static_cast<int>(iTime) - iHour * 3600000 - iMin * 60000) / 1000;
   if (!bGM) {
     GetLocalTimeZone(iZoneHour, iZoneMin, iZoneSec);
     iHour += iZoneHour;
     iMin += iZoneMin;
     iSec += iZoneSec;
   }
   int32_t iRet = 0;
   CFX_ByteString strIsoTime;
   strIsoTime.Format("%02d:%02d:%02d", iHour, iMin, iSec);
   if (bGM) {
     iRet =
-        GetGMTTime(hThis, strIsoTime.AsStringC(), szFormat, szLocale, strTime);
+        GetGMTTime(pThis, strIsoTime.AsStringC(), szFormat, szLocale, strTime);
   } else {
-    iRet = IsoTime2Local(hThis, strIsoTime.AsStringC(), szFormat, szLocale,
+    iRet = IsoTime2Local(pThis, strIsoTime.AsStringC(), szFormat, szLocale,
                          strTime);
   }
   if (!iRet) {
     strTime = "";
   }
 }
 
 void CXFA_FM2JSContext::GetLocalTimeZone(int32_t& iHour,
                                          int32_t& iMin,
                                          int32_t& iSec) {
   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;
   struct tm* pLocal = localtime(&now);
   int32_t iLocalHour = pLocal->tm_hour;
   int32_t iLocalMin = pLocal->tm_min;
   int32_t iLocalSec = pLocal->tm_sec;
   iHour = iLocalHour - iGMHour;
   iMin = iLocalMin - iGMMin;
   iSec = iLocalSec - iGMSec;
 }
-void CXFA_FM2JSContext::Apr(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::Apr(CFXJSE_Value* pThis,
                             const CFX_ByteStringC& szFuncName,
                             CFXJSE_Arguments& args) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   if (args.GetLength() == 3) {
     FX_BOOL bFlags = FALSE;
     FX_DOUBLE nPrincipal = 0;
     FX_DOUBLE nPayment = 0;
     FX_DOUBLE nPeriods = 0;
-    FXJSE_HVALUE argOne = GetSimpleHValue(hThis, args, 0);
-    FXJSE_HVALUE argTwo = GetSimpleHValue(hThis, args, 1);
-    FXJSE_HVALUE argThree = GetSimpleHValue(hThis, args, 2);
-    bFlags = (HValueIsNull(hThis, argOne) || HValueIsNull(hThis, argTwo) ||
-              HValueIsNull(hThis, argThree));
+    CFXJSE_Value* argOne = GetSimpleValue(pThis, args, 0);
+    CFXJSE_Value* argTwo = GetSimpleValue(pThis, args, 1);
+    CFXJSE_Value* argThree = GetSimpleValue(pThis, args, 2);
+    bFlags = (ValueIsNull(pThis, argOne) || ValueIsNull(pThis, argTwo) ||
+              ValueIsNull(pThis, argThree));
     if (bFlags) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
-      nPrincipal = HValueToDouble(hThis, argOne);
-      nPayment = HValueToDouble(hThis, argTwo);
-      nPeriods = HValueToDouble(hThis, argThree);
+      nPrincipal = ValueToDouble(pThis, argOne);
+      nPayment = ValueToDouble(pThis, argTwo);
+      nPeriods = ValueToDouble(pThis, argThree);
       bFlags = ((nPrincipal <= 0) || (nPayment <= 0) || (nPeriods <= 0));
       if (bFlags) {
         pContext->ThrowScriptErrorMessage(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);
         }
@@ skipping 25 matching lines @@
       }
     }
     FXJSE_Value_Release(argOne);
     FXJSE_Value_Release(argTwo);
     FXJSE_Value_Release(argThree);
   } else {
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"Apr");
   }
 }
-void CXFA_FM2JSContext::CTerm(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::CTerm(CFXJSE_Value* pThis,
                               const CFX_ByteStringC& szFuncName,
                               CFXJSE_Arguments& args) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   if (args.GetLength() == 3) {
     FX_BOOL bFlags = FALSE;
     FX_FLOAT nRate = 0;
     FX_FLOAT nFutureValue = 0;
     FX_FLOAT nInitAmount = 0;
-    FXJSE_HVALUE argOne = GetSimpleHValue(hThis, args, 0);
-    FXJSE_HVALUE argTwo = GetSimpleHValue(hThis, args, 1);
-    FXJSE_HVALUE argThree = GetSimpleHValue(hThis, args, 2);
-    bFlags = (HValueIsNull(hThis, argOne) || HValueIsNull(hThis, argTwo) ||
-              HValueIsNull(hThis, argThree));
+    CFXJSE_Value* argOne = GetSimpleValue(pThis, args, 0);
+    CFXJSE_Value* argTwo = GetSimpleValue(pThis, args, 1);
+    CFXJSE_Value* argThree = GetSimpleValue(pThis, args, 2);
+    bFlags = (ValueIsNull(pThis, argOne) || ValueIsNull(pThis, argTwo) ||
+              ValueIsNull(pThis, argThree));
     if (bFlags) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
-      nRate = HValueToFloat(hThis, argOne);
-      nFutureValue = HValueToFloat(hThis, argTwo);
-      nInitAmount = HValueToFloat(hThis, argThree);
+      nRate = ValueToFloat(pThis, argOne);
+      nFutureValue = ValueToFloat(pThis, argTwo);
+      nInitAmount = ValueToFloat(pThis, argThree);
       bFlags = ((nRate <= 0) || (nFutureValue <= 0) || (nInitAmount <= 0));
       if (bFlags) {
         pContext->ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
       } else {
         FXJSE_Value_SetFloat(args.GetReturnValue(),
                              FXSYS_log((FX_FLOAT)(nFutureValue / nInitAmount)) /
                                  FXSYS_log((FX_FLOAT)(1 + nRate)));
       }
     }
     FXJSE_Value_Release(argOne);
     FXJSE_Value_Release(argTwo);
     FXJSE_Value_Release(argThree);
   } else {
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"CTerm");
   }
 }
-void CXFA_FM2JSContext::FV(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::FV(CFXJSE_Value* pThis,
                            const CFX_ByteStringC& szFuncName,
                            CFXJSE_Arguments& args) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   if (args.GetLength() == 3) {
     FX_BOOL bFlags = FALSE;
     FX_DOUBLE nAmount = 0;
     FX_DOUBLE nRate = 0;
     FX_DOUBLE nPeriod = 0;
-    FXJSE_HVALUE argOne = GetSimpleHValue(hThis, args, 0);
-    FXJSE_HVALUE argTwo = GetSimpleHValue(hThis, args, 1);
-    FXJSE_HVALUE argThree = GetSimpleHValue(hThis, args, 2);
-    bFlags = (HValueIsNull(hThis, argOne) || HValueIsNull(hThis, argTwo) ||
-              HValueIsNull(hThis, argThree));
+    CFXJSE_Value* argOne = GetSimpleValue(pThis, args, 0);
+    CFXJSE_Value* argTwo = GetSimpleValue(pThis, args, 1);
+    CFXJSE_Value* argThree = GetSimpleValue(pThis, args, 2);
+    bFlags = (ValueIsNull(pThis, argOne) || ValueIsNull(pThis, argTwo) ||
+              ValueIsNull(pThis, argThree));
     if (bFlags) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
-      nAmount = HValueToDouble(hThis, argOne);
-      nRate = HValueToDouble(hThis, argTwo);
-      nPeriod = HValueToDouble(hThis, argThree);
+      nAmount = ValueToDouble(pThis, argOne);
+      nRate = ValueToDouble(pThis, argTwo);
+      nPeriod = ValueToDouble(pThis, argThree);
       bFlags = ((nRate < 0) || (nPeriod <= 0) || (nAmount <= 0));
       if (bFlags) {
         pContext->ThrowScriptErrorMessage(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);
       }
     }
     FXJSE_Value_Release(argOne);
     FXJSE_Value_Release(argTwo);
     FXJSE_Value_Release(argThree);
   } else {
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"FV");
   }
 }
-void CXFA_FM2JSContext::IPmt(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::IPmt(CFXJSE_Value* pThis,
                              const CFX_ByteStringC& szFuncName,
                              CFXJSE_Arguments& args) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   if (args.GetLength() == 5) {
     FX_BOOL bFlags = FALSE;
     FX_FLOAT nPrincpalAmount = 0;
     FX_FLOAT nRate = 0;
     FX_FLOAT nPayment = 0;
     FX_FLOAT nFirstMonth = 0;
     FX_FLOAT nNumberOfMonths = 0;
-    FXJSE_HVALUE argOne = GetSimpleHValue(hThis, args, 0);
-    FXJSE_HVALUE argTwo = GetSimpleHValue(hThis, args, 1);
-    FXJSE_HVALUE argThree = GetSimpleHValue(hThis, args, 2);
-    FXJSE_HVALUE argFour = GetSimpleHValue(hThis, args, 3);
-    FXJSE_HVALUE argFive = GetSimpleHValue(hThis, args, 4);
-    bFlags = (HValueIsNull(hThis, argOne) || HValueIsNull(hThis, argTwo) ||
-              HValueIsNull(hThis, argThree) || HValueIsNull(hThis, argFour) ||
-              HValueIsNull(hThis, argFive));
+    CFXJSE_Value* argOne = GetSimpleValue(pThis, args, 0);
+    CFXJSE_Value* argTwo = GetSimpleValue(pThis, args, 1);
+    CFXJSE_Value* argThree = GetSimpleValue(pThis, args, 2);
+    CFXJSE_Value* argFour = GetSimpleValue(pThis, args, 3);
+    CFXJSE_Value* argFive = GetSimpleValue(pThis, args, 4);
+    bFlags = (ValueIsNull(pThis, argOne) || ValueIsNull(pThis, argTwo) ||
+              ValueIsNull(pThis, argThree) || ValueIsNull(pThis, argFour) ||
+              ValueIsNull(pThis, argFive));
     if (bFlags) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
-      nPrincpalAmount = HValueToFloat(hThis, argOne);
-      nRate = HValueToFloat(hThis, argTwo);
-      nPayment = HValueToFloat(hThis, argThree);
-      nFirstMonth = HValueToFloat(hThis, argFour);
-      nNumberOfMonths = HValueToFloat(hThis, argFive);
+      nPrincpalAmount = ValueToFloat(pThis, argOne);
+      nRate = ValueToFloat(pThis, argTwo);
+      nPayment = ValueToFloat(pThis, argThree);
+      nFirstMonth = ValueToFloat(pThis, argFour);
+      nNumberOfMonths = ValueToFloat(pThis, argFive);
       bFlags = ((nPrincpalAmount <= 0) || (nRate <= 0) || (nPayment <= 0) ||
                 (nFirstMonth < 0) || (nNumberOfMonths < 0));
       if (bFlags) {
         pContext->ThrowScriptErrorMessage(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 -
@@ skipping 25 matching lines @@
     FXJSE_Value_Release(argOne);
     FXJSE_Value_Release(argTwo);
     FXJSE_Value_Release(argThree);
     FXJSE_Value_Release(argFour);
     FXJSE_Value_Release(argFive);
   } else {
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"IPmt");
   }
 }
-void CXFA_FM2JSContext::NPV(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::NPV(CFXJSE_Value* pThis,
                             const CFX_ByteStringC& szFuncName,
                             CFXJSE_Arguments& args) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   int32_t argc = args.GetLength();
   if (argc > 2) {
     FX_BOOL bFlags = FALSE;
-    FXJSE_HVALUE* argValues = FX_Alloc(FXJSE_HVALUE, argc);
+    CFXJSE_Value** argValues = FX_Alloc(CFXJSE_Value*, argc);
     for (int32_t i = 0; i < argc; i++) {
-      argValues[i] = GetSimpleHValue(hThis, args, i);
-      if (HValueIsNull(hThis, argValues[i])) {
+      argValues[i] = GetSimpleValue(pThis, args, i);
+      if (ValueIsNull(pThis, argValues[i])) {
         bFlags = TRUE;
       }
     }
     if (!bFlags) {
       FX_DOUBLE nRate = 0;
-      nRate = HValueToDouble(hThis, argValues[0]);
+      nRate = ValueToDouble(pThis, argValues[0]);
       if (nRate <= 0) {
         pContext->ThrowScriptErrorMessage(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] = HValueToDouble(hThis, argValues[i]);
+          pData[i - 1] = ValueToDouble(pThis, argValues[i]);
         }
         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());
     }
     for (int32_t i = 0; i < argc; i++) {
       FXJSE_Value_Release(argValues[i]);
     }
     FX_Free(argValues);
   } else {
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"NPV");
   }
 }
-void CXFA_FM2JSContext::Pmt(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::Pmt(CFXJSE_Value* pThis,
                             const CFX_ByteStringC& szFuncName,
                             CFXJSE_Arguments& args) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   if (args.GetLength() == 3) {
     FX_BOOL bFlags = FALSE;
     FX_FLOAT nPrincipal = 0;
     FX_FLOAT nRate = 0;
     FX_FLOAT nPeriods = 0;
-    FXJSE_HVALUE argOne = GetSimpleHValue(hThis, args, 0);
-    FXJSE_HVALUE argTwo = GetSimpleHValue(hThis, args, 1);
-    FXJSE_HVALUE argThree = GetSimpleHValue(hThis, args, 2);
-    bFlags = (HValueIsNull(hThis, argOne) || HValueIsNull(hThis, argTwo) ||
-              HValueIsNull(hThis, argThree));
+    CFXJSE_Value* argOne = GetSimpleValue(pThis, args, 0);
+    CFXJSE_Value* argTwo = GetSimpleValue(pThis, args, 1);
+    CFXJSE_Value* argThree = GetSimpleValue(pThis, args, 2);
+    bFlags = (ValueIsNull(pThis, argOne) || ValueIsNull(pThis, argTwo) ||
+              ValueIsNull(pThis, argThree));
     if (bFlags) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
-      nPrincipal = HValueToFloat(hThis, argOne);
-      nRate = HValueToFloat(hThis, argTwo);
-      nPeriods = HValueToFloat(hThis, argThree);
+      nPrincipal = ValueToFloat(pThis, argOne);
+      nRate = ValueToFloat(pThis, argTwo);
+      nPeriods = ValueToFloat(pThis, argThree);
       bFlags = ((nPrincipal <= 0) || (nRate <= 0) || (nPeriods <= 0));
       if (bFlags) {
         pContext->ThrowScriptErrorMessage(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));
       }
     }
     FXJSE_Value_Release(argOne);
     FXJSE_Value_Release(argTwo);
     FXJSE_Value_Release(argThree);
   } else {
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"Pmt");
   }
 }
-void CXFA_FM2JSContext::PPmt(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::PPmt(CFXJSE_Value* pThis,
                              const CFX_ByteStringC& szFuncName,
                              CFXJSE_Arguments& args) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   if (args.GetLength() == 5) {
     FX_BOOL bFlags = FALSE;
     FX_FLOAT nPrincpalAmount = 0;
     FX_FLOAT nRate = 0;
     FX_FLOAT nPayment = 0;
     FX_FLOAT nFirstMonth = 0;
     FX_FLOAT nNumberOfMonths = 0;
-    FXJSE_HVALUE argOne = GetSimpleHValue(hThis, args, 0);
-    FXJSE_HVALUE argTwo = GetSimpleHValue(hThis, args, 1);
-    FXJSE_HVALUE argThree = GetSimpleHValue(hThis, args, 2);
-    FXJSE_HVALUE argFour = GetSimpleHValue(hThis, args, 3);
-    FXJSE_HVALUE argFive = GetSimpleHValue(hThis, args, 4);
-    bFlags = (HValueIsNull(hThis, argOne) || HValueIsNull(hThis, argTwo) ||
-              HValueIsNull(hThis, argThree) || HValueIsNull(hThis, argFour) ||
-              HValueIsNull(hThis, argFive));
+    CFXJSE_Value* argOne = GetSimpleValue(pThis, args, 0);
+    CFXJSE_Value* argTwo = GetSimpleValue(pThis, args, 1);
+    CFXJSE_Value* argThree = GetSimpleValue(pThis, args, 2);
+    CFXJSE_Value* argFour = GetSimpleValue(pThis, args, 3);
+    CFXJSE_Value* argFive = GetSimpleValue(pThis, args, 4);
+    bFlags = (ValueIsNull(pThis, argOne) || ValueIsNull(pThis, argTwo) ||
+              ValueIsNull(pThis, argThree) || ValueIsNull(pThis, argFour) ||
+              ValueIsNull(pThis, argFive));
     if (bFlags) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
-      nPrincpalAmount = HValueToFloat(hThis, argOne);
-      nRate = HValueToFloat(hThis, argTwo);
-      nPayment = HValueToFloat(hThis, argThree);
-      nFirstMonth = HValueToFloat(hThis, argFour);
-      nNumberOfMonths = HValueToFloat(hThis, argFive);
+      nPrincpalAmount = ValueToFloat(pThis, argOne);
+      nRate = ValueToFloat(pThis, argTwo);
+      nPayment = ValueToFloat(pThis, argThree);
+      nFirstMonth = ValueToFloat(pThis, argFour);
+      nNumberOfMonths = ValueToFloat(pThis, argFive);
       bFlags = ((nPrincpalAmount <= 0) || (nRate <= 0) || (nPayment <= 0) ||
                 (nFirstMonth < 0) || (nNumberOfMonths < 0));
       if (bFlags) {
         pContext->ThrowScriptErrorMessage(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)) -
@@ skipping 26 matching lines @@
     FXJSE_Value_Release(argOne);
     FXJSE_Value_Release(argTwo);
     FXJSE_Value_Release(argThree);
     FXJSE_Value_Release(argFour);
     FXJSE_Value_Release(argFive);
   } else {
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"PPmt");
   }
 }
-void CXFA_FM2JSContext::PV(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::PV(CFXJSE_Value* pThis,
                            const CFX_ByteStringC& szFuncName,
                            CFXJSE_Arguments& args) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   if (args.GetLength() == 3) {
     FX_BOOL bFlags = FALSE;
     FX_DOUBLE nAmount = 0;
     FX_DOUBLE nRate = 0;
     FX_DOUBLE nPeriod = 0;
-    FXJSE_HVALUE argOne = GetSimpleHValue(hThis, args, 0);
-    FXJSE_HVALUE argTwo = GetSimpleHValue(hThis, args, 1);
-    FXJSE_HVALUE argThree = GetSimpleHValue(hThis, args, 2);
-    bFlags = (HValueIsNull(hThis, argOne) || HValueIsNull(hThis, argTwo) ||
-              HValueIsNull(hThis, argThree));
+    CFXJSE_Value* argOne = GetSimpleValue(pThis, args, 0);
+    CFXJSE_Value* argTwo = GetSimpleValue(pThis, args, 1);
+    CFXJSE_Value* argThree = GetSimpleValue(pThis, args, 2);
+    bFlags = (ValueIsNull(pThis, argOne) || ValueIsNull(pThis, argTwo) ||
+              ValueIsNull(pThis, argThree));
     if (bFlags) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
-      nAmount = HValueToDouble(hThis, argOne);
-      nRate = HValueToDouble(hThis, argTwo);
-      nPeriod = HValueToDouble(hThis, argThree);
+      nAmount = ValueToDouble(pThis, argOne);
+      nRate = ValueToDouble(pThis, argTwo);
+      nPeriod = ValueToDouble(pThis, argThree);
       bFlags = ((nAmount <= 0) || (nRate < 0) || (nPeriod <= 0));
       if (bFlags) {
         pContext->ThrowScriptErrorMessage(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));
       }
     }
     FXJSE_Value_Release(argOne);
     FXJSE_Value_Release(argTwo);
     FXJSE_Value_Release(argThree);
   } else {
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"PV");
   }
 }
-void CXFA_FM2JSContext::Rate(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::Rate(CFXJSE_Value* pThis,
                              const CFX_ByteStringC& szFuncName,
                              CFXJSE_Arguments& args) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   if (args.GetLength() == 3) {
     FX_BOOL bFlags = FALSE;
     FX_FLOAT nFuture = 0;
     FX_FLOAT nPresent = 0;
     FX_FLOAT nTotalNumber = 0;
-    FXJSE_HVALUE argOne = GetSimpleHValue(hThis, args, 0);
-    FXJSE_HVALUE argTwo = GetSimpleHValue(hThis, args, 1);
-    FXJSE_HVALUE argThree = GetSimpleHValue(hThis, args, 2);
-    bFlags = (HValueIsNull(hThis, argOne) || HValueIsNull(hThis, argTwo) ||
-              HValueIsNull(hThis, argThree));
+    CFXJSE_Value* argOne = GetSimpleValue(pThis, args, 0);
+    CFXJSE_Value* argTwo = GetSimpleValue(pThis, args, 1);
+    CFXJSE_Value* argThree = GetSimpleValue(pThis, args, 2);
+    bFlags = (ValueIsNull(pThis, argOne) || ValueIsNull(pThis, argTwo) ||
+              ValueIsNull(pThis, argThree));
     if (bFlags) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
-      nFuture = HValueToFloat(hThis, argOne);
-      nPresent = HValueToFloat(hThis, argTwo);
-      nTotalNumber = HValueToFloat(hThis, argThree);
+      nFuture = ValueToFloat(pThis, argOne);
+      nPresent = ValueToFloat(pThis, argTwo);
+      nTotalNumber = ValueToFloat(pThis, argThree);
       bFlags = ((nFuture <= 0) || (nPresent < 0) || (nTotalNumber <= 0));
       if (bFlags) {
         pContext->ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
       } else {
         FXJSE_Value_SetFloat(args.GetReturnValue(),
                              (FXSYS_pow((FX_FLOAT)(nFuture / nPresent),
                                         (FX_FLOAT)(1 / nTotalNumber)) -
                               1));
       }
     }
     FXJSE_Value_Release(argOne);
     FXJSE_Value_Release(argTwo);
     FXJSE_Value_Release(argThree);
   } else {
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"Rate");
   }
 }
-void CXFA_FM2JSContext::Term(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::Term(CFXJSE_Value* pThis,
                              const CFX_ByteStringC& szFuncName,
                              CFXJSE_Arguments& args) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   if (args.GetLength() == 3) {
     FX_BOOL bFlags = FALSE;
     FX_FLOAT nMount = 0;
     FX_FLOAT nRate = 0;
     FX_FLOAT nFuture = 0;
-    FXJSE_HVALUE argOne = GetSimpleHValue(hThis, args, 0);
-    FXJSE_HVALUE argTwo = GetSimpleHValue(hThis, args, 1);
-    FXJSE_HVALUE argThree = GetSimpleHValue(hThis, args, 2);
+    CFXJSE_Value* argOne = GetSimpleValue(pThis, args, 0);
+    CFXJSE_Value* argTwo = GetSimpleValue(pThis, args, 1);
+    CFXJSE_Value* argThree = GetSimpleValue(pThis, args, 2);
     bFlags = (FXJSE_Value_IsNull(argOne) || FXJSE_Value_IsNull(argTwo) ||
               FXJSE_Value_IsNull(argThree));
     if (bFlags) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
-      nMount = HValueToFloat(hThis, argOne);
-      nRate = HValueToFloat(hThis, argTwo);
-      nFuture = HValueToFloat(hThis, argThree);
+      nMount = ValueToFloat(pThis, argOne);
+      nRate = ValueToFloat(pThis, argTwo);
+      nFuture = ValueToFloat(pThis, argThree);
       bFlags = ((nMount <= 0) || (nRate <= 0) || (nFuture <= 0));
       if (bFlags) {
         pContext->ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
       } else {
         FXJSE_Value_SetFloat(
             args.GetReturnValue(),
             (FXSYS_log((FX_FLOAT)(nFuture / nMount * nRate) + 1) /
              FXSYS_log((FX_FLOAT)(1 + nRate))));
       }
     }
     FXJSE_Value_Release(argOne);
     FXJSE_Value_Release(argTwo);
     FXJSE_Value_Release(argThree);
   } else {
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"Term");
   }
 }
-void CXFA_FM2JSContext::Choose(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::Choose(CFXJSE_Value* pThis,
                                const CFX_ByteStringC& szFuncName,
                                CFXJSE_Arguments& args) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   v8::Isolate* pIsolate = pContext->GetScriptRuntime();
   int32_t argc = args.GetLength();
   if (argc > 1) {
-    FXJSE_HVALUE argOne = args.GetValue(0);
+    CFXJSE_Value* argOne = args.GetValue(0);
     FX_BOOL argOneIsNull = FALSE;
     int32_t iIndex = 0;
-    argOneIsNull = HValueIsNull(hThis, argOne);
+    argOneIsNull = ValueIsNull(pThis, argOne);
     if (!argOneIsNull) {
-      iIndex = (int32_t)HValueToFloat(hThis, argOne);
+      iIndex = (int32_t)ValueToFloat(pThis, argOne);
     }
     FXJSE_Value_Release(argOne);
     if (argOneIsNull) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else if (iIndex < 1) {
       FXJSE_Value_SetUTF8String(args.GetReturnValue(), "");
     } else {
       FX_BOOL bFound = FALSE;
       FX_BOOL bStopCounterFlags = FALSE;
       int32_t iArgIndex = 1;
       int32_t iValueIndex = 0;
       while (!bFound && !bStopCounterFlags && (iArgIndex < argc)) {
-        FXJSE_HVALUE argIndexValue = args.GetValue(iArgIndex);
+        CFXJSE_Value* argIndexValue = args.GetValue(iArgIndex);
         if (FXJSE_Value_IsArray(argIndexValue)) {
-          FXJSE_HVALUE lengthValue = FXJSE_Value_Create(pIsolate);
+          CFXJSE_Value* lengthValue = FXJSE_Value_Create(pIsolate);
           FXJSE_Value_GetObjectProp(argIndexValue, "length", lengthValue);
           int32_t iLength = FXJSE_Value_ToInteger(lengthValue);
           FXJSE_Value_Release(lengthValue);
           if (iLength > 3) {
             bStopCounterFlags = TRUE;
           }
           iValueIndex += (iLength - 2);
           if (iValueIndex >= iIndex) {
-            FXJSE_HVALUE propertyValue = FXJSE_Value_Create(pIsolate);
-            FXJSE_HVALUE jsobjectValue = FXJSE_Value_Create(pIsolate);
-            FXJSE_HVALUE newProperty = FXJSE_Value_Create(pIsolate);
+            CFXJSE_Value* propertyValue = FXJSE_Value_Create(pIsolate);
+            CFXJSE_Value* jsobjectValue = FXJSE_Value_Create(pIsolate);
+            CFXJSE_Value* newProperty = FXJSE_Value_Create(pIsolate);
             FXJSE_Value_GetObjectPropByIdx(argIndexValue, 1, propertyValue);
             FXJSE_Value_GetObjectPropByIdx(
                 argIndexValue, ((iLength - 1) - (iValueIndex - iIndex)),
                 jsobjectValue);
             if (FXJSE_Value_IsNull(propertyValue)) {
               GetObjectDefaultValue(jsobjectValue, newProperty);
             } else {
               CFX_ByteString propStr;
               FXJSE_Value_ToUTF8String(propertyValue, propStr);
               FXJSE_Value_GetObjectProp(jsobjectValue, propStr.AsStringC(),
                                         newProperty);
             }
             CFX_ByteString bsChoosed;
-            HValueToUTF8String(newProperty, bsChoosed);
+            ValueToUTF8String(newProperty, bsChoosed);
             FXJSE_Value_SetUTF8String(args.GetReturnValue(),
                                       bsChoosed.AsStringC());
             FXJSE_Value_Release(newProperty);
             FXJSE_Value_Release(jsobjectValue);
             FXJSE_Value_Release(propertyValue);
             bFound = TRUE;
           }
         } else {
           iValueIndex++;
           if (iValueIndex == iIndex) {
             CFX_ByteString bsChoosed;
-            HValueToUTF8String(argIndexValue, bsChoosed);
+            ValueToUTF8String(argIndexValue, bsChoosed);
             FXJSE_Value_SetUTF8String(args.GetReturnValue(),
                                       bsChoosed.AsStringC());
             bFound = TRUE;
           }
         }
         FXJSE_Value_Release(argIndexValue);
         iArgIndex++;
       }
       if (!bFound) {
         FXJSE_Value_SetUTF8String(args.GetReturnValue(), "");
       }
     }
   } else {
     CXFA_FM2JSContext* pContext =
-        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"Choose");
   }
 }
-void CXFA_FM2JSContext::Exists(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::Exists(CFXJSE_Value* pThis,
                                const CFX_ByteStringC& szFuncName,
                                CFXJSE_Arguments& args) {
   if (args.GetLength() == 1) {
-    FXJSE_HVALUE argOne = args.GetValue(0);
+    CFXJSE_Value* argOne = args.GetValue(0);
     FXJSE_Value_SetInteger(args.GetReturnValue(), FXJSE_Value_IsObject(argOne));
     FXJSE_Value_Release(argOne);
   } else {
     CXFA_FM2JSContext* pContext =
-        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"Exists");
   }
 }
-void CXFA_FM2JSContext::HasValue(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::HasValue(CFXJSE_Value* pThis,
                                  const CFX_ByteStringC& szFuncName,
                                  CFXJSE_Arguments& args) {
   if (args.GetLength() == 1) {
-    FXJSE_HVALUE argOne = GetSimpleHValue(hThis, args, 0);
+    CFXJSE_Value* argOne = GetSimpleValue(pThis, args, 0);
     if (FXJSE_Value_IsUTF8String(argOne)) {
       CFX_ByteString valueStr;
       FXJSE_Value_ToUTF8String(argOne, valueStr);
       valueStr.TrimLeft();
       FXJSE_Value_SetInteger(args.GetReturnValue(), (!valueStr.IsEmpty()));
     } else if (FXJSE_Value_IsNumber(argOne) || FXJSE_Value_IsBoolean(argOne)) {
       FXJSE_Value_SetInteger(args.GetReturnValue(), TRUE);
     } else {
       FXJSE_Value_SetInteger(args.GetReturnValue(), FALSE);
     }
     FXJSE_Value_Release(argOne);
   } else {
     CXFA_FM2JSContext* pContext =
-        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"HasValue");
   }
 }
-void CXFA_FM2JSContext::Oneof(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::Oneof(CFXJSE_Value* pThis,
                               const CFX_ByteStringC& szFuncName,
                               CFXJSE_Arguments& args) {
   int32_t argc = args.GetLength();
   if (argc > 1) {
     FX_BOOL bFlags = FALSE;
-    FXJSE_HVALUE argOne = GetSimpleHValue(hThis, args, 0);
-    FXJSE_HVALUE* parametersValue = 0;
+    CFXJSE_Value* argOne = GetSimpleValue(pThis, args, 0);
+    CFXJSE_Value** parametersValue = nullptr;
     int32_t iCount = 0;
-    unfoldArgs(hThis, args, parametersValue, iCount, 1);
+    unfoldArgs(pThis, args, parametersValue, iCount, 1);
     for (int32_t i = 0; i < iCount; i++) {
-      if (simpleValueCompare(hThis, argOne, parametersValue[i])) {
+      if (simpleValueCompare(pThis, argOne, parametersValue[i])) {
         bFlags = TRUE;
         break;
       }
     }
     FXJSE_Value_SetInteger(args.GetReturnValue(), bFlags);
     FXJSE_Value_Release(argOne);
     for (int32_t i = 0; i < iCount; i++) {
       FXJSE_Value_Release(parametersValue[i]);
     }
     FX_Free(parametersValue);
     parametersValue = 0;
   } else {
     CXFA_FM2JSContext* pContext =
-        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"Oneof");
   }
 }
-void CXFA_FM2JSContext::Within(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::Within(CFXJSE_Value* pThis,
                                const CFX_ByteStringC& szFuncName,
                                CFXJSE_Arguments& args) {
   int32_t argc = args.GetLength();
   if (argc == 3) {
-    FXJSE_HVALUE argOne = GetSimpleHValue(hThis, args, 0);
+    CFXJSE_Value* argOne = GetSimpleValue(pThis, args, 0);
     if (FXJSE_Value_IsNull(argOne)) {
       FXJSE_Value_SetUndefined(args.GetReturnValue());
     } else {
-      FXJSE_HVALUE argLow = GetSimpleHValue(hThis, args, 1);
-      FXJSE_HVALUE argHeight = GetSimpleHValue(hThis, args, 2);
+      CFXJSE_Value* argLow = GetSimpleValue(pThis, args, 1);
+      CFXJSE_Value* argHeight = GetSimpleValue(pThis, args, 2);
       if (FXJSE_Value_IsNumber(argOne)) {
-        FX_FLOAT oneNumber = HValueToFloat(hThis, argOne);
-        FX_FLOAT lowNumber = HValueToFloat(hThis, argLow);
-        FX_FLOAT heightNumber = HValueToFloat(hThis, argHeight);
+        FX_FLOAT oneNumber = ValueToFloat(pThis, argOne);
+        FX_FLOAT lowNumber = ValueToFloat(pThis, argLow);
+        FX_FLOAT heightNumber = ValueToFloat(pThis, argHeight);
         FXJSE_Value_SetInteger(
             args.GetReturnValue(),
             ((oneNumber >= lowNumber) && (oneNumber <= heightNumber)));
       } else {
         CFX_ByteString oneString;
         CFX_ByteString lowString;
         CFX_ByteString heightString;
-        HValueToUTF8String(argOne, oneString);
-        HValueToUTF8String(argLow, lowString);
-        HValueToUTF8String(argHeight, heightString);
+        ValueToUTF8String(argOne, oneString);
+        ValueToUTF8String(argLow, lowString);
+        ValueToUTF8String(argHeight, heightString);
         FXJSE_Value_SetInteger(
             args.GetReturnValue(),
             ((oneString.Compare(lowString.AsStringC()) >= 0) &&
              (oneString.Compare(heightString.AsStringC()) <= 0)));
       }
       FXJSE_Value_Release(argLow);
       FXJSE_Value_Release(argHeight);
     }
     FXJSE_Value_Release(argOne);
   } else {
     CXFA_FM2JSContext* pContext =
-        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"Within");
   }
 }
-void CXFA_FM2JSContext::If(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::If(CFXJSE_Value* pThis,
                            const CFX_ByteStringC& szFuncName,
                            CFXJSE_Arguments& args) {
   if (args.GetLength() == 3) {
-    FXJSE_HVALUE argCondition = GetSimpleHValue(hThis, args, 0);
-    FXJSE_HVALUE argFirstValue = GetSimpleHValue(hThis, args, 1);
-    FXJSE_HVALUE argSecondValue = GetSimpleHValue(hThis, args, 2);
+    CFXJSE_Value* argCondition = GetSimpleValue(pThis, args, 0);
+    CFXJSE_Value* argFirstValue = GetSimpleValue(pThis, args, 1);
+    CFXJSE_Value* argSecondValue = GetSimpleValue(pThis, args, 2);
     FX_BOOL bCondition = FXJSE_Value_ToBoolean(argCondition);
     FXJSE_Value_Set(args.GetReturnValue(),
                     bCondition ? argFirstValue : argSecondValue);
     FXJSE_Value_Release(argSecondValue);
     FXJSE_Value_Release(argFirstValue);
     FXJSE_Value_Release(argCondition);
   } else {
     CXFA_FM2JSContext* pContext =
-        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"If");
   }
 }
-void CXFA_FM2JSContext::Eval(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::Eval(CFXJSE_Value* pThis,
                              const CFX_ByteStringC& szFuncName,
                              CFXJSE_Arguments& args) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   v8::Isolate* pIsolate = pContext->GetScriptRuntime();
   if (args.GetLength() == 1) {
-    FXJSE_HVALUE scriptValue = GetSimpleHValue(hThis, args, 0);
+    CFXJSE_Value* scriptValue = GetSimpleValue(pThis, args, 0);
     CFX_ByteString utf8ScriptString;
-    HValueToUTF8String(scriptValue, utf8ScriptString);
+    ValueToUTF8String(scriptValue, utf8ScriptString);
     if (utf8ScriptString.IsEmpty()) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
       CFX_WideTextBuf wsJavaScriptBuf;
       CFX_WideString javaScript;
       CFX_WideString wsError;
       XFA_FM2JS_Translate(
           CFX_WideString::FromUTF8(utf8ScriptString.AsStringC()).AsStringC(),
           wsJavaScriptBuf, wsError);
       CFXJSE_Context* pContext = FXJSE_Context_Create(pIsolate);
-      FXJSE_HVALUE returnValue = FXJSE_Value_Create(pIsolate);
+      CFXJSE_Value* returnValue = FXJSE_Value_Create(pIsolate);
       javaScript = wsJavaScriptBuf.AsStringC();
       FXJSE_ExecuteScript(
           pContext,
           FX_UTF8Encode(javaScript.c_str(), javaScript.GetLength()).c_str(),
           returnValue);
       FXJSE_Value_Set(args.GetReturnValue(), returnValue);
       FXJSE_Value_Release(returnValue);
       FXJSE_Context_Release(pContext);
     }
     FXJSE_Value_Release(scriptValue);
   } else {
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"Eval");
   }
 }
-void CXFA_FM2JSContext::Ref(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::Ref(CFXJSE_Value* pThis,
                             const CFX_ByteStringC& szFuncName,
                             CFXJSE_Arguments& args) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   v8::Isolate* pIsolate = pContext->GetScriptRuntime();
   if (args.GetLength() == 1) {
-    FXJSE_HVALUE argOne = args.GetValue(0);
+    CFXJSE_Value* argOne = args.GetValue(0);
     if (FXJSE_Value_IsNull(argOne)) {
-      FXJSE_HVALUE rgValues[3];
+      CFXJSE_Value* rgValues[3];
       for (int32_t i = 0; i < 3; i++) {
         rgValues[i] = FXJSE_Value_Create(pIsolate);
       }
       FXJSE_Value_SetInteger(rgValues[0], 4);
       FXJSE_Value_SetNull(rgValues[1]);
       FXJSE_Value_SetNull(rgValues[2]);
       FXJSE_Value_SetArray(args.GetReturnValue(), 3, rgValues);
       for (int32_t i = 0; i < 3; i++) {
         FXJSE_Value_Release(rgValues[i]);
       }
     } else if (FXJSE_Value_IsArray(argOne)) {
 #ifndef NDEBUG
-      FXJSE_HVALUE lengthValue = FXJSE_Value_Create(pIsolate);
+      CFXJSE_Value* lengthValue = FXJSE_Value_Create(pIsolate);
       FXJSE_Value_GetObjectProp(argOne, "length", lengthValue);
       ASSERT(FXJSE_Value_ToInteger(lengthValue) >= 3);
       FXJSE_Value_Release(lengthValue);
 #endif
-      FXJSE_HVALUE propertyValue = FXJSE_Value_Create(pIsolate);
-      FXJSE_HVALUE jsObjectValue = FXJSE_Value_Create(pIsolate);
+      CFXJSE_Value* propertyValue = FXJSE_Value_Create(pIsolate);
+      CFXJSE_Value* jsObjectValue = FXJSE_Value_Create(pIsolate);
       FXJSE_Value_GetObjectPropByIdx(argOne, 1, propertyValue);
       FXJSE_Value_GetObjectPropByIdx(argOne, 2, jsObjectValue);
       if (FXJSE_Value_IsNull(jsObjectValue)) {
         pContext->ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
       } else if (FXJSE_Value_IsNull(propertyValue) &&
                  (!FXJSE_Value_IsNull(jsObjectValue))) {
-        FXJSE_HVALUE rgValues[3];
+        CFXJSE_Value* rgValues[3];
         for (int32_t i = 0; i < 3; i++) {
           rgValues[i] = FXJSE_Value_Create(pIsolate);
         }
         FXJSE_Value_SetInteger(rgValues[0], 3);
         FXJSE_Value_SetNull(rgValues[1]);
         FXJSE_Value_Set(rgValues[2], jsObjectValue);
         FXJSE_Value_SetArray(args.GetReturnValue(), 3, rgValues);
         for (int32_t i = 0; i < 3; i++) {
           FXJSE_Value_Release(rgValues[i]);
         }
       } else {
         pContext->ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
       }
       FXJSE_Value_Release(jsObjectValue);
       FXJSE_Value_Release(propertyValue);
     } else if (FXJSE_Value_IsObject(argOne)) {
-      FXJSE_HVALUE rgValues[3];
+      CFXJSE_Value* rgValues[3];
       for (int32_t i = 0; i < 3; i++) {
         rgValues[i] = FXJSE_Value_Create(pIsolate);
       }
       FXJSE_Value_SetInteger(rgValues[0], 3);
       FXJSE_Value_SetNull(rgValues[1]);
       FXJSE_Value_Set(rgValues[2], argOne);
       FXJSE_Value_SetArray(args.GetReturnValue(), 3, rgValues);
       for (int32_t i = 0; i < 3; i++) {
         FXJSE_Value_Release(rgValues[i]);
       }
     } else if (FXJSE_Value_IsBoolean(argOne) ||
                FXJSE_Value_IsUTF8String(argOne) ||
                FXJSE_Value_IsNumber(argOne)) {
       FXJSE_Value_Set(args.GetReturnValue(), argOne);
     } else {
       pContext->ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
     }
     FXJSE_Value_Release(argOne);
   } else {
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"Ref");
   }
 }
-void CXFA_FM2JSContext::UnitType(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::UnitType(CFXJSE_Value* pThis,
                                  const CFX_ByteStringC& szFuncName,
                                  CFXJSE_Arguments& args) {
   if (args.GetLength() == 1) {
-    FXJSE_HVALUE unitspanValue = GetSimpleHValue(hThis, args, 0);
+    CFXJSE_Value* unitspanValue = GetSimpleValue(pThis, args, 0);
     if (FXJSE_Value_IsNull(unitspanValue)) {
       FXJSE_Value_SetNull(args.GetReturnValue());
       FXJSE_Value_Release(unitspanValue);
       return;
     }
     CFX_ByteString unitspanString;
-    HValueToUTF8String(unitspanValue, unitspanString);
+    ValueToUTF8String(unitspanValue, unitspanString);
     if (unitspanString.IsEmpty()) {
       FXJSE_Value_SetUTF8String(args.GetReturnValue(), "in");
     } else {
       enum XFA_FM2JS_VALUETYPE_ParserStatus {
         VALUETYPE_START,
         VALUETYPE_HAVEINVALIDCHAR,
         VALUETYPE_HAVEDIGIT,
         VALUETYPE_HAVEDIGITWHITE,
         VALUETYPE_ISCM,
         VALUETYPE_ISMM,
@@ skipping 80 matching lines @@
           FXJSE_Value_SetUTF8String(args.GetReturnValue(), "mp");
           break;
         default:
           FXJSE_Value_SetUTF8String(args.GetReturnValue(), "in");
           break;
       }
     }
     FXJSE_Value_Release(unitspanValue);
   } else {
     CXFA_FM2JSContext* pContext =
-        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"UnitType");
   }
 }
-void CXFA_FM2JSContext::UnitValue(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::UnitValue(CFXJSE_Value* pThis,
                                   const CFX_ByteStringC& szFuncName,
                                   CFXJSE_Arguments& args) {
   int32_t argc = args.GetLength();
   if ((argc == 1) || (argc == 2)) {
-    FXJSE_HVALUE unitspanValue = GetSimpleHValue(hThis, args, 0);
-    FXJSE_HVALUE unitValue = 0;
+    CFXJSE_Value* unitspanValue = GetSimpleValue(pThis, args, 0);
+    CFXJSE_Value* unitValue = nullptr;
     CFX_ByteString unitspanString;
     FX_DOUBLE dFirstNumber = 0;
     CFX_ByteString strFirstUnit;
     CFX_ByteString strUnit;
     if (FXJSE_Value_IsNull(unitspanValue)) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
-      HValueToUTF8String(unitspanValue, unitspanString);
+      ValueToUTF8String(unitspanValue, unitspanString);
       const FX_CHAR* pData = unitspanString.c_str();
       if (pData) {
         int32_t u = 0;
         while (*(pData + u) == 0x20 || *(pData + u) == 0x09 ||
                *(pData + u) == 0x0B || *(pData + u) == 0x0C ||
                *(pData + u) == 0x0A || *(pData + u) == 0x0D) {
           ++u;
         }
         while (u < unitspanString.GetLength()) {
           if ((*(pData + u) > '9' || *(pData + u) < '0') &&
@@ skipping 12 matching lines @@
         int32_t uLen = unitspanString.GetLength();
         while (u < uLen) {
           if (*(pData + u) == ' ') {
             break;
           }
           strFirstUnit += (*(pData + u));
           ++u;
         }
         strFirstUnit.MakeLower();
         if (argc == 2) {
-          unitValue = GetSimpleHValue(hThis, args, 1);
+          unitValue = GetSimpleValue(pThis, args, 1);
           CFX_ByteString unitTempString;
-          HValueToUTF8String(unitValue, unitTempString);
+          ValueToUTF8String(unitValue, unitTempString);
           const FX_CHAR* pData = unitTempString.c_str();
           int32_t u = 0;
           while (*(pData + u) == ' ' || *(pData + u) == 0x09 ||
                  *(pData + u) == 0x0B || *(pData + u) == 0x0C ||
                  *(pData + u) == 0x0A || *(pData + u) == 0x0D) {
             ++u;
           }
           while (u < unitTempString.GetLength()) {
             if ((*(pData + u) > '9' || *(pData + u) < '0') &&
                 *(pData + u) != '.') {
@@ skipping 84 matching lines @@
       } else {
         FXJSE_Value_SetInteger(args.GetReturnValue(), 0);
       }
     }
     FXJSE_Value_Release(unitspanValue);
     if (argc == 2) {
       FXJSE_Value_Release(unitValue);
     }
   } else {
     CXFA_FM2JSContext* pContext =
-        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"UnitValue");
   }
 }
-void CXFA_FM2JSContext::At(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::At(CFXJSE_Value* pThis,
                            const CFX_ByteStringC& szFuncName,
                            CFXJSE_Arguments& args) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   if (args.GetLength() == 2) {
-    FXJSE_HVALUE argOne = GetSimpleHValue(hThis, args, 0);
-    FXJSE_HVALUE argTwo = GetSimpleHValue(hThis, args, 1);
-    if (HValueIsNull(hThis, argOne) || HValueIsNull(hThis, argTwo)) {
+    CFXJSE_Value* argOne = GetSimpleValue(pThis, args, 0);
+    CFXJSE_Value* argTwo = GetSimpleValue(pThis, args, 1);
+    if (ValueIsNull(pThis, argOne) || ValueIsNull(pThis, argTwo)) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
       CFX_ByteString stringTwo;
-      HValueToUTF8String(argTwo, stringTwo);
+      ValueToUTF8String(argTwo, stringTwo);
       if (stringTwo.IsEmpty()) {
         FXJSE_Value_SetInteger(args.GetReturnValue(), 1);
       } else {
         CFX_ByteString stringOne;
-        HValueToUTF8String(argOne, stringOne);
+        ValueToUTF8String(argOne, stringOne);
         FX_STRSIZE iPosition = stringOne.Find(stringTwo.AsStringC());
         FXJSE_Value_SetInteger(args.GetReturnValue(), iPosition + 1);
       }
     }
     FXJSE_Value_Release(argOne);
     FXJSE_Value_Release(argTwo);
   } else {
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"At");
   }
 }
-void CXFA_FM2JSContext::Concat(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::Concat(CFXJSE_Value* pThis,
                                const CFX_ByteStringC& szFuncName,
                                CFXJSE_Arguments& args) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   int32_t argc = args.GetLength();
   if (argc >= 1) {
     CFX_ByteString resultString;
     FX_BOOL bAllNull = TRUE;
-    FXJSE_HVALUE* argValues = FX_Alloc(FXJSE_HVALUE, argc);
+    CFXJSE_Value** argValues = FX_Alloc(CFXJSE_Value*, argc);
     for (int32_t i = 0; i < argc; i++) {
-      argValues[i] = GetSimpleHValue(hThis, args, i);
-      if (!HValueIsNull(hThis, argValues[i])) {
+      argValues[i] = GetSimpleValue(pThis, args, i);
+      if (!ValueIsNull(pThis, argValues[i])) {
         CFX_ByteString valueStr;
-        HValueToUTF8String(argValues[i], valueStr);
+        ValueToUTF8String(argValues[i], valueStr);
         resultString += valueStr;
         bAllNull = FALSE;
       }
     }
     for (int32_t i = 0; i < argc; i++) {
       FXJSE_Value_Release(argValues[i]);
     }
     FX_Free(argValues);
     if (bAllNull) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
       FXJSE_Value_SetUTF8String(args.GetReturnValue(),
                                 resultString.AsStringC());
     }
   } else {
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"Concat");
   }
 }
-void CXFA_FM2JSContext::Decode(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::Decode(CFXJSE_Value* pThis,
                                const CFX_ByteStringC& szFuncName,
                                CFXJSE_Arguments& args) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   int32_t argc = args.GetLength();
   if (argc == 1) {
-    FXJSE_HVALUE argOne = GetSimpleHValue(hThis, args, 0);
-    if (HValueIsNull(hThis, argOne)) {
+    CFXJSE_Value* argOne = GetSimpleValue(pThis, args, 0);
+    if (ValueIsNull(pThis, argOne)) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
       CFX_ByteString toDecodeString;
-      HValueToUTF8String(argOne, toDecodeString);
+      ValueToUTF8String(argOne, toDecodeString);
       CFX_ByteTextBuf resultBuf;
       DecodeURL(toDecodeString.AsStringC(), resultBuf);
       FXJSE_Value_SetUTF8String(args.GetReturnValue(), resultBuf.AsStringC());
     }
     FXJSE_Value_Release(argOne);
   } else if (argc == 2) {
-    FXJSE_HVALUE argOne = GetSimpleHValue(hThis, args, 0);
-    FXJSE_HVALUE argTwo = GetSimpleHValue(hThis, args, 1);
-    if (HValueIsNull(hThis, argOne) || HValueIsNull(hThis, argTwo)) {
+    CFXJSE_Value* argOne = GetSimpleValue(pThis, args, 0);
+    CFXJSE_Value* argTwo = GetSimpleValue(pThis, args, 1);
+    if (ValueIsNull(pThis, argOne) || ValueIsNull(pThis, argTwo)) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
       CFX_ByteString toDecodeString;
-      HValueToUTF8String(argOne, toDecodeString);
+      ValueToUTF8String(argOne, toDecodeString);
       CFX_ByteString identifyString;
-      HValueToUTF8String(argTwo, identifyString);
+      ValueToUTF8String(argTwo, identifyString);
       CFX_ByteTextBuf resultBuf;
       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());
     }
@@ skipping 223 matching lines @@
     iStrIndex = 0;
     strString[iStrIndex] = 0;
     ++i;
     iCode = 0;
   }
   wsXMLBuf.AppendChar(0);
   szResultString.Clear();
   szResultString << FX_UTF8Encode(wsXMLBuf.GetBuffer(), wsXMLBuf.GetLength())
                         .AsStringC();
 }
-void CXFA_FM2JSContext::Encode(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::Encode(CFXJSE_Value* pThis,
                                const CFX_ByteStringC& szFuncName,
                                CFXJSE_Arguments& args) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   int32_t argc = args.GetLength();
   if (argc == 1) {
-    FXJSE_HVALUE argOne = GetSimpleHValue(hThis, args, 0);
-    if (HValueIsNull(hThis, argOne)) {
+    CFXJSE_Value* argOne = GetSimpleValue(pThis, args, 0);
+    if (ValueIsNull(pThis, argOne)) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
       CFX_ByteString toEncodeString;
-      HValueToUTF8String(argOne, toEncodeString);
+      ValueToUTF8String(argOne, toEncodeString);
       CFX_ByteTextBuf resultBuf;
       EncodeURL(toEncodeString.AsStringC(), resultBuf);
       FXJSE_Value_SetUTF8String(args.GetReturnValue(), resultBuf.AsStringC());
     }
     FXJSE_Value_Release(argOne);
   } else if (argc == 2) {
-    FXJSE_HVALUE argOne = GetSimpleHValue(hThis, args, 0);
-    FXJSE_HVALUE argTwo = GetSimpleHValue(hThis, args, 1);
-    if (HValueIsNull(hThis, argOne) || HValueIsNull(hThis, argTwo)) {
+    CFXJSE_Value* argOne = GetSimpleValue(pThis, args, 0);
+    CFXJSE_Value* argTwo = GetSimpleValue(pThis, args, 1);
+    if (ValueIsNull(pThis, argOne) || ValueIsNull(pThis, argTwo)) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
       CFX_ByteString toEncodeString;
-      HValueToUTF8String(argOne, toEncodeString);
+      ValueToUTF8String(argOne, toEncodeString);
       CFX_ByteString identifyString;
-      HValueToUTF8String(argTwo, identifyString);
+      ValueToUTF8String(argTwo, identifyString);
       CFX_ByteTextBuf resultBuf;
       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());
     }
@@ skipping 363 matching lines @@
         break;
       }
     }
     iIndex++;
   }
   if (patternType == XFA_VT_NULL) {
     patternType = XFA_VT_TEXT | XFA_VT_FLOAT;
   }
   return FALSE;
 }
-void CXFA_FM2JSContext::Format(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::Format(CFXJSE_Value* pThis,
                                const CFX_ByteStringC& szFuncName,
                                CFXJSE_Arguments& args) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   int32_t argc = args.GetLength();
   if (argc >= 2) {
-    FXJSE_HVALUE argOne = GetSimpleHValue(hThis, args, 0);
-    FXJSE_HVALUE argTwo = GetSimpleHValue(hThis, args, 1);
+    CFXJSE_Value* argOne = GetSimpleValue(pThis, args, 0);
+    CFXJSE_Value* argTwo = GetSimpleValue(pThis, args, 1);
     CFX_ByteString szPattern;
-    HValueToUTF8String(argOne, szPattern);
+    ValueToUTF8String(argOne, szPattern);
     CFX_ByteString szValue;
-    HValueToUTF8String(argTwo, szValue);
+    ValueToUTF8String(argTwo, szValue);
     CXFA_Document* pDoc = pContext->GetDocument();
     IFX_LocaleMgr* pMgr = (IFX_LocaleMgr*)pDoc->GetLocalMgr();
     CXFA_Node* pThisNode = ToNode(pDoc->GetScriptContext()->GetThisObject());
     ASSERT(pThisNode);
     CXFA_WidgetData widgetData(pThisNode);
     IFX_Locale* pLocale = widgetData.GetLocal();
     uint32_t patternType;
     FX_BOOL bCompelte =
         XFA_PATTERN_STRING_Type(szPattern.AsStringC(), patternType);
     CFX_WideString wsPattern = CFX_WideString::FromUTF8(szPattern.AsStringC());
@@ skipping 55 matching lines @@
     } else {
       FXJSE_Value_SetUTF8String(args.GetReturnValue(), "");
     }
     FXJSE_Value_Release(argOne);
     FXJSE_Value_Release(argTwo);
   } else {
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"Format");
   }
 }
-void CXFA_FM2JSContext::Left(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::Left(CFXJSE_Value* pThis,
                              const CFX_ByteStringC& szFuncName,
                              CFXJSE_Arguments& args) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   if (args.GetLength() == 2) {
-    FXJSE_HVALUE argOne = GetSimpleHValue(hThis, args, 0);
-    FXJSE_HVALUE argTwo = GetSimpleHValue(hThis, args, 1);
+    CFXJSE_Value* argOne = GetSimpleValue(pThis, args, 0);
+    CFXJSE_Value* argTwo = GetSimpleValue(pThis, args, 1);
     FX_BOOL argIsNull = FALSE;
-    if ((HValueIsNull(hThis, argOne)) || (HValueIsNull(hThis, argTwo))) {
+    if ((ValueIsNull(pThis, argOne)) || (ValueIsNull(pThis, argTwo))) {
       argIsNull = TRUE;
     }
     if (argIsNull) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
       CFX_ByteString sourceString;
-      HValueToUTF8String(argOne, sourceString);
-      int32_t count = HValueToInteger(hThis, argTwo);
+      ValueToUTF8String(argOne, sourceString);
+      int32_t count = ValueToInteger(pThis, argTwo);
       if (count < 0) {
         count = 0;
       }
       FXJSE_Value_SetUTF8String(args.GetReturnValue(),
                                 sourceString.Left(count).AsStringC());
     }
     FXJSE_Value_Release(argOne);
     FXJSE_Value_Release(argTwo);
   } else {
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"Left");
   }
 }
-void CXFA_FM2JSContext::Len(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::Len(CFXJSE_Value* pThis,
                             const CFX_ByteStringC& szFuncName,
                             CFXJSE_Arguments& args) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   if (args.GetLength() == 1) {
-    FXJSE_HVALUE argOne = GetSimpleHValue(hThis, args, 0);
-    if (HValueIsNull(hThis, argOne)) {
+    CFXJSE_Value* argOne = GetSimpleValue(pThis, args, 0);
+    if (ValueIsNull(pThis, argOne)) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
       CFX_ByteString sourceString;
-      HValueToUTF8String(argOne, sourceString);
+      ValueToUTF8String(argOne, sourceString);
       FXJSE_Value_SetInteger(args.GetReturnValue(), sourceString.GetLength());
     }
     FXJSE_Value_Release(argOne);
   } else {
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"Len");
   }
 }
-void CXFA_FM2JSContext::Lower(FXJSE_HOBJECT hThis,
+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;
-    FXJSE_HVALUE argOne = GetSimpleHValue(hThis, args, 0);
-    FXJSE_HVALUE localeValue = 0;
-    if (HValueIsNull(hThis, argOne)) {
+    CFXJSE_Value* argOne = GetSimpleValue(pThis, args, 0);
+    CFXJSE_Value* localeValue = nullptr;
+    if (ValueIsNull(pThis, argOne)) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
       if (argc == 2) {
-        localeValue = GetSimpleHValue(hThis, args, 1);
+        localeValue = GetSimpleValue(pThis, args, 1);
       }
-      HValueToUTF8String(argOne, argString);
+      ValueToUTF8String(argOne, argString);
       CFX_WideTextBuf lowStringBuf;
       CFX_WideString wsArgString =
           CFX_WideString::FromUTF8(argString.AsStringC());
       const FX_WCHAR* pData = wsArgString.c_str();
       int32_t iLen = argString.GetLength();
       int32_t i = 0;
       int32_t ch = 0;
       while (i < iLen) {
         ch = *(pData + i);
         if (ch >= 0x41 && ch <= 0x5A) {
@@ skipping 11 matching lines @@
           args.GetReturnValue(),
           FX_UTF8Encode(lowStringBuf.GetBuffer(), lowStringBuf.GetLength())
               .AsStringC());
       if (argc == 2) {
         FXJSE_Value_Release(localeValue);
       }
     }
     FXJSE_Value_Release(argOne);
   } else {
     CXFA_FM2JSContext* pContext =
-        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"Lower");
   }
 }
-void CXFA_FM2JSContext::Ltrim(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::Ltrim(CFXJSE_Value* pThis,
                               const CFX_ByteStringC& szFuncName,
                               CFXJSE_Arguments& args) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   if (args.GetLength() == 1) {
-    FXJSE_HVALUE argOne = GetSimpleHValue(hThis, args, 0);
-    if (HValueIsNull(hThis, argOne)) {
+    CFXJSE_Value* argOne = GetSimpleValue(pThis, args, 0);
+    if (ValueIsNull(pThis, argOne)) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
       CFX_ByteString sourceString;
-      HValueToUTF8String(argOne, sourceString);
+      ValueToUTF8String(argOne, sourceString);
       sourceString.TrimLeft();
       FXJSE_Value_SetUTF8String(args.GetReturnValue(),
                                 sourceString.AsStringC());
     }
     FXJSE_Value_Release(argOne);
   } else {
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"Ltrim");
   }
 }
-void CXFA_FM2JSContext::Parse(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::Parse(CFXJSE_Value* pThis,
                               const CFX_ByteStringC& szFuncName,
                               CFXJSE_Arguments& args) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   if (args.GetLength() == 2) {
-    FXJSE_HVALUE argOne = GetSimpleHValue(hThis, args, 0);
-    FXJSE_HVALUE argTwo = GetSimpleHValue(hThis, args, 1);
-    if (HValueIsNull(hThis, argTwo)) {
+    CFXJSE_Value* argOne = GetSimpleValue(pThis, args, 0);
+    CFXJSE_Value* argTwo = GetSimpleValue(pThis, args, 1);
+    if (ValueIsNull(pThis, argTwo)) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
       CFX_ByteString szPattern;
-      HValueToUTF8String(argOne, szPattern);
+      ValueToUTF8String(argOne, szPattern);
       CFX_ByteString szValue;
-      HValueToUTF8String(argTwo, szValue);
+      ValueToUTF8String(argTwo, szValue);
       CXFA_Document* pDoc = pContext->GetDocument();
       IFX_LocaleMgr* pMgr = (IFX_LocaleMgr*)pDoc->GetLocalMgr();
       CXFA_Node* pThisNode = ToNode(pDoc->GetScriptContext()->GetThisObject());
       ASSERT(pThisNode);
       CXFA_WidgetData widgetData(pThisNode);
       IFX_Locale* pLocale = widgetData.GetLocal();
       uint32_t patternType;
       FX_BOOL bCompletePattern =
           XFA_PATTERN_STRING_Type(szPattern.AsStringC(), patternType);
       CFX_WideString wsPattern =
@@ skipping 108 matching lines @@
         }
       }
     }
     FXJSE_Value_Release(argOne);
     FXJSE_Value_Release(argTwo);
   } else {
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"Parse");
   }
 }
-void CXFA_FM2JSContext::Replace(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::Replace(CFXJSE_Value* pThis,
                                 const CFX_ByteStringC& szFuncName,
                                 CFXJSE_Arguments& args) {
   int32_t argc = args.GetLength();
   if ((argc == 2) || (argc == 3)) {
-    FXJSE_HVALUE argOne = GetSimpleHValue(hThis, args, 0);
-    FXJSE_HVALUE argTwo = GetSimpleHValue(hThis, args, 1);
-    FXJSE_HVALUE argThree = 0;
+    CFXJSE_Value* argOne = GetSimpleValue(pThis, args, 0);
+    CFXJSE_Value* argTwo = GetSimpleValue(pThis, args, 1);
+    CFXJSE_Value* argThree = nullptr;
     CFX_ByteString oneString;
     CFX_ByteString twoString;
     CFX_ByteString threeString;
-    if (!HValueIsNull(hThis, argOne) && !HValueIsNull(hThis, argTwo)) {
-      HValueToUTF8String(argOne, oneString);
-      HValueToUTF8String(argTwo, twoString);
+    if (!ValueIsNull(pThis, argOne) && !ValueIsNull(pThis, argTwo)) {
+      ValueToUTF8String(argOne, oneString);
+      ValueToUTF8String(argTwo, twoString);
     }
     if (argc == 3) {
-      argThree = GetSimpleHValue(hThis, args, 2);
-      HValueToUTF8String(argThree, threeString);
+      argThree = GetSimpleValue(pThis, args, 2);
+      ValueToUTF8String(argThree, threeString);
     }
     int32_t iSrcLen = oneString.GetLength();
     int32_t iFindLen = twoString.GetLength();
     CFX_ByteTextBuf resultString;
     int32_t iFindIndex = 0;
     uint8_t ch = 0;
     for (int32_t u = 0; u < iSrcLen; ++u) {
       ch = oneString.GetAt(u);
       if (ch == twoString.GetAt(iFindIndex)) {
         int32_t iTemp = u + 1;
@@ skipping 22 matching lines @@
     }
     resultString.AppendChar(0);
     FXJSE_Value_SetUTF8String(args.GetReturnValue(), resultString.AsStringC());
     FXJSE_Value_Release(argOne);
     FXJSE_Value_Release(argTwo);
     if (argc == 3) {
       FXJSE_Value_Release(argThree);
     }
   } else {
     CXFA_FM2JSContext* pContext =
-        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"Replace");
   }
 }
-void CXFA_FM2JSContext::Right(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::Right(CFXJSE_Value* pThis,
                               const CFX_ByteStringC& szFuncName,
                               CFXJSE_Arguments& args) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   if (args.GetLength() == 2) {
-    FXJSE_HVALUE argOne = GetSimpleHValue(hThis, args, 0);
-    FXJSE_HVALUE argTwo = GetSimpleHValue(hThis, args, 1);
+    CFXJSE_Value* argOne = GetSimpleValue(pThis, args, 0);
+    CFXJSE_Value* argTwo = GetSimpleValue(pThis, args, 1);
     FX_BOOL argIsNull = FALSE;
-    if ((HValueIsNull(hThis, argOne)) || (HValueIsNull(hThis, argTwo))) {
+    if ((ValueIsNull(pThis, argOne)) || (ValueIsNull(pThis, argTwo))) {
       argIsNull = TRUE;
     }
     if (argIsNull) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
       CFX_ByteString sourceString;
-      HValueToUTF8String(argOne, sourceString);
-      int32_t count = HValueToInteger(hThis, argTwo);
+      ValueToUTF8String(argOne, sourceString);
+      int32_t count = ValueToInteger(pThis, argTwo);
       if (count < 0) {
         count = 0;
       }
       FXJSE_Value_SetUTF8String(args.GetReturnValue(),
                                 sourceString.Right(count).AsStringC());
     }
     FXJSE_Value_Release(argOne);
     FXJSE_Value_Release(argTwo);
   } else {
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"Right");
   }
 }
-void CXFA_FM2JSContext::Rtrim(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::Rtrim(CFXJSE_Value* pThis,
                               const CFX_ByteStringC& szFuncName,
                               CFXJSE_Arguments& args) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   if (args.GetLength() == 1) {
-    FXJSE_HVALUE argOne = GetSimpleHValue(hThis, args, 0);
-    if (HValueIsNull(hThis, argOne)) {
+    CFXJSE_Value* argOne = GetSimpleValue(pThis, args, 0);
+    if (ValueIsNull(pThis, argOne)) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
       CFX_ByteString sourceString;
-      HValueToUTF8String(argOne, sourceString);
+      ValueToUTF8String(argOne, sourceString);
       sourceString.TrimRight();
       FXJSE_Value_SetUTF8String(args.GetReturnValue(),
                                 sourceString.AsStringC());
     }
     FXJSE_Value_Release(argOne);
   } else {
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"Rtrim");
   }
 }
-void CXFA_FM2JSContext::Space(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::Space(CFXJSE_Value* pThis,
                               const CFX_ByteStringC& szFuncName,
                               CFXJSE_Arguments& args) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   if (args.GetLength() == 1) {
-    FXJSE_HVALUE argOne = GetSimpleHValue(hThis, args, 0);
+    CFXJSE_Value* argOne = GetSimpleValue(pThis, args, 0);
     if (FXJSE_Value_IsNull(argOne)) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
       int32_t count = 0;
-      count = HValueToInteger(hThis, argOne);
+      count = ValueToInteger(pThis, argOne);
       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());
     }
     FXJSE_Value_Release(argOne);
   } else {
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"Space");
   }
 }
-void CXFA_FM2JSContext::Str(FXJSE_HOBJECT hThis,
+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;
     FX_FLOAT fNumber = 0.0f;
     int32_t iWidth = 10;
     int32_t iPrecision = 0;
-    FXJSE_HVALUE numberValue = GetSimpleHValue(hThis, args, 0);
-    FXJSE_HVALUE widthValue = 0;
-    FXJSE_HVALUE precisionValue = 0;
+    CFXJSE_Value* numberValue = GetSimpleValue(pThis, args, 0);
+    CFXJSE_Value* widthValue = nullptr;
+    CFXJSE_Value* precisionValue = nullptr;
     if (FXJSE_Value_IsNull(numberValue)) {
       bFlags = TRUE;
     } else {
-      fNumber = HValueToFloat(hThis, numberValue);
+      fNumber = ValueToFloat(pThis, numberValue);
     }
     if (argc > 1) {
-      widthValue = GetSimpleHValue(hThis, args, 1);
-      iWidth = (int32_t)HValueToFloat(hThis, widthValue);
+      widthValue = GetSimpleValue(pThis, args, 1);
+      iWidth = (int32_t)ValueToFloat(pThis, widthValue);
     }
     if (argc == 3) {
-      precisionValue = GetSimpleHValue(hThis, args, 2);
-      iPrecision = (int32_t)HValueToFloat(hThis, precisionValue);
+      precisionValue = GetSimpleValue(pThis, args, 2);
+      iPrecision = (int32_t)ValueToFloat(pThis, precisionValue);
       if (iPrecision < 0) {
         iPrecision = 0;
       }
     }
     if (!bFlags) {
       CFX_ByteString numberString;
       CFX_ByteString formatStr = "%";
       if (iPrecision) {
         formatStr += ".";
         formatStr += CFX_ByteString::FormatInteger(iPrecision);
@@ skipping 77 matching lines @@
     }
     FXJSE_Value_Release(numberValue);
     if (argc > 1) {
       FXJSE_Value_Release(widthValue);
       if (argc == 3) {
         FXJSE_Value_Release(precisionValue);
       }
     }
   } else {
     CXFA_FM2JSContext* pContext =
-        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"Str");
   }
 }
-void CXFA_FM2JSContext::Stuff(FXJSE_HOBJECT hThis,
+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;
     CFX_ByteString insertString;
     int32_t iLength = 0;
     int32_t iStart = 0;
     int32_t iDelete = 0;
-    FXJSE_HVALUE sourceValue = GetSimpleHValue(hThis, args, 0);
-    FXJSE_HVALUE startValue = GetSimpleHValue(hThis, args, 1);
-    FXJSE_HVALUE deleteValue = GetSimpleHValue(hThis, args, 2);
-    FXJSE_HVALUE insertValue = 0;
+    CFXJSE_Value* sourceValue = GetSimpleValue(pThis, args, 0);
+    CFXJSE_Value* startValue = GetSimpleValue(pThis, args, 1);
+    CFXJSE_Value* deleteValue = GetSimpleValue(pThis, args, 2);
+    CFXJSE_Value* insertValue = nullptr;
     if (!FXJSE_Value_IsNull(sourceValue) && !FXJSE_Value_IsNull(startValue) &&
         !FXJSE_Value_IsNull(deleteValue)) {
-      HValueToUTF8String(sourceValue, sourceString);
+      ValueToUTF8String(sourceValue, sourceString);
       iLength = sourceString.GetLength();
-      iStart = (int32_t)HValueToFloat(hThis, startValue);
+      iStart = (int32_t)ValueToFloat(pThis, startValue);
       if (iStart < 1) {
         iStart = 1;
       }
       if (iStart > iLength) {
         iStart = iLength;
       }
-      iDelete = (int32_t)HValueToFloat(hThis, deleteValue);
+      iDelete = (int32_t)ValueToFloat(pThis, deleteValue);
       if (iDelete <= 0) {
         iDelete = 0;
       }
     }
     if (argc == 4) {
-      insertValue = GetSimpleHValue(hThis, args, 3);
-      HValueToUTF8String(insertValue, insertString);
+      insertValue = GetSimpleValue(pThis, args, 3);
+      ValueToUTF8String(insertValue, insertString);
     }
     iStart -= 1;
     CFX_ByteTextBuf resultString;
     int32_t i = 0;
     while (i < iStart) {
       resultString.AppendChar(sourceString.GetAt(i));
       ++i;
     }
     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());
     FXJSE_Value_Release(sourceValue);
     FXJSE_Value_Release(startValue);
     FXJSE_Value_Release(deleteValue);
     if (argc == 4) {
       FXJSE_Value_Release(insertValue);
     }
   } else {
     CXFA_FM2JSContext* pContext =
-        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"Stuff");
   }
 }
-void CXFA_FM2JSContext::Substr(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::Substr(CFXJSE_Value* pThis,
                                const CFX_ByteStringC& szFuncName,
                                CFXJSE_Arguments& args) {
   int32_t argc = args.GetLength();
   if (argc == 3) {
-    FXJSE_HVALUE stringValue = GetSimpleHValue(hThis, args, 0);
-    FXJSE_HVALUE startValue = GetSimpleHValue(hThis, args, 1);
-    FXJSE_HVALUE endValue = GetSimpleHValue(hThis, args, 2);
-    if (HValueIsNull(hThis, stringValue) || (HValueIsNull(hThis, startValue)) ||
-        (HValueIsNull(hThis, endValue))) {
+    CFXJSE_Value* stringValue = GetSimpleValue(pThis, args, 0);
+    CFXJSE_Value* startValue = GetSimpleValue(pThis, args, 1);
+    CFXJSE_Value* endValue = GetSimpleValue(pThis, args, 2);
+    if (ValueIsNull(pThis, stringValue) || (ValueIsNull(pThis, startValue)) ||
+        (ValueIsNull(pThis, endValue))) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
       CFX_ByteString szSourceStr;
       int32_t iStart = 0;
       int32_t iCount = 0;
-      HValueToUTF8String(stringValue, szSourceStr);
+      ValueToUTF8String(stringValue, szSourceStr);
       int32_t iLength = szSourceStr.GetLength();
       if (iLength == 0) {
         FXJSE_Value_SetUTF8String(args.GetReturnValue(), "");
       } else {
-        iStart = (int32_t)HValueToFloat(hThis, startValue);
-        iCount = (int32_t)HValueToFloat(hThis, endValue);
+        iStart = (int32_t)ValueToFloat(pThis, startValue);
+        iCount = (int32_t)ValueToFloat(pThis, endValue);
         if (iStart < 1) {
           iStart = 1;
         }
         if (iStart > iLength) {
           iStart = iLength;
         }
         if (iCount <= 0) {
           iCount = 0;
         }
         iStart -= 1;
         FXJSE_Value_SetUTF8String(args.GetReturnValue(),
                                   szSourceStr.Mid(iStart, iCount).AsStringC());
       }
     }
     FXJSE_Value_Release(stringValue);
     FXJSE_Value_Release(startValue);
     FXJSE_Value_Release(endValue);
   } else {
     CXFA_FM2JSContext* pContext =
-        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"Substr");
   }
 }
-void CXFA_FM2JSContext::Uuid(FXJSE_HOBJECT hThis,
+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;
-    FXJSE_HVALUE argOne = 0;
+    CFXJSE_Value* argOne = nullptr;
     if (argc == 1) {
-      argOne = GetSimpleHValue(hThis, args, 0);
-      iNum = (int32_t)HValueToFloat(hThis, argOne);
+      argOne = GetSimpleValue(pThis, args, 0);
+      iNum = (int32_t)ValueToFloat(pThis, argOne);
     }
     FX_GUID guid;
     FX_GUID_CreateV4(&guid);
     CFX_ByteString bsUId;
     FX_GUID_ToString(&guid, bsUId, iNum);
     FXJSE_Value_SetUTF8String(args.GetReturnValue(), bsUId.AsStringC());
     if (argc == 1) {
       FXJSE_Value_Release(argOne);
     }
   } else {
     CXFA_FM2JSContext* pContext =
-        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"Uuid");
   }
 }
-void CXFA_FM2JSContext::Upper(FXJSE_HOBJECT hThis,
+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;
-    FXJSE_HVALUE argOne = GetSimpleHValue(hThis, args, 0);
-    FXJSE_HVALUE localeValue = 0;
-    if (HValueIsNull(hThis, argOne)) {
+    CFXJSE_Value* argOne = GetSimpleValue(pThis, args, 0);
+    CFXJSE_Value* localeValue = nullptr;
+    if (ValueIsNull(pThis, argOne)) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
       if (argc == 2) {
-        localeValue = GetSimpleHValue(hThis, args, 1);
+        localeValue = GetSimpleValue(pThis, args, 1);
       }
-      HValueToUTF8String(argOne, argString);
+      ValueToUTF8String(argOne, argString);
       CFX_WideTextBuf upperStringBuf;
       CFX_WideString wsArgString =
           CFX_WideString::FromUTF8(argString.AsStringC());
       const FX_WCHAR* pData = wsArgString.c_str();
       int32_t iLen = wsArgString.GetLength();
       int32_t i = 0;
       int32_t ch = 0;
       while (i < iLen) {
         ch = *(pData + i);
         if (ch >= 0x61 && ch <= 0x7A) {
@@ skipping 11 matching lines @@
           args.GetReturnValue(),
           FX_UTF8Encode(upperStringBuf.GetBuffer(), upperStringBuf.GetLength())
               .AsStringC());
       if (argc == 2) {
         FXJSE_Value_Release(localeValue);
       }
     }
     FXJSE_Value_Release(argOne);
   } else {
     CXFA_FM2JSContext* pContext =
-        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"Upper");
   }
 }
-void CXFA_FM2JSContext::WordNum(FXJSE_HOBJECT hThis,
+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;
     FX_FLOAT fNumber = 0.0f;
     int32_t iIdentifier = 0;
     CFX_ByteString localeString;
-    FXJSE_HVALUE numberValue = GetSimpleHValue(hThis, args, 0);
-    FXJSE_HVALUE identifierValue = 0;
-    FXJSE_HVALUE localeValue = 0;
+    CFXJSE_Value* numberValue = GetSimpleValue(pThis, args, 0);
+    CFXJSE_Value* identifierValue = nullptr;
+    CFXJSE_Value* localeValue = nullptr;
     if (FXJSE_Value_IsNull(numberValue)) {
       bFlags = TRUE;
     } else {
-      fNumber = HValueToFloat(hThis, numberValue);
+      fNumber = ValueToFloat(pThis, numberValue);
     }
     if (argc > 1) {
-      identifierValue = GetSimpleHValue(hThis, args, 1);
+      identifierValue = GetSimpleValue(pThis, args, 1);
       if (FXJSE_Value_IsNull(identifierValue)) {
         bFlags = TRUE;
       } else {
-        iIdentifier = (int32_t)HValueToFloat(hThis, identifierValue);
+        iIdentifier = (int32_t)ValueToFloat(pThis, identifierValue);
       }
     }
     if (argc == 3) {
-      localeValue = GetSimpleHValue(hThis, args, 2);
+      localeValue = GetSimpleValue(pThis, args, 2);
       if (FXJSE_Value_IsNull(localeValue)) {
         bFlags = TRUE;
       } else {
-        HValueToUTF8String(localeValue, localeString);
+        ValueToUTF8String(localeValue, localeString);
       }
     }
     if (!bFlags) {
       if ((fNumber < 0) || (fNumber > 922337203685477550)) {
         FXJSE_Value_SetUTF8String(args.GetReturnValue(), "*");
       } else {
         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());
     }
     FXJSE_Value_Release(numberValue);
     if (argc > 1) {
       FXJSE_Value_Release(identifierValue);
       if (argc == 3) {
         FXJSE_Value_Release(localeValue);
       }
     }
   } else {
     CXFA_FM2JSContext* pContext =
-        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"WordNum");
   }
 }
 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 179 matching lines @@
             strBuf << " Trillion ";
           }
         }
         strBuf << " Cents";
       }
     } break;
     default:
       break;
   }
 }
-void CXFA_FM2JSContext::Get(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::Get(CFXJSE_Value* pThis,
                             const CFX_ByteStringC& szFuncName,
                             CFXJSE_Arguments& args) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   int32_t argc = args.GetLength();
   if (argc == 1) {
     CXFA_Document* pDoc = pContext->GetDocument();
     if (!pDoc) {
       return;
     }
     IXFA_AppProvider* pAppProvider =
         pDoc->GetParser()->GetNotify()->GetAppProvider();
     if (!pAppProvider) {
       return;
     }
-    FXJSE_HVALUE argOne = GetSimpleHValue(hThis, args, 0);
+    CFXJSE_Value* argOne = GetSimpleValue(pThis, args, 0);
     CFX_ByteString urlString;
-    HValueToUTF8String(argOne, urlString);
+    ValueToUTF8String(argOne, urlString);
     IFX_FileRead* pFile = pAppProvider->DownloadURL(
         CFX_WideString::FromUTF8(urlString.AsStringC()));
     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();
     }
     FXJSE_Value_Release(argOne);
   } else {
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"Get");
   }
 }
-void CXFA_FM2JSContext::Post(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::Post(CFXJSE_Value* pThis,
                              const CFX_ByteStringC& szFuncName,
                              CFXJSE_Arguments& args) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   int32_t argc = args.GetLength();
   if ((argc >= 2) && (argc <= 5)) {
     CXFA_Document* pDoc = pContext->GetDocument();
     if (!pDoc) {
       return;
     }
     IXFA_AppProvider* pAppProvider =
         pDoc->GetParser()->GetNotify()->GetAppProvider();
     if (!pAppProvider) {
       return;
     }
     CFX_ByteString bsURL;
     CFX_ByteString bsData;
     CFX_ByteString bsContentType;
     CFX_ByteString bsEncode;
     CFX_ByteString bsHeader;
-    FXJSE_HVALUE argThree = nullptr;
-    FXJSE_HVALUE argFour = nullptr;
-    FXJSE_HVALUE argFive = nullptr;
-    FXJSE_HVALUE argOne = GetSimpleHValue(hThis, args, 0);
-    HValueToUTF8String(argOne, bsURL);
-    FXJSE_HVALUE argTwo = GetSimpleHValue(hThis, args, 1);
-    HValueToUTF8String(argTwo, bsData);
+    CFXJSE_Value* argThree = nullptr;
+    CFXJSE_Value* argFour = nullptr;
+    CFXJSE_Value* argFive = nullptr;
+    CFXJSE_Value* argOne = GetSimpleValue(pThis, args, 0);
+    ValueToUTF8String(argOne, bsURL);
+    CFXJSE_Value* argTwo = GetSimpleValue(pThis, args, 1);
+    ValueToUTF8String(argTwo, bsData);
     if (argc > 2) {
-      argThree = GetSimpleHValue(hThis, args, 2);
-      HValueToUTF8String(argThree, bsContentType);
+      argThree = GetSimpleValue(pThis, args, 2);
+      ValueToUTF8String(argThree, bsContentType);
     }
     if (argc > 3) {
-      argFour = GetSimpleHValue(hThis, args, 3);
-      HValueToUTF8String(argFour, bsEncode);
+      argFour = GetSimpleValue(pThis, args, 3);
+      ValueToUTF8String(argFour, bsEncode);
     }
     if (argc > 4) {
-      argFive = GetSimpleHValue(hThis, args, 4);
-      HValueToUTF8String(argFive, bsHeader);
+      argFive = GetSimpleValue(pThis, args, 4);
+      ValueToUTF8String(argFive, bsHeader);
     }
     CFX_WideString decodedResponse;
     FX_BOOL bFlags = pAppProvider->PostRequestURL(
         CFX_WideString::FromUTF8(bsURL.AsStringC()),
         CFX_WideString::FromUTF8(bsData.AsStringC()),
         CFX_WideString::FromUTF8(bsContentType.AsStringC()),
         CFX_WideString::FromUTF8(bsEncode.AsStringC()),
         CFX_WideString::FromUTF8(bsHeader.AsStringC()), decodedResponse);
     FXJSE_Value_Release(argOne);
     FXJSE_Value_Release(argTwo);
@@ skipping 12 matching lines @@
           FX_UTF8Encode(decodedResponse.c_str(), decodedResponse.GetLength())
               .AsStringC());
     } else {
       pContext->ThrowScriptErrorMessage(XFA_IDS_SERVER_DENY);
     }
   } else {
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"Post");
   }
 }
-void CXFA_FM2JSContext::Put(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::Put(CFXJSE_Value* pThis,
                             const CFX_ByteStringC& szFuncName,
                             CFXJSE_Arguments& args) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   int32_t argc = args.GetLength();
   if ((argc == 2) || (argc == 3)) {
     CXFA_Document* pDoc = pContext->GetDocument();
     if (!pDoc) {
       return;
     }
     IXFA_AppProvider* pAppProvider =
         pDoc->GetParser()->GetNotify()->GetAppProvider();
     if (!pAppProvider) {
       return;
     }
     CFX_ByteString bsURL;
     CFX_ByteString bsData;
     CFX_ByteString bsEncode;
-    FXJSE_HVALUE argThree = nullptr;
-    FXJSE_HVALUE argOne = GetSimpleHValue(hThis, args, 0);
-    HValueToUTF8String(argOne, bsURL);
-    FXJSE_HVALUE argTwo = GetSimpleHValue(hThis, args, 1);
-    HValueToUTF8String(argTwo, bsData);
+    CFXJSE_Value* argThree = nullptr;
+    CFXJSE_Value* argOne = GetSimpleValue(pThis, args, 0);
+    ValueToUTF8String(argOne, bsURL);
+    CFXJSE_Value* argTwo = GetSimpleValue(pThis, args, 1);
+    ValueToUTF8String(argTwo, bsData);
     if (argc > 2) {
-      argThree = GetSimpleHValue(hThis, args, 2);
-      HValueToUTF8String(argThree, bsEncode);
+      argThree = GetSimpleValue(pThis, args, 2);
+      ValueToUTF8String(argThree, bsEncode);
     }
     FX_BOOL bFlags = pAppProvider->PutRequestURL(
         CFX_WideString::FromUTF8(bsURL.AsStringC()),
         CFX_WideString::FromUTF8(bsData.AsStringC()),
         CFX_WideString::FromUTF8(bsEncode.AsStringC()));
     FXJSE_Value_Release(argOne);
     FXJSE_Value_Release(argTwo);
     if (argc > 2) {
       FXJSE_Value_Release(argThree);
     }
     if (bFlags) {
       FXJSE_Value_SetUTF8String(args.GetReturnValue(), "");
     } else {
       pContext->ThrowScriptErrorMessage(XFA_IDS_SERVER_DENY);
     }
   } else {
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"Put");
   }
 }
-void CXFA_FM2JSContext::assign_value_operator(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::assign_value_operator(CFXJSE_Value* pThis,
                                               const CFX_ByteStringC& szFuncName,
                                               CFXJSE_Arguments& args) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   v8::Isolate* pIsolate = pContext->GetScriptRuntime();
   if (args.GetLength() == 2) {
-    FXJSE_HVALUE lValue = args.GetValue(0);
-    FXJSE_HVALUE rValue = GetSimpleHValue(hThis, args, 1);
+    CFXJSE_Value* lValue = args.GetValue(0);
+    CFXJSE_Value* rValue = GetSimpleValue(pThis, args, 1);
     FX_BOOL bSetStatus = TRUE;
     if (FXJSE_Value_IsArray(lValue)) {
-      FXJSE_HVALUE leftLengthValue = FXJSE_Value_Create(pIsolate);
+      CFXJSE_Value* leftLengthValue = FXJSE_Value_Create(pIsolate);
       FXJSE_Value_GetObjectProp(lValue, "length", leftLengthValue);
       int32_t iLeftLength = FXJSE_Value_ToInteger(leftLengthValue);
       FXJSE_Value_Release(leftLengthValue);
-      FXJSE_HVALUE jsObjectValue = FXJSE_Value_Create(pIsolate);
-      FXJSE_HVALUE propertyValue = FXJSE_Value_Create(pIsolate);
+      CFXJSE_Value* jsObjectValue = FXJSE_Value_Create(pIsolate);
+      CFXJSE_Value* propertyValue = FXJSE_Value_Create(pIsolate);
       FXJSE_Value_GetObjectPropByIdx(lValue, 1, propertyValue);
       if (FXJSE_Value_IsNull(propertyValue)) {
         for (int32_t i = 2; i < iLeftLength; i++) {
           FXJSE_Value_GetObjectPropByIdx(lValue, i, jsObjectValue);
           bSetStatus = SetObjectDefaultValue(jsObjectValue, rValue);
           if (!bSetStatus) {
             pContext->ThrowScriptErrorMessage(XFA_IDS_NOT_DEFAUL_VALUE);
             break;
           }
         }
@@ skipping 14 matching lines @@
         pContext->ThrowScriptErrorMessage(XFA_IDS_NOT_DEFAUL_VALUE);
       }
     }
     FXJSE_Value_Set(args.GetReturnValue(), rValue);
     FXJSE_Value_Release(lValue);
     FXJSE_Value_Release(rValue);
   } else {
     pContext->ThrowScriptErrorMessage(XFA_IDS_COMPILER_ERROR);
   }
 }
-void CXFA_FM2JSContext::logical_or_operator(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::logical_or_operator(CFXJSE_Value* pThis,
                                             const CFX_ByteStringC& szFuncName,
                                             CFXJSE_Arguments& args) {
   if (args.GetLength() == 2) {
-    FXJSE_HVALUE argFirst = GetSimpleHValue(hThis, args, 0);
-    FXJSE_HVALUE argSecond = GetSimpleHValue(hThis, args, 1);
+    CFXJSE_Value* argFirst = GetSimpleValue(pThis, args, 0);
+    CFXJSE_Value* argSecond = GetSimpleValue(pThis, args, 1);
     if (FXJSE_Value_IsNull(argFirst) && FXJSE_Value_IsNull(argSecond)) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
-      FX_FLOAT first = HValueToFloat(hThis, argFirst);
-      FX_FLOAT second = HValueToFloat(hThis, argSecond);
+      FX_FLOAT first = ValueToFloat(pThis, argFirst);
+      FX_FLOAT second = ValueToFloat(pThis, argSecond);
       FXJSE_Value_SetInteger(args.GetReturnValue(), (first || second) ? 1 : 0);
     }
     FXJSE_Value_Release(argFirst);
     FXJSE_Value_Release(argSecond);
   } else {
     CXFA_FM2JSContext* pContext =
-        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
     pContext->ThrowScriptErrorMessage(XFA_IDS_COMPILER_ERROR);
   }
 }
-void CXFA_FM2JSContext::logical_and_operator(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::logical_and_operator(CFXJSE_Value* pThis,
                                              const CFX_ByteStringC& szFuncName,
                                              CFXJSE_Arguments& args) {
   if (args.GetLength() == 2) {
-    FXJSE_HVALUE argFirst = GetSimpleHValue(hThis, args, 0);
-    FXJSE_HVALUE argSecond = GetSimpleHValue(hThis, args, 1);
+    CFXJSE_Value* argFirst = GetSimpleValue(pThis, args, 0);
+    CFXJSE_Value* argSecond = GetSimpleValue(pThis, args, 1);
     if (FXJSE_Value_IsNull(argFirst) && FXJSE_Value_IsNull(argSecond)) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
-      FX_FLOAT first = HValueToFloat(hThis, argFirst);
-      FX_FLOAT second = HValueToFloat(hThis, argSecond);
+      FX_FLOAT first = ValueToFloat(pThis, argFirst);
+      FX_FLOAT second = ValueToFloat(pThis, argSecond);
       FXJSE_Value_SetInteger(args.GetReturnValue(), (first && second) ? 1 : 0);
     }
     FXJSE_Value_Release(argFirst);
     FXJSE_Value_Release(argSecond);
   } else {
     CXFA_FM2JSContext* pContext =
-        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
     pContext->ThrowScriptErrorMessage(XFA_IDS_COMPILER_ERROR);
   }
 }
-void CXFA_FM2JSContext::equality_operator(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::equality_operator(CFXJSE_Value* pThis,
                                           const CFX_ByteStringC& szFuncName,
                                           CFXJSE_Arguments& args) {
   if (args.GetLength() == 2) {
-    if (fm_ref_equal(hThis, args)) {
+    if (fm_ref_equal(pThis, args)) {
       FXJSE_Value_SetInteger(args.GetReturnValue(), 1);
     } else {
-      FXJSE_HVALUE argFirst = GetSimpleHValue(hThis, args, 0);
-      FXJSE_HVALUE argSecond = GetSimpleHValue(hThis, args, 1);
+      CFXJSE_Value* argFirst = GetSimpleValue(pThis, args, 0);
+      CFXJSE_Value* argSecond = GetSimpleValue(pThis, args, 1);
       if (FXJSE_Value_IsNull(argFirst) || FXJSE_Value_IsNull(argSecond)) {
         FXJSE_Value_SetInteger(
             args.GetReturnValue(),
             (FXJSE_Value_IsNull(argFirst) && FXJSE_Value_IsNull(argSecond))
                 ? 1
                 : 0);
       } else if (FXJSE_Value_IsUTF8String(argFirst) &&
                  FXJSE_Value_IsUTF8String(argSecond)) {
         CFX_ByteString firstOutput;
         CFX_ByteString secondOutput;
         FXJSE_Value_ToUTF8String(argFirst, firstOutput);
         FXJSE_Value_ToUTF8String(argSecond, secondOutput);
         FXJSE_Value_SetInteger(args.GetReturnValue(),
                                firstOutput == secondOutput);
       } else {
-        FX_DOUBLE first = HValueToDouble(hThis, argFirst);
-        FX_DOUBLE second = HValueToDouble(hThis, argSecond);
+        FX_DOUBLE first = ValueToDouble(pThis, argFirst);
+        FX_DOUBLE second = ValueToDouble(pThis, argSecond);
         FXJSE_Value_SetInteger(args.GetReturnValue(),
                                (first == second) ? 1 : 0);
       }
       FXJSE_Value_Release(argFirst);
       FXJSE_Value_Release(argSecond);
     }
   } else {
     CXFA_FM2JSContext* pContext =
-        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
     pContext->ThrowScriptErrorMessage(XFA_IDS_COMPILER_ERROR);
   }
 }
-void CXFA_FM2JSContext::notequality_operator(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::notequality_operator(CFXJSE_Value* pThis,
                                              const CFX_ByteStringC& szFuncName,
                                              CFXJSE_Arguments& args) {
   if (args.GetLength() == 2) {
-    if (fm_ref_equal(hThis, args)) {
+    if (fm_ref_equal(pThis, args)) {
       FXJSE_Value_SetInteger(args.GetReturnValue(), 0);
     } else {
-      FXJSE_HVALUE argFirst = GetSimpleHValue(hThis, args, 0);
-      FXJSE_HVALUE argSecond = GetSimpleHValue(hThis, args, 1);
+      CFXJSE_Value* argFirst = GetSimpleValue(pThis, args, 0);
+      CFXJSE_Value* argSecond = GetSimpleValue(pThis, args, 1);
       if (FXJSE_Value_IsNull(argFirst) || FXJSE_Value_IsNull(argSecond)) {
         FXJSE_Value_SetInteger(
             args.GetReturnValue(),
             (FXJSE_Value_IsNull(argFirst) && FXJSE_Value_IsNull(argSecond))
                 ? 0
                 : 1);
       } else if (FXJSE_Value_IsUTF8String(argFirst) &&
                  FXJSE_Value_IsUTF8String(argSecond)) {
         CFX_ByteString firstOutput;
         CFX_ByteString secondOutput;
         FXJSE_Value_ToUTF8String(argFirst, firstOutput);
         FXJSE_Value_ToUTF8String(argSecond, secondOutput);
         FXJSE_Value_SetInteger(args.GetReturnValue(),
                                firstOutput != secondOutput);
       } else {
-        FX_DOUBLE first = HValueToDouble(hThis, argFirst);
-        FX_DOUBLE second = HValueToDouble(hThis, argSecond);
+        FX_DOUBLE first = ValueToDouble(pThis, argFirst);
+        FX_DOUBLE second = ValueToDouble(pThis, argSecond);
         FXJSE_Value_SetInteger(args.GetReturnValue(), first != second);
       }
       FXJSE_Value_Release(argFirst);
       FXJSE_Value_Release(argSecond);
     }
   } else {
     CXFA_FM2JSContext* pContext =
-        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
     pContext->ThrowScriptErrorMessage(XFA_IDS_COMPILER_ERROR);
   }
 }
-FX_BOOL CXFA_FM2JSContext::fm_ref_equal(FXJSE_HOBJECT hThis,
+FX_BOOL CXFA_FM2JSContext::fm_ref_equal(CFXJSE_Value* pThis,
                                         CFXJSE_Arguments& args) {
   FX_BOOL bRet = FALSE;
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   v8::Isolate* pIsolate = pContext->GetScriptRuntime();
-  FXJSE_HVALUE argFirst = args.GetValue(0);
-  FXJSE_HVALUE argSecond = args.GetValue(0);
+  CFXJSE_Value* argFirst = args.GetValue(0);
+  CFXJSE_Value* argSecond = args.GetValue(0);
   if (FXJSE_Value_IsArray(argFirst) && FXJSE_Value_IsArray(argSecond)) {
-    FXJSE_HVALUE firstFlagValue = FXJSE_Value_Create(pIsolate);
-    FXJSE_HVALUE secondFlagValue = FXJSE_Value_Create(pIsolate);
+    CFXJSE_Value* firstFlagValue = FXJSE_Value_Create(pIsolate);
+    CFXJSE_Value* secondFlagValue = FXJSE_Value_Create(pIsolate);
     FXJSE_Value_GetObjectPropByIdx(argFirst, 0, firstFlagValue);
     FXJSE_Value_GetObjectPropByIdx(argSecond, 0, secondFlagValue);
     if ((FXJSE_Value_ToInteger(firstFlagValue) == 3) &&
         (FXJSE_Value_ToInteger(secondFlagValue) == 3)) {
-      FXJSE_HVALUE firstJSObject = FXJSE_Value_Create(pIsolate);
-      FXJSE_HVALUE secondJSObject = FXJSE_Value_Create(pIsolate);
+      CFXJSE_Value* firstJSObject = FXJSE_Value_Create(pIsolate);
+      CFXJSE_Value* secondJSObject = FXJSE_Value_Create(pIsolate);
       FXJSE_Value_GetObjectPropByIdx(argFirst, 2, firstJSObject);
       FXJSE_Value_GetObjectPropByIdx(argSecond, 2, secondJSObject);
       if (!FXJSE_Value_IsNull(firstJSObject) &&
           !FXJSE_Value_IsNull(secondJSObject)) {
         bRet = (FXJSE_Value_ToObject(firstJSObject) ==
                 FXJSE_Value_ToObject(secondJSObject));
       }
       FXJSE_Value_Release(firstJSObject);
       FXJSE_Value_Release(secondJSObject);
     }
     FXJSE_Value_Release(firstFlagValue);
     FXJSE_Value_Release(secondFlagValue);
   }
   FXJSE_Value_Release(argFirst);
   FXJSE_Value_Release(argSecond);
   return bRet;
 }
-void CXFA_FM2JSContext::less_operator(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::less_operator(CFXJSE_Value* pThis,
                                       const CFX_ByteStringC& szFuncName,
                                       CFXJSE_Arguments& args) {
   if (args.GetLength() == 2) {
-    FXJSE_HVALUE argFirst = GetSimpleHValue(hThis, args, 0);
-    FXJSE_HVALUE argSecond = GetSimpleHValue(hThis, args, 1);
+    CFXJSE_Value* argFirst = GetSimpleValue(pThis, args, 0);
+    CFXJSE_Value* argSecond = GetSimpleValue(pThis, args, 1);
     if (FXJSE_Value_IsNull(argFirst) || FXJSE_Value_IsNull(argSecond)) {
       FXJSE_Value_SetInteger(args.GetReturnValue(), 0);
     } else if (FXJSE_Value_IsUTF8String(argFirst) &&
                FXJSE_Value_IsUTF8String(argSecond)) {
       CFX_ByteString firstOutput;
       CFX_ByteString secondOutput;
       FXJSE_Value_ToUTF8String(argFirst, firstOutput);
       FXJSE_Value_ToUTF8String(argSecond, secondOutput);
       FXJSE_Value_SetInteger(
           args.GetReturnValue(),
           firstOutput.Compare(secondOutput.AsStringC()) == -1);
     } else {
-      FX_DOUBLE first = HValueToDouble(hThis, argFirst);
-      FX_DOUBLE second = HValueToDouble(hThis, argSecond);
+      FX_DOUBLE first = ValueToDouble(pThis, argFirst);
+      FX_DOUBLE second = ValueToDouble(pThis, argSecond);
       FXJSE_Value_SetInteger(args.GetReturnValue(), (first < second) ? 1 : 0);
     }
     FXJSE_Value_Release(argFirst);
     FXJSE_Value_Release(argSecond);
   } else {
     CXFA_FM2JSContext* pContext =
-        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
     pContext->ThrowScriptErrorMessage(XFA_IDS_COMPILER_ERROR);
   }
 }
-void CXFA_FM2JSContext::lessequal_operator(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::lessequal_operator(CFXJSE_Value* pThis,
                                            const CFX_ByteStringC& szFuncName,
                                            CFXJSE_Arguments& args) {
   if (args.GetLength() == 2) {
-    FXJSE_HVALUE argFirst = GetSimpleHValue(hThis, args, 0);
-    FXJSE_HVALUE argSecond = GetSimpleHValue(hThis, args, 1);
+    CFXJSE_Value* argFirst = GetSimpleValue(pThis, args, 0);
+    CFXJSE_Value* argSecond = GetSimpleValue(pThis, args, 1);
     if (FXJSE_Value_IsNull(argFirst) || FXJSE_Value_IsNull(argSecond)) {
       FXJSE_Value_SetInteger(
           args.GetReturnValue(),
           (FXJSE_Value_IsNull(argFirst) && FXJSE_Value_IsNull(argSecond)) ? 1
                                                                           : 0);
     } else if (FXJSE_Value_IsUTF8String(argFirst) &&
                FXJSE_Value_IsUTF8String(argSecond)) {
       CFX_ByteString firstOutput;
       CFX_ByteString secondOutput;
       FXJSE_Value_ToUTF8String(argFirst, firstOutput);
       FXJSE_Value_ToUTF8String(argSecond, secondOutput);
       FXJSE_Value_SetInteger(
           args.GetReturnValue(),
           firstOutput.Compare(secondOutput.AsStringC()) != 1);
     } else {
-      FX_DOUBLE first = HValueToDouble(hThis, argFirst);
-      FX_DOUBLE second = HValueToDouble(hThis, argSecond);
+      FX_DOUBLE first = ValueToDouble(pThis, argFirst);
+      FX_DOUBLE second = ValueToDouble(pThis, argSecond);
       FXJSE_Value_SetInteger(args.GetReturnValue(), (first <= second) ? 1 : 0);
     }
     FXJSE_Value_Release(argFirst);
     FXJSE_Value_Release(argSecond);
   } else {
     CXFA_FM2JSContext* pContext =
-        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
     pContext->ThrowScriptErrorMessage(XFA_IDS_COMPILER_ERROR);
   }
 }
-void CXFA_FM2JSContext::greater_operator(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::greater_operator(CFXJSE_Value* pThis,
                                          const CFX_ByteStringC& szFuncName,
                                          CFXJSE_Arguments& args) {
   if (args.GetLength() == 2) {
-    FXJSE_HVALUE argFirst = GetSimpleHValue(hThis, args, 0);
-    FXJSE_HVALUE argSecond = GetSimpleHValue(hThis, args, 1);
+    CFXJSE_Value* argFirst = GetSimpleValue(pThis, args, 0);
+    CFXJSE_Value* argSecond = GetSimpleValue(pThis, args, 1);
     if (FXJSE_Value_IsNull(argFirst) || FXJSE_Value_IsNull(argSecond)) {
       FXJSE_Value_SetInteger(args.GetReturnValue(), 0);
     } else if (FXJSE_Value_IsUTF8String(argFirst) &&
                FXJSE_Value_IsUTF8String(argSecond)) {
       CFX_ByteString firstOutput;
       CFX_ByteString secondOutput;
       FXJSE_Value_ToUTF8String(argFirst, firstOutput);
       FXJSE_Value_ToUTF8String(argSecond, secondOutput);
       FXJSE_Value_SetInteger(
           args.GetReturnValue(),
           firstOutput.Compare(secondOutput.AsStringC()) == 1);
     } else {
-      FX_DOUBLE first = HValueToDouble(hThis, argFirst);
-      FX_DOUBLE second = HValueToDouble(hThis, argSecond);
+      FX_DOUBLE first = ValueToDouble(pThis, argFirst);
+      FX_DOUBLE second = ValueToDouble(pThis, argSecond);
       FXJSE_Value_SetInteger(args.GetReturnValue(), (first > second) ? 1 : 0);
     }
     FXJSE_Value_Release(argFirst);
     FXJSE_Value_Release(argSecond);
   } else {
     CXFA_FM2JSContext* pContext =
-        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
     pContext->ThrowScriptErrorMessage(XFA_IDS_COMPILER_ERROR);
   }
 }
-void CXFA_FM2JSContext::greaterequal_operator(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::greaterequal_operator(CFXJSE_Value* pThis,
                                               const CFX_ByteStringC& szFuncName,
                                               CFXJSE_Arguments& args) {
   if (args.GetLength() == 2) {
-    FXJSE_HVALUE argFirst = GetSimpleHValue(hThis, args, 0);
-    FXJSE_HVALUE argSecond = GetSimpleHValue(hThis, args, 1);
+    CFXJSE_Value* argFirst = GetSimpleValue(pThis, args, 0);
+    CFXJSE_Value* argSecond = GetSimpleValue(pThis, args, 1);
     if (FXJSE_Value_IsNull(argFirst) || FXJSE_Value_IsNull(argSecond)) {
       FXJSE_Value_SetInteger(
           args.GetReturnValue(),
           (FXJSE_Value_IsNull(argFirst) && FXJSE_Value_IsNull(argSecond)) ? 1
                                                                           : 0);
     } else if (FXJSE_Value_IsUTF8String(argFirst) &&
                FXJSE_Value_IsUTF8String(argSecond)) {
       CFX_ByteString firstOutput;
       CFX_ByteString secondOutput;
       FXJSE_Value_ToUTF8String(argFirst, firstOutput);
       FXJSE_Value_ToUTF8String(argSecond, secondOutput);
       FXJSE_Value_SetInteger(
           args.GetReturnValue(),
           firstOutput.Compare(secondOutput.AsStringC()) != -1);
     } else {
-      FX_DOUBLE first = HValueToDouble(hThis, argFirst);
-      FX_DOUBLE second = HValueToDouble(hThis, argSecond);
+      FX_DOUBLE first = ValueToDouble(pThis, argFirst);
+      FX_DOUBLE second = ValueToDouble(pThis, argSecond);
       FXJSE_Value_SetInteger(args.GetReturnValue(), (first >= second) ? 1 : 0);
     }
     FXJSE_Value_Release(argFirst);
     FXJSE_Value_Release(argSecond);
   } else {
     CXFA_FM2JSContext* pContext =
-        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
     pContext->ThrowScriptErrorMessage(XFA_IDS_COMPILER_ERROR);
   }
 }
-void CXFA_FM2JSContext::plus_operator(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::plus_operator(CFXJSE_Value* pThis,
                                       const CFX_ByteStringC& szFuncName,
                                       CFXJSE_Arguments& args) {
   if (args.GetLength() == 2) {
-    FXJSE_HVALUE argFirst = args.GetValue(0);
-    FXJSE_HVALUE argSecond = args.GetValue(1);
-    if (HValueIsNull(hThis, argFirst) && HValueIsNull(hThis, argSecond)) {
+    CFXJSE_Value* argFirst = args.GetValue(0);
+    CFXJSE_Value* argSecond = args.GetValue(1);
+    if (ValueIsNull(pThis, argFirst) && ValueIsNull(pThis, argSecond)) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
-      FX_DOUBLE first = HValueToDouble(hThis, argFirst);
-      FX_DOUBLE second = HValueToDouble(hThis, argSecond);
+      FX_DOUBLE first = ValueToDouble(pThis, argFirst);
+      FX_DOUBLE second = ValueToDouble(pThis, argSecond);
       FXJSE_Value_SetDouble(args.GetReturnValue(), first + second);
     }
     FXJSE_Value_Release(argFirst);
     FXJSE_Value_Release(argSecond);
   } else {
     CXFA_FM2JSContext* pContext =
-        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
     pContext->ThrowScriptErrorMessage(XFA_IDS_COMPILER_ERROR);
   }
 }
-void CXFA_FM2JSContext::minus_operator(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::minus_operator(CFXJSE_Value* pThis,
                                        const CFX_ByteStringC& szFuncName,
                                        CFXJSE_Arguments& args) {
   if (args.GetLength() == 2) {
-    FXJSE_HVALUE argFirst = GetSimpleHValue(hThis, args, 0);
-    FXJSE_HVALUE argSecond = GetSimpleHValue(hThis, args, 1);
+    CFXJSE_Value* argFirst = GetSimpleValue(pThis, args, 0);
+    CFXJSE_Value* argSecond = GetSimpleValue(pThis, args, 1);
     if (FXJSE_Value_IsNull(argFirst) && FXJSE_Value_IsNull(argSecond)) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
-      FX_DOUBLE first = HValueToDouble(hThis, argFirst);
-      FX_DOUBLE second = HValueToDouble(hThis, argSecond);
+      FX_DOUBLE first = ValueToDouble(pThis, argFirst);
+      FX_DOUBLE second = ValueToDouble(pThis, argSecond);
       FXJSE_Value_SetDouble(args.GetReturnValue(), first - second);
     }
     FXJSE_Value_Release(argFirst);
     FXJSE_Value_Release(argSecond);
   } else {
     CXFA_FM2JSContext* pContext =
-        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
     pContext->ThrowScriptErrorMessage(XFA_IDS_COMPILER_ERROR);
   }
 }
-void CXFA_FM2JSContext::multiple_operator(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::multiple_operator(CFXJSE_Value* pThis,
                                           const CFX_ByteStringC& szFuncName,
                                           CFXJSE_Arguments& args) {
   if (args.GetLength() == 2) {
-    FXJSE_HVALUE argFirst = GetSimpleHValue(hThis, args, 0);
-    FXJSE_HVALUE argSecond = GetSimpleHValue(hThis, args, 1);
+    CFXJSE_Value* argFirst = GetSimpleValue(pThis, args, 0);
+    CFXJSE_Value* argSecond = GetSimpleValue(pThis, args, 1);
     if (FXJSE_Value_IsNull(argFirst) && FXJSE_Value_IsNull(argSecond)) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
-      FX_DOUBLE first = HValueToDouble(hThis, argFirst);
-      FX_DOUBLE second = HValueToDouble(hThis, argSecond);
+      FX_DOUBLE first = ValueToDouble(pThis, argFirst);
+      FX_DOUBLE second = ValueToDouble(pThis, argSecond);
       FXJSE_Value_SetDouble(args.GetReturnValue(), first * second);
     }
     FXJSE_Value_Release(argFirst);
     FXJSE_Value_Release(argSecond);
   } else {
     CXFA_FM2JSContext* pContext =
-        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
     pContext->ThrowScriptErrorMessage(XFA_IDS_COMPILER_ERROR);
   }
 }
-void CXFA_FM2JSContext::divide_operator(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::divide_operator(CFXJSE_Value* pThis,
                                         const CFX_ByteStringC& szFuncName,
                                         CFXJSE_Arguments& args) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   if (args.GetLength() == 2) {
-    FXJSE_HVALUE argFirst = GetSimpleHValue(hThis, args, 0);
-    FXJSE_HVALUE argSecond = GetSimpleHValue(hThis, args, 1);
+    CFXJSE_Value* argFirst = GetSimpleValue(pThis, args, 0);
+    CFXJSE_Value* argSecond = GetSimpleValue(pThis, args, 1);
     if (FXJSE_Value_IsNull(argFirst) && FXJSE_Value_IsNull(argSecond)) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
-      FX_DOUBLE first = HValueToDouble(hThis, argFirst);
-      FX_DOUBLE second = HValueToDouble(hThis, argSecond);
+      FX_DOUBLE first = ValueToDouble(pThis, argFirst);
+      FX_DOUBLE second = ValueToDouble(pThis, argSecond);
       if (second == 0.0) {
         pContext->ThrowScriptErrorMessage(XFA_IDS_DIVIDE_ZERO);
       } else {
         FXJSE_Value_SetDouble(args.GetReturnValue(), first / second);
       }
     }
     FXJSE_Value_Release(argFirst);
     FXJSE_Value_Release(argSecond);
   } else {
     pContext->ThrowScriptErrorMessage(XFA_IDS_COMPILER_ERROR);
   }
 }
-void CXFA_FM2JSContext::positive_operator(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::positive_operator(CFXJSE_Value* pThis,
                                           const CFX_ByteStringC& szFuncName,
                                           CFXJSE_Arguments& args) {
   int32_t iLength = args.GetLength();
   if (iLength == 1) {
-    FXJSE_HVALUE argOne = GetSimpleHValue(hThis, args, 0);
+    CFXJSE_Value* argOne = GetSimpleValue(pThis, args, 0);
     if (FXJSE_Value_IsNull(argOne)) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
       FXJSE_Value_SetDouble(args.GetReturnValue(),
-                            0.0 + HValueToDouble(hThis, argOne));
+                            0.0 + ValueToDouble(pThis, argOne));
     }
     FXJSE_Value_Release(argOne);
   } else {
     CXFA_FM2JSContext* pContext =
-        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
     pContext->ThrowScriptErrorMessage(XFA_IDS_COMPILER_ERROR);
   }
 }
-void CXFA_FM2JSContext::negative_operator(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::negative_operator(CFXJSE_Value* pThis,
                                           const CFX_ByteStringC& szFuncName,
                                           CFXJSE_Arguments& args) {
   int32_t iLength = args.GetLength();
   if (iLength == 1) {
-    FXJSE_HVALUE argOne = GetSimpleHValue(hThis, args, 0);
+    CFXJSE_Value* argOne = GetSimpleValue(pThis, args, 0);
     if (FXJSE_Value_IsNull(argOne)) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
       FXJSE_Value_SetDouble(args.GetReturnValue(),
-                            0.0 - HValueToDouble(hThis, argOne));
+                            0.0 - ValueToDouble(pThis, argOne));
     }
     FXJSE_Value_Release(argOne);
   } else {
     CXFA_FM2JSContext* pContext =
-        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
     pContext->ThrowScriptErrorMessage(XFA_IDS_COMPILER_ERROR);
   }
 }
-void CXFA_FM2JSContext::logical_not_operator(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::logical_not_operator(CFXJSE_Value* pThis,
                                              const CFX_ByteStringC& szFuncName,
                                              CFXJSE_Arguments& args) {
   int32_t iLength = args.GetLength();
   if (iLength == 1) {
-    FXJSE_HVALUE argOne = GetSimpleHValue(hThis, args, 0);
+    CFXJSE_Value* argOne = GetSimpleValue(pThis, args, 0);
     if (FXJSE_Value_IsNull(argOne)) {
       FXJSE_Value_SetNull(args.GetReturnValue());
     } else {
-      FX_DOUBLE first = HValueToDouble(hThis, argOne);
+      FX_DOUBLE first = ValueToDouble(pThis, argOne);
       FXJSE_Value_SetInteger(args.GetReturnValue(), (first == 0.0) ? 1 : 0);
     }
     FXJSE_Value_Release(argOne);
   } else {
     CXFA_FM2JSContext* pContext =
-        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+        (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
     pContext->ThrowScriptErrorMessage(XFA_IDS_COMPILER_ERROR);
   }
 }
-void CXFA_FM2JSContext::dot_accessor(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::dot_accessor(CFXJSE_Value* pThis,
                                      const CFX_ByteStringC& szFuncName,
                                      CFXJSE_Arguments& args) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   v8::Isolate* pIsolate = pContext->GetScriptRuntime();
   int32_t argc = args.GetLength();
   if ((argc == 4) || (argc == 5)) {
     FX_BOOL bIsStar = TRUE;
-    FXJSE_HVALUE argAccessor = args.GetValue(0);
+    CFXJSE_Value* argAccessor = args.GetValue(0);
     CFX_ByteString bsAccessorName = args.GetUTF8String(1);
     CFX_ByteString szName = args.GetUTF8String(2);
     int32_t iIndexFlags = args.GetInt32(3);
     int32_t iIndexValue = 0;
-    FXJSE_HVALUE argIndex = NULL;
+    CFXJSE_Value* argIndex = NULL;
     if (argc == 5) {
       bIsStar = FALSE;
       argIndex = args.GetValue(4);
-      iIndexValue = HValueToInteger(hThis, argIndex);
+      iIndexValue = ValueToInteger(pThis, argIndex);
     }
     CFX_ByteString szSomExp;
     GenerateSomExpression(szName.AsStringC(), iIndexFlags, iIndexValue, bIsStar,
                           szSomExp);
     if (FXJSE_Value_IsArray(argAccessor)) {
-      FXJSE_HVALUE hLengthValue = FXJSE_Value_Create(pIsolate);
-      FXJSE_Value_GetObjectProp(argAccessor, "length", hLengthValue);
-      int32_t iLength = FXJSE_Value_ToInteger(hLengthValue);
-      FXJSE_Value_Release(hLengthValue);
+      CFXJSE_Value* pLengthValue = FXJSE_Value_Create(pIsolate);
+      FXJSE_Value_GetObjectProp(argAccessor, "length", pLengthValue);
+      int32_t iLength = FXJSE_Value_ToInteger(pLengthValue);
+      FXJSE_Value_Release(pLengthValue);
       int32_t iCounter = 0;
-      FXJSE_HVALUE** hResolveValues = FX_Alloc(FXJSE_HVALUE*, iLength - 2);
+      CFXJSE_Value*** hResolveValues = FX_Alloc(CFXJSE_Value**, iLength - 2);
       int32_t* iSizes = FX_Alloc(int32_t, iLength - 2);
       for (int32_t i = 0; i < (iLength - 2); i++) {
         iSizes[i] = 0;
       }
-      FXJSE_HVALUE hJSObjValue = FXJSE_Value_Create(pIsolate);
+      CFXJSE_Value* hJSObjValue = FXJSE_Value_Create(pIsolate);
       FX_BOOL bAttribute = FALSE;
       for (int32_t i = 2; i < iLength; i++) {
         FXJSE_Value_GetObjectPropByIdx(argAccessor, i, hJSObjValue);
         XFA_RESOLVENODE_RS resoveNodeRS;
-        int32_t iRet = ResolveObjects(hThis, hJSObjValue, szSomExp.AsStringC(),
+        int32_t iRet = ResolveObjects(pThis, hJSObjValue, szSomExp.AsStringC(),
                                       resoveNodeRS, TRUE, szName.IsEmpty());
         if (iRet > 0) {
-          ParseResolveResult(hThis, resoveNodeRS, hJSObjValue,
+          ParseResolveResult(pThis, resoveNodeRS, hJSObjValue,
                              hResolveValues[i - 2], iSizes[i - 2], bAttribute);
           iCounter += iSizes[i - 2];
         }
       }
       FXJSE_Value_Release(hJSObjValue);
       if (iCounter > 0) {
-        FXJSE_HVALUE* rgValues = FX_Alloc(FXJSE_HVALUE, iCounter + 2);
+        CFXJSE_Value** rgValues = FX_Alloc(CFXJSE_Value*, iCounter + 2);
         for (int32_t i = 0; i < (iCounter + 2); i++) {
           rgValues[i] = FXJSE_Value_Create(pIsolate);
         }
         FXJSE_Value_SetInteger(rgValues[0], 1);
         if (bAttribute) {
           FXJSE_Value_SetUTF8String(rgValues[1], szName.AsStringC());
         } else {
           FXJSE_Value_SetNull(rgValues[1]);
         }
         int32_t iIndex = 2;
@@ skipping 25 matching lines @@
           FX_Free(hResolveValues[i]);
         }
       }
       FX_Free(hResolveValues);
       FX_Free(iSizes);
     } else {
       XFA_RESOLVENODE_RS resoveNodeRS;
       int32_t iRet = 0;
       if (FXJSE_Value_IsObject(argAccessor) ||
           (FXJSE_Value_IsNull(argAccessor) && bsAccessorName.IsEmpty())) {
-        iRet = ResolveObjects(hThis, argAccessor, szSomExp.AsStringC(),
+        iRet = ResolveObjects(pThis, argAccessor, szSomExp.AsStringC(),
                               resoveNodeRS, TRUE, szName.IsEmpty());
       } else if (!FXJSE_Value_IsObject(argAccessor) &&
                  !bsAccessorName.IsEmpty()) {
         FX_BOOL bGetObject =
-            GetObjectByName(hThis, argAccessor, bsAccessorName.AsStringC());
+            GetObjectByName(pThis, argAccessor, bsAccessorName.AsStringC());
         if (bGetObject) {
-          iRet = ResolveObjects(hThis, argAccessor, szSomExp.AsStringC(),
+          iRet = ResolveObjects(pThis, argAccessor, szSomExp.AsStringC(),
                                 resoveNodeRS, TRUE, szName.IsEmpty());
         }
       }
       if (iRet > 0) {
-        FXJSE_HVALUE* hResolveValues;
+        CFXJSE_Value** hResolveValues;
         int32_t iSize = 0;
         FX_BOOL bAttribute = FALSE;
-        ParseResolveResult(hThis, resoveNodeRS, argAccessor, hResolveValues,
+        ParseResolveResult(pThis, resoveNodeRS, argAccessor, hResolveValues,
                            iSize, bAttribute);
-        FXJSE_HVALUE* rgValues = FX_Alloc(FXJSE_HVALUE, iSize + 2);
+        CFXJSE_Value** rgValues = FX_Alloc(CFXJSE_Value*, iSize + 2);
         for (int32_t i = 0; i < (iSize + 2); i++) {
           rgValues[i] = FXJSE_Value_Create(pIsolate);
         }
         FXJSE_Value_SetInteger(rgValues[0], 1);
         if (bAttribute) {
           FXJSE_Value_SetUTF8String(rgValues[1], szName.AsStringC());
         } else {
           FXJSE_Value_SetNull(rgValues[1]);
         }
         for (int32_t i = 0; i < iSize; i++) {
@@ skipping 19 matching lines @@
       }
     }
     if (argc == 5) {
       FXJSE_Value_Release(argIndex);
     }
     FXJSE_Value_Release(argAccessor);
   } else {
     pContext->ThrowScriptErrorMessage(XFA_IDS_COMPILER_ERROR);
   }
 }
-void CXFA_FM2JSContext::dotdot_accessor(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::dotdot_accessor(CFXJSE_Value* pThis,
                                         const CFX_ByteStringC& szFuncName,
                                         CFXJSE_Arguments& args) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   v8::Isolate* pIsolate = pContext->GetScriptRuntime();
   int32_t argc = args.GetLength();
   if ((argc == 4) || (argc == 5)) {
     FX_BOOL bIsStar = TRUE;
-    FXJSE_HVALUE argAccessor = args.GetValue(0);
+    CFXJSE_Value* argAccessor = args.GetValue(0);
     CFX_ByteString bsAccessorName = args.GetUTF8String(1);
     CFX_ByteString szName = args.GetUTF8String(2);
     int32_t iIndexFlags = args.GetInt32(3);
     int32_t iIndexValue = 0;
-    FXJSE_HVALUE argIndex = NULL;
+    CFXJSE_Value* argIndex = NULL;
     if (argc == 5) {
       bIsStar = FALSE;
       argIndex = args.GetValue(4);
-      iIndexValue = HValueToInteger(hThis, argIndex);
+      iIndexValue = ValueToInteger(pThis, argIndex);
     }
     CFX_ByteString szSomExp;
     GenerateSomExpression(szName.AsStringC(), iIndexFlags, iIndexValue, bIsStar,
                           szSomExp);
     if (FXJSE_Value_IsArray(argAccessor)) {
-      FXJSE_HVALUE hLengthValue = FXJSE_Value_Create(pIsolate);
-      FXJSE_Value_GetObjectProp(argAccessor, "length", hLengthValue);
-      int32_t iLength = FXJSE_Value_ToInteger(hLengthValue);
+      CFXJSE_Value* pLengthValue = FXJSE_Value_Create(pIsolate);
+      FXJSE_Value_GetObjectProp(argAccessor, "length", pLengthValue);
+      int32_t iLength = FXJSE_Value_ToInteger(pLengthValue);
       int32_t iCounter = 0;
-      FXJSE_HVALUE** hResolveValues = FX_Alloc(FXJSE_HVALUE*, iLength - 2);
+      CFXJSE_Value*** hResolveValues = FX_Alloc(CFXJSE_Value**, iLength - 2);
       int32_t* iSizes = FX_Alloc(int32_t, iLength - 2);
-      FXJSE_HVALUE hJSObjValue = FXJSE_Value_Create(pIsolate);
+      CFXJSE_Value* hJSObjValue = FXJSE_Value_Create(pIsolate);
       FX_BOOL bAttribute = FALSE;
       for (int32_t i = 2; i < iLength; i++) {
         FXJSE_Value_GetObjectPropByIdx(argAccessor, i, hJSObjValue);
         XFA_RESOLVENODE_RS resoveNodeRS;
-        int32_t iRet = ResolveObjects(hThis, hJSObjValue, szSomExp.AsStringC(),
+        int32_t iRet = ResolveObjects(pThis, hJSObjValue, szSomExp.AsStringC(),
                                       resoveNodeRS, FALSE);
         if (iRet > 0) {
-          ParseResolveResult(hThis, resoveNodeRS, hJSObjValue,
+          ParseResolveResult(pThis, resoveNodeRS, hJSObjValue,
                              hResolveValues[i - 2], iSizes[i - 2], bAttribute);
           iCounter += iSizes[i - 2];
         }
       }
       FXJSE_Value_Release(hJSObjValue);
       if (iCounter > 0) {
-        FXJSE_HVALUE* rgValues = FX_Alloc(FXJSE_HVALUE, iCounter + 2);
+        CFXJSE_Value** rgValues = FX_Alloc(CFXJSE_Value*, iCounter + 2);
         for (int32_t i = 0; i < (iCounter + 2); i++) {
           rgValues[i] = FXJSE_Value_Create(pIsolate);
         }
         FXJSE_Value_SetInteger(rgValues[0], 1);
         if (bAttribute) {
           FXJSE_Value_SetUTF8String(rgValues[1], szName.AsStringC());
         } else {
           FXJSE_Value_SetNull(rgValues[1]);
         }
         int32_t iIndex = 2;
@@ skipping 18 matching lines @@
                                           wsSomExpression.c_str());
       }
       for (int32_t i = 0; i < iLength - 2; i++) {
         for (int32_t j = 0; j < iSizes[i]; j++) {
           FXJSE_Value_Release(hResolveValues[i][j]);
         }
         FX_Free(hResolveValues[i]);
       }
       FX_Free(hResolveValues);
       FX_Free(iSizes);
-      FXJSE_Value_Release(hLengthValue);
+      FXJSE_Value_Release(pLengthValue);
     } else {
       XFA_RESOLVENODE_RS resoveNodeRS;
       int32_t iRet = 0;
       if (FXJSE_Value_IsObject(argAccessor) ||
           (FXJSE_Value_IsNull(argAccessor) && bsAccessorName.IsEmpty())) {
-        iRet = ResolveObjects(hThis, argAccessor, szSomExp.AsStringC(),
+        iRet = ResolveObjects(pThis, argAccessor, szSomExp.AsStringC(),
                               resoveNodeRS, FALSE);
       } else if (!FXJSE_Value_IsObject(argAccessor) &&
                  !bsAccessorName.IsEmpty()) {
         FX_BOOL bGetObject =
-            GetObjectByName(hThis, argAccessor, bsAccessorName.AsStringC());
+            GetObjectByName(pThis, argAccessor, bsAccessorName.AsStringC());
         if (bGetObject) {
-          iRet = ResolveObjects(hThis, argAccessor, szSomExp.AsStringC(),
+          iRet = ResolveObjects(pThis, argAccessor, szSomExp.AsStringC(),
                                 resoveNodeRS, FALSE);
         }
       }
       if (iRet > 0) {
-        FXJSE_HVALUE* hResolveValues;
+        CFXJSE_Value** hResolveValues;
         int32_t iSize = 0;
         FX_BOOL bAttribute = FALSE;
-        ParseResolveResult(hThis, resoveNodeRS, argAccessor, hResolveValues,
+        ParseResolveResult(pThis, resoveNodeRS, argAccessor, hResolveValues,
                            iSize, bAttribute);
-        FXJSE_HVALUE* rgValues = FX_Alloc(FXJSE_HVALUE, iSize + 2);
+        CFXJSE_Value** rgValues = FX_Alloc(CFXJSE_Value*, iSize + 2);
         for (int32_t i = 0; i < (iSize + 2); i++) {
           rgValues[i] = FXJSE_Value_Create(pIsolate);
         }
         FXJSE_Value_SetInteger(rgValues[0], 1);
         if (bAttribute) {
           FXJSE_Value_SetUTF8String(rgValues[1], szName.AsStringC());
         } else {
           FXJSE_Value_SetNull(rgValues[1]);
         }
         for (int32_t i = 0; i < iSize; i++) {
@@ skipping 19 matching lines @@
       }
     }
     if (argc == 5) {
       FXJSE_Value_Release(argIndex);
     }
     FXJSE_Value_Release(argAccessor);
   } else {
     pContext->ThrowScriptErrorMessage(XFA_IDS_COMPILER_ERROR);
   }
 }
-void CXFA_FM2JSContext::eval_translation(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::eval_translation(CFXJSE_Value* pThis,
                                          const CFX_ByteStringC& szFuncName,
                                          CFXJSE_Arguments& args) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   int32_t argc = args.GetLength();
   if (argc == 1) {
-    FXJSE_HVALUE argOne = GetSimpleHValue(hThis, args, 0);
+    CFXJSE_Value* argOne = GetSimpleValue(pThis, args, 0);
     CFX_ByteString argString;
-    HValueToUTF8String(argOne, argString);
+    ValueToUTF8String(argOne, argString);
     if (argString.IsEmpty()) {
       pContext->ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
     } else {
       CFX_WideString scriptString =
           CFX_WideString::FromUTF8(argString.AsStringC());
       CFX_WideTextBuf wsJavaScriptBuf;
       CFX_WideString wsError;
       XFA_FM2JS_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);
       }
     }
     FXJSE_Value_Release(argOne);
   } else {
     pContext->ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                                       L"Eval");
   }
 }
-void CXFA_FM2JSContext::is_fm_object(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::is_fm_object(CFXJSE_Value* pThis,
                                      const CFX_ByteStringC& szFuncName,
                                      CFXJSE_Arguments& args) {
   int32_t iLength = args.GetLength();
   if (iLength == 1) {
-    FXJSE_HVALUE argOne = args.GetValue(0);
+    CFXJSE_Value* argOne = args.GetValue(0);
     FXJSE_Value_SetBoolean(args.GetReturnValue(), FXJSE_Value_IsObject(argOne));
     FXJSE_Value_Release(argOne);
   } else {
     FXJSE_Value_SetBoolean(args.GetReturnValue(), FALSE);
   }
 }
-void CXFA_FM2JSContext::is_fm_array(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::is_fm_array(CFXJSE_Value* pThis,
                                     const CFX_ByteStringC& szFuncName,
                                     CFXJSE_Arguments& args) {
   int32_t iLength = args.GetLength();
   if (iLength == 1) {
-    FXJSE_HVALUE argOne = args.GetValue(0);
+    CFXJSE_Value* argOne = args.GetValue(0);
     FX_BOOL bIsArray = FXJSE_Value_IsArray(argOne);
     FXJSE_Value_SetBoolean(args.GetReturnValue(), bIsArray);
     FXJSE_Value_Release(argOne);
   } else {
     FXJSE_Value_SetBoolean(args.GetReturnValue(), FALSE);
   }
 }
-void CXFA_FM2JSContext::get_fm_value(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::get_fm_value(CFXJSE_Value* pThis,
                                      const CFX_ByteStringC& szFuncName,
                                      CFXJSE_Arguments& args) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   v8::Isolate* pIsolate = pContext->GetScriptRuntime();
   int32_t iLength = args.GetLength();
   if (iLength == 1) {
-    FXJSE_HVALUE argOne = args.GetValue(0);
+    CFXJSE_Value* argOne = args.GetValue(0);
     if (FXJSE_Value_IsArray(argOne)) {
-      FXJSE_HVALUE propertyValue = FXJSE_Value_Create(pIsolate);
-      FXJSE_HVALUE jsobjectValue = FXJSE_Value_Create(pIsolate);
+      CFXJSE_Value* propertyValue = FXJSE_Value_Create(pIsolate);
+      CFXJSE_Value* jsobjectValue = FXJSE_Value_Create(pIsolate);
       FXJSE_Value_GetObjectPropByIdx(argOne, 1, propertyValue);
       FXJSE_Value_GetObjectPropByIdx(argOne, 2, jsobjectValue);
       if (FXJSE_Value_IsNull(propertyValue)) {
         GetObjectDefaultValue(jsobjectValue, args.GetReturnValue());
       } else {
         CFX_ByteString propertyStr;
         FXJSE_Value_ToUTF8String(propertyValue, propertyStr);
         FXJSE_Value_GetObjectProp(jsobjectValue, propertyStr.AsStringC(),
                                   args.GetReturnValue());
       }
       FXJSE_Value_Release(propertyValue);
       FXJSE_Value_Release(jsobjectValue);
     } else if (FXJSE_Value_IsObject(argOne)) {
       GetObjectDefaultValue(argOne, args.GetReturnValue());
     } else {
       FXJSE_Value_Set(args.GetReturnValue(), argOne);
     }
     FXJSE_Value_Release(argOne);
   } else {
     pContext->ThrowScriptErrorMessage(XFA_IDS_COMPILER_ERROR);
   }
 }
-void CXFA_FM2JSContext::get_fm_jsobj(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::get_fm_jsobj(CFXJSE_Value* pThis,
                                      const CFX_ByteStringC& szFuncName,
                                      CFXJSE_Arguments& args) {
   CXFA_FM2JSContext* pContext =
-      static_cast<CXFA_FM2JSContext*>(FXJSE_Value_ToObject(hThis));
+      static_cast<CXFA_FM2JSContext*>(FXJSE_Value_ToObject(pThis));
   int32_t argc = args.GetLength();
   if (argc == 1) {
-    FXJSE_HVALUE argOne = args.GetValue(0);
+    CFXJSE_Value* argOne = args.GetValue(0);
     if (FXJSE_Value_IsArray(argOne)) {
 #ifndef NDEBUG
       v8::Isolate* pIsolate = pContext->GetScriptRuntime();
-      FXJSE_HVALUE lengthValue = FXJSE_Value_Create(pIsolate);
+      CFXJSE_Value* lengthValue = FXJSE_Value_Create(pIsolate);
       FXJSE_Value_GetObjectProp(argOne, "length", lengthValue);
       ASSERT(FXJSE_Value_ToInteger(lengthValue) >= 3);
       FXJSE_Value_Release(lengthValue);
 #endif
       FXJSE_Value_GetObjectPropByIdx(argOne, 2, args.GetReturnValue());
     } else {
       FXJSE_Value_Set(args.GetReturnValue(), argOne);
     }
     FXJSE_Value_Release(argOne);
   } else {
     pContext->ThrowScriptErrorMessage(XFA_IDS_COMPILER_ERROR);
   }
 }
-void CXFA_FM2JSContext::fm_var_filter(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::fm_var_filter(CFXJSE_Value* pThis,
                                       const CFX_ByteStringC& szFuncName,
                                       CFXJSE_Arguments& args) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   v8::Isolate* pIsolate = pContext->GetScriptRuntime();
   int32_t argc = args.GetLength();
   if (argc == 1) {
-    FXJSE_HVALUE argOne = args.GetValue(0);
+    CFXJSE_Value* argOne = args.GetValue(0);
     if (FXJSE_Value_IsArray(argOne)) {
 #ifndef NDEBUG
-      FXJSE_HVALUE lengthValue = FXJSE_Value_Create(pIsolate);
+      CFXJSE_Value* lengthValue = FXJSE_Value_Create(pIsolate);
       FXJSE_Value_GetObjectProp(argOne, "length", lengthValue);
       ASSERT(FXJSE_Value_ToInteger(lengthValue) >= 3);
       FXJSE_Value_Release(lengthValue);
 #endif
-      FXJSE_HVALUE flagsValue = FXJSE_Value_Create(pIsolate);
+      CFXJSE_Value* flagsValue = FXJSE_Value_Create(pIsolate);
       FXJSE_Value_GetObjectPropByIdx(argOne, 0, flagsValue);
       int32_t iFlags = FXJSE_Value_ToInteger(flagsValue);
       FXJSE_Value_Release(flagsValue);
       if (iFlags == 4) {
-        FXJSE_HVALUE rgValues[3];
+        CFXJSE_Value* rgValues[3];
         for (int32_t i = 0; i < 3; i++) {
           rgValues[i] = FXJSE_Value_Create(pIsolate);
         }
         FXJSE_Value_SetInteger(rgValues[0], 3);
         FXJSE_Value_SetNull(rgValues[1]);
         FXJSE_Value_SetNull(rgValues[2]);
         FXJSE_Value_SetArray(args.GetReturnValue(), 3, rgValues);
         for (int32_t i = 0; i < 3; i++) {
           FXJSE_Value_Release(rgValues[i]);
         }
       } else if (iFlags == 3) {
-        FXJSE_HVALUE objectValue = FXJSE_Value_Create(pIsolate);
+        CFXJSE_Value* objectValue = FXJSE_Value_Create(pIsolate);
         FXJSE_Value_GetObjectPropByIdx(argOne, 2, objectValue);
         if (!FXJSE_Value_IsNull(objectValue)) {
           FXJSE_Value_Set(args.GetReturnValue(), argOne);
         } else {
           pContext->ThrowScriptErrorMessage(XFA_IDS_COMPILER_ERROR);
         }
         FXJSE_Value_Release(objectValue);
       } else {
-        FXJSE_HVALUE simpleValue = GetSimpleHValue(hThis, args, 0);
+        CFXJSE_Value* simpleValue = GetSimpleValue(pThis, args, 0);
         FXJSE_Value_Set(args.GetReturnValue(), simpleValue);
         FXJSE_Value_Release(simpleValue);
       }
     } else {
-      FXJSE_HVALUE simpleValue = GetSimpleHValue(hThis, args, 0);
+      CFXJSE_Value* simpleValue = GetSimpleValue(pThis, args, 0);
       FXJSE_Value_Set(args.GetReturnValue(), simpleValue);
       FXJSE_Value_Release(simpleValue);
     }
     FXJSE_Value_Release(argOne);
   } else {
     pContext->ThrowScriptErrorMessage(XFA_IDS_COMPILER_ERROR);
   }
 }
-void CXFA_FM2JSContext::concat_fm_object(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::concat_fm_object(CFXJSE_Value* pThis,
                                          const CFX_ByteStringC& szFuncName,
                                          CFXJSE_Arguments& args) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   v8::Isolate* pIsolate = pContext->GetScriptRuntime();
   uint32_t iLength = 0;
   int32_t argCount = args.GetLength();
-  FXJSE_HVALUE* argValues = FX_Alloc(FXJSE_HVALUE, argCount);
+  CFXJSE_Value** argValues = FX_Alloc(CFXJSE_Value*, argCount);
   for (int32_t i = 0; i < argCount; i++) {
     argValues[i] = args.GetValue(i);
     if (FXJSE_Value_IsArray(argValues[i])) {
-      FXJSE_HVALUE lengthValue = FXJSE_Value_Create(pIsolate);
+      CFXJSE_Value* lengthValue = FXJSE_Value_Create(pIsolate);
       FXJSE_Value_GetObjectProp(argValues[i], "length", lengthValue);
       int32_t length = FXJSE_Value_ToInteger(lengthValue);
       iLength = iLength + ((length > 2) ? (length - 2) : 0);
       FXJSE_Value_Release(lengthValue);
     }
     iLength += 1;
   }
-  FXJSE_HVALUE* returnValues = FX_Alloc(FXJSE_HVALUE, iLength);
+  CFXJSE_Value** returnValues = FX_Alloc(CFXJSE_Value*, iLength);
   for (int32_t i = 0; i < (int32_t)iLength; i++) {
     returnValues[i] = FXJSE_Value_Create(pIsolate);
   }
   int32_t index = 0;
   for (int32_t i = 0; i < argCount; i++) {
     if (FXJSE_Value_IsArray(argValues[i])) {
-      FXJSE_HVALUE lengthValue = FXJSE_Value_Create(pIsolate);
+      CFXJSE_Value* lengthValue = FXJSE_Value_Create(pIsolate);
       FXJSE_Value_GetObjectProp(argValues[i], "length", lengthValue);
       int32_t length = FXJSE_Value_ToInteger(lengthValue);
       for (int32_t j = 2; j < length; j++) {
         FXJSE_Value_GetObjectPropByIdx(argValues[i], j, returnValues[index]);
         index++;
       }
       FXJSE_Value_Release(lengthValue);
     }
     FXJSE_Value_Set(returnValues[index], argValues[i]);
     index++;
   }
   FXJSE_Value_SetArray(args.GetReturnValue(), iLength, returnValues);
   for (int32_t i = 0; i < argCount; i++) {
     FXJSE_Value_Release(argValues[i]);
   }
   FX_Free(argValues);
   for (int32_t i = 0; i < (int32_t)iLength; i++) {
     FXJSE_Value_Release(returnValues[i]);
   }
   FX_Free(returnValues);
 }
-FXJSE_HVALUE CXFA_FM2JSContext::GetSimpleHValue(FXJSE_HOBJECT hThis,
+CFXJSE_Value* CXFA_FM2JSContext::GetSimpleValue(CFXJSE_Value* pThis,
                                                 CFXJSE_Arguments& args,
                                                 uint32_t index) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   v8::Isolate* pIsolate = pContext->GetScriptRuntime();
   ASSERT(index < (uint32_t)args.GetLength());
-  FXJSE_HVALUE argIndex = args.GetValue(index);
+  CFXJSE_Value* argIndex = args.GetValue(index);
   if (FXJSE_Value_IsArray(argIndex)) {
-    FXJSE_HVALUE lengthValue = FXJSE_Value_Create(pIsolate);
+    CFXJSE_Value* lengthValue = FXJSE_Value_Create(pIsolate);
     FXJSE_Value_GetObjectProp(argIndex, "length", lengthValue);
     int32_t iLength = FXJSE_Value_ToInteger(lengthValue);
     FXJSE_Value_Release(lengthValue);
-    FXJSE_HVALUE simpleValue = FXJSE_Value_Create(pIsolate);
+    CFXJSE_Value* simpleValue = FXJSE_Value_Create(pIsolate);
     if (iLength > 2) {
-      FXJSE_HVALUE propertyValue = FXJSE_Value_Create(pIsolate);
-      FXJSE_HVALUE jsobjectValue = FXJSE_Value_Create(pIsolate);
+      CFXJSE_Value* propertyValue = FXJSE_Value_Create(pIsolate);
+      CFXJSE_Value* jsobjectValue = FXJSE_Value_Create(pIsolate);
       FXJSE_Value_GetObjectPropByIdx(argIndex, 1, propertyValue);
       FXJSE_Value_GetObjectPropByIdx(argIndex, 2, jsobjectValue);
       if (FXJSE_Value_IsNull(propertyValue)) {
         GetObjectDefaultValue(jsobjectValue, simpleValue);
       } else {
         CFX_ByteString propertyStr;
         FXJSE_Value_ToUTF8String(propertyValue, propertyStr);
         FXJSE_Value_GetObjectProp(jsobjectValue, propertyStr.AsStringC(),
                                   simpleValue);
       }
       FXJSE_Value_Release(propertyValue);
       FXJSE_Value_Release(jsobjectValue);
     } else {
       FXJSE_Value_SetUndefined(simpleValue);
     }
     FXJSE_Value_Release(argIndex);
     return simpleValue;
   } else if (FXJSE_Value_IsObject(argIndex)) {
-    FXJSE_HVALUE defaultValue = FXJSE_Value_Create(pIsolate);
+    CFXJSE_Value* defaultValue = FXJSE_Value_Create(pIsolate);
     GetObjectDefaultValue(argIndex, defaultValue);
     FXJSE_Value_Release(argIndex);
     return defaultValue;
   } else {
     return argIndex;
   }
 }
-FX_BOOL CXFA_FM2JSContext::HValueIsNull(FXJSE_HOBJECT hThis, FXJSE_HVALUE arg) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+FX_BOOL CXFA_FM2JSContext::ValueIsNull(CFXJSE_Value* pThis, CFXJSE_Value* arg) {
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   v8::Isolate* pIsolate = pContext->GetScriptRuntime();
   FX_BOOL isNull = FALSE;
   if (FXJSE_Value_IsNull(arg)) {
     isNull = TRUE;
   } else if (FXJSE_Value_IsArray(arg)) {
-    int32_t iLength = hvalue_get_array_length(hThis, arg);
+    int32_t iLength = hvalue_get_array_length(pThis, arg);
     if (iLength > 2) {
-      FXJSE_HVALUE propertyValue = FXJSE_Value_Create(pIsolate);
-      FXJSE_HVALUE jsObjectValue = FXJSE_Value_Create(pIsolate);
+      CFXJSE_Value* propertyValue = FXJSE_Value_Create(pIsolate);
+      CFXJSE_Value* jsObjectValue = FXJSE_Value_Create(pIsolate);
       FXJSE_Value_GetObjectPropByIdx(arg, 1, propertyValue);
       FXJSE_Value_GetObjectPropByIdx(arg, 2, jsObjectValue);
       if (FXJSE_Value_IsNull(propertyValue)) {
-        FXJSE_HVALUE defaultValue = FXJSE_Value_Create(pIsolate);
+        CFXJSE_Value* defaultValue = FXJSE_Value_Create(pIsolate);
         GetObjectDefaultValue(jsObjectValue, defaultValue);
         if (FXJSE_Value_IsNull(defaultValue)) {
           isNull = TRUE;
         }
         FXJSE_Value_Release(defaultValue);
       } else {
         CFX_ByteString propertyStr;
         FXJSE_Value_ToUTF8String(propertyValue, propertyStr);
-        FXJSE_HVALUE newPropertyValue = FXJSE_Value_Create(pIsolate);
+        CFXJSE_Value* newPropertyValue = FXJSE_Value_Create(pIsolate);
         FXJSE_Value_GetObjectProp(jsObjectValue, propertyStr.AsStringC(),
                                   newPropertyValue);
         if (FXJSE_Value_IsNull(newPropertyValue)) {
           isNull = TRUE;
         }
         FXJSE_Value_Release(newPropertyValue);
       }
       FXJSE_Value_Release(propertyValue);
       FXJSE_Value_Release(jsObjectValue);
     } else {
       isNull = TRUE;
     }
   } else if (FXJSE_Value_IsObject(arg)) {
-    FXJSE_HVALUE defaultValue = FXJSE_Value_Create(pIsolate);
+    CFXJSE_Value* defaultValue = FXJSE_Value_Create(pIsolate);
     GetObjectDefaultValue(arg, defaultValue);
     if (FXJSE_Value_IsNull(defaultValue)) {
       isNull = TRUE;
     }
     FXJSE_Value_Release(defaultValue);
   }
   return isNull;
 }
-int32_t CXFA_FM2JSContext::hvalue_get_array_length(FXJSE_HOBJECT hThis,
-                                                   FXJSE_HVALUE arg) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+int32_t CXFA_FM2JSContext::hvalue_get_array_length(CFXJSE_Value* pThis,
+                                                   CFXJSE_Value* arg) {
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   v8::Isolate* pIsolate = pContext->GetScriptRuntime();
   int32_t iLength = 0;
   if (FXJSE_Value_IsArray(arg)) {
-    FXJSE_HVALUE lengthValue = FXJSE_Value_Create(pIsolate);
+    CFXJSE_Value* lengthValue = FXJSE_Value_Create(pIsolate);
     FXJSE_Value_GetObjectProp(arg, "length", lengthValue);
     iLength = FXJSE_Value_ToInteger(lengthValue);
     FXJSE_Value_Release(lengthValue);
   }
   return iLength;
 }
-FX_BOOL CXFA_FM2JSContext::simpleValueCompare(FXJSE_HOBJECT hThis,
-                                              FXJSE_HVALUE firstValue,
-                                              FXJSE_HVALUE secondValue) {
+FX_BOOL CXFA_FM2JSContext::simpleValueCompare(CFXJSE_Value* pThis,
+                                              CFXJSE_Value* firstValue,
+                                              CFXJSE_Value* secondValue) {
   FX_BOOL bReturn = FALSE;
   if (FXJSE_Value_IsUTF8String(firstValue)) {
     CFX_ByteString firstString, secondString;
-    HValueToUTF8String(firstValue, firstString);
-    HValueToUTF8String(secondValue, secondString);
+    ValueToUTF8String(firstValue, firstString);
+    ValueToUTF8String(secondValue, secondString);
     bReturn = firstString == secondString;
   } else if (FXJSE_Value_IsNumber(firstValue)) {
-    FX_FLOAT first = HValueToFloat(hThis, firstValue);
-    FX_FLOAT second = HValueToFloat(hThis, secondValue);
+    FX_FLOAT first = ValueToFloat(pThis, firstValue);
+    FX_FLOAT second = ValueToFloat(pThis, secondValue);
     bReturn = (first == second);
   } else if (FXJSE_Value_IsBoolean(firstValue)) {
     bReturn = (FXJSE_Value_ToBoolean(firstValue) ==
                FXJSE_Value_ToBoolean(secondValue));
   } else if (FXJSE_Value_IsNull(firstValue) &&
              FXJSE_Value_IsNull(secondValue)) {
     bReturn = TRUE;
   }
   return bReturn;
 }
-void CXFA_FM2JSContext::unfoldArgs(FXJSE_HOBJECT hThis,
+void CXFA_FM2JSContext::unfoldArgs(CFXJSE_Value* pThis,
                                    CFXJSE_Arguments& args,
-                                   FXJSE_HVALUE*& resultValues,
+                                   CFXJSE_Value**& resultValues,
                                    int32_t& iCount,
                                    int32_t iStart) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   v8::Isolate* pIsolate = pContext->GetScriptRuntime();
   iCount = 0;
   int32_t argc = args.GetLength();
-  FXJSE_HVALUE* argsValue = FX_Alloc(FXJSE_HVALUE, argc);
+  CFXJSE_Value** argsValue = FX_Alloc(CFXJSE_Value*, argc);
   for (int32_t i = iStart; i < argc; i++) {
     argsValue[i] = args.GetValue(i);
     if (FXJSE_Value_IsArray(argsValue[i])) {
-      FXJSE_HVALUE lengthValue = FXJSE_Value_Create(pIsolate);
+      CFXJSE_Value* lengthValue = FXJSE_Value_Create(pIsolate);
       FXJSE_Value_GetObjectProp(argsValue[i], "length", lengthValue);
       int32_t iLength = FXJSE_Value_ToInteger(lengthValue);
       FXJSE_Value_Release(lengthValue);
       iCount += ((iLength > 2) ? (iLength - 2) : 0);
     } else {
       iCount += 1;
     }
   }
-  resultValues = FX_Alloc(FXJSE_HVALUE, iCount);
+  resultValues = FX_Alloc(CFXJSE_Value*, iCount);
   for (int32_t i = 0; i < iCount; i++) {
     resultValues[i] = FXJSE_Value_Create(pIsolate);
   }
   int32_t index = 0;
   for (int32_t i = iStart; i < argc; i++) {
     if (FXJSE_Value_IsArray(argsValue[i])) {
-      FXJSE_HVALUE lengthValue = FXJSE_Value_Create(pIsolate);
+      CFXJSE_Value* lengthValue = FXJSE_Value_Create(pIsolate);
       FXJSE_Value_GetObjectProp(argsValue[i], "length", lengthValue);
       int32_t iLength = FXJSE_Value_ToInteger(lengthValue);
       FXJSE_Value_Release(lengthValue);
       if (iLength > 2) {
-        FXJSE_HVALUE propertyValue = FXJSE_Value_Create(pIsolate);
-        FXJSE_HVALUE jsObjectValue = FXJSE_Value_Create(pIsolate);
+        CFXJSE_Value* propertyValue = FXJSE_Value_Create(pIsolate);
+        CFXJSE_Value* jsObjectValue = FXJSE_Value_Create(pIsolate);
         FXJSE_Value_GetObjectPropByIdx(argsValue[i], 1, propertyValue);
         if (FXJSE_Value_IsNull(propertyValue)) {
           for (int32_t j = 2; j < iLength; j++) {
             FXJSE_Value_GetObjectPropByIdx(argsValue[i], j, jsObjectValue);
             GetObjectDefaultValue(jsObjectValue, resultValues[index]);
             index++;
           }
         } else {
           CFX_ByteString propertyString;
           FXJSE_Value_ToUTF8String(propertyValue, propertyString);
@@ skipping 13 matching lines @@
     } else {
       FXJSE_Value_Set(resultValues[index], argsValue[i]);
       index++;
     }
   }
   for (int32_t i = iStart; i < argc; i++) {
     FXJSE_Value_Release(argsValue[i]);
   }
   FX_Free(argsValue);
 }
-void CXFA_FM2JSContext::GetObjectDefaultValue(FXJSE_HVALUE hObjectValue,
-                                              FXJSE_HVALUE hDefaultValue) {
-  CXFA_Node* pNode = ToNode((CXFA_Object*)FXJSE_Value_ToObject(hObjectValue));
+void CXFA_FM2JSContext::GetObjectDefaultValue(CFXJSE_Value* pObjectValue,
+                                              CFXJSE_Value* pDefaultValue) {
+  CXFA_Node* pNode = ToNode((CXFA_Object*)FXJSE_Value_ToObject(pObjectValue));
   if (pNode) {
-    pNode->Script_Som_DefaultValue(hDefaultValue, FALSE, (XFA_ATTRIBUTE)-1);
+    pNode->Script_Som_DefaultValue(pDefaultValue, FALSE, (XFA_ATTRIBUTE)-1);
   } else {
-    FXJSE_Value_SetNull(hDefaultValue);
+    FXJSE_Value_SetNull(pDefaultValue);
   }
 }
-FX_BOOL CXFA_FM2JSContext::SetObjectDefaultValue(FXJSE_HVALUE hObjectValue,
-                                                 FXJSE_HVALUE hNewValue) {
-  CXFA_Node* pNode = ToNode((CXFA_Object*)FXJSE_Value_ToObject(hObjectValue));
+FX_BOOL CXFA_FM2JSContext::SetObjectDefaultValue(CFXJSE_Value* pObjectValue,
+                                                 CFXJSE_Value* hNewValue) {
+  CXFA_Node* pNode = ToNode((CXFA_Object*)FXJSE_Value_ToObject(pObjectValue));
   if (pNode) {
     pNode->Script_Som_DefaultValue(hNewValue, TRUE, (XFA_ATTRIBUTE)-1);
     return TRUE;
   }
   return FALSE;
 }
 void CXFA_FM2JSContext::GenerateSomExpression(const CFX_ByteStringC& szName,
                                               int32_t iIndexFlags,
                                               int32_t iIndexValue,
                                               FX_BOOL bIsStar,
@@ skipping 16 matching lines @@
     szSomExp += CFX_ByteString::FormatInteger(iIndexValue);
     szSomExp += "]";
   } else {
     szSomExp = (iIndexValue < 0) ? (szName + "[") : (szName + "[-");
     iIndexValue = (iIndexValue < 0) ? (0 - iIndexValue) : iIndexValue;
     szSomExp += CFX_ByteString::FormatInteger(iIndexValue);
     szSomExp += "]";
   }
 }
 FX_BOOL CXFA_FM2JSContext::GetObjectByName(
-    FXJSE_HOBJECT hThis,
-    FXJSE_HVALUE accessorValue,
+    CFXJSE_Value* pThis,
+    CFXJSE_Value* accessorValue,
     const CFX_ByteStringC& szAccessorName) {
   FX_BOOL bFlags = FALSE;
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   CXFA_Document* pDoc = pContext->GetDocument();
   if (!pDoc) {
     return bFlags;
   }
   CXFA_ScriptContext* pScriptContext = pDoc->GetScriptContext();
   XFA_RESOLVENODE_RS resoveNodeRS;
   uint32_t dwFlags = XFA_RESOLVENODE_Children | XFA_RESOLVENODE_Properties |
                      XFA_RESOLVENODE_Siblings | XFA_RESOLVENODE_Parent;
   int32_t iRet = pScriptContext->ResolveObjects(
       pScriptContext->GetThisObject(),
       CFX_WideString::FromUTF8(szAccessorName).AsStringC(), resoveNodeRS,
       dwFlags);
   if (iRet >= 1 && resoveNodeRS.dwFlags == XFA_RESOVENODE_RSTYPE_Nodes) {
     FXJSE_Value_Set(accessorValue, pScriptContext->GetJSValueFromMap(
                                        resoveNodeRS.nodes.GetAt(0)));
     bFlags = TRUE;
   }
   return bFlags;
 }
-int32_t CXFA_FM2JSContext::ResolveObjects(FXJSE_HOBJECT hThis,
-                                          FXJSE_HVALUE hRefValue,
+int32_t CXFA_FM2JSContext::ResolveObjects(CFXJSE_Value* pThis,
+                                          CFXJSE_Value* pRefValue,
                                           const CFX_ByteStringC& bsSomExp,
                                           XFA_RESOLVENODE_RS& resoveNodeRS,
                                           FX_BOOL bdotAccessor,
                                           FX_BOOL bHasNoResolveName) {
   CFX_WideString wsSomExpression = CFX_WideString::FromUTF8(bsSomExp);
   int32_t iRet = -1;
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   CXFA_Document* pDoc = pContext->GetDocument();
   if (!pDoc) {
     return iRet;
   }
   CXFA_ScriptContext* pScriptContext = pDoc->GetScriptContext();
   CXFA_Object* pNode = NULL;
   uint32_t dFlags = 0UL;
   if (bdotAccessor) {
-    if (FXJSE_Value_IsNull(hRefValue)) {
+    if (FXJSE_Value_IsNull(pRefValue)) {
       pNode = pScriptContext->GetThisObject();
       dFlags = XFA_RESOLVENODE_Siblings | XFA_RESOLVENODE_Parent;
     } else {
-      pNode = (CXFA_Object*)FXJSE_Value_ToObject(hRefValue);
+      pNode = (CXFA_Object*)FXJSE_Value_ToObject(pRefValue);
       ASSERT(pNode);
       if (bHasNoResolveName) {
         CFX_WideString wsName;
         if (CXFA_Node* pXFANode = pNode->AsNode()) {
           pXFANode->GetAttribute(XFA_ATTRIBUTE_Name, wsName, FALSE);
         }
         if (wsName.IsEmpty()) {
           CFX_WideStringC className;
           pNode->GetClassName(className);
           wsName = FX_WSTRC(L"#") + className;
         }
         wsSomExpression = wsName + wsSomExpression;
         dFlags = XFA_RESOLVENODE_Siblings;
       } else {
         dFlags = (bsSomExp == "*")
                      ? (XFA_RESOLVENODE_Children)
                      : (XFA_RESOLVENODE_Children | XFA_RESOLVENODE_Attributes |
                         XFA_RESOLVENODE_Properties);
       }
     }
   } else {
-    pNode = (CXFA_Object*)FXJSE_Value_ToObject(hRefValue);
+    pNode = (CXFA_Object*)FXJSE_Value_ToObject(pRefValue);
     dFlags = XFA_RESOLVENODE_AnyChild;
   }
   iRet = pScriptContext->ResolveObjects(pNode, wsSomExpression.AsStringC(),
                                         resoveNodeRS, dFlags);
   return iRet;
 }
 void CXFA_FM2JSContext::ParseResolveResult(
-    FXJSE_HOBJECT hThis,
+    CFXJSE_Value* pThis,
     const XFA_RESOLVENODE_RS& resoveNodeRS,
-    FXJSE_HVALUE hParentValue,
-    FXJSE_HVALUE*& resultValues,
+    CFXJSE_Value* pParentValue,
+    CFXJSE_Value**& resultValues,
     int32_t& iSize,
     FX_BOOL& bAttribute) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   v8::Isolate* pIsolate = pContext->GetScriptRuntime();
   iSize = 0;
   resultValues = NULL;
   if (resoveNodeRS.dwFlags == XFA_RESOVENODE_RSTYPE_Nodes) {
     bAttribute = FALSE;
     iSize = resoveNodeRS.nodes.GetSize();
-    resultValues = FX_Alloc(FXJSE_HVALUE, iSize);
+    resultValues = FX_Alloc(CFXJSE_Value*, iSize);
     for (int32_t i = 0; i < iSize; i++) {
       resultValues[i] = FXJSE_Value_Create(pIsolate);
       FXJSE_Value_Set(
           resultValues[i],
           pContext->GetDocument()->GetScriptContext()->GetJSValueFromMap(
               resoveNodeRS.nodes.GetAt(i)));
     }
   } else {
-    CXFA_HVALUEArray objectProperties(pIsolate);
+    CXFA_ValueArray objectProperties(pIsolate);
     int32_t iRet = resoveNodeRS.GetAttributeResult(objectProperties);
     bAttribute = (iRet == 0);
     if (bAttribute) {
-      if (FXJSE_Value_IsObject(hParentValue)) {
+      if (FXJSE_Value_IsObject(pParentValue)) {
         iSize = 1;
-        resultValues = FX_Alloc(FXJSE_HVALUE, 1);
+        resultValues = FX_Alloc(CFXJSE_Value*, 1);
         resultValues[0] = FXJSE_Value_Create(pIsolate);
-        FXJSE_Value_Set(resultValues[0], hParentValue);
+        FXJSE_Value_Set(resultValues[0], pParentValue);
       }
     } else {
       iSize = iRet;
-      resultValues = FX_Alloc(FXJSE_HVALUE, iSize);
+      resultValues = FX_Alloc(CFXJSE_Value*, iSize);
       for (int32_t i = 0; i < iSize; i++) {
         resultValues[i] = FXJSE_Value_Create(pIsolate);
         FXJSE_Value_Set(resultValues[i], objectProperties[i]);
       }
     }
   }
 }
-int32_t CXFA_FM2JSContext::HValueToInteger(FXJSE_HOBJECT hThis,
-                                           FXJSE_HVALUE hValue) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+int32_t CXFA_FM2JSContext::ValueToInteger(CFXJSE_Value* pThis,
+                                          CFXJSE_Value* pValue) {
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   v8::Isolate* pIsolate = pContext->GetScriptRuntime();
   int32_t iValue = 0;
-  if (FXJSE_Value_IsArray(hValue)) {
-    FXJSE_HVALUE propertyValue = FXJSE_Value_Create(pIsolate);
-    FXJSE_HVALUE jsobjectValue = FXJSE_Value_Create(pIsolate);
-    FXJSE_HVALUE newProperty = FXJSE_Value_Create(pIsolate);
-    FXJSE_Value_GetObjectPropByIdx(hValue, 1, propertyValue);
-    FXJSE_Value_GetObjectPropByIdx(hValue, 2, jsobjectValue);
+  if (FXJSE_Value_IsArray(pValue)) {
+    CFXJSE_Value* propertyValue = FXJSE_Value_Create(pIsolate);
+    CFXJSE_Value* jsobjectValue = FXJSE_Value_Create(pIsolate);
+    CFXJSE_Value* newProperty = FXJSE_Value_Create(pIsolate);
+    FXJSE_Value_GetObjectPropByIdx(pValue, 1, propertyValue);
+    FXJSE_Value_GetObjectPropByIdx(pValue, 2, jsobjectValue);
     if (FXJSE_Value_IsNull(propertyValue)) {
       GetObjectDefaultValue(jsobjectValue, newProperty);
     } else {
       CFX_ByteString propertyStr;
       FXJSE_Value_ToUTF8String(propertyValue, propertyStr);
       FXJSE_Value_GetObjectProp(jsobjectValue, propertyStr.AsStringC(),
                                 newProperty);
     }
-    iValue = HValueToInteger(hThis, newProperty);
+    iValue = ValueToInteger(pThis, newProperty);
     FXJSE_Value_Release(newProperty);
     FXJSE_Value_Release(jsobjectValue);
     FXJSE_Value_Release(propertyValue);
     return iValue;
-  } else if (FXJSE_Value_IsObject(hValue)) {
-    FXJSE_HVALUE newProperty = FXJSE_Value_Create(pIsolate);
-    GetObjectDefaultValue(hValue, newProperty);
-    iValue = HValueToInteger(hThis, newProperty);
+  } else if (FXJSE_Value_IsObject(pValue)) {
+    CFXJSE_Value* newProperty = FXJSE_Value_Create(pIsolate);
+    GetObjectDefaultValue(pValue, newProperty);
+    iValue = ValueToInteger(pThis, newProperty);
     FXJSE_Value_Release(newProperty);
     return iValue;
-  } else if (FXJSE_Value_IsUTF8String(hValue)) {
+  } else if (FXJSE_Value_IsUTF8String(pValue)) {
     CFX_ByteString szValue;
-    FXJSE_Value_ToUTF8String(hValue, szValue);
+    FXJSE_Value_ToUTF8String(pValue, szValue);
     iValue = FXSYS_atoi(szValue.c_str());
   } else {
-    iValue = FXJSE_Value_ToInteger(hValue);
+    iValue = FXJSE_Value_ToInteger(pValue);
   }
   return iValue;
 }
 FX_DOUBLE CXFA_FM2JSContext::StringToDouble(
     const CFX_ByteStringC& szStringVal) {
   return XFA_ByteStringToDouble(szStringVal);
 }
-FX_FLOAT CXFA_FM2JSContext::HValueToFloat(FXJSE_HOBJECT hThis,
-                                          FXJSE_HVALUE arg) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+FX_FLOAT CXFA_FM2JSContext::ValueToFloat(CFXJSE_Value* pThis,
+                                         CFXJSE_Value* arg) {
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   v8::Isolate* pIsolate = pContext->GetScriptRuntime();
   FX_FLOAT fRet = 0.0f;
   if (FXJSE_Value_IsArray(arg)) {
-    FXJSE_HVALUE propertyValue = FXJSE_Value_Create(pIsolate);
-    FXJSE_HVALUE jsobjectValue = FXJSE_Value_Create(pIsolate);
-    FXJSE_HVALUE newProperty = FXJSE_Value_Create(pIsolate);
+    CFXJSE_Value* propertyValue = FXJSE_Value_Create(pIsolate);
+    CFXJSE_Value* jsobjectValue = FXJSE_Value_Create(pIsolate);
+    CFXJSE_Value* newProperty = FXJSE_Value_Create(pIsolate);
     FXJSE_Value_GetObjectPropByIdx(arg, 1, propertyValue);
     FXJSE_Value_GetObjectPropByIdx(arg, 2, jsobjectValue);
     if (FXJSE_Value_IsNull(propertyValue)) {
       GetObjectDefaultValue(jsobjectValue, newProperty);
     } else {
       CFX_ByteString propertyStr;
       FXJSE_Value_ToUTF8String(propertyValue, propertyStr);
       FXJSE_Value_GetObjectProp(jsobjectValue, propertyStr.AsStringC(),
                                 newProperty);
     }
-    fRet = HValueToFloat(hThis, newProperty);
+    fRet = ValueToFloat(pThis, newProperty);
     FXJSE_Value_Release(newProperty);
     FXJSE_Value_Release(jsobjectValue);
     FXJSE_Value_Release(propertyValue);
   } else if (FXJSE_Value_IsObject(arg)) {
-    FXJSE_HVALUE newProperty = FXJSE_Value_Create(pIsolate);
+    CFXJSE_Value* newProperty = FXJSE_Value_Create(pIsolate);
     GetObjectDefaultValue(arg, newProperty);
-    fRet = HValueToFloat(hThis, newProperty);
+    fRet = ValueToFloat(pThis, newProperty);
     FXJSE_Value_Release(newProperty);
   } else if (FXJSE_Value_IsUTF8String(arg)) {
     CFX_ByteString bsOutput;
     FXJSE_Value_ToUTF8String(arg, bsOutput);
     fRet = (FX_FLOAT)StringToDouble(bsOutput.AsStringC());
   } else if (FXJSE_Value_IsUndefined(arg)) {
     fRet = 0;
   } else {
     fRet = FXJSE_Value_ToFloat(arg);
   }
   return fRet;
 }
-FX_DOUBLE CXFA_FM2JSContext::HValueToDouble(FXJSE_HOBJECT hThis,
-                                            FXJSE_HVALUE arg) {
-  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(hThis);
+FX_DOUBLE CXFA_FM2JSContext::ValueToDouble(CFXJSE_Value* pThis,
+                                           CFXJSE_Value* arg) {
+  CXFA_FM2JSContext* pContext = (CXFA_FM2JSContext*)FXJSE_Value_ToObject(pThis);
   v8::Isolate* pIsolate = pContext->GetScriptRuntime();
   FX_DOUBLE dRet = 0;
   if (FXJSE_Value_IsArray(arg)) {
-    FXJSE_HVALUE propertyValue = FXJSE_Value_Create(pIsolate);
-    FXJSE_HVALUE jsobjectValue = FXJSE_Value_Create(pIsolate);
-    FXJSE_HVALUE newProperty = FXJSE_Value_Create(pIsolate);
+    CFXJSE_Value* propertyValue = FXJSE_Value_Create(pIsolate);
+    CFXJSE_Value* jsobjectValue = FXJSE_Value_Create(pIsolate);
+    CFXJSE_Value* newProperty = FXJSE_Value_Create(pIsolate);
     FXJSE_Value_GetObjectPropByIdx(arg, 1, propertyValue);
     FXJSE_Value_GetObjectPropByIdx(arg, 2, jsobjectValue);
     if (FXJSE_Value_IsNull(propertyValue)) {
       GetObjectDefaultValue(jsobjectValue, newProperty);
     } else {
       CFX_ByteString propertyStr;
       FXJSE_Value_ToUTF8String(propertyValue, propertyStr);
       FXJSE_Value_GetObjectProp(jsobjectValue, propertyStr.AsStringC(),
                                 newProperty);
     }
-    dRet = HValueToDouble(hThis, newProperty);
+    dRet = ValueToDouble(pThis, newProperty);
     FXJSE_Value_Release(newProperty);
     FXJSE_Value_Release(jsobjectValue);
     FXJSE_Value_Release(propertyValue);
   } else if (FXJSE_Value_IsObject(arg)) {
-    FXJSE_HVALUE newProperty = FXJSE_Value_Create(pIsolate);
+    CFXJSE_Value* newProperty = FXJSE_Value_Create(pIsolate);
     GetObjectDefaultValue(arg, newProperty);
-    dRet = HValueToDouble(hThis, newProperty);
+    dRet = ValueToDouble(pThis, newProperty);
     FXJSE_Value_Release(newProperty);
   } else if (FXJSE_Value_IsUTF8String(arg)) {
     CFX_ByteString bsOutput;
     FXJSE_Value_ToUTF8String(arg, bsOutput);
     dRet = StringToDouble(bsOutput.AsStringC());
   } else if (FXJSE_Value_IsUndefined(arg)) {
     dRet = 0;
   } else {
     dRet = FXJSE_Value_ToDouble(arg);
   }
   return dRet;
 }
-void CXFA_FM2JSContext::HValueToUTF8String(FXJSE_HVALUE arg,
-                                           CFX_ByteString& szOutputString) {
+void CXFA_FM2JSContext::ValueToUTF8String(CFXJSE_Value* arg,
+                                          CFX_ByteString& szOutputString) {
   if (FXJSE_Value_IsNull(arg) || FXJSE_Value_IsUndefined(arg)) {
     szOutputString = "";
   } else if (FXJSE_Value_IsBoolean(arg)) {
     szOutputString = FXJSE_Value_ToBoolean(arg) ? "1" : "0";
   } else {
     szOutputString = "";
     FXJSE_Value_ToUTF8String(arg, szOutputString);
   }
 }
 static FXJSE_FUNCTION formcalc_fm2js_functions[] = {
@@ skipping 86 matching lines @@
     {"is_fm_object", CXFA_FM2JSContext::is_fm_object},
     {"is_fm_array", CXFA_FM2JSContext::is_fm_array},
     {"get_fm_value", CXFA_FM2JSContext::get_fm_value},
     {"get_fm_jsobj", CXFA_FM2JSContext::get_fm_jsobj},
     {"fm_var_filter", CXFA_FM2JSContext::fm_var_filter},
 };
 CXFA_FM2JSContext::CXFA_FM2JSContext()
     : m_pFMClass(nullptr), m_pDocument(nullptr) {
   FXSYS_memset(&m_fmClass, 0, sizeof(FXJSE_CLASS));
 }
+
 CXFA_FM2JSContext::~CXFA_FM2JSContext() {
-  m_pDocument = NULL;
-  if (m_hValue) {
-    FXJSE_Value_Release(m_hValue);
-    m_hValue = NULL;
-  }
-  m_pIsolate = NULL;
+  if (m_pValue)
+    FXJSE_Value_Release(m_pValue);
 }
+
 void CXFA_FM2JSContext::Initialize(v8::Isolate* pScriptIsolate,
                                    CFXJSE_Context* pScriptContext,
                                    CXFA_Document* pDoc) {
   m_pDocument = pDoc;
   m_pIsolate = pScriptIsolate;
   m_fmClass.name = "XFA_FM2JS_FormCalcClass";
   m_fmClass.constructor = NULL;
   m_fmClass.properties = NULL;
   m_fmClass.methods = formcalc_fm2js_functions;
   m_fmClass.propNum = 0;
   m_fmClass.methNum =
       sizeof(formcalc_fm2js_functions) / sizeof(formcalc_fm2js_functions[0]);
   m_pFMClass = FXJSE_DefineClass(pScriptContext, &m_fmClass);
-  m_hValue = FXJSE_Value_Create(pScriptIsolate);
-  FXJSE_Value_SetNull(m_hValue);
-  FXJSE_Value_SetObject(m_hValue, this, m_pFMClass);
+  m_pValue = FXJSE_Value_Create(pScriptIsolate);
+  FXJSE_Value_SetNull(m_pValue);
+  FXJSE_Value_SetObject(m_pValue, this, m_pFMClass);
 }
-void CXFA_FM2JSContext::GlobalPropertyGetter(FXJSE_HVALUE hValue) {
-  FXJSE_Value_Set(hValue, m_hValue);
+void CXFA_FM2JSContext::GlobalPropertyGetter(CFXJSE_Value* pValue) {
+  FXJSE_Value_Set(pValue, m_pValue);
 }
 void CXFA_FM2JSContext::ThrowScriptErrorMessage(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());
 }