//-------------------------------------------------------------------------------------------------------

// Copyright (C) Microsoft. All rights reserved.

// Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.

//-------------------------------------------------------------------------------------------------------

#include "JsrtPch.h"

#include "jsrtInternal.h"

#include "JsrtExternalObject.h"

#include "JsrtExternalArrayBuffer.h"

#include "JsrtSourceHolder.h"

#include "ByteCode\ByteCodeSerializer.h"

#include "common\ByteSwap.h"

#include "Library\dataview.h"

#include "Library\JavascriptSymbol.h"

#include "Base\ThreadContextTLSEntry.h"

// Parser Includes

#include "cmperr.h" // For ERRnoMemory

#include "screrror.h" // For CompileScriptException

#ifdef ENABLE_DEBUG_CONFIG_OPTIONS

#include "TestHooksRt.h"

#endif

JsErrorCode CheckContext(JsrtContext *currentContext, bool verifyRuntimeState, bool allowInObjectBeforeCollectCallback)

{

if (currentContext == nullptr)

{

return JsErrorNoCurrentContext;

}

Js::ScriptContext *scriptContext = currentContext->GetScriptContext();

Assert(scriptContext != nullptr);

Recycler *recycler = scriptContext->GetRecycler();

ThreadContext *threadContext = scriptContext->GetThreadContext();

// We don't need parameter check if it's checked in previous wrapper.

if (verifyRuntimeState)

{

if (recycler && recycler->IsHeapEnumInProgress())

{

return JsErrorHeapEnumInProgress;

}

else if (!allowInObjectBeforeCollectCallback && recycler && recycler->IsInObjectBeforeCollectCallback())

{

return JsErrorInObjectBeforeCollectCallback;

}

else if (threadContext->IsExecutionDisabled())

{

return JsErrorInDisabledState;

}

else if (scriptContext->IsInProfileCallback())

{

return JsErrorInProfileCallback;

}

else if (threadContext->IsInThreadServiceCallback())

{

return JsErrorInThreadServiceCallback;

}

// Make sure we don't have an outstanding exception.

if (scriptContext->GetThreadContext()->GetRecordedException() != nullptr)

{

return JsErrorInExceptionState;

}

}

return JsNoError;

}

template <class Fn, class T>

T CallbackWrapper(Fn fn, T default)

{

T result = default;

try

{

AUTO_NESTED_HANDLED_EXCEPTION_TYPE((ExceptionType)(ExceptionType_OutOfMemory | ExceptionType_StackOverflow));

result = fn();

}

catch (Js::OutOfMemoryException)

{

}

catch (Js::StackOverflowException)

{

}

catch (Js::ExceptionBase)

{

AssertMsg(false, "Unexpected engine exception.");

}

catch (...)

{

AssertMsg(false, "Unexpected non-engine exception.");

}

return result;

}

template <class Fn>

bool CallbackWrapper(Fn fn)

{

return CallbackWrapper(fn, false);

}

STDAPI_(JsErrorCode) JsCreateRuntime(_In_ JsRuntimeAttributes attributes, _In_opt_ JsThreadServiceCallback threadService, _Out_ JsRuntimeHandle *runtimeHandle)

