Merge to XFA: Use stdint.h types throughout PDFium.

xfa/src/fxjse/src/value.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 "../../foxitlib.h"
 #include "fxv8.h"
 #include "value.h"
 #include "class.h"
@@ skipping 66 matching lines @@
     CFXJSE_Value* lpValue = reinterpret_cast<CFXJSE_Value*>(hValue);
     ASSERT(lpValue);
     return lpValue->ToDouble();
 }
 void            FXJSE_Value_ToUTF8String        (FXJSE_HVALUE hValue, CFX_ByteString& szStrOutput)
 {
     CFXJSE_Value* lpValue = reinterpret_cast<CFXJSE_Value*>(hValue);
     ASSERT(lpValue);
     return lpValue->ToString(szStrOutput);
 }
-FX_INT32        FXJSE_Value_ToInteger           (FXJSE_HVALUE hValue)
+int32_t FXJSE_Value_ToInteger           (FXJSE_HVALUE hValue)
 {
     CFXJSE_Value* lpValue = reinterpret_cast<CFXJSE_Value*>(hValue);
     ASSERT(lpValue);
     return lpValue->ToInteger();
 }
 FX_LPVOID       FXJSE_Value_ToObject            (FXJSE_HVALUE hValue, FXJSE_HCLASS hClass)
 {
     CFXJSE_Value* lpValue = reinterpret_cast<CFXJSE_Value*>(hValue);
     CFXJSE_Class* lpClass = reinterpret_cast<CFXJSE_Class*>(hClass);
     ASSERT(lpValue);
@@ skipping 16 matching lines @@
     CFXJSE_Value* lpValue = reinterpret_cast<CFXJSE_Value*>(hValue);
     ASSERT(lpValue);
     return lpValue->SetBoolean(bBoolean);
 }
 void            FXJSE_Value_SetUTF8String       (FXJSE_HVALUE hValue, FX_BSTR   szString)
 {
     CFXJSE_Value* lpValue = reinterpret_cast<CFXJSE_Value*>(hValue);
     ASSERT(lpValue);
     return lpValue->SetString(szString);
 }
-void            FXJSE_Value_SetInteger          (FXJSE_HVALUE hValue, FX_INT32  nInteger)
+void            FXJSE_Value_SetInteger          (FXJSE_HVALUE hValue, int32_t  nInteger)
 {
     CFXJSE_Value* lpValue = reinterpret_cast<CFXJSE_Value*>(hValue);
     ASSERT(lpValue);
     return lpValue->SetInteger(nInteger);
 }
 void            FXJSE_Value_SetFloat            (FXJSE_HVALUE hValue, FX_FLOAT  fFloat)
 {
     CFXJSE_Value* lpValue = reinterpret_cast<CFXJSE_Value*>(hValue);
     ASSERT(lpValue);
     return lpValue->SetFloat(fFloat);
 }
 void            FXJSE_Value_SetDouble           (FXJSE_HVALUE hValue, FXJSE_DOUBLE dDouble)
 {
     CFXJSE_Value* lpValue = reinterpret_cast<CFXJSE_Value*>(hValue);
     ASSERT(lpValue);
     return lpValue->SetDouble(dDouble);
 }
 void            FXJSE_Value_SetObject           (FXJSE_HVALUE hValue, FX_LPVOID lpObject, FXJSE_HCLASS hClass)
 {
     CFXJSE_Value* lpValue = reinterpret_cast<CFXJSE_Value*>(hValue);
     CFXJSE_Class* lpClass = reinterpret_cast<CFXJSE_Class*>(hClass);
     if(lpClass == NULL) {
         ASSERT(lpObject == NULL);
         lpValue->SetJSObject();
     } else if(lpClass != NULL) {
         lpValue->SetHostObject(lpObject, lpClass);
     }
 }
