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

// Copyright (C) Microsoft Corporation and contributors. All rights reserved.

// Copyright (c) 2021 ChakraCore Project Contributors. All rights reserved.

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

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

#include "stdafx.h"

#include "PlatformAgnostic/ChakraICU.h"

#if defined(__APPLE__)

#ifdef ctime

#undef ctime

#define CTIME_UNDEFED

#endif

#endif

#include <vector>

#include <ctime>

#include <ratio>

#include <chrono>

#if defined(_X86_) || defined(_M_IX86)

#define CPU_ARCH_TEXT "x86"

#elif defined(_AMD64_) || defined(_IA64_) || defined(_M_AMD64) || defined(_M_IA64)

#define CPU_ARCH_TEXT "x86_64"

#elif defined(_ARM_) || defined(_M_ARM)

#define CPU_ARCH_TEXT "ARM"

#elif defined(_ARM64_) || defined(_M_ARM64)

#define CPU_ARCH_TEXT "ARM64"

#endif

// do not change the order below

// otherwise, i.e. android system can be marked as posix? etc..

#ifdef _WIN32

#define DEST_PLATFORM_TEXT "win32"

#else // ! _WIN32

#if defined(__APPLE__)

#ifdef __IOS__

#define DEST_PLATFORM_TEXT "ios"

#else // ! iOS

#define DEST_PLATFORM_TEXT "darwin"

#endif // iOS ?

#elif defined(__ANDROID__)

#define DEST_PLATFORM_TEXT "android"

#elif defined(__linux__)

#define DEST_PLATFORM_TEXT "posix"

#elif defined(__FreeBSD__) || defined(__unix__)

#define DEST_PLATFORM_TEXT "bsd"

#endif // FreeBSD or unix ?

#endif // _WIN32 ?

#pragma prefast(disable:26444, "This warning unfortunately raises false positives when auto is used for declaring the type of an iterator in a loop.")

#ifdef HAS_ICU

#define INTL_LIBRARY_TEXT "icu"

#elif defined(_WIN32)

#define INTL_LIBRARY_TEXT "winglob"

#else

#define INTL_LIBRARY_TEXT ""

#endif

struct ArrayBufferTransferInfo {

byte* buffer;

uint length;

ArrayBufferFreeFn freeFn;

};

struct SerializerBlob

{

void *data;

size_t dataLength;

std::vector<ArrayBufferTransferInfo> transferableArrays;

};

MessageQueue* WScriptJsrt::messageQueue = nullptr;

std::map<std::string, JsModuleRecord> WScriptJsrt::moduleRecordMap;

std::map<JsModuleRecord, std::string> WScriptJsrt::moduleDirMap;

std::map<JsModuleRecord, ModuleState> WScriptJsrt::moduleErrMap;

std::map<DWORD_PTR, std::string> WScriptJsrt::scriptDirMap;

DWORD_PTR WScriptJsrt::sourceContext = 0;

#define ERROR_MESSAGE_TO_STRING(errorCode, errorMessage, errorMessageString) \

JsErrorCode errorCode = JsNoError; \

do \

{ \

const char *outOfMemoryString = \

"Failed to convert wide string. Out of memory?";\

\

char *errorMessageNarrow; \

if (FAILED(WideStringToNarrowDynamic(errorMessage, &errorMessageNarrow))) \

{ \

errorCode = ChakraRTInterface::JsCreateString(outOfMemoryString, \

strlen(outOfMemoryString), &errorMessageString); \

} \

else \

{ \

errorCode = ChakraRTInterface::JsCreateString(errorMessageNarrow, \

strlen(errorMessageNarrow), &errorMessageString); \

free(errorMessageNarrow); \

} \

} \

while(0)

DWORD_PTR WScriptJsrt::GetNextSourceContext()

{

return sourceContext++;

}

void WScriptJsrt::RegisterScriptDir(DWORD_PTR sourceContext, LPCSTR fullDirNarrow)

{

GetDir(fullDirNarrow, &scriptDirMap[sourceContext]);

}

bool WScriptJsrt::CreateArgumentsObject(JsValueRef *argsObject)

{

LPWSTR *argv = HostConfigFlags::argsVal;

JsValueRef retArr;

Assert(argsObject);

*argsObject = nullptr;

IfJsrtErrorFail(ChakraRTInterface::JsCreateArray(HostConfigFlags::argsCount, &retArr), false);

for (int i = 0; i < HostConfigFlags::argsCount; i++)

{

JsValueRef value;

JsValueRef index;

char *argNarrow;

if (FAILED(WideStringToNarrowDynamic(argv[i], &argNarrow)))

{

return false;

}

JsErrorCode errCode = ChakraRTInterface::JsCreateString(

argNarrow,

strlen(argNarrow), &value);

free(argNarrow);

IfJsrtErrorFail(errCode, false);

IfJsrtErrorFail(ChakraRTInterface::JsDoubleToNumber(i, &index), false);

IfJsrtErrorFail(ChakraRTInterface::JsSetIndexedProperty(retArr, index, value), false);

}

*argsObject = retArr;

return true;

}