{

return GlobalAPIWrapper([&] () -> JsErrorCode {

PARAM_NOT_NULL(runtimeHandle);

*runtimeHandle = nullptr;

const JsRuntimeAttributes JsRuntimeAttributesAll =

(JsRuntimeAttributes)(

JsRuntimeAttributeDisableBackgroundWork |

JsRuntimeAttributeAllowScriptInterrupt |

JsRuntimeAttributeEnableIdleProcessing |

JsRuntimeAttributeDisableEval |

JsRuntimeAttributeDisableNativeCodeGeneration |

JsRuntimeAttributeEnableExperimentalFeatures |

JsRuntimeAttributeDispatchSetExceptionsToDebugger

#ifdef ENABLE_DEBUG_CONFIG_OPTIONS

| JsRuntimeAttributeSerializeLibraryByteCode

#endif

);

Assert((attributes & ~JsRuntimeAttributesAll) == 0);

if ((attributes & ~JsRuntimeAttributesAll) != 0)

{

return JsErrorInvalidArgument;

}

AllocationPolicyManager * policyManager = HeapNew(AllocationPolicyManager, (attributes & JsRuntimeAttributeDisableBackgroundWork) == 0);

bool enableExperimentalFeatures = (attributes & JsRuntimeAttributeEnableExperimentalFeatures) != 0;

ThreadContext * threadContext = HeapNew(ThreadContext, policyManager, threadService, enableExperimentalFeatures);

if (((attributes & JsRuntimeAttributeDisableBackgroundWork) != 0)

#ifdef ENABLE_DEBUG_CONFIG_OPTIONS

&& !Js::Configuration::Global.flags.ConcurrentRuntime

#endif

)

{

threadContext->OptimizeForManyInstances(true);

#if ENABLE_NATIVE_CODEGEN

threadContext->EnableBgJit(false);

#endif

}

if (!threadContext->IsRentalThreadingEnabledInJSRT()

#ifdef ENABLE_DEBUG_CONFIG_OPTIONS

|| Js::Configuration::Global.flags.DisableRentalThreading

#endif

)

{

threadContext->SetIsThreadBound();

}

if (attributes & JsRuntimeAttributeAllowScriptInterrupt)

{

threadContext->SetThreadContextFlag(ThreadContextFlagCanDisableExecution);

}

if (attributes & JsRuntimeAttributeDisableEval)

{

threadContext->SetThreadContextFlag(ThreadContextFlagEvalDisabled);

}

if (attributes & JsRuntimeAttributeDisableNativeCodeGeneration)

{

threadContext->SetThreadContextFlag(ThreadContextFlagNoJIT);

}

#ifdef ENABLE_DEBUG_CONFIG_OPTIONS

if (Js::Configuration::Global.flags.PrimeRecycler)

{

threadContext->EnsureRecycler()->Prime();

}

#endif

bool enableIdle = (attributes & JsRuntimeAttributeEnableIdleProcessing) == JsRuntimeAttributeEnableIdleProcessing;

bool dispatchExceptions = (attributes & JsRuntimeAttributeDispatchSetExceptionsToDebugger) == JsRuntimeAttributeDispatchSetExceptionsToDebugger;

JsrtRuntime * runtime = HeapNew(JsrtRuntime, threadContext, enableIdle, dispatchExceptions);

threadContext->SetCurrentThreadId(ThreadContext::NoThread);

*runtimeHandle = runtime->ToHandle();

#ifdef ENABLE_DEBUG_CONFIG_OPTIONS

runtime->SetSerializeByteCodeForLibrary((attributes & JsRuntimeAttributeSerializeLibraryByteCode) != 0);

#endif

return JsNoError;

});

}

template <CollectionFlags flags>

JsErrorCode JsCollectGarbageCommon(JsRuntimeHandle runtimeHandle)

{

return GlobalAPIWrapper([&]() -> JsErrorCode {

VALIDATE_INCOMING_RUNTIME_HANDLE(runtimeHandle);

ThreadContext * threadContext = JsrtRuntime::FromHandle(runtimeHandle)->GetThreadContext();

if (threadContext->GetRecycler() && threadContext->GetRecycler()->IsHeapEnumInProgress())

{

return JsErrorHeapEnumInProgress;

}

else if (threadContext->IsInThreadServiceCallback())

{

return JsErrorInThreadServiceCallback;

}

ThreadContextScope scope(threadContext);

if (!scope.IsValid())

{

return JsErrorWrongThread;

}

Recycler* recycler = threadContext->EnsureRecycler();

#ifdef ENABLE_DEBUG_CONFIG_OPTIONS

if (flags & CollectOverride_SkipStack)

{

Recycler::AutoEnterExternalStackSkippingGCMode autoGC(recycler);

recycler->CollectNow<flags>();

}

else

#endif

{

recycler->CollectNow<flags>();

}

return JsNoError;

});

}

STDAPI_(JsErrorCode) JsCollectGarbage(_In_ JsRuntimeHandle runtimeHandle)

{

return JsCollectGarbageCommon<CollectNowExhaustive>(runtimeHandle);

}

#ifdef ENABLE_DEBUG_CONFIG_OPTIONS

STDAPI_(JsErrorCode) JsPrivateCollectGarbageSkipStack(_In_ JsRuntimeHandle runtimeHandle)

{

return JsCollectGarbageCommon<CollectNowExhaustiveSkipStack>(runtimeHandle);

}

#endif

STDAPI_(JsErrorCode) JsDisposeRuntime(_In_ JsRuntimeHandle runtimeHandle)