-void            FXJSE_Value_SetArray            (FXJSE_HVALUE hValue, FX_UINT32 uValueCount, FXJSE_HVALUE* rgValues)
+void            FXJSE_Value_SetArray            (FXJSE_HVALUE hValue, uint32_t uValueCount, FXJSE_HVALUE* rgValues)
 {
     CFXJSE_Value* lpValue = reinterpret_cast<CFXJSE_Value*>(hValue);
     return lpValue->SetArray(uValueCount, reinterpret_cast<CFXJSE_Value**>(rgValues));
 }
 void            FXJSE_Value_SetDate                     (FXJSE_HVALUE hValue, FXJSE_DOUBLE dDouble)
 {
     CFXJSE_Value* lpValue = reinterpret_cast<CFXJSE_Value*>(hValue);
     return lpValue->SetDate(dDouble);
 }
 void            FXJSE_Value_Set                         (FXJSE_HVALUE hValue, FXJSE_HVALUE hOriginalValue)
@@ skipping 10 matching lines @@
     ASSERT(lpValue && lpPropValue);
     return lpValue->GetObjectProperty(szPropName, lpPropValue);
 }
 FX_BOOL         FXJSE_Value_SetObjectProp               (FXJSE_HVALUE hValue, FX_BSTR   szPropName,     FXJSE_HVALUE hPropValue)
 {
     CFXJSE_Value* lpValue = reinterpret_cast<CFXJSE_Value*>(hValue);
     CFXJSE_Value* lpPropValue = reinterpret_cast<CFXJSE_Value*>(hPropValue);
     ASSERT(lpValue && lpPropValue);
     return lpValue->SetObjectProperty(szPropName, lpPropValue);
 }
-FX_BOOL         FXJSE_Value_GetObjectPropByIdx  (FXJSE_HVALUE hValue, FX_UINT32 uPropIdx,       FXJSE_HVALUE hPropValue)
+FX_BOOL         FXJSE_Value_GetObjectPropByIdx  (FXJSE_HVALUE hValue, uint32_t  uPropIdx,       FXJSE_HVALUE hPropValue)
 {
     CFXJSE_Value* lpValue = reinterpret_cast<CFXJSE_Value*>(hValue);
     CFXJSE_Value* lpPropValue = reinterpret_cast<CFXJSE_Value*>(hPropValue);
     ASSERT(lpValue && lpPropValue);
     return lpValue->GetObjectProperty(uPropIdx, lpPropValue);
 }
-FX_BOOL         FXJSE_Value_SetObjectPropByIdx  (FXJSE_HVALUE hValue, FX_UINT32 uPropIdx,       FXJSE_HVALUE hPropValue)
+FX_BOOL         FXJSE_Value_SetObjectPropByIdx  (FXJSE_HVALUE hValue, uint32_t  uPropIdx,       FXJSE_HVALUE hPropValue)
 {
     CFXJSE_Value* lpValue = reinterpret_cast<CFXJSE_Value*>(hValue);
     CFXJSE_Value* lpPropValue = reinterpret_cast<CFXJSE_Value*>(hPropValue);
     ASSERT(lpValue && lpPropValue);
     return lpValue->SetObjectProperty(uPropIdx, lpPropValue);
 }
 FX_BOOL         FXJSE_Value_DeleteObjectProp    (FXJSE_HVALUE hValue, FX_BSTR szPropName)
 {
     CFXJSE_Value* lpValue = reinterpret_cast<CFXJSE_Value*>(hValue);
     ASSERT(lpValue);
@@ skipping 13 matching lines @@
     return lpValue->SetObjectOwnProperty(szPropName, lpPropValue);
 }
 FX_BOOL         FXJSE_Value_SetFunctionBind     (FXJSE_HVALUE hValue, FXJSE_HVALUE hOldFunction, FXJSE_HVALUE hNewThis)
 {
     CFXJSE_Value* lpValue = reinterpret_cast<CFXJSE_Value*>(hValue);
     CFXJSE_Value* lpOldFunction = reinterpret_cast<CFXJSE_Value*>(hOldFunction);
     CFXJSE_Value* lpNewThis = reinterpret_cast<CFXJSE_Value*>(hNewThis);
     ASSERT(lpValue && lpOldFunction && lpNewThis);
     return lpValue->SetFunctionBind(lpOldFunction, lpNewThis);
 }