JsValueRef __stdcall WScriptJsrt::EchoCallback(JsValueRef callee, bool isConstructCall, JsValueRef *arguments, unsigned short argumentCount, void *callbackState)

{

for (unsigned int i = 1; i < argumentCount; i++)

{

JsValueRef strValue;

JsErrorCode error = ChakraRTInterface::JsConvertValueToString(arguments[i], &strValue);

if (error == JsNoError)

{

AutoString str(strValue);

if (str.GetError() == JsNoError)

{

if (i > 1)

{

wprintf(_u(" "));

}

charcount_t len;

LPWSTR ws = str.GetWideString(&len);

LPWSTR wsNoNull = new WCHAR[((size_t)len) + 1];

charcount_t newIndex = 0;

for (charcount_t j = 0; j < len; j++)

{

if (ws[j] != _u('\0'))

{

wsNoNull[newIndex++] = ws[j];

}

}

wsNoNull[newIndex] = _u('\0');

wprintf(_u("%s"), wsNoNull);

delete[] wsNoNull;

}

}

if (error == JsErrorScriptException)

{

return nullptr;

}

}

wprintf(_u("\n"));

fflush(stdout);

JsValueRef undefinedValue;

if (ChakraRTInterface::JsGetUndefinedValue(&undefinedValue) == JsNoError)

{

return undefinedValue;

}

else

{

return nullptr;

}

}

JsValueRef __stdcall WScriptJsrt::QuitCallback(JsValueRef callee, bool isConstructCall, JsValueRef *arguments, unsigned short argumentCount, void *callbackState)

{

int exitCode = 0;

if (argumentCount > 1)

{

double exitCodeDouble;

IfJsrtErrorFail(ChakraRTInterface::JsNumberToDouble(arguments[1], &exitCodeDouble), JS_INVALID_REFERENCE);

exitCode = (int)exitCodeDouble;

}

ExitProcess(exitCode);

}

JsValueRef __stdcall WScriptJsrt::LoadScriptFileCallback(JsValueRef callee, bool isConstructCall, JsValueRef *arguments, unsigned short argumentCount, void *callbackState)

{

return LoadScriptFileHelper(callee, arguments, argumentCount, false);

}

// needed because of calling convention differences between _stdcall and _cdecl

void CHAKRA_CALLBACK WScriptJsrt::FinalizeFree(void* addr)

{

free(addr);

}

JsValueRef WScriptJsrt::LoadScriptFileHelper(JsValueRef callee, JsValueRef *arguments, unsigned short argumentCount, bool isSourceModule)

{

HRESULT hr = E_FAIL;

JsValueRef returnValue = JS_INVALID_REFERENCE;

JsErrorCode errorCode = JsNoError;

LPCWSTR errorMessage = _u("");

if (argumentCount < 2 || argumentCount > 4)

{

errorCode = JsErrorInvalidArgument;

errorMessage = _u("Need more or fewer arguments for WScript.LoadScript");

}

else

{

LPCSTR fileContent;

AutoString fileName(arguments[1]);

IfJsrtErrorSetGo(fileName.GetError());

AutoString scriptInjectType;

if (argumentCount > 2)

{

IfJsrtErrorSetGo(scriptInjectType.Initialize(arguments[2]));

}

if (errorCode == JsNoError)

{

hr = Helpers::LoadScriptFromFile(*fileName, fileContent);

if (FAILED(hr))

{

fprintf(stderr, "Couldn't load file '%s'\n", fileName.GetString());

IfJsrtErrorSetGo(ChakraRTInterface::JsGetUndefinedValue(&returnValue));

return returnValue;

}

returnValue = LoadScript(callee, *fileName, fileContent, *scriptInjectType ? *scriptInjectType : "self", isSourceModule, WScriptJsrt::FinalizeFree, true);

}

}

Error:

SetExceptionIf(errorCode, errorMessage);

return returnValue;

}

void WScriptJsrt::SetExceptionIf(JsErrorCode errorCode, LPCWSTR errorMessage)

{

if (errorCode != JsNoError)

{

// If the exception is already is set - no need to create a new exception.

bool hasException = false;

if (!(ChakraRTInterface::JsHasException(&hasException) == JsNoError && hasException))

{

JsValueRef errorObject;

JsValueRef errorMessageString;

if (wcscmp(errorMessage, _u("")) == 0)

{

errorMessage = ConvertErrorCodeToMessage(errorCode);

}

ERROR_MESSAGE_TO_STRING(errCode, errorMessage, errorMessageString);

ChakraRTInterface::JsCreateError(errorMessageString, &errorObject);

ChakraRTInterface::JsSetException(errorObject);

}

}

}