{

return GlobalAPIWrapper([&] () -> JsErrorCode {

VALIDATE_INCOMING_RUNTIME_HANDLE(runtimeHandle);

JsrtRuntime * runtime = JsrtRuntime::FromHandle(runtimeHandle);

ThreadContext * threadContext = runtime->GetThreadContext();

ThreadContextScope scope(threadContext);

// We should not dispose if the runtime is being used.

if (!scope.IsValid() ||

scope.WasInUse() ||

(threadContext->GetRecycler() && threadContext->GetRecycler()->IsHeapEnumInProgress()))

{

return JsErrorRuntimeInUse;

}

else if (threadContext->IsInThreadServiceCallback())

{

return JsErrorInThreadServiceCallback;

}

// Invoke and clear the callbacks while the contexts and runtime are still available

{

Recycler* recycler = threadContext->GetRecycler();

if (recycler != nullptr)

{

recycler->ClearObjectBeforeCollectCallbacks();

}

}

// Close any open Contexts.

// We need to do this before recycler shutdown, because ScriptEngine->Close won't work then.

runtime->CloseContexts();

#if defined(CHECK_MEMORY_LEAK) || defined(LEAK_REPORT)

bool doFinalGC = false;

#if defined(LEAK_REPORT)

if (Js::Configuration::Global.flags.IsEnabled(Js::LeakReportFlag))

{

doFinalGC = true;

}

#endif

#if defined(CHECK_MEMORY_LEAK)

if (Js::Configuration::Global.flags.CheckMemoryLeak)

{

doFinalGC = true;

}

#endif

if (doFinalGC)

{

Recycler *recycler = threadContext->GetRecycler();

if (recycler)

{

recycler->EnsureNotCollecting();

recycler->CollectNow<CollectNowFinalGC>();

Assert(!recycler->CollectionInProgress());

}

}

#endif

runtime->SetBeforeCollectCallback(nullptr, nullptr);

threadContext->CloseForJSRT();

HeapDelete(threadContext);

HeapDelete(runtime);

scope.Invalidate();

return JsNoError;

});

}

STDAPI_(JsErrorCode) JsAddRef(_In_ JsRef ref, _Out_opt_ unsigned int *count)

{

VALIDATE_JSREF(ref);

if (count != nullptr)

{

*count = 0;

}

if (Js::TaggedNumber::Is(ref))

{

// The count is always one because these are never collected

if (count)

{

*count = 1;

}

return JsNoError;

}

if (JsrtContext::Is(ref))

{

return GlobalAPIWrapper([&] () -> JsErrorCode

{

Recycler * recycler = static_cast<JsrtContext *>(ref)->GetRuntime()->GetThreadContext()->GetRecycler();

recycler->RootAddRef(ref, count);

return JsNoError;

});

}

else

{

return ContextAPINoScriptWrapper([&] (Js::ScriptContext *scriptContext) -> JsErrorCode

{

Recycler * recycler = scriptContext->GetRecycler();

// Note, some references may live in arena-allocated memory, so we need to do this check

if (!recycler->IsValidObject(ref))

{

return JsNoError;

}

recycler->RootAddRef(ref, count);

return JsNoError;

},

/*allowInObjectBeforeCollectCallback*/true);

}

}

STDAPI_(JsErrorCode) JsRelease(_In_ JsRef ref, _Out_opt_ unsigned int *count)

{

VALIDATE_JSREF(ref);

if (count != nullptr)

{

*count = 0;

}

if (Js::TaggedNumber::Is(ref))

{

// The count is always one because these are never collected

if (count)

{

*count = 1;

}

return JsNoError;

}

if (JsrtContext::Is(ref))

{

return GlobalAPIWrapper([&] () -> JsErrorCode

{

Recycler * recycler = static_cast<JsrtContext *>(ref)->GetRuntime()->GetThreadContext()->GetRecycler();

recycler->RootRelease(ref, count);

return JsNoError;

});

}

else

{

return ContextAPINoScriptWrapper([&] (Js::ScriptContext *scriptContext) -> JsErrorCode

{

Recycler * recycler = scriptContext->GetRecycler();

// Note, some references may live in arena-allocated memory, so we need to do this check

if (!recycler->IsValidObject(ref))

{

return JsNoError;

}

recycler->RootRelease(ref, count);

return JsNoError;

},

/*allowInObjectBeforeCollectCallback*/true);

}

}

