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

// 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"

#ifdef ENABLE_SCRIPT_DEBUGGING

#include "JsrtDebuggerObject.h"

#include "JsrtDebugUtils.h"

#include "JsrtDebugManager.h"

JsrtDebuggerObjectBase::JsrtDebuggerObjectBase(JsrtDebuggerObjectType type, JsrtDebuggerObjectsManager* debuggerObjectsManager) :

type(type),

debuggerObjectsManager(debuggerObjectsManager)

{

Assert(debuggerObjectsManager != nullptr);

this->handle = debuggerObjectsManager->GetNextHandle();

}

JsrtDebuggerObjectBase::~JsrtDebuggerObjectBase()

{

this->debuggerObjectsManager = nullptr;

}

JsrtDebuggerObjectsManager * JsrtDebuggerObjectBase::GetDebuggerObjectsManager()

{

return this->debuggerObjectsManager;

}

Js::DynamicObject * JsrtDebuggerObjectBase::GetChildren(Js::ScriptContext * scriptContext, uint fromCount, uint totalCount)

{

AssertMsg(false, "Wrong type for GetChildren");

return nullptr;

}

Js::DynamicObject * JsrtDebuggerObjectBase::GetChildren(WeakArenaReference<Js::IDiagObjectModelWalkerBase>* walkerRef, Js::ScriptContext * scriptContext, uint fromCount, uint totalCount)

{

Js::DynamicObject* childrensObject = scriptContext->GetLibrary()->CreateObject();

uint propertiesArrayCount = 0;

Js::JavascriptArray* propertiesArray = scriptContext->GetLibrary()->CreateArray();

uint debuggerOnlyPropertiesArrayCount = 0;

Js::JavascriptArray* debuggerOnlyPropertiesArray = scriptContext->GetLibrary()->CreateArray();

Js::IDiagObjectModelWalkerBase* walker = walkerRef->GetStrongReference();

uint32 childrensCount = 0;

if (walker != nullptr)

{

try

{

childrensCount = walker->GetChildrenCount();

}

catch (const Js::JavascriptException& err)

{

err.GetAndClear(); // discard exception object

}

if (fromCount < childrensCount)

{

for (uint32 i = fromCount; i < childrensCount && (propertiesArrayCount + debuggerOnlyPropertiesArrayCount) < totalCount; ++i)

{

Js::ResolvedObject resolvedObject;

try

{

walker->Get(i, &resolvedObject);

}

catch (const Js::JavascriptException& err)

{

Js::JavascriptExceptionObject* exception = err.GetAndClear();

Js::Var error = exception->GetThrownObject(scriptContext);

resolvedObject.obj = error;

resolvedObject.address = nullptr;

resolvedObject.scriptContext = exception->GetScriptContext();

resolvedObject.typeId = Js::JavascriptOperators::GetTypeId(error);

resolvedObject.name = _u("{error}");

resolvedObject.propId = Js::Constants::NoProperty;

}

AutoPtr<WeakArenaReference<Js::IDiagObjectModelDisplay>> objectDisplayWeakRef(resolvedObject.GetObjectDisplay());

Js::IDiagObjectModelDisplay* resolvedObjectDisplay = objectDisplayWeakRef->GetStrongReference();

if (resolvedObjectDisplay != nullptr)

{

JsrtDebuggerObjectBase* debuggerObject = JsrtDebuggerObjectProperty::Make(this->GetDebuggerObjectsManager(), objectDisplayWeakRef);

Js::DynamicObject* object = debuggerObject->GetJSONObject(resolvedObject.scriptContext, /* forceSetValueProp */ false);

Js::Var marshaledObj = Js::CrossSite::MarshalVar(scriptContext, object);

if (resolvedObjectDisplay->IsFake())

{

Js::JavascriptOperators::OP_SetElementI((Js::Var)debuggerOnlyPropertiesArray, Js::JavascriptNumber::ToVar(debuggerOnlyPropertiesArrayCount++, scriptContext), marshaledObj, scriptContext);

}

else

{

Js::JavascriptOperators::OP_SetElementI((Js::Var)propertiesArray, Js::JavascriptNumber::ToVar(propertiesArrayCount++, scriptContext), marshaledObj, scriptContext);

}

objectDisplayWeakRef->ReleaseStrongReference();

objectDisplayWeakRef.Detach();

}

}

}

walkerRef->ReleaseStrongReference();

}

JsrtDebugUtils::AddPropertyToObject(childrensObject, JsrtDebugPropertyId::totalPropertiesOfObject, childrensCount, scriptContext);

JsrtDebugUtils::AddPropertyToObject(childrensObject, JsrtDebugPropertyId::properties, propertiesArray, scriptContext);

JsrtDebugUtils::AddPropertyToObject(childrensObject, JsrtDebugPropertyId::debuggerOnlyProperties, debuggerOnlyPropertiesArray, scriptContext);

return childrensObject;

}

JsrtDebuggerObjectsManager::JsrtDebuggerObjectsManager(JsrtDebugManager* jsrtDebugManager) :

handleId(0),

jsrtDebugManager(jsrtDebugManager),

handleToDebuggerObjectsDictionary(nullptr),