byte * CHAKRA_CALLBACK ReallocateBufferMemory(void * state, byte *oldBuffer, size_t newSize, size_t *allocatedSize)

{

void* data = realloc((void*)oldBuffer, newSize);

if (allocatedSize)

{

*allocatedSize = newSize;

}

return (byte*)data;

}

bool CHAKRA_CALLBACK WriteHostObject(void * state, JsValueRef data)

{

// Not implemented

return true;

}

JsValueRef __stdcall WScriptJsrt::SerializeObject(JsValueRef callee, bool isConstructCall, JsValueRef *arguments, unsigned short argumentCount, void *callbackState)

{

JsErrorCode errorCode = JsNoError;

LPCWSTR errorMessage = _u("");

JsValueRef returnValue = JS_INVALID_REFERENCE;

HRESULT hr = S_OK;

JsValueRef *transferVarsArray = nullptr;

int transferVarsCount = 0;

if (argumentCount < 2)

{

errorCode = JsErrorInvalidArgument;

errorMessage = _u("Need an argument for WScript.Serialize");

}

else

{

JsValueRef rootObject = arguments[1];

JsValueRef transferArray = nullptr;

if (argumentCount > 2)

{

JsValueType argumentType = JsUndefined;

transferArray = arguments[2];

IfJsrtErrorSetGo(ChakraRTInterface::JsGetValueType(transferArray, &argumentType));

if (argumentType != JsUndefined)

{

if (argumentType != JsArray)

{

errorCode = JsErrorInvalidArgument;

goto Error;

}

JsPropertyIdRef lengthPropId;

JsValueRef arrayLengthObj = JS_INVALID_REFERENCE;

int arrayLength = 0;

IfJsrtErrorSetGo(CreatePropertyIdFromString("length", &lengthPropId));

IfJsrtErrorSetGo(ChakraRTInterface::JsGetProperty(transferArray, lengthPropId, &arrayLengthObj));

IfJsrtErrorSetGo(ChakraRTInterface::JsNumberToInt(arrayLengthObj, &arrayLength));

if (arrayLength > 0)

{

transferVarsArray = new JsValueRef[arrayLength];

if (transferVarsArray == nullptr)

{

errorCode = JsErrorOutOfMemory;

goto Error;

}

for (int i = 0; i < arrayLength; i++)

{

JsValueRef index;

JsValueRef value = JS_INVALID_REFERENCE;

JsValueType jsType = JsUndefined;

IfJsrtErrorSetGo(ChakraRTInterface::JsIntToNumber(i, &index));

IfJsrtErrorSetGo(ChakraRTInterface::JsGetIndexedProperty(transferArray, index, &value));

IfJsrtErrorSetGo(ChakraRTInterface::JsGetValueType(value, &jsType));

if (jsType == JsArrayBuffer)

{

*(transferVarsArray + transferVarsCount) = value;

transferVarsCount++;

}

}

}

}

}

JsVarSerializerHandle serializerHandle = nullptr;

// This memory will be claimed at WScriptJsrt::Deserialize.

SerializerBlob *blob = new SerializerBlob();

IfJsrtErrorSetGo(ChakraRTInterface::JsVarSerializer(ReallocateBufferMemory, WriteHostObject, nullptr, &serializerHandle));

IfJsrtErrorSetGo(ChakraRTInterface::JsVarSerializerSetTransferableVars(serializerHandle, transferVarsArray, transferVarsCount));

IfJsrtErrorSetGo(ChakraRTInterface::JsVarSerializerWriteValue(serializerHandle, rootObject));

IfJsrtErrorSetGo(ChakraRTInterface::JsVarSerializerReleaseData(serializerHandle, (byte**)&blob->data, &blob->dataLength));

for (int i = 0; i < transferVarsCount; i++)

{

JsValueRef arrayBuffer = transferVarsArray[i];

ArrayBufferTransferInfo bufferInfo;

IfJsrtErrorSetGo(ChakraRTInterface::JsGetArrayBufferStorage(arrayBuffer, &bufferInfo.buffer, &bufferInfo.length));

IfJsrtErrorSetGo(ChakraRTInterface::JsExternalizeArrayBuffer(arrayBuffer));

IfJsrtErrorSetGo(ChakraRTInterface::JsGetArrayBufferFreeFunction(arrayBuffer, &bufferInfo.freeFn));

blob->transferableArrays.push_back(bufferInfo);

IfJsrtErrorSetGo(ChakraRTInterface::JsDetachArrayBuffer(arrayBuffer));

}

errorCode = ChakraRTInterface::JsCreateExternalArrayBuffer((void*)blob, sizeof(SerializerBlob), nullptr, nullptr, &returnValue);

IfJsrtErrorSetGo(ChakraRTInterface::JsVarSerializerFree(serializerHandle));

}

Error:

SetExceptionIf(errorCode, errorMessage);

if (transferVarsArray)

{

delete[] transferVarsArray;

}

return returnValue;

}