STDAPI_(JsErrorCode) JsSetObjectBeforeCollectCallback(_In_ JsRef ref, _In_opt_ void *callbackState, _In_ JsObjectBeforeCollectCallback objectBeforeCollectCallback)

{

VALIDATE_JSREF(ref);

if (Js::TaggedNumber::Is(ref))

{

return JsErrorInvalidArgument;

}

if (JsrtContext::Is(ref))

{

return GlobalAPIWrapper([&]() -> JsErrorCode

{

Recycler * recycler = static_cast<JsrtContext *>(ref)->GetRuntime()->GetThreadContext()->GetRecycler();

recycler->SetObjectBeforeCollectCallback(ref, reinterpret_cast<Recycler::ObjectBeforeCollectCallback>(objectBeforeCollectCallback), callbackState);

return JsNoError;

});

}

else

{

return ContextAPINoScriptWrapper([&](Js::ScriptContext *scriptContext) -> JsErrorCode

{

Recycler * recycler = scriptContext->GetRecycler();

if (!recycler->IsValidObject(ref))

{

return JsErrorInvalidArgument;

}

recycler->SetObjectBeforeCollectCallback(ref, reinterpret_cast<Recycler::ObjectBeforeCollectCallback>(objectBeforeCollectCallback), callbackState);

return JsNoError;

},

/*allowInObjectBeforeCollectCallback*/true);

}

}

STDAPI_(JsErrorCode) JsCreateContext(_In_ JsRuntimeHandle runtimeHandle, _Out_ JsContextRef *newContext)

{

return GlobalAPIWrapper([&]() -> JsErrorCode {

PARAM_NOT_NULL(newContext);

VALIDATE_INCOMING_RUNTIME_HANDLE(runtimeHandle);

JsrtRuntime * runtime = JsrtRuntime::FromHandle(runtimeHandle);

ThreadContext * threadContext = runtime->GetThreadContext();

if (threadContext->GetRecycler() && threadContext->GetRecycler()->IsHeapEnumInProgress())

{

return JsErrorHeapEnumInProgress;

}

else if (threadContext->IsInThreadServiceCallback())

{

return JsErrorInThreadServiceCallback;

}

ThreadContextScope scope(threadContext);

if (!scope.IsValid())

{

return JsErrorWrongThread;

}

JsrtContext * context = JsrtContext::New(runtime);

if (runtime->GetDebugObject() != nullptr)

{

context->GetScriptContext()->InitializeDebugging();

context->GetScriptContext()->GetDebugContext()->GetProbeContainer()->InitializeInlineBreakEngine(runtime->GetDebugObject());

context->GetScriptContext()->GetDebugContext()->GetProbeContainer()->InitializeDebuggerScriptOptionCallback(runtime->GetDebugObject());

}

*newContext = (JsContextRef)context;

return JsNoError;

});

}

STDAPI_(JsErrorCode) JsGetCurrentContext(_Out_ JsContextRef *currentContext)

{

PARAM_NOT_NULL(currentContext);

BEGIN_JSRT_NO_EXCEPTION

{

*currentContext = (JsContextRef)JsrtContext::GetCurrent();

}

END_JSRT_NO_EXCEPTION

}

STDAPI_(JsErrorCode) JsSetCurrentContext(_In_ JsContextRef newContext)

{

return GlobalAPIWrapper([&] () -> JsErrorCode {

JsrtContext *currentContext = JsrtContext::GetCurrent();

if (currentContext && currentContext->GetScriptContext()->GetRecycler()->IsHeapEnumInProgress())

{

return JsErrorHeapEnumInProgress;

}

else if (currentContext && currentContext->GetRuntime()->GetThreadContext()->IsInThreadServiceCallback())

{

return JsErrorInThreadServiceCallback;

}

if (!JsrtContext::TrySetCurrent((JsrtContext *)newContext))

{

return JsErrorWrongThread;

}

return JsNoError;

});

}

STDAPI_(JsErrorCode) JsGetContextOfObject(_In_ JsValueRef object, _Out_ JsContextRef *context)

{

VALIDATE_JSREF(object);

PARAM_NOT_NULL(context);

BEGIN_JSRT_NO_EXCEPTION

{

if(!Js::RecyclableObject::Is(object))

{

RETURN_NO_EXCEPTION(JsErrorArgumentNotObject);

}

Js::RecyclableObject* obj = Js::RecyclableObject::FromVar(object);

*context = (JsContextRef)obj->GetScriptContext()->GetLibrary()->GetPinnedJsrtContextObject();

}

END_JSRT_NO_EXCEPTION

}