dataToDebuggerObjectsDictionary(nullptr)

{

Assert(jsrtDebugManager != nullptr);

}

JsrtDebuggerObjectsManager::~JsrtDebuggerObjectsManager()

{

if (this->dataToDebuggerObjectsDictionary != nullptr)

{

AssertMsg(this->dataToDebuggerObjectsDictionary->Count() == 0, "Should have cleared all debugger objects by now?");

Adelete(this->GetDebugObjectArena(), this->dataToDebuggerObjectsDictionary);

this->dataToDebuggerObjectsDictionary = nullptr;

}

if (this->handleToDebuggerObjectsDictionary != nullptr)

{

AssertMsg(this->handleToDebuggerObjectsDictionary->Count() == 0, "Should have cleared all handle by now?");

Adelete(this->GetDebugObjectArena(), this->handleToDebuggerObjectsDictionary);

this->handleToDebuggerObjectsDictionary = nullptr;

}

}

void JsrtDebuggerObjectsManager::ClearAll()

{

if (this->dataToDebuggerObjectsDictionary != nullptr)

{

this->dataToDebuggerObjectsDictionary->Clear();

}

if (this->handleToDebuggerObjectsDictionary != nullptr)

{

this->handleToDebuggerObjectsDictionary->Map([this](uint handle, JsrtDebuggerObjectBase* debuggerObject) {

Adelete(this->GetDebugObjectArena(), debuggerObject);

});

this->handleToDebuggerObjectsDictionary->Clear();

}

this->handleId = 0;

}

ArenaAllocator * JsrtDebuggerObjectsManager::GetDebugObjectArena()

{

return this->GetJsrtDebugManager()->GetDebugObjectArena();

}

bool JsrtDebuggerObjectsManager::TryGetDebuggerObjectFromHandle(uint handle, JsrtDebuggerObjectBase ** debuggerObject)

{

if (this->handleToDebuggerObjectsDictionary == nullptr)

{

return false;

}

return this->handleToDebuggerObjectsDictionary->TryGetValue(handle, debuggerObject);

}

void JsrtDebuggerObjectsManager::AddToDebuggerObjectsDictionary(JsrtDebuggerObjectBase * debuggerObject)

{

Assert(debuggerObject != nullptr);

uint handle = debuggerObject->GetHandle();

Assert(handle > 0);

if (this->handleToDebuggerObjectsDictionary == nullptr)

{

this->handleToDebuggerObjectsDictionary = Anew(this->GetDebugObjectArena(), DebuggerObjectsDictionary, this->GetDebugObjectArena(), 10);

}

Assert(!this->handleToDebuggerObjectsDictionary->ContainsKey(handle));

int index = this->handleToDebuggerObjectsDictionary->Add(handle, debuggerObject);

Assert(index != -1);

}

void JsrtDebuggerObjectsManager::AddToDataToDebuggerObjectsDictionary(void * data, JsrtDebuggerObjectBase * debuggerObject)

{

Assert(data != nullptr);

Assert(debuggerObject != nullptr);

if (this->dataToDebuggerObjectsDictionary == nullptr)

{

this->dataToDebuggerObjectsDictionary = Anew(this->GetDebugObjectArena(), DataToDebuggerObjectsDictionary, this->GetDebugObjectArena(), 10);

}

Assert(!this->dataToDebuggerObjectsDictionary->ContainsKey(data));

int index = this->dataToDebuggerObjectsDictionary->Add(data, debuggerObject);

Assert(index != -1);

this->AddToDebuggerObjectsDictionary(debuggerObject);

}

bool JsrtDebuggerObjectsManager::TryGetDataFromDataToDebuggerObjectsDictionary(void * data, JsrtDebuggerObjectBase ** debuggerObject)

{

if (this->dataToDebuggerObjectsDictionary == nullptr)

{

return false;

}

return this->dataToDebuggerObjectsDictionary->TryGetValue(data, debuggerObject);

}

JsrtDebuggerStackFrame::JsrtDebuggerStackFrame(JsrtDebuggerObjectsManager * debuggerObjectsManager, Js::DiagStackFrame * stackFrame, uint frameIndex) :

debuggerObjectsManager(debuggerObjectsManager),

frameIndex(frameIndex),

stackFrame(stackFrame)

{

Assert(this->stackFrame != nullptr);

}

JsrtDebuggerStackFrame::~JsrtDebuggerStackFrame()

{

this->debuggerObjectsManager = nullptr;

this->stackFrame = nullptr;

}

Js::DynamicObject * JsrtDebuggerStackFrame::GetJSONObject(Js::ScriptContext* scriptContext)