JsValueRef CHAKRA_CALLBACK ReadHostObject(void * state)

{

Assert(false); // TBD

return nullptr;

}

JsValueRef CHAKRA_CALLBACK GetSharedArrayBufferFromId(void * state, uint32_t id)

{

Assert(false); // TBD

return nullptr;

}

JsValueRef CHAKRA_CALLBACK GetWasmModuleFromId(void * state, uint32_t transfer_id)

{

Assert(false); // TBD

return nullptr;

}

struct BufferFreeFunctionState {

ArrayBufferFreeFn freeFn;

void* buffer;

};

void CHAKRA_CALLBACK BufferFreeFunction(void * state)

{

BufferFreeFunctionState* bufferState = (BufferFreeFunctionState*)state;

if (!bufferState)

{

return;

}

if (bufferState->freeFn)

{

bufferState->freeFn(bufferState->buffer);

}

delete bufferState;

}

JsValueRef __stdcall WScriptJsrt::Deserialize(JsValueRef callee, bool isConstructCall, JsValueRef *arguments, unsigned short argumentCount, void *callbackState)

{

JsErrorCode errorCode = JsNoError;

LPCWSTR errorMessage = _u("");

JsValueRef returnValue = JS_INVALID_REFERENCE;

JsValueRef * transferables = nullptr;

HRESULT hr = S_OK;

if (argumentCount < 2)

{

errorCode = JsErrorInvalidArgument;

errorMessage = _u("Need an argument for WScript.Deserialize");

}

else

{

JsValueRef dataObject = arguments[1];

uint32 dataLength = 0;

BYTE *data = nullptr;

IfJsrtErrorSetGo(ChakraRTInterface::JsGetArrayBufferStorage(dataObject, &data, &dataLength));

SerializerBlob *blob = (SerializerBlob*)data;

JsVarDeserializerHandle deserializerHandle = nullptr;

IfJsrtErrorSetGo(ChakraRTInterface::JsVarDeserializer(blob->data, blob->dataLength, ReadHostObject, GetSharedArrayBufferFromId, nullptr, &deserializerHandle));

size_t arraySize = blob->transferableArrays.size();

if (arraySize > 0)

{

transferables = new JsValueRef[arraySize];

for (size_t i = 0; i < arraySize; ++i)

{

JsValueRef result = nullptr;

BufferFreeFunctionState* bufferFreeState = new BufferFreeFunctionState();

bufferFreeState->buffer = blob->transferableArrays[i].buffer;

bufferFreeState->freeFn = blob->transferableArrays[i].freeFn;

IfJsrtErrorSetGo(ChakraRTInterface::JsCreateExternalArrayBuffer(blob->transferableArrays[i].buffer, blob->transferableArrays[i].length, BufferFreeFunction, bufferFreeState, &result));

transferables[i] = result;

}

IfJsrtErrorSetGo(ChakraRTInterface::JsVarDeserializerSetTransferableVars(deserializerHandle, transferables, arraySize));

}

IfJsrtErrorSetGo(ChakraRTInterface::JsVarDeserializerReadValue(deserializerHandle, &returnValue));

IfJsrtErrorSetGo(ChakraRTInterface::JsVarDeserializerFree(deserializerHandle));

delete blob;

}

Error:

SetExceptionIf(errorCode, errorMessage);

if (transferables)

{

delete[] transferables;

}

return returnValue;

}

JsValueRef __stdcall WScriptJsrt::GetModuleNamespace(JsValueRef callee, bool isConstructCall, JsValueRef *arguments, unsigned short argumentCount, void *callbackState)