STDAPI_(JsErrorCode) JsGetContextData(_In_ JsContextRef context, _Out_ void **data)

{

VALIDATE_JSREF(context);

PARAM_NOT_NULL(data);

BEGIN_JSRT_NO_EXCEPTION

{

if (!JsrtContext::Is(context))

{

RETURN_NO_EXCEPTION(JsErrorInvalidArgument);

}

*data = static_cast<JsrtContext *>(context)->GetExternalData();

}

END_JSRT_NO_EXCEPTION

}

STDAPI_(JsErrorCode) JsSetContextData(_In_ JsContextRef context, _In_ void *data)

{

VALIDATE_JSREF(context);

BEGIN_JSRT_NO_EXCEPTION

{

if (!JsrtContext::Is(context))

{

RETURN_NO_EXCEPTION(JsErrorInvalidArgument);

}

static_cast<JsrtContext *>(context)->SetExternalData(data);

}

END_JSRT_NO_EXCEPTION

}

void HandleScriptCompileError(Js::ScriptContext * scriptContext, CompileScriptException * se)

{

HRESULT hr = se->ei.scode;

if (hr == E_OUTOFMEMORY || hr == VBSERR_OutOfMemory || hr == VBSERR_OutOfStack || hr == ERRnoMemory)

{

Js::Throw::OutOfMemory();

}

Js::JavascriptError * error = Js::JavascriptError::MapParseError(scriptContext, hr);

const Js::PropertyRecord *record;

Js::Var value = Js::JavascriptString::NewCopySz(se->ei.bstrDescription, scriptContext);

Js::JavascriptOperators::OP_SetProperty(error, Js::PropertyIds::message, value, scriptContext);

if (se->hasLineNumberInfo)

{

value = Js::JavascriptNumber::New(se->line, scriptContext);

scriptContext->GetOrAddPropertyRecord(L"line", &record);

Js::JavascriptOperators::OP_SetProperty(error, record->GetPropertyId(), value, scriptContext);

}

if (se->hasLineNumberInfo)

{

value = Js::JavascriptNumber::New(se->ichMin - se->ichMinLine, scriptContext);

scriptContext->GetOrAddPropertyRecord(L"column", &record);

Js::JavascriptOperators::OP_SetProperty(error, record->GetPropertyId(), value, scriptContext);

}

if (se->hasLineNumberInfo)

{

value = Js::JavascriptNumber::New(se->ichLim - se->ichMin, scriptContext);

Js::JavascriptOperators::OP_SetProperty(error, Js::PropertyIds::length, value, scriptContext);

}

if (se->bstrLine != nullptr)

{

value = Js::JavascriptString::NewCopySz(se->bstrLine, scriptContext);

Js::JavascriptOperators::OP_SetProperty(error, Js::PropertyIds::source, value, scriptContext);

}

Js::JavascriptExceptionObject * exceptionObject = RecyclerNew(scriptContext->GetRecycler(),

Js::JavascriptExceptionObject, error, scriptContext, nullptr);

scriptContext->GetThreadContext()->SetRecordedException(exceptionObject);

}

STDAPI_(JsErrorCode) JsGetUndefinedValue(_Out_ JsValueRef *undefinedValue)

{

return ContextAPINoScriptWrapper([&] (Js::ScriptContext *scriptContext) -> JsErrorCode {

PARAM_NOT_NULL(undefinedValue);

*undefinedValue = scriptContext->GetLibrary()->GetUndefined();

return JsNoError;

},

/*allowInObjectBeforeCollectCallback*/true);

}

STDAPI_(JsErrorCode) JsGetNullValue(_Out_ JsValueRef *nullValue)

{

return ContextAPINoScriptWrapper([&] (Js::ScriptContext *scriptContext) -> JsErrorCode {

PARAM_NOT_NULL(nullValue);

*nullValue = scriptContext->GetLibrary()->GetNull();

return JsNoError;

},

/*allowInObjectBeforeCollectCallback*/true);

}

STDAPI_(JsErrorCode) JsGetTrueValue(_Out_ JsValueRef *trueValue)