{

Js::ScriptContext *frameScriptContext = stackFrame->GetScriptContext();

Js::DynamicObject* stackTraceObject = frameScriptContext->GetLibrary()->CreateObject();

Js::FunctionBody* functionBody = stackFrame->GetFunction();

Js::Utf8SourceInfo* utf8SourceInfo = functionBody->GetUtf8SourceInfo();

JsrtDebugUtils::AddPropertyToObject(stackTraceObject, JsrtDebugPropertyId::index, frameIndex, scriptContext);

JsrtDebugUtils::AddScriptIdToObject(stackTraceObject, utf8SourceInfo);

int currentByteCodeOffset = stackFrame->GetByteCodeOffset();

if (stackFrame->IsInterpreterFrame() && frameIndex != 0)

{

// For non-leaf interpreter frames back up 1 instruction so we see the caller

// rather than the statement after the caller

currentByteCodeOffset--;

}

JsrtDebugUtils::AddLineColumnToObject(stackTraceObject, functionBody, currentByteCodeOffset);

JsrtDebugUtils::AddSourceLengthAndTextToObject(stackTraceObject, functionBody, currentByteCodeOffset);

Js::JavascriptFunction* javascriptFunction = stackFrame->GetJavascriptFunction();

JsrtDebuggerObjectBase* functionObject = nullptr;

if (!this->debuggerObjectsManager->TryGetDataFromDataToDebuggerObjectsDictionary(javascriptFunction, &functionObject))

{

functionObject = JsrtDebuggerObjectFunction::Make(this->debuggerObjectsManager, javascriptFunction);

}

JsrtDebugUtils::AddPropertyToObject(stackTraceObject, JsrtDebugPropertyId::functionHandle, functionObject->GetHandle(), frameScriptContext);

return stackTraceObject;

}

Js::DynamicObject * JsrtDebuggerStackFrame::GetLocalsObject(Js::ScriptContext* scriptContext)