{

JsErrorCode errorCode = JsNoError;

JsValueRef returnValue = JS_INVALID_REFERENCE;

LPCWSTR errorMessage = _u("");

char fullPath[_MAX_PATH];

if (argumentCount < 2)

{

errorCode = JsErrorInvalidArgument;

errorMessage = _u("Need an argument for WScript.GetModuleNamespace");

}

else

{

AutoString specifierStr(arguments[1]);

errorCode = specifierStr.GetError();

if (errorCode == JsNoError)

{

if (_fullpath(fullPath, specifierStr.GetString(), _MAX_PATH) == nullptr)

{

errorCode = JsErrorInvalidArgument;

}

else

{

auto moduleEntry = moduleRecordMap.find(fullPath);

if (moduleEntry == moduleRecordMap.end())

{

errorCode = JsErrorInvalidArgument;

errorMessage = _u("Need to supply a path for an already loaded module for WScript.GetModuleNamespace");

}

else

{

errorCode = ChakraRTInterface::JsGetModuleNamespace(moduleEntry->second, &returnValue);

if (errorCode == JsErrorModuleNotEvaluated)

{

errorMessage = _u("GetModuleNamespace called with un-evaluated module");

}

}

}

}

}

SetExceptionIf(errorCode, errorMessage);

return returnValue;

}

JsValueRef __stdcall WScriptJsrt::LoadScriptCallback(JsValueRef callee, bool isConstructCall, JsValueRef *arguments, unsigned short argumentCount, void *callbackState)

{

return LoadScriptHelper(callee, isConstructCall, arguments, argumentCount, callbackState, false);

}

JsValueRef __stdcall WScriptJsrt::LoadModuleCallback(JsValueRef callee, bool isConstructCall, JsValueRef *arguments, unsigned short argumentCount, void *callbackState)

{

return LoadScriptHelper(callee, isConstructCall, arguments, argumentCount, callbackState, true);

}

JsValueRef WScriptJsrt::LoadScriptHelper(JsValueRef callee, bool isConstructCall, JsValueRef *arguments, unsigned short argumentCount, void *callbackState, bool isSourceModule)

{

HRESULT hr = E_FAIL;

JsErrorCode errorCode = JsNoError;

LPCWSTR errorMessage = _u("");

JsValueRef returnValue = JS_INVALID_REFERENCE;

if (argumentCount < 2 || argumentCount > 4)

{

errorCode = JsErrorInvalidArgument;

errorMessage = _u("Need more or fewer arguments for WScript.LoadScript");

}

else

{

AutoString fileContent;

char *fileNameNarrow = nullptr;

AutoString fileName;

AutoString scriptInjectType;

char fileNameBuffer[MAX_PATH];

bool isFile = true;

IfJsrtErrorSetGo(fileContent.Initialize(arguments[1]));

// ExternalArrayBuffer Finalize will clean this up

// but only if we actually register a finalizecallback for this

fileContent.MakePersistent();

if (argumentCount > 2)

{

IfJsrtErrorSetGo(scriptInjectType.Initialize(arguments[2]));

if (argumentCount > 3)

{

IfJsrtErrorSetGo(fileName.Initialize(arguments[3]));

fileNameNarrow = *fileName;

}

}

if (!fileNameNarrow)

{

isFile = false;

if (isSourceModule)

{

sprintf_s(fileNameBuffer, MAX_PATH, "moduleScript%i.js", (int)sourceContext);

fileNameNarrow = fileNameBuffer;

}

}

if (*fileContent)

{

// TODO: This is CESU-8. How to tell the engine?

// TODO: How to handle this source (script) life time?

returnValue = LoadScript(callee, fileNameNarrow, *fileContent, *scriptInjectType ? *scriptInjectType : "self", isSourceModule, WScriptJsrt::FinalizeFree, isFile);

}

}

Error:

SetExceptionIf(errorCode, errorMessage);

return returnValue;

}

void WScriptJsrt::GetDir(LPCSTR fullPathNarrow, std::string *fullDirNarrow)

{

char fileDrive[_MAX_DRIVE];

char fileDir[_MAX_DIR];

std::string result;

if (_splitpath_s(fullPathNarrow, fileDrive, _countof(fileDrive), fileDir, _countof(fileDir), nullptr, 0, nullptr, 0) == 0)

{

result += fileDrive;

result += fileDir;

}

*fullDirNarrow = result;

}

JsErrorCode WScriptJsrt::ModuleEntryPoint(LPCSTR fileName, LPCSTR fileContent, LPCSTR fullName)

{

return LoadModuleFromString(fileName, fileContent, fullName, true);

}

JsErrorCode WScriptJsrt::LoadModuleFromString(LPCSTR fileName, LPCSTR fileContent, LPCSTR fullName, bool isFile)