{

return ContextAPINoScriptWrapper([&] (Js::ScriptContext *scriptContext) -> JsErrorCode {

PARAM_NOT_NULL(trueValue);

*trueValue = scriptContext->GetLibrary()->GetTrue();

return JsNoError;

},

/*allowInObjectBeforeCollectCallback*/true);

}

STDAPI_(JsErrorCode) JsGetFalseValue(_Out_ JsValueRef *falseValue)

{

return ContextAPINoScriptWrapper([&] (Js::ScriptContext *scriptContext) -> JsErrorCode {

PARAM_NOT_NULL(falseValue);

*falseValue = scriptContext->GetLibrary()->GetFalse();

return JsNoError;

},

/*allowInObjectBeforeCollectCallback*/true);

}

STDAPI_(JsErrorCode) JsBoolToBoolean(_In_ bool value, _Out_ JsValueRef *booleanValue)

{

return ContextAPINoScriptWrapper([&] (Js::ScriptContext *scriptContext) -> JsErrorCode {

PARAM_NOT_NULL(booleanValue);

*booleanValue = value ? scriptContext->GetLibrary()->GetTrue() :

scriptContext->GetLibrary()->GetFalse();

return JsNoError;

},

/*allowInObjectBeforeCollectCallback*/true);

}

STDAPI_(JsErrorCode) JsBooleanToBool(_In_ JsValueRef value, _Out_ bool *boolValue)

{

VALIDATE_JSREF(value);

PARAM_NOT_NULL(boolValue);

BEGIN_JSRT_NO_EXCEPTION

{

if (!Js::JavascriptBoolean::Is(value))

{

RETURN_NO_EXCEPTION(JsErrorInvalidArgument);

}

*boolValue = Js::JavascriptBoolean::FromVar(value)->GetValue() ? true : false;

}

END_JSRT_NO_EXCEPTION

}

STDAPI_(JsErrorCode) JsConvertValueToBoolean(_In_ JsValueRef value, _Out_ JsValueRef *result)

{

return ContextAPIWrapper<true>([&] (Js::ScriptContext *scriptContext) -> JsErrorCode {

VALIDATE_INCOMING_REFERENCE(value, scriptContext);

PARAM_NOT_NULL(result);

if (Js::JavascriptConversion::ToBool((Js::Var)value, scriptContext))

{

*result = scriptContext->GetLibrary()->GetTrue();

return JsNoError;

}

else

{

*result = scriptContext->GetLibrary()->GetFalse();

return JsNoError;

}

});

}

STDAPI_(JsErrorCode) JsGetValueType(_In_ JsValueRef value, _Out_ JsValueType *type)

{

VALIDATE_JSREF(value);

PARAM_NOT_NULL(type);

BEGIN_JSRT_NO_EXCEPTION

{

Js::TypeId typeId = Js::JavascriptOperators::GetTypeId(value);

switch (typeId)

{

case Js::TypeIds_Undefined:

*type = JsUndefined;

break;

case Js::TypeIds_Null:

*type = JsNull;

break;

case Js::TypeIds_Boolean:

*type = JsBoolean;

break;

case Js::TypeIds_Integer:

case Js::TypeIds_Number:

case Js::TypeIds_Int64Number:

case Js::TypeIds_UInt64Number:

*type = JsNumber;

break;

case Js::TypeIds_String:

*type = JsString;

break;

case Js::TypeIds_Function:

*type = JsFunction;

break;

case Js::TypeIds_Error:

*type = JsError;

break;

case Js::TypeIds_Array:

case Js::TypeIds_NativeIntArray:

#if ENABLE_COPYONACCESS_ARRAY

case Js::TypeIds_CopyOnAccessNativeIntArray:

#endif

case Js::TypeIds_NativeFloatArray:

case Js::TypeIds_ES5Array:

*type = JsArray;

break;

case Js::TypeIds_Symbol:

*type = JsSymbol;

break;

case Js::TypeIds_ArrayBuffer:

*type = JsArrayBuffer;

break;

case Js::TypeIds_DataView:

*type = JsDataView;

break;

default:

if (Js::TypedArrayBase::Is(typeId))

{

*type = JsTypedArray;

}

else

{

*type = JsObject;

}

break;

}

}

END_JSRT_NO_EXCEPTION

}

STDAPI_(JsErrorCode) JsDoubleToNumber(_In_ double dbl, _Out_ JsValueRef *asValue)