{

/*

{

"thisObject" : {},

"exception" : {},

"arguments" : {},

"returnValue" : {},

"functionCallsReturn" : [{}, {}],

"locals" : [],

"scopes" : [{}, {}],

"globals" : {}

}

*/

Js::DynamicObject* propertiesObject = scriptContext->GetLibrary()->CreateObject();

Js::Var returnValueObject = nullptr;

uint functionCallsReturnCount = 0;

Js::JavascriptArray* functionCallsReturn = scriptContext->GetLibrary()->CreateArray();

uint totalLocalsCount = 0;

Js::JavascriptArray* localsArray = scriptContext->GetLibrary()->CreateArray();

uint scopesCount = 0;

Js::JavascriptArray* scopesArray = scriptContext->GetLibrary()->CreateArray();

Js::DynamicObject* globalsObject = nullptr;

ReferencedArenaAdapter* pRefArena = scriptContext->GetThreadContext()->GetDebugManager()->GetDiagnosticArena();

Js::IDiagObjectModelDisplay* pLocalsDisplay = Anew(pRefArena->Arena(), Js::LocalsDisplay, this->stackFrame);

WeakArenaReference<Js::IDiagObjectModelWalkerBase>* objectModelWalker = pLocalsDisplay->CreateWalker();

if (objectModelWalker != nullptr)

{

Js::LocalsWalker* localsWalker = (Js::LocalsWalker*)objectModelWalker->GetStrongReference();

if (localsWalker != nullptr)

{

// If 'this' is available add 'thisObject'

Js::ResolvedObject thisResolvedObject;

{

ENFORCE_ENTRYEXITRECORD_HASCALLER(scriptContext);

thisResolvedObject.obj = this->stackFrame->GetThisFromFrame(&thisResolvedObject.address, localsWalker);

}

if (thisResolvedObject.obj != nullptr)

{

thisResolvedObject.scriptContext = scriptContext;

thisResolvedObject.name = _u("this");

thisResolvedObject.typeId = Js::JavascriptOperators::GetTypeId(thisResolvedObject.obj);

JsrtDebuggerObjectBase::CreateDebuggerObject<JsrtDebuggerObjectProperty>(this->debuggerObjectsManager, thisResolvedObject, this->stackFrame->GetScriptContext(), false, [&](Js::Var marshaledObj)

{

JsrtDebugUtils::AddPropertyToObject(propertiesObject, JsrtDebugPropertyId::thisObject, marshaledObj, scriptContext);

});

}

uint32 totalProperties = localsWalker->GetChildrenCount();

if (totalProperties > 0)

{

int index = 0;

Js::ResolvedObject resolvedObject;

resolvedObject.scriptContext = this->stackFrame->GetScriptContext();

// If we have a exception add 'exception'

if (Js::VariableWalkerBase::GetExceptionObject(index, this->stackFrame, &resolvedObject))

{

JsrtDebuggerObjectBase::CreateDebuggerObject<JsrtDebuggerObjectProperty>(this->debuggerObjectsManager, resolvedObject, scriptContext, false, [&](Js::Var marshaledObj)

{

JsrtDebugUtils::AddPropertyToObject(propertiesObject, JsrtDebugPropertyId::exception, marshaledObj, scriptContext);

});

}

// If user have not explicitly defined 'arguments' add 'arguments'

if (localsWalker->HasUserNotDefinedArguments() && localsWalker->CreateArgumentsObject(&resolvedObject))

{

JsrtDebuggerObjectBase::CreateDebuggerObject<JsrtDebuggerObjectProperty>(this->debuggerObjectsManager, resolvedObject, scriptContext, false, [&](Js::Var marshaledObj)

{

JsrtDebugUtils::AddPropertyToObject(propertiesObject, JsrtDebugPropertyId::arguments, marshaledObj, scriptContext);

});

}

Js::ReturnedValueList *returnedValueList = this->stackFrame->GetScriptContext()->GetDebugContext()->GetProbeContainer()->GetReturnedValueList();

// If we have return value(s) add them to 'returnValue' or 'functionCallsReturn'

if (returnedValueList != nullptr && returnedValueList->Count() > 0 && this->stackFrame->IsTopFrame())

{

for (int i = 0; i < returnedValueList->Count(); ++i)

{

Js::ReturnedValue * returnValue = returnedValueList->Item(i);

Js::VariableWalkerBase::GetReturnedValueResolvedObject(returnValue, this->stackFrame, &resolvedObject);

JsrtDebuggerObjectBase::CreateDebuggerObject<JsrtDebuggerObjectProperty>(debuggerObjectsManager, resolvedObject, scriptContext, false, [&](Js::Var marshaledObj)

{

if (returnValue->isValueOfReturnStatement)

{

returnValueObject = marshaledObj;

}

else

{

Js::JavascriptOperators::OP_SetElementI((Js::Var)functionCallsReturn, Js::JavascriptNumber::ToVar(functionCallsReturnCount, scriptContext), marshaledObj, scriptContext);

functionCallsReturnCount++;

}

});

}

if (returnValueObject != nullptr)

{

JsrtDebugUtils::AddPropertyToObject(propertiesObject, JsrtDebugPropertyId::returnValue, returnValueObject, scriptContext);

}

if (functionCallsReturnCount > 0)

{

JsrtDebugUtils::AddPropertyToObject(propertiesObject, JsrtDebugPropertyId::functionCallsReturn, functionCallsReturn, scriptContext);

}

}

// Add all locals variable(s) available under 'locals'

uint32 localsCount = localsWalker->GetLocalVariablesCount();

for (uint32 i = 0; i < localsCount; ++i)

{

if (!localsWalker->GetLocal(i, &resolvedObject))

{

break;

}

JsrtDebuggerObjectBase::CreateDebuggerObject<JsrtDebuggerObjectProperty>(debuggerObjectsManager, resolvedObject, scriptContext, false, [&](Js::Var marshaledObj)

{

Js::JavascriptOperators::OP_SetElementI((Js::Var)localsArray, Js::JavascriptNumber::ToVar(totalLocalsCount, scriptContext), marshaledObj, scriptContext);

totalLocalsCount++;

});

}

// Add all variable(s) captured under 'scopes'

index = 0;

BOOL foundGroup = TRUE;

while (foundGroup)

{

foundGroup = localsWalker->GetScopeObject(index++, &resolvedObject);

if (foundGroup == TRUE)

{

AutoPtr<WeakArenaReference<Js::IDiagObjectModelDisplay>> objectDisplayWeakRef(resolvedObject.GetObjectDisplay());

JsrtDebuggerObjectBase* debuggerObject = JsrtDebuggerObjectScope::Make(debuggerObjectsManager, objectDisplayWeakRef, scopesCount);

Js::DynamicObject* object = debuggerObject->GetJSONObject(resolvedObject.scriptContext, /* forceSetValueProp */ false);

Assert(object != nullptr);

Js::Var marshaledObj = Js::CrossSite::MarshalVar(scriptContext, object);

Js::JavascriptOperators::OP_SetElementI((Js::Var)scopesArray, Js::JavascriptNumber::ToVar(scopesCount, scriptContext), marshaledObj, scriptContext);

scopesCount++;

objectDisplayWeakRef.Detach();

}

}

// Add globals handle

if (localsWalker->GetGlobalsObject(&resolvedObject))

{

JsrtDebuggerObjectBase::CreateDebuggerObject<JsrtDebuggerObjectGlobalsNode>(this->debuggerObjectsManager, resolvedObject, scriptContext, false, [&](Js::Var marshaledObj)

{

globalsObject = (Js::DynamicObject*)marshaledObj;

});

}

}

objectModelWalker->ReleaseStrongReference();

HeapDelete(objectModelWalker);

}

Adelete(pRefArena->Arena(), pLocalsDisplay);

}

JsrtDebugUtils::AddPropertyToObject(propertiesObject, JsrtDebugPropertyId::locals, localsArray, scriptContext);

JsrtDebugUtils::AddPropertyToObject(propertiesObject, JsrtDebugPropertyId::scopes, scopesArray, scriptContext);

if (globalsObject == nullptr)

{

globalsObject = scriptContext->GetLibrary()->CreateObject();

}

JsrtDebugUtils::AddPropertyToObject(propertiesObject, JsrtDebugPropertyId::globals, globalsObject, scriptContext);

return propertiesObject;

}

bool JsrtDebuggerStackFrame::Evaluate(Js::ScriptContext* scriptContext, const char16 *source, int sourceLength, bool isLibraryCode, bool forceSetValueProp, Js::DynamicObject** evalResult)