-FX_BOOL FXJSE_Value_CallFunction(FXJSE_HVALUE hFunction, FXJSE_HVALUE hThis, FXJSE_HVALUE hRetValue, FX_UINT32 nArgCount, FXJSE_HVALUE* lpArgs)
+FX_BOOL FXJSE_Value_CallFunction(FXJSE_HVALUE hFunction, FXJSE_HVALUE hThis, FXJSE_HVALUE hRetValue, uint32_t nArgCount, FXJSE_HVALUE* lpArgs)
 {
     CFXJSE_Value* lpFunction = reinterpret_cast<CFXJSE_Value*>(hFunction);
     CFXJSE_Value* lpThis = reinterpret_cast<CFXJSE_Value*>(hThis);
     CFXJSE_Value* lpRetValue = reinterpret_cast<CFXJSE_Value*>(hRetValue);
     ASSERT(lpFunction);
     return lpFunction->Call(lpThis, lpRetValue, nArgCount, lpArgs);
 }
 FXJSE_HVALUE    FXJSE_Value_Create              (FXJSE_HRUNTIME hRuntime)
 {
     CFXJSE_Value* lpValue = CFXJSE_Value::Create(reinterpret_cast<v8::Isolate*>(hRuntime));
@@ skipping 50 matching lines @@
         return NULL;
     }
     return FXJSE_RetrieveObjectBinding(hValue.As<v8::Object>(), lpClass);
 }
 V8_INLINE static double FXJSE_ftod(FX_FLOAT fNumber)
 {
     if(sizeof(FX_FLOAT) != 4) {
         ASSERT(FALSE);
         return fNumber;
     }
-    FX_UINT32 nFloatBits = (FX_UINT32&)fNumber;
-    FX_UINT8  nExponent  = (FX_UINT8)(nFloatBits >> 16 >> 7 );
+    uint32_t nFloatBits = (uint32_t&)fNumber;
+    uint8_t  nExponent  = (uint8_t)(nFloatBits >> 16 >> 7 );
     if(nExponent == 0 || nExponent == 255) {
         return fNumber;
     }
-    FX_INT8 nErrExp = nExponent - 127 - 23;
+    int8_t nErrExp = nExponent - 127 - 23;
     if(nErrExp >= 0) {
         return fNumber;
     }
     double dwError = pow(2.0, nErrExp), dwErrorHalf = dwError / 2;
     double dNumber = fNumber,  dNumberAbs = fabs(fNumber);
     double dNumberAbsMin = dNumberAbs - dwErrorHalf, dNumberAbsMax = dNumberAbs + dwErrorHalf;
-    FX_INT32 iErrPos = 0;
+    int32_t iErrPos = 0;
     if(floor(dNumberAbsMin) == floor(dNumberAbsMax)) {
         dNumberAbsMin = fmod(dNumberAbsMin, 1.0);
         dNumberAbsMax = fmod(dNumberAbsMax, 1.0);
-        FX_INT32 iErrPosMin = 1, iErrPosMax = 38;
+        int32_t iErrPosMin = 1, iErrPosMax = 38;
         do {
-            FX_INT32 iMid = (iErrPosMin + iErrPosMax) / 2;
+            int32_t iMid = (iErrPosMin + iErrPosMax) / 2;
             double dPow = pow(10.0, iMid);
             if(floor(dNumberAbsMin * dPow) == floor(dNumberAbsMax * dPow)) {
                 iErrPosMin = iMid + 1;
             } else {
                 iErrPosMax = iMid;
             }
         } while (iErrPosMin < iErrPosMax);
         iErrPos = iErrPosMax;
     }
     double dPow = pow(10.0, iErrPos);
     return fNumber < 0 ? ceil(dNumber * dPow - 0.5) / dPow : floor(dNumber * dPow + 0.5) / dPow;
 }
 void CFXJSE_Value::SetFloat(FX_FLOAT fFloat)
 {
     CFXJSE_ScopeUtil_IsolateHandle scope(m_pIsolate);
     v8::Local<v8::Value> hValue = v8::Number::New(m_pIsolate, FXJSE_ftod(fFloat));
     m_hValue.Reset(m_pIsolate, hValue);
 }
 void CFXJSE_Value::SetHostObject(FX_LPVOID lpObject, CFXJSE_Class* lpClass)
 {
     CFXJSE_ScopeUtil_IsolateHandleRootContext scope(m_pIsolate);
     ASSERT(lpClass);
     v8::Local<v8::FunctionTemplate> hClass = v8::Local<v8::FunctionTemplate>::New(m_pIsolate, lpClass->m_hTemplate);
     v8::Local<v8::Object> hObject = hClass->InstanceTemplate()->NewInstance();
     FXJSE_UpdateObjectBinding(hObject, lpObject);
     m_hValue.Reset(m_pIsolate, hObject);
 }