{

PARAM_NOT_NULL(asValue);

if (Js::JavascriptNumber::TryToVarFastWithCheck(dbl, asValue)) {

return JsNoError;

}

return ContextAPINoScriptWrapper([&](Js::ScriptContext *scriptContext) -> JsErrorCode {

*asValue = Js::JavascriptNumber::ToVarNoCheck(dbl, scriptContext);

return JsNoError;

});

}

STDAPI_(JsErrorCode) JsIntToNumber(_In_ int intValue, _Out_ JsValueRef *asValue)

{

PARAM_NOT_NULL(asValue);

if (Js::JavascriptNumber::TryToVarFast(intValue, asValue))

{

return JsNoError;

}

return ContextAPINoScriptWrapper([&](Js::ScriptContext *scriptContext) -> JsErrorCode {

*asValue = Js::JavascriptNumber::ToVar(intValue, scriptContext);

return JsNoError;

});

}

STDAPI_(JsErrorCode) JsNumberToDouble(_In_ JsValueRef value, _Out_ double *asDouble)

{

VALIDATE_JSREF(value);

PARAM_NOT_NULL(asDouble);

BEGIN_JSRT_NO_EXCEPTION

{

if (Js::TaggedInt::Is(value))

{

*asDouble = Js::TaggedInt::ToDouble(value);

}

else if (Js::JavascriptNumber::Is_NoTaggedIntCheck(value))

{

*asDouble = Js::JavascriptNumber::GetValue(value);

}

else

{

*asDouble = 0;

RETURN_NO_EXCEPTION(JsErrorInvalidArgument);

}

}

END_JSRT_NO_EXCEPTION

}

STDAPI_(JsErrorCode) JsNumberToInt(_In_ JsValueRef value, _Out_ int *asInt)

{

VALIDATE_JSREF(value);

PARAM_NOT_NULL(asInt);

BEGIN_JSRT_NO_EXCEPTION

{

if (Js::TaggedInt::Is(value))

{

*asInt = Js::TaggedInt::ToInt32(value);

}

else if (Js::JavascriptNumber::Is_NoTaggedIntCheck(value))

{

*asInt = Js::JavascriptConversion::ToInt32(Js::JavascriptNumber::GetValue(value));

}

else

{

*asInt = 0;

RETURN_NO_EXCEPTION(JsErrorInvalidArgument);

}

}

END_JSRT_NO_EXCEPTION

}

STDAPI_(JsErrorCode) JsConvertValueToNumber(_In_ JsValueRef value, _Out_ JsValueRef *result)

{

return ContextAPIWrapper<true>([&] (Js::ScriptContext *scriptContext) -> JsErrorCode {

VALIDATE_INCOMING_REFERENCE(value, scriptContext);

PARAM_NOT_NULL(result);

*result = (JsValueRef)Js::JavascriptOperators::ToNumber((Js::Var)value, scriptContext);

return JsNoError;

});

}

STDAPI_(JsErrorCode) JsGetStringLength(_In_ JsValueRef value, _Out_ int *length)

{

VALIDATE_JSREF(value);

PARAM_NOT_NULL(length);

BEGIN_JSRT_NO_EXCEPTION

{

if (!Js::JavascriptString::Is(value))

{

RETURN_NO_EXCEPTION(JsErrorInvalidArgument);

}

*length = Js::JavascriptString::FromVar(value)->GetLengthAsSignedInt();

}

END_JSRT_NO_EXCEPTION

}

STDAPI_(JsErrorCode) JsPointerToString(_In_reads_(stringLength) const wchar_t *stringValue, _In_ size_t stringLength, _Out_ JsValueRef *string)

{

return ContextAPINoScriptWrapper([&](Js::ScriptContext *scriptContext) -> JsErrorCode {

PARAM_NOT_NULL(stringValue);

PARAM_NOT_NULL(string);

if (!Js::IsValidCharCount(stringLength))

{

Js::JavascriptError::ThrowOutOfMemoryError(scriptContext);

}

*string = Js::JavascriptString::NewCopyBuffer(stringValue, static_cast<charcount_t>(stringLength), scriptContext);

return JsNoError;

});

}

// TODO: The annotation of stringPtr is wrong. Need to fix definition in chakrart.h

// The warning is '*stringPtr' could be '0' : this does not adhere to the specification for the function 'JsStringToPointer'.

#pragma warning(suppress:6387)

STDAPI_(JsErrorCode) JsStringToPointer(_In_ JsValueRef stringValue, _Outptr_result_buffer_(*stringLength) const wchar_t **stringPtr, _Out_ size_t *stringLength)