{

*evalResult = nullptr;

bool success = false;

if (this->stackFrame != nullptr)

{

Js::ResolvedObject resolvedObject;

HRESULT hr = S_OK;

Js::ScriptContext* frameScriptContext = this->stackFrame->GetScriptContext();

Js::JavascriptExceptionObject *exceptionObject = nullptr;

{

BEGIN_JS_RUNTIME_CALL_EX_AND_TRANSLATE_EXCEPTION_AND_ERROROBJECT_TO_HRESULT_NESTED(frameScriptContext, false)

{

ENFORCE_ENTRYEXITRECORD_HASCALLER(frameScriptContext);

this->stackFrame->EvaluateImmediate(source, sourceLength, isLibraryCode, &resolvedObject);

}

END_JS_RUNTIME_CALL_AND_TRANSLATE_AND_GET_EXCEPTION_AND_ERROROBJECT_TO_HRESULT(hr, frameScriptContext, exceptionObject);

}

if (resolvedObject.obj == nullptr)

{

resolvedObject.name = _u("{exception}");

resolvedObject.typeId = Js::TypeIds_Error;

resolvedObject.address = nullptr;

if (exceptionObject != nullptr)

{

resolvedObject.obj = exceptionObject->GetThrownObject(scriptContext);

}

else

{

resolvedObject.obj = scriptContext->GetLibrary()->GetUndefined();

}

}

else

{

success = true;

}

if (resolvedObject.obj != nullptr)

{

resolvedObject.scriptContext = frameScriptContext;

charcount_t len = Js::JavascriptString::GetBufferLength(source);

resolvedObject.name = AnewNoThrowArray(this->debuggerObjectsManager->GetDebugObjectArena(), WCHAR, len + 1);

if (resolvedObject.name != nullptr)

{

wcscpy_s((WCHAR*)resolvedObject.name, len + 1, source);

}

else

{

// len can be big, if we failed just have empty string

resolvedObject.name = _u("");

}

resolvedObject.typeId = Js::JavascriptOperators::GetTypeId(resolvedObject.obj);

JsrtDebuggerObjectBase::CreateDebuggerObject<JsrtDebuggerObjectProperty>(this->debuggerObjectsManager, resolvedObject, scriptContext, forceSetValueProp, [&](Js::Var marshaledObj)

{

*evalResult = (Js::DynamicObject*)marshaledObj;

});

}

}

return success;

}

JsrtDebuggerObjectProperty::JsrtDebuggerObjectProperty(JsrtDebuggerObjectsManager* debuggerObjectsManager, WeakArenaReference<Js::IDiagObjectModelDisplay>* objectDisplay) :

JsrtDebuggerObjectBase(JsrtDebuggerObjectType::Property, debuggerObjectsManager),

objectDisplay(objectDisplay),

walkerRef(nullptr)

{

Assert(objectDisplay != nullptr);

}

JsrtDebuggerObjectProperty::~JsrtDebuggerObjectProperty()

{

if (this->objectDisplay != nullptr)

{

HeapDelete(this->objectDisplay);

this->objectDisplay = nullptr;

}

if (this->walkerRef != nullptr)

{

HeapDelete(this->walkerRef);

this->walkerRef = nullptr;

}

}

JsrtDebuggerObjectBase * JsrtDebuggerObjectProperty::Make(JsrtDebuggerObjectsManager* debuggerObjectsManager, WeakArenaReference<Js::IDiagObjectModelDisplay>* objectDisplay)

{

JsrtDebuggerObjectBase* debuggerObject = Anew(debuggerObjectsManager->GetDebugObjectArena(), JsrtDebuggerObjectProperty, debuggerObjectsManager, objectDisplay);

debuggerObjectsManager->AddToDebuggerObjectsDictionary(debuggerObject);

return debuggerObject;

}

Js::DynamicObject * JsrtDebuggerObjectProperty::GetJSONObject(Js::ScriptContext* scriptContext, bool forceSetValueProp)

{

Js::IDiagObjectModelDisplay* objectDisplayRef = this->objectDisplay->GetStrongReference();

Js::DynamicObject* propertyObject = nullptr;

if (objectDisplayRef != nullptr)

{

propertyObject = scriptContext->GetLibrary()->CreateObject();

LPCWSTR name = objectDisplayRef->Name();

JsrtDebugUtils::AddPropertyToObject(propertyObject, JsrtDebugPropertyId::name, name, wcslen(name), scriptContext);

JsrtDebugUtils::AddPropertyType(propertyObject, objectDisplayRef, scriptContext, forceSetValueProp); // Will add type, value, display, className, propertyAttributes

JsrtDebugUtils::AddPropertyToObject(propertyObject, JsrtDebugPropertyId::handle, this->GetHandle(), scriptContext);

this->objectDisplay->ReleaseStrongReference();

}

return propertyObject;

}

Js::DynamicObject* JsrtDebuggerObjectProperty::GetChildren(Js::ScriptContext* scriptContext, uint fromCount, uint totalCount)

{

Js::IDiagObjectModelDisplay* objectDisplayRef = objectDisplay->GetStrongReference();

if (objectDisplayRef == nullptr)

{

return nullptr;

}

if (this->walkerRef == nullptr)

{

this->walkerRef = objectDisplayRef->CreateWalker();

}

Js::DynamicObject* childrens = __super::GetChildren(this->walkerRef, scriptContext, fromCount, totalCount);

objectDisplay->ReleaseStrongReference();

return childrens;

}