{

DWORD_PTR dwSourceCookie = WScriptJsrt::GetNextSourceContext();

JsModuleRecord requestModule = JS_INVALID_REFERENCE;

LPCSTR moduleRecordKey = fullName ? fullName : fileName;

auto moduleRecordEntry = moduleRecordMap.find(std::string(moduleRecordKey));

JsErrorCode errorCode = JsNoError;

// we need to create a new moduleRecord if the specifier (fileName) is not found;

// otherwise we'll use the old one.

if (moduleRecordEntry == moduleRecordMap.end())

{

JsValueRef specifier = nullptr;

if (isFile && fullName)

{

errorCode = ChakraRTInterface::JsCreateString(

fullName, strlen(fullName), &specifier);

}

if (errorCode == JsNoError)

{

errorCode = ChakraRTInterface::JsInitializeModuleRecord(

nullptr, specifier, &requestModule);

}

if (errorCode == JsNoError)

{

if (fullName)

{

GetDir(fullName, &moduleDirMap[requestModule]);

}

moduleRecordMap[std::string(moduleRecordKey)] = requestModule;

moduleErrMap[requestModule] = RootModule;

}

}

else

{

requestModule = moduleRecordEntry->second;

}

IfJsrtErrorFailLogAndRetErrorCode(errorCode);

JsValueRef errorObject = JS_INVALID_REFERENCE;

// ParseModuleSource is sync, while additional fetch & evaluation are async.

unsigned int fileContentLength = (fileContent == nullptr) ? 0 : (unsigned int)strlen(fileContent);

errorCode = ChakraRTInterface::JsParseModuleSource(requestModule, dwSourceCookie, (LPBYTE)fileContent,

fileContentLength, JsParseModuleSourceFlags_DataIsUTF8, &errorObject);

if ((errorCode != JsNoError) && errorObject != JS_INVALID_REFERENCE && fileContent != nullptr && !HostConfigFlags::flags.IgnoreScriptErrorCode && moduleErrMap[requestModule] == RootModule)

{

ChakraRTInterface::JsSetException(errorObject);

moduleErrMap[requestModule] = ErroredModule;

return errorCode;

}

return JsNoError;

}

JsValueRef WScriptJsrt::LoadScript(JsValueRef callee, LPCSTR fileName,

LPCSTR fileContent, LPCSTR scriptInjectType, bool isSourceModule, JsFinalizeCallback finalizeCallback, bool isFile)