{

VALIDATE_JSREF(stringValue);

PARAM_NOT_NULL(stringPtr);

*stringPtr = nullptr;

PARAM_NOT_NULL(stringLength);

*stringLength = 0;

if (!Js::JavascriptString::Is(stringValue))

{

return JsErrorInvalidArgument;

}

return GlobalAPIWrapper([&]() -> JsErrorCode {

Js::JavascriptString *jsString = Js::JavascriptString::FromVar(stringValue);

*stringPtr = jsString->GetSz();

*stringLength = jsString->GetLength();

return JsNoError;

});

}

STDAPI_(JsErrorCode) JsConvertValueToString(_In_ JsValueRef value, _Out_ JsValueRef *result)

{

return ContextAPIWrapper<true>([&] (Js::ScriptContext *scriptContext) -> JsErrorCode {

VALIDATE_INCOMING_REFERENCE(value, scriptContext);

PARAM_NOT_NULL(result);

*result = nullptr;

*result = (JsValueRef) Js::JavascriptConversion::ToString((Js::Var)value, scriptContext);

return JsNoError;

});

}

STDAPI_(JsErrorCode) JsGetGlobalObject(_Out_ JsValueRef *globalObject)

{

return ContextAPINoScriptWrapper([&](Js::ScriptContext *scriptContext) -> JsErrorCode {

PARAM_NOT_NULL(globalObject);

*globalObject = (JsValueRef)scriptContext->GetGlobalObject();

return JsNoError;

},

/*allowInObjectBeforeCollectCallback*/true);

}

STDAPI_(JsErrorCode) JsCreateObject(_Out_ JsValueRef *object)

{

return ContextAPINoScriptWrapper([&](Js::ScriptContext *scriptContext) -> JsErrorCode {

PARAM_NOT_NULL(object);

*object = scriptContext->GetLibrary()->CreateObject();

return JsNoError;

});

}

STDAPI_(JsErrorCode) JsCreateExternalObject(_In_opt_ void *data, _In_opt_ JsFinalizeCallback finalizeCallback, _Out_ JsValueRef *object)

{

return ContextAPINoScriptWrapper([&](Js::ScriptContext *scriptContext) -> JsErrorCode {

PARAM_NOT_NULL(object);

*object = RecyclerNewFinalized(scriptContext->GetRecycler(), JsrtExternalObject, RecyclerNew(scriptContext->GetRecycler(), JsrtExternalType, scriptContext, finalizeCallback), data);

return JsNoError;

});

}

STDAPI_(JsErrorCode) JsConvertValueToObject(_In_ JsValueRef value, _Out_ JsValueRef *result)

{

return ContextAPIWrapper<true>([&] (Js::ScriptContext *scriptContext) -> JsErrorCode {

VALIDATE_INCOMING_REFERENCE(value, scriptContext);

PARAM_NOT_NULL(result);

*result = (JsValueRef)Js::JavascriptOperators::ToObject((Js::Var)value, scriptContext);

Assert(*result == nullptr || !Js::CrossSite::NeedMarshalVar(*result, scriptContext));

return JsNoError;

});

}

STDAPI_(JsErrorCode) JsGetPrototype(_In_ JsValueRef object, _Out_ JsValueRef *prototypeObject)

{

return ContextAPIWrapper<true>([&] (Js::ScriptContext *scriptContext) -> JsErrorCode {

VALIDATE_INCOMING_OBJECT(object, scriptContext);

PARAM_NOT_NULL(prototypeObject);

*prototypeObject = (JsValueRef)Js::JavascriptOperators::OP_GetPrototype(object, scriptContext);

Assert(*prototypeObject == nullptr || !Js::CrossSite::NeedMarshalVar(*prototypeObject, scriptContext));

return JsNoError;

});

}

STDAPI_(JsErrorCode) JsSetPrototype(_In_ JsValueRef object, _In_ JsValueRef prototypeObject)

{

return ContextAPIWrapper<true>([&] (Js::ScriptContext *scriptContext) -> JsErrorCode {

VALIDATE_INCOMING_OBJECT(object, scriptContext);

VALIDATE_INCOMING_OBJECT_OR_NULL(prototypeObject, scriptContext);

// We're not allowed to set this.

if (object == scriptContext->GetLibrary()->GetObjectPrototype())

{