JsrtDebuggerObjectScope::JsrtDebuggerObjectScope(JsrtDebuggerObjectsManager * debuggerObjectsManager, WeakArenaReference<Js::IDiagObjectModelDisplay>* objectDisplay, uint index) :

JsrtDebuggerObjectBase(JsrtDebuggerObjectType::Scope, debuggerObjectsManager),

objectDisplay(objectDisplay),

index(index),

walkerRef(nullptr)

{

Assert(this->objectDisplay != nullptr);

}

JsrtDebuggerObjectScope::~JsrtDebuggerObjectScope()

{

if (this->objectDisplay != nullptr)

{

HeapDelete(this->objectDisplay);

this->objectDisplay = nullptr;

}

if (this->walkerRef != nullptr)

{

HeapDelete(this->walkerRef);

this->walkerRef = nullptr;

}

}

JsrtDebuggerObjectBase * JsrtDebuggerObjectScope::Make(JsrtDebuggerObjectsManager * debuggerObjectsManager, WeakArenaReference<Js::IDiagObjectModelDisplay>* objectDisplay, uint index)

{

JsrtDebuggerObjectBase* debuggerObject = Anew(debuggerObjectsManager->GetDebugObjectArena(), JsrtDebuggerObjectScope, debuggerObjectsManager, objectDisplay, index);

debuggerObjectsManager->AddToDebuggerObjectsDictionary(debuggerObject);

return debuggerObject;

}

Js::DynamicObject * JsrtDebuggerObjectScope::GetJSONObject(Js::ScriptContext* scriptContext, bool forceSetValueProp)

{

Js::IDiagObjectModelDisplay* modelDisplay = this->objectDisplay->GetStrongReference();

Js::DynamicObject* scopeObject = nullptr;

if (modelDisplay != nullptr)

{

scopeObject = scriptContext->GetLibrary()->CreateObject();

JsrtDebugUtils::AddPropertyToObject(scopeObject, JsrtDebugPropertyId::index, this->index, scriptContext);

JsrtDebugUtils::AddPropertyToObject(scopeObject, JsrtDebugPropertyId::handle, this->GetHandle(), scriptContext);

this->objectDisplay->ReleaseStrongReference();

}

return scopeObject;

}

Js::DynamicObject * JsrtDebuggerObjectScope::GetChildren(Js::ScriptContext * scriptContext, uint fromCount, uint totalCount)

{

Js::IDiagObjectModelDisplay* objectDisplayRef = objectDisplay->GetStrongReference();

if (objectDisplayRef == nullptr)

{

return nullptr;

}

if (this->walkerRef == nullptr)

{

this->walkerRef = objectDisplayRef->CreateWalker();

}

Js::DynamicObject* childrens = __super::GetChildren(this->walkerRef, scriptContext, fromCount, totalCount);

objectDisplay->ReleaseStrongReference();

return childrens;

}

JsrtDebuggerObjectFunction::JsrtDebuggerObjectFunction(JsrtDebuggerObjectsManager* debuggerObjectsManager, Js::JavascriptFunction* javascriptFunction) :

JsrtDebuggerObjectBase(JsrtDebuggerObjectType::Function, debuggerObjectsManager),

javascriptFunction(javascriptFunction),

objectDisplay(nullptr),

walkerRef(nullptr)

{

}

JsrtDebuggerObjectFunction::~JsrtDebuggerObjectFunction()

{

if (this->objectDisplay != nullptr)

{

HeapDelete(this->objectDisplay);

this->objectDisplay = nullptr;

}

if (this->walkerRef != nullptr)

{

HeapDelete(this->walkerRef);

this->walkerRef = nullptr;

}

this->javascriptFunction = nullptr;

}

JsrtDebuggerObjectBase * JsrtDebuggerObjectFunction::Make(JsrtDebuggerObjectsManager * debuggerObjectsManager, Js::JavascriptFunction* javascriptFunction)

{

JsrtDebuggerObjectBase* debuggerObject = nullptr;

Assert(!debuggerObjectsManager->TryGetDataFromDataToDebuggerObjectsDictionary(javascriptFunction, &debuggerObject));

debuggerObject = Anew(debuggerObjectsManager->GetDebugObjectArena(), JsrtDebuggerObjectFunction, debuggerObjectsManager, javascriptFunction);

debuggerObjectsManager->AddToDataToDebuggerObjectsDictionary(javascriptFunction, debuggerObject);

return debuggerObject;

}

Js::DynamicObject * JsrtDebuggerObjectFunction::GetJSONObject(Js::ScriptContext * scriptContext, bool forceSetValueProp)

{

Js::DynamicObject* functionObject = scriptContext->GetLibrary()->CreateObject();

Js::FunctionBody* functionBody = this->javascriptFunction->GetFunctionBody();

JsrtDebugUtils::AddScriptIdToObject(functionObject, functionBody->GetUtf8SourceInfo());

JsrtDebugUtils::AddPropertyToObject(functionObject, JsrtDebugPropertyId::line, (uint32)functionBody->GetLineNumber(), scriptContext);

JsrtDebugUtils::AddPropertyToObject(functionObject, JsrtDebugPropertyId::column, (uint32)functionBody->GetColumnNumber(), scriptContext);

JsrtDebugUtils::AddPropertyToObject(functionObject, JsrtDebugPropertyId::name, functionBody->GetDisplayName(), functionBody->GetDisplayNameLength(), scriptContext);

JsrtDebugUtils::AddPropertyToObject(functionObject, JsrtDebugPropertyId::type, scriptContext->GetLibrary()->GetFunctionTypeDisplayString(), scriptContext);

JsrtDebugUtils::AddPropertyToObject(functionObject, JsrtDebugPropertyId::handle, this->GetHandle(), scriptContext);

return functionObject;

}