{

HRESULT hr = E_FAIL;

JsErrorCode errorCode = JsNoError;

LPCWSTR errorMessage = _u("Internal error.");

JsValueRef returnValue = JS_INVALID_REFERENCE;

JsContextRef currentContext = JS_INVALID_REFERENCE;

JsRuntimeHandle runtime = JS_INVALID_RUNTIME_HANDLE;

void *callbackArg = (finalizeCallback != nullptr ? (void*)fileContent : nullptr);

char fullPath[_MAX_PATH];

IfJsrtErrorSetGo(ChakraRTInterface::JsGetCurrentContext(&currentContext));

IfJsrtErrorSetGo(ChakraRTInterface::JsGetRuntime(currentContext, &runtime));

if (fileName == nullptr)

{

fileName = "script.js";

}

if (_fullpath(fullPath, fileName, _MAX_PATH) == nullptr)

{

goto Error;

}

// this is called with LoadModuleCallback method as well where caller pass in a string that should be

// treated as a module source text instead of opening a new file.

if (isSourceModule || (strcmp(scriptInjectType, "module") == 0))

{

errorCode = LoadModuleFromString(fileName, fileContent, fullPath, isFile);

}

else if (strcmp(scriptInjectType, "self") == 0)

{

JsContextRef calleeContext;

IfJsrtErrorSetGo(ChakraRTInterface::JsGetContextOfObject(callee, &calleeContext));

IfJsrtErrorSetGo(ChakraRTInterface::JsSetCurrentContext(calleeContext));

JsValueRef scriptSource;

IfJsrtErrorSetGo(ChakraRTInterface::JsCreateExternalArrayBuffer((void*)fileContent,

(unsigned int)strlen(fileContent), finalizeCallback, callbackArg, &scriptSource));

JsValueRef fname;

IfJsrtErrorSetGo(ChakraRTInterface::JsCreateString(fullPath,

strlen(fullPath), &fname));

JsSourceContext sourceContext = GetNextSourceContext();

RegisterScriptDir(sourceContext, fullPath);

if (HostConfigFlags::flags.UseParserStateCacheIsEnabled)

{

JsValueRef parserState;

IfJsrtErrorSetGo(ChakraRTInterface::JsSerializeParserState(scriptSource, &parserState, JsParseScriptAttributeNone));

errorCode = ChakraRTInterface::JsRunScriptWithParserState(scriptSource, sourceContext, fname, JsParseScriptAttributeNone, parserState, &returnValue);

}

else

{

errorCode = ChakraRTInterface::JsRun(scriptSource, sourceContext, fname, JsParseScriptAttributeNone, &returnValue);

}

if(errorCode == JsNoError)

{

errorCode = ChakraRTInterface::JsGetGlobalObject(&returnValue);

}

IfJsrtErrorSetGo(ChakraRTInterface::JsSetCurrentContext(currentContext));

}

else if (strcmp(scriptInjectType, "samethread") == 0)

{

JsValueRef newContext = JS_INVALID_REFERENCE;

// Create a new context and set it as the current context

IfJsrtErrorSetGo(ChakraRTInterface::JsCreateContext(runtime, &newContext));

#if ENABLE_TTD

//We need this here since this context is created in record

IfJsrtErrorSetGo(ChakraRTInterface::JsSetObjectBeforeCollectCallback(newContext, nullptr, WScriptJsrt::JsContextBeforeCollectCallback));

#endif

IfJsrtErrorSetGo(ChakraRTInterface::JsSetCurrentContext(newContext));

IfJsErrorFailLog(ChakraRTInterface::JsSetPromiseContinuationCallback(PromiseContinuationCallback, (void*)messageQueue));

// Initialize the host objects

Initialize();

JsValueRef scriptSource;

IfJsrtErrorSetGo(ChakraRTInterface::JsCreateExternalArrayBuffer((void*)fileContent,

(unsigned int)strlen(fileContent), finalizeCallback, callbackArg, &scriptSource));

JsValueRef fname;

IfJsrtErrorSetGo(ChakraRTInterface::JsCreateString(fullPath,

strlen(fullPath), &fname));

JsSourceContext sourceContext = GetNextSourceContext();

RegisterScriptDir(sourceContext, fullPath);

if (HostConfigFlags::flags.UseParserStateCacheIsEnabled)

{

JsValueRef parserState;

IfJsrtErrorSetGo(ChakraRTInterface::JsSerializeParserState(scriptSource, &parserState, JsParseScriptAttributeNone));

errorCode = ChakraRTInterface::JsRunScriptWithParserState(scriptSource, sourceContext, fname, JsParseScriptAttributeNone, parserState, &returnValue);

}

else

{

errorCode = ChakraRTInterface::JsRun(scriptSource, sourceContext, fname, JsParseScriptAttributeNone, &returnValue);

}

if (errorCode == JsNoError)

{

errorCode = ChakraRTInterface::JsGetGlobalObject(&returnValue);

}

// Set the context back to the old one

ChakraRTInterface::JsSetCurrentContext(currentContext);

}

else if (strcmp(scriptInjectType, "crossthread") == 0)

{

auto& threadData = GetRuntimeThreadLocalData().threadData;

if (threadData == nullptr)

{

threadData = new RuntimeThreadData();

}

RuntimeThreadData* child = new RuntimeThreadData();

child->initialSource = fileContent;

threadData->children.push_back(child);

child->parent = threadData;

// TODO: need to add a switch in case we don't need to wait for

// child initial script completion

ResetEvent(threadData->hevntInitialScriptCompleted);

child->hThread = ::CreateThread(NULL, NULL, [](void* param) -> DWORD

{

return ((RuntimeThreadData*)param)->ThreadProc();

}, (void*)child, NULL, NULL);

WaitForSingleObject(threadData->hevntInitialScriptCompleted, INFINITE);

}

else

{

errorCode = JsErrorInvalidArgument;

errorMessage = _u("Unsupported argument type inject type.");

}

Error:

JsValueRef value = returnValue;

if (errorCode != JsNoError)

{

SetExceptionIf(errorCode, errorMessage);

ChakraRTInterface::JsDoubleToNumber(errorCode, &value);

}

_flushall();

return value;

}

JsValueRef WScriptJsrt::MonotonicNowCallback(JsValueRef callee, bool isConstructCall, JsValueRef *arguments, unsigned short argumentCount, void *callbackState)

{

LPCWSTR errorMessage = _u("invalid call to WScript.monotonicNow");

JsErrorCode errorCode = JsNoError;

HRESULT hr = S_OK;

JsValueRef result;

IfJsrtErrorSetGo(ChakraRTInterface::JsDoubleToNumber(static_cast<double>(std::chrono::steady_clock::now().time_since_epoch().count()) / 1e6 /* ns in ms */, &result));

#ifdef CTIME_UNDEFED

#define ctime PAL_ctime

#undef CTIME_UNDEFED

#endif

return result;

Error:

SetExceptionIf(errorCode, errorMessage);

return JS_INVALID_REFERENCE;

}

JsValueRef WScriptJsrt::SetTimeoutCallback(JsValueRef callee, bool isConstructCall, JsValueRef *arguments, unsigned short argumentCount, void *callbackState)