-void CFXJSE_Value::SetArray(FX_UINT32 uValueCount, CFXJSE_Value** rgValues)
+void CFXJSE_Value::SetArray(uint32_t uValueCount, CFXJSE_Value** rgValues)
 {
     CFXJSE_ScopeUtil_IsolateHandleRootContext scope(m_pIsolate);
     v8::Local<v8::Array> hArrayObject = v8::Array::New(m_pIsolate, uValueCount);
     if (rgValues) {
-        for(FX_UINT32 i = 0; i < uValueCount; i++) {
+        for(uint32_t i = 0; i < uValueCount; i++) {
             if(rgValues[i]) {
                 hArrayObject->Set(i, v8::Local<v8::Value>::New(m_pIsolate, rgValues[i]->DirectGetValue()));
             }
         }
     }
     m_hValue.Reset(m_pIsolate, hArrayObject);
 }
 void CFXJSE_Value::SetDate(FXJSE_DOUBLE dDouble)
 {
     CFXJSE_ScopeUtil_IsolateHandleRootContext scope(m_pIsolate);
@@ skipping 14 matching lines @@
 {
     CFXJSE_ScopeUtil_IsolateHandleRootContext scope(m_pIsolate);
     v8::Local<v8::Value> hObject = v8::Local<v8::Value>::New(m_pIsolate, m_hValue);
     if(!hObject->IsObject()) {
         return FALSE;
     }
     v8::Local<v8::Value> hPropValue = hObject.As<v8::Object>()->Get(v8::String::NewFromUtf8(m_pIsolate, szPropName.GetCStr(), v8::String::kNormalString, szPropName.GetLength()));
     lpPropValue->ForceSetValue(hPropValue);
     return TRUE;
 }
-FX_BOOL CFXJSE_Value::SetObjectProperty(FX_UINT32 uPropIdx, CFXJSE_Value* lpPropValue)
+FX_BOOL CFXJSE_Value::SetObjectProperty(uint32_t uPropIdx, CFXJSE_Value* lpPropValue)
 {
     CFXJSE_ScopeUtil_IsolateHandleRootContext scope(m_pIsolate);
     v8::Local<v8::Value> hObject = v8::Local<v8::Value>::New(m_pIsolate, m_hValue);
     if(!hObject->IsObject()) {
         return FALSE;
     }
     v8::Local<v8::Value> hPropValue = v8::Local<v8::Value>::New(m_pIsolate, lpPropValue->DirectGetValue());
     return (FX_BOOL)hObject.As<v8::Object>()->Set(uPropIdx, hPropValue);
 }
-FX_BOOL CFXJSE_Value::GetObjectProperty(FX_UINT32 uPropIdx, CFXJSE_Value* lpPropValue)
+FX_BOOL CFXJSE_Value::GetObjectProperty(uint32_t uPropIdx, CFXJSE_Value* lpPropValue)
 {
     CFXJSE_ScopeUtil_IsolateHandleRootContext scope(m_pIsolate);
     v8::Local<v8::Value> hObject = v8::Local<v8::Value>::New(m_pIsolate, m_hValue);
     if(!hObject->IsObject()) {
         return FALSE;
     }
     v8::Local<v8::Value> hPropValue = hObject.As<v8::Object>()->Get(uPropIdx);
     lpPropValue->ForceSetValue(hPropValue);
     return TRUE;
 }
@@ skipping 43 matching lines @@
     rgArgs[1] = hNewThis;
     v8::Local<v8::String> hBinderFuncSource = v8::String::NewFromUtf8(m_pIsolate, "(function (oldfunction, newthis) { return oldfunction.bind(newthis); })");
     v8::Local<v8::Function> hBinderFunc = v8::Script::Compile(hBinderFuncSource)->Run().As<v8::Function>();
     v8::Local<v8::Value> hBoundFunction = hBinderFunc->Call(m_pIsolate->GetCurrentContext()->Global(), 2, rgArgs);
     if(hBoundFunction.IsEmpty() || !hBoundFunction->IsFunction()) {
         return FALSE;
     }
     m_hValue.Reset(m_pIsolate, hBoundFunction);
     return TRUE;
 }
-#define FXJSE_INVALID_PTR ((FX_LPVOID)(FX_INTPTR)-1)
-FX_BOOL CFXJSE_Value::Call(CFXJSE_Value* lpReceiver, CFXJSE_Value* lpRetValue, FX_UINT32 nArgCount, FXJSE_HVALUE* lpArgs)
+#define FXJSE_INVALID_PTR ((FX_LPVOID)(intptr_t)-1)
+FX_BOOL CFXJSE_Value::Call(CFXJSE_Value* lpReceiver, CFXJSE_Value* lpRetValue, uint32_t nArgCount, FXJSE_HVALUE* lpArgs)
 {
     CFXJSE_ScopeUtil_IsolateHandleRootContext scope(m_pIsolate);
     v8::Local<v8::Value> hFunctionValue = v8::Local<v8::Value>::New(m_pIsolate, DirectGetValue());
     v8::Local<v8::Object> hFunctionObject = !hFunctionValue.IsEmpty() && hFunctionValue->IsObject() ? hFunctionValue.As<v8::Object>() : v8::Local<v8::Object>();
     v8::TryCatch trycatch;
     if (hFunctionObject.IsEmpty() || !hFunctionObject->IsCallable()) {
         if(lpRetValue) {
             lpRetValue->ForceSetValue(FXJSE_CreateReturnValue(m_pIsolate, trycatch));
         }
         return FALSE;
     }
     v8::Local<v8::Value> hReturnValue;
     v8::Local<v8::Value>* lpLocalArgs = NULL;
     if(nArgCount) {
         lpLocalArgs = FX_Alloc(v8::Local<v8::Value>, nArgCount);
         if (!lpLocalArgs) {
             return FALSE;
         }
-        for (FX_UINT32 i = 0; i < nArgCount; i++) {
+        for (uint32_t i = 0; i < nArgCount; i++) {
             new (lpLocalArgs + i) v8::Local<v8::Value>;
             CFXJSE_Value* lpArg = (CFXJSE_Value*)lpArgs[i];
             if(lpArg) {
                 lpLocalArgs[i] = v8::Local<v8::Value>::New(m_pIsolate, lpArg->DirectGetValue());
             }
             if (lpLocalArgs[i].IsEmpty()) {
                 lpLocalArgs[i] = v8::Undefined(m_pIsolate);
             }
         }
     }
@@ skipping 11 matching lines @@
         hReturnValue = hFunctionObject->CallAsFunction(hReceiver, nArgCount, lpLocalArgs);
     }
     if(trycatch.HasCaught()) {
         hReturnValue =  FXJSE_CreateReturnValue(m_pIsolate, trycatch);
         bRetValue = FALSE;
     }
     if(lpRetValue) {
         lpRetValue->ForceSetValue(hReturnValue);
     }
     if(lpLocalArgs) {
-        for (FX_UINT32 i = 0; i < nArgCount; i++) {
+        for (uint32_t i = 0; i < nArgCount; i++) {
             lpLocalArgs[i].~Local();
         }
         FX_Free(lpLocalArgs);
     }
     return bRetValue;
 }