Js::DynamicObject * JsrtDebuggerObjectFunction::GetChildren(Js::ScriptContext * scriptContext, uint fromCount, uint totalCount)

{

if (this->objectDisplay == nullptr)

{

Js::ResolvedObject functionResolvedObject;

functionResolvedObject.obj = this->javascriptFunction;

functionResolvedObject.scriptContext = scriptContext;

functionResolvedObject.name = _u("Function");

functionResolvedObject.typeId = Js::JavascriptOperators::GetTypeId(functionResolvedObject.obj);

this->objectDisplay = functionResolvedObject.GetObjectDisplay();

}

Js::IDiagObjectModelDisplay* objectDisplayRef = this->objectDisplay->GetStrongReference();

if (objectDisplayRef == nullptr)

{

return nullptr;

}

if (this->walkerRef == nullptr)

{

this->walkerRef = objectDisplayRef->CreateWalker();

}

Js::DynamicObject* childrens = __super::GetChildren(this->walkerRef, scriptContext, fromCount, totalCount);

this->objectDisplay->ReleaseStrongReference();

return childrens;

}

JsrtDebuggerObjectGlobalsNode::JsrtDebuggerObjectGlobalsNode(JsrtDebuggerObjectsManager* debuggerObjectsManager, WeakArenaReference<Js::IDiagObjectModelDisplay>* objectDisplay) :

JsrtDebuggerObjectBase(JsrtDebuggerObjectType::Globals, debuggerObjectsManager),

objectDisplay(objectDisplay),

walkerRef(nullptr)

{

Assert(objectDisplay != nullptr);

}

JsrtDebuggerObjectGlobalsNode::~JsrtDebuggerObjectGlobalsNode()

{

if (this->objectDisplay != nullptr)

{

HeapDelete(this->objectDisplay);

this->objectDisplay = nullptr;

}

if (this->walkerRef != nullptr)

{

HeapDelete(this->walkerRef);

this->walkerRef = nullptr;

}

}

JsrtDebuggerObjectBase * JsrtDebuggerObjectGlobalsNode::Make(JsrtDebuggerObjectsManager * debuggerObjectsManager, WeakArenaReference<Js::IDiagObjectModelDisplay>* objectDisplay)

{

JsrtDebuggerObjectBase* debuggerObject = Anew(debuggerObjectsManager->GetDebugObjectArena(), JsrtDebuggerObjectGlobalsNode, debuggerObjectsManager, objectDisplay);

debuggerObjectsManager->AddToDebuggerObjectsDictionary(debuggerObject);

return debuggerObject;

}

Js::DynamicObject * JsrtDebuggerObjectGlobalsNode::GetJSONObject(Js::ScriptContext * scriptContext, bool forceSetValueProp)

{

Js::IDiagObjectModelDisplay* objectDisplayRef = this->objectDisplay->GetStrongReference();

Js::DynamicObject* globalsNode = nullptr;

if (objectDisplayRef != nullptr)

{

globalsNode = scriptContext->GetLibrary()->CreateObject();

JsrtDebugUtils::AddPropertyToObject(globalsNode, JsrtDebugPropertyId::handle, this->GetHandle(), scriptContext);

this->objectDisplay->ReleaseStrongReference();

}

return globalsNode;

}

Js::DynamicObject * JsrtDebuggerObjectGlobalsNode::GetChildren(Js::ScriptContext * scriptContext, uint fromCount, uint totalCount)

{

Js::IDiagObjectModelDisplay* objectDisplayRef = objectDisplay->GetStrongReference();

if (objectDisplayRef == nullptr)

{

return nullptr;

}

if (this->walkerRef == nullptr)

{

this->walkerRef = objectDisplayRef->CreateWalker();

}

Js::DynamicObject* childrens = __super::GetChildren(this->walkerRef, scriptContext, fromCount, totalCount);

objectDisplay->ReleaseStrongReference();

return childrens;

}

JsrtDebugStackFrames::JsrtDebugStackFrames(JsrtDebugManager* jsrtDebugManager):

framesDictionary(nullptr)

{

Assert(jsrtDebugManager != nullptr);

this->jsrtDebugManager = jsrtDebugManager;

}

JsrtDebugStackFrames::~JsrtDebugStackFrames()

{

if (this->framesDictionary != nullptr)

{

this->ClearFrameDictionary();

Adelete(this->jsrtDebugManager->GetDebugObjectArena(), this->framesDictionary);

this->framesDictionary = nullptr;

}

}

static int __cdecl DiagStackFrameSorter(void * dispatchHaltFrameAddress, const void * diagStackFrame1, const void * diagStackFrame2)

{

const DWORD_PTR *p1 = reinterpret_cast<const DWORD_PTR*>(diagStackFrame1);

const DWORD_PTR *p2 = reinterpret_cast<const DWORD_PTR*>(diagStackFrame2);

Js::DiagStackFrame * pStackFrame1 = (Js::DiagStackFrame *)(*p1);

Js::DiagStackFrame * pStackFrame2 = (Js::DiagStackFrame *)(*p2);

DWORD_PTR stackAddress1 = pStackFrame1->GetStackAddress();

DWORD_PTR stackAddress2 = pStackFrame2->GetStackAddress();

return stackAddress1 > stackAddress2 ? 1 : -1;

}

Js::JavascriptArray * JsrtDebugStackFrames::StackFrames(Js::ScriptContext * scriptContext)

{

Js::JavascriptArray* stackTraceArray = nullptr;

ThreadContext* threadContext = scriptContext->GetThreadContext();

DWORD_PTR dispatchHaltFrameAddress = threadContext->GetDebugManager()->GetDispatchHaltFrameAddress();

AssertMsg(dispatchHaltFrameAddress > 0, "Didn't set the dispatchHaltFrameAddress at time of break?");

if (dispatchHaltFrameAddress != 0)

{

if (this->framesDictionary == nullptr)

{

this->framesDictionary = Anew(this->jsrtDebugManager->GetDebugObjectArena(), FramesDictionary, this->jsrtDebugManager->GetDebugObjectArena(), 10);

}

else

{

this->ClearFrameDictionary();

}

typedef JsUtil::List<Js::DiagStackFrame*, ArenaAllocator> DiagStackFrameList;

DiagStackFrameList* stackList = Anew(this->jsrtDebugManager->GetDebugObjectArena(), DiagStackFrameList, this->jsrtDebugManager->GetDebugObjectArena(), 10);

// Walk all the script contexts and collect the frames which are below the address when break was reported.

for (Js::ScriptContext *tempScriptContext = threadContext->GetScriptContextList();

tempScriptContext != nullptr && tempScriptContext->IsScriptContextInDebugMode();

tempScriptContext = tempScriptContext->next)

{

Js::WeakDiagStack * framePointers = tempScriptContext->GetDebugContext()->GetProbeContainer()->GetFramePointers(dispatchHaltFrameAddress);

if (framePointers != nullptr)

{

Js::DiagStack* stackFrames = framePointers->GetStrongReference();

if (stackFrames != nullptr)

{

int count = stackFrames->Count();

for (int frameIndex = 0; frameIndex < count; ++frameIndex)

{

Js::DiagStackFrame* stackFrame = stackFrames->Peek(frameIndex);

stackList->Add(stackFrame);

}

}

framePointers->ReleaseStrongReference();

HeapDelete(framePointers);

}

}

// Frames can be from multiple contexts, sort them based on stack address

stackList->Sort(DiagStackFrameSorter, (void*)dispatchHaltFrameAddress);

stackTraceArray = scriptContext->GetLibrary()->CreateArray(stackList->Count(), stackList->Count());

stackList->Map([&](int index, Js::DiagStackFrame* stackFrame)

{

AssertMsg(index != 0 || stackFrame->IsTopFrame(), "Index 0 frame is not marked as top frame");

Js::DynamicObject* stackTraceObject = this->GetStackFrame(stackFrame, index);

Js::Var marshaledObj = Js::CrossSite::MarshalVar(scriptContext, stackTraceObject);

stackTraceArray->DirectSetItemAt(index, marshaledObj);

});

Adelete(this->jsrtDebugManager->GetDebugObjectArena(), stackList);

}

else

{

// Empty array

stackTraceArray = scriptContext->GetLibrary()->CreateArray(0, 0);

}

return stackTraceArray;

}

bool JsrtDebugStackFrames::TryGetFrameObjectFromFrameIndex(uint frameIndex, JsrtDebuggerStackFrame ** debuggerStackFrame)

{

if (this->framesDictionary != nullptr)

{

return this->framesDictionary->TryGetValue(frameIndex, debuggerStackFrame);

}

return false;

}

Js::DynamicObject * JsrtDebugStackFrames::GetStackFrame(Js::DiagStackFrame * stackFrame, uint frameIndex)

{

JsrtDebuggerStackFrame* debuggerStackFrame = Anew(this->jsrtDebugManager->GetDebugObjectArena(), JsrtDebuggerStackFrame, this->jsrtDebugManager->GetDebuggerObjectsManager(), stackFrame, frameIndex);

Assert(this->framesDictionary != nullptr);

this->framesDictionary->Add(frameIndex, debuggerStackFrame);

return debuggerStackFrame->GetJSONObject(stackFrame->GetScriptContext());

}

void JsrtDebugStackFrames::ClearFrameDictionary()

{

if (this->framesDictionary != nullptr)

{

this->framesDictionary->Map([this](uint handle, JsrtDebuggerStackFrame* debuggerStackFrame) {

Adelete(this->jsrtDebugManager->GetDebugObjectArena(), debuggerStackFrame);

});

this->framesDictionary->Clear();

}

}

#endif