{

LPCWSTR errorMessage = _u("invalid call to WScript.SetTimeout");

JsErrorCode errorCode = JsNoError;

HRESULT hr = S_OK;

JsValueRef function;

JsValueRef timerId;

unsigned int time;

double tmp;

CallbackMessage *msg = nullptr;

if (argumentCount != 3)

{

errorCode = JsErrorInvalidArgument;

goto Error;

}

function = arguments[1];

IfJsrtErrorSetGo(ChakraRTInterface::JsNumberToDouble(arguments[2], &tmp));

time = static_cast<int>(tmp);

msg = new CallbackMessage(time, function);

messageQueue->InsertSorted(msg);

IfJsrtErrorSetGo(ChakraRTInterface::JsDoubleToNumber(static_cast<double>(msg->GetId()), &timerId));

return timerId;

Error:

SetExceptionIf(errorCode, errorMessage);

return JS_INVALID_REFERENCE;

}

JsValueRef WScriptJsrt::ClearTimeoutCallback(JsValueRef callee, bool isConstructCall, JsValueRef *arguments, unsigned short argumentCount, void *callbackState)

{

LPCWSTR errorMessage = _u("invalid call to WScript.ClearTimeout");

JsErrorCode errorCode = JsNoError;

HRESULT hr = S_OK;

if (argumentCount != 2)

{

errorCode = JsErrorInvalidArgument;

goto Error;

}

unsigned int timerId;

double tmp;

JsValueRef undef;

if (ChakraRTInterface::JsNumberToDouble(arguments[1], &tmp) == JsNoError)

{

timerId = static_cast<int>(tmp);

messageQueue->RemoveById(timerId);

}

IfJsrtErrorSetGo(ChakraRTInterface::JsGetUndefinedValue(&undef));

return undef;

Error:

SetExceptionIf(errorCode, errorMessage);

return JS_INVALID_REFERENCE;

}

template <class DebugOperationFunc>

void QueueDebugOperation(JsValueRef function, const DebugOperationFunc& operation)

{

WScriptJsrt::PushMessage(WScriptJsrt::CallbackMessage::Create(function, operation));

}

JsValueRef WScriptJsrt::AttachCallback(JsValueRef callee, bool isConstructCall, JsValueRef *arguments, unsigned short argumentCount, void *callbackState)

{

LPCWSTR errorMessage = _u("WScript.Attach requires a function, like WScript.Attach(foo);");

JsErrorCode errorCode = JsNoError;

HRESULT hr = S_OK;

JsValueType argumentType = JsUndefined;

if (argumentCount != 2)

{

errorCode = JsErrorInvalidArgument;

goto Error;

}

IfJsrtErrorSetGo(ChakraRTInterface::JsGetValueType(arguments[1], &argumentType));

if (argumentType != JsFunction)

{

errorCode = JsErrorInvalidArgument;

goto Error;

}

QueueDebugOperation(arguments[1], [](WScriptJsrt::CallbackMessage& msg)

{

JsContextRef currentContext = JS_INVALID_REFERENCE;

ChakraRTInterface::JsGetCurrentContext(&currentContext);

JsRuntimeHandle currentRuntime = JS_INVALID_RUNTIME_HANDLE;

ChakraRTInterface::JsGetRuntime(currentContext, &currentRuntime);

Debugger* debugger = Debugger::GetDebugger(currentRuntime);

debugger->StartDebugging(currentRuntime);

debugger->SourceRunDown();

return msg.CallFunction("");

});

Error:

SetExceptionIf(errorCode, errorMessage);

return JS_INVALID_REFERENCE;

}

JsValueRef WScriptJsrt::DetachCallback(JsValueRef callee, bool isConstructCall, JsValueRef *arguments, unsigned short argumentCount, void *callbackState)

{

LPCWSTR errorMessage = _u("WScript.Detach requires a function, like WScript.Detach(foo);");

JsErrorCode errorCode = JsNoError;

HRESULT hr = S_OK;

JsValueType argumentType = JsUndefined;

if (argumentCount != 2)

{

errorCode = JsErrorInvalidArgument;

goto Error;

}

IfJsrtErrorSetGo(ChakraRTInterface::JsGetValueType(arguments[1], &argumentType));

if (argumentType != JsFunction)

{

errorCode = JsErrorInvalidArgument;

goto Error;

}

QueueDebugOperation(arguments[1], [](WScriptJsrt::CallbackMessage& msg)

{

JsContextRef currentContext = JS_INVALID_REFERENCE;

ChakraRTInterface::JsGetCurrentContext(&currentContext);

JsRuntimeHandle currentRuntime = JS_INVALID_RUNTIME_HANDLE;

ChakraRTInterface::JsGetRuntime(currentContext, &currentRuntime);

if (Debugger::debugger != nullptr)

{

Debugger* debugger = Debugger::GetDebugger(currentRuntime);

debugger->StopDebugging(currentRuntime);

}

return msg.CallFunction("");

});

Error: