openharmony/ark_js_runtime
1
0
Fork 0
mirror of https://github.com/openharmony/ark_js_runtime.git synced 2026-08-27 02:31:17 -04:00
Code Issues 1 Packages Projects Releases Wiki Activity
Files
7c650ba0158676f3d94de2bbda3ab5fd3ed68980
ark_js_runtime/ecmascript/tooling/base/pt_events.cpp
T
hjzhangcm a760638caa fix codex warning 
Signed-off-by: hjzhangcm <zhanghaijun20@huawei.com>
2022-05-06 17:52:55 +08:00

1233 lines
49 KiB
C++
Raw Blame History

/*
* Copyright (c) 2021 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "ecmascript/tooling/base/pt_events.h"
namespace panda::ecmascript::tooling {
std::unique_ptr<BreakpointResolved> BreakpointResolved::Create(const EcmaVM *ecmaVm, const Local<JSValueRef> &params)
{
if (params.IsEmpty()) {
LOG(ERROR, DEBUGGER) << "BreakpointResolved::Create params is nullptr";
return nullptr;
}
CString error;
auto breakpointResolved = std::make_unique<BreakpointResolved>();
Local<JSValueRef> result =
Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "breakpointId")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsString()) {
breakpointResolved->breakpointId_ = DebuggerApi::ToCString(result);
} else {
error += "'breakpointId' should a String;";
}
} else {
error += "should contain 'breakpointId';";
}
result = Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "location")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsObject()) {
std::unique_ptr<Location> location = Location::Create(ecmaVm, result);
if (location == nullptr) {
error += "'location' format error;";
} else {
breakpointResolved->location_ = std::move(location);
}
} else {
error += "'exception' should a Object;";
}
} else {
error += "should contain 'location';";
}
if (!error.empty()) {
LOG(ERROR, DEBUGGER) << "BreakpointResolved::Create " << error;
return nullptr;
}
return breakpointResolved;
}
Local<ObjectRef> BreakpointResolved::ToObject(const EcmaVM *ecmaVm)
{
Local<ObjectRef> params = NewObject(ecmaVm);
params->Set(ecmaVm,
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "breakpointId")),
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, breakpointId_.c_str())));
params->Set(ecmaVm,
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "location")),
Local<JSValueRef>(location_->ToObject(ecmaVm)));
Local<ObjectRef> object = NewObject(ecmaVm);
object->Set(ecmaVm,
StringRef::NewFromUtf8(ecmaVm, "method"),
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, GetName().c_str())));
object->Set(ecmaVm, StringRef::NewFromUtf8(ecmaVm, "params"), Local<JSValueRef>(params));
return object;
}
std::unique_ptr<Paused> Paused::Create(const EcmaVM *ecmaVm, const Local<JSValueRef> &params)
{
if (params.IsEmpty()) {
LOG(ERROR, DEBUGGER) << "Paused::Create params is nullptr";
return nullptr;
}
CString error;
auto paused = std::make_unique<Paused>();
Local<JSValueRef> result =
Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "callFrames")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsArray(ecmaVm)) {
auto array = Local<ArrayRef>(result);
int32_t len = array->Length(ecmaVm);
Local<JSValueRef> key = JSValueRef::Undefined(ecmaVm);
for (int32_t i = 0; i < len; ++i) {
key = IntegerRef::New(ecmaVm, i);
Local<JSValueRef> resultValue = Local<ObjectRef>(array)->Get(ecmaVm, key->ToString(ecmaVm));
std::unique_ptr<CallFrame> callFrame = CallFrame::Create(ecmaVm, resultValue);
if (resultValue.IsEmpty() || callFrame == nullptr) {
error += "'callFrames' format invalid;";
}
paused->callFrames_.emplace_back(std::move(callFrame));
}
} else {
error += "'callFrames' should a Array;";
}
} else {
error += "should contain 'callFrames';";
}
result = Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "reason")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsString()) {
paused->reason_ = DebuggerApi::ToCString(result);
} else {
error += "'reason' should a String;";
}
} else {
error += "should contain 'reason';";
}
result = Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "data")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsObject()) {
std::unique_ptr<RemoteObject> obj = RemoteObject::Create(ecmaVm, result);
if (obj == nullptr) {
error += "'data' format error;";
} else {
paused->data_ = std::move(obj);
}
} else {
error += "'data' should a Object;";
}
}
result = Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "hitBreakpoints")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsArray(ecmaVm)) {
CVector<BreakpointId> breakPoints;
auto array = Local<ArrayRef>(result);
int32_t len = array->Length(ecmaVm);
Local<JSValueRef> key = JSValueRef::Undefined(ecmaVm);
for (int32_t i = 0; i < len; ++i) {
key = IntegerRef::New(ecmaVm, i);
Local<JSValueRef> resultValue = Local<ObjectRef>(array)->Get(ecmaVm, key->ToString(ecmaVm));
if (resultValue.IsEmpty()) {
error += "'hitBreakpoints' format invalid;";
}
breakPoints.emplace_back(DebuggerApi::ToCString(result));
}
paused->hitBreakpoints_ = std::move(breakPoints);
} else {
error += "'hitBreakpoints' should a Array;";
}
}
if (!error.empty()) {
LOG(ERROR, DEBUGGER) << "Parsed::Create " << error;
return nullptr;
}
return paused;
}
Local<ObjectRef> Paused::ToObject(const EcmaVM *ecmaVm)
{
Local<ObjectRef> params = NewObject(ecmaVm);
size_t len = callFrames_.size();
Local<ArrayRef> values = ArrayRef::New(ecmaVm, len);
for (size_t i = 0; i < len; i++) {
Local<ObjectRef> callFrame = callFrames_[i]->ToObject(ecmaVm);
values->Set(ecmaVm, i, callFrame);
}
params->Set(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "callFrames")), values);
params->Set(ecmaVm,
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "reason")),
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, reason_.c_str())));
if (data_) {
params->Set(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "data")),
Local<JSValueRef>(data_.value()->ToObject(ecmaVm)));
}
if (hitBreakpoints_) {
len = hitBreakpoints_->size();
values = ArrayRef::New(ecmaVm, len);
for (size_t i = 0; i < len; i++) {
Local<StringRef> id = StringRef::NewFromUtf8(ecmaVm, hitBreakpoints_.value()[i].c_str());
values->Set(ecmaVm, i, id);
}
params->Set(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "hitBreakpoints")), values);
}
Local<ObjectRef> object = NewObject(ecmaVm);
object->Set(ecmaVm,
StringRef::NewFromUtf8(ecmaVm, "method"),
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, GetName().c_str())));
object->Set(ecmaVm, StringRef::NewFromUtf8(ecmaVm, "params"), Local<JSValueRef>(params));
return object;
}
std::unique_ptr<Resumed> Resumed::Create([[maybe_unused]] const EcmaVM *ecmaVm,
[[maybe_unused]] const Local<JSValueRef> &params)
{
return std::make_unique<Resumed>();
}
Local<ObjectRef> Resumed::ToObject(const EcmaVM *ecmaVm)
{
Local<ObjectRef> params = NewObject(ecmaVm);
Local<ObjectRef> object = NewObject(ecmaVm);
object->Set(ecmaVm,
StringRef::NewFromUtf8(ecmaVm, "method"),
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, GetName().c_str())));
object->Set(ecmaVm, StringRef::NewFromUtf8(ecmaVm, "params"), Local<JSValueRef>(params));
return object;
}
std::unique_ptr<ScriptFailedToParse> ScriptFailedToParse::Create(const EcmaVM *ecmaVm, const Local<JSValueRef> &params)
{
if (params.IsEmpty()) {
LOG(ERROR, DEBUGGER) << "ScriptFailedToParse::Create params is nullptr";
return nullptr;
}
CString error;
auto scriptEvent = std::make_unique<ScriptFailedToParse>();
Local<JSValueRef> result = Local<ObjectRef>(params)->Get(ecmaVm, StringRef::NewFromUtf8(ecmaVm, "scriptId"));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsString()) {
scriptEvent->scriptId_ = static_cast<uint32_t>(DebuggerApi::StringToInt(result));
} else {
error += "'scriptId' should a String;";
}
} else {
error += "should contain 'scriptId';";
}
result = Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "url")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsString()) {
scriptEvent->url_ = DebuggerApi::ToCString(result);
} else {
error += "'url' should a String;";
}
} else {
error += "should contain 'url';";
}
result = Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "startLine")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsNumber()) {
scriptEvent->startLine_ = Local<NumberRef>(result)->Value();
} else {
error += "'startLine' should a Number;";
}
} else {
error += "should contain 'startLine';";
}
result = Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "startColumn")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsNumber()) {
scriptEvent->startColumn_ = Local<NumberRef>(result)->Value();
} else {
error += "'startColumn' should a Number;";
}
} else {
error += "should contain 'startColumn';";
}
result = Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "endLine")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsNumber()) {
scriptEvent->endLine_ = Local<NumberRef>(result)->Value();
} else {
error += "'endLine' should a Number;";
}
} else {
error += "should contain 'endLine';";
}
result = Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "endColumn")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsNumber()) {
scriptEvent->endColumn_ = Local<NumberRef>(result)->Value();
} else {
error += "'endColumn' should a Number;";
}
} else {
error += "should contain 'endColumn';";
}
result =
Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "executionContextId")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsNumber()) {
scriptEvent->executionContextId_ = static_cast<ExecutionContextId>(Local<NumberRef>(result)->Value());
} else {
error += "'executionContextId' should a Number;";
}
} else {
error += "should contain 'executionContextId';";
}
result = Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "hash")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsString()) {
scriptEvent->hash_ = DebuggerApi::ToCString(result);
} else {
error += "'hash' should a String;";
}
} else {
error += "should contain 'hash';";
}
result = Local<ObjectRef>(params)->Get(ecmaVm,
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "executionContextAuxData")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsObject()) {
scriptEvent->execContextAuxData_ = Local<ObjectRef>(result);
} else {
error += "'executionContextAuxData' should a Object;";
}
}
result = Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "sourceMapURL")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsString()) {
scriptEvent->sourceMapUrl_ = DebuggerApi::ToCString(result);
} else {
error += "'sourceMapURL' should a String;";
}
}
result = Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "hasSourceURL")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsBoolean()) {
scriptEvent->hasSourceUrl_ = result->IsTrue();
} else {
error += "'hasSourceURL' should a Boolean;";
}
}
result = Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "isModule")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsBoolean()) {
scriptEvent->isModule_ = result->IsTrue();
} else {
error += "'isModule' should a Boolean;";
}
}
result = Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "length")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsNumber()) {
scriptEvent->length_ = static_cast<uint32_t>(Local<NumberRef>(result)->Value());
} else {
error += "'length' should a Number;";
}
}
result = Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "codeOffset")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsNumber()) {
scriptEvent->codeOffset_ = static_cast<uint32_t>(Local<NumberRef>(result)->Value());
} else {
error += "'codeOffset' should a Number;";
}
}
result = Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "scriptLanguage")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsString()) {
scriptEvent->scriptLanguage_ = DebuggerApi::ToCString(result);
} else {
error += "'scriptLanguage' should a String;";
}
}
result = Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "embedderName")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsString()) {
scriptEvent->embedderName_ = DebuggerApi::ToCString(result);
} else {
error += "'embedderName' should a String;";
}
}
if (!error.empty()) {
LOG(ERROR, DEBUGGER) << "ScriptFailedToParse::Create " << error;
return nullptr;
}
return scriptEvent;
}
Local<ObjectRef> ScriptFailedToParse::ToObject(const EcmaVM *ecmaVm)
{
Local<ObjectRef> params = NewObject(ecmaVm);
params->Set(ecmaVm,
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "scriptId")),
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, std::to_string(scriptId_).c_str())));
params->Set(ecmaVm,
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "url")),
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, url_.c_str())));
params->Set(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "startLine")),
IntegerRef::New(ecmaVm, startLine_));
params->Set(ecmaVm,
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "startColumn")),
IntegerRef::New(ecmaVm, startColumn_));
params->Set(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "endLine")),
IntegerRef::New(ecmaVm, endLine_));
params->Set(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "endColumn")),
IntegerRef::New(ecmaVm, endColumn_));
params->Set(ecmaVm,
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "executionContextId")),
IntegerRef::New(ecmaVm, executionContextId_));
params->Set(ecmaVm,
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "hash")),
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, hash_.c_str())));
if (execContextAuxData_) {
params->Set(ecmaVm,
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "executionContextAuxData")),
Local<JSValueRef>(execContextAuxData_.value()));
}
if (sourceMapUrl_) {
params->Set(ecmaVm,
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "sourceMapURL")),
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, sourceMapUrl_->c_str())));
}
if (hasSourceUrl_) {
params->Set(ecmaVm,
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "hasSourceURL")),
BooleanRef::New(ecmaVm, hasSourceUrl_.value()));
}
if (isModule_) {
params->Set(ecmaVm,
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "isModule")),
BooleanRef::New(ecmaVm, isModule_.value()));
}
if (length_) {
params->Set(ecmaVm,
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "length")),
IntegerRef::New(ecmaVm, length_.value()));
}
if (codeOffset_) {
params->Set(ecmaVm,
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "codeOffset")),
IntegerRef::New(ecmaVm, codeOffset_.value()));
}
if (scriptLanguage_) {
params->Set(ecmaVm,
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "scriptLanguage")),
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, scriptLanguage_->c_str())));
}
if (embedderName_) {
params->Set(ecmaVm,
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "embedderName")),
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, embedderName_->c_str())));
}
Local<ObjectRef> object = NewObject(ecmaVm);
object->Set(ecmaVm,
StringRef::NewFromUtf8(ecmaVm, "method"),
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, GetName().c_str())));
object->Set(ecmaVm, StringRef::NewFromUtf8(ecmaVm, "params"), Local<JSValueRef>(params));
return object;
}
std::unique_ptr<ScriptParsed> ScriptParsed::Create(const std::unique_ptr<PtScript> &script)
{
std::unique_ptr<ScriptParsed> scriptParsed = std::make_unique<ScriptParsed>();
scriptParsed->SetScriptId(script->GetScriptId())
.SetUrl(script->GetUrl())
.SetStartLine(0)
.SetStartColumn(0)
.SetEndLine(script->GetEndLine())
.SetEndColumn(0)
.SetExecutionContextId(0)
.SetHash(script->GetHash());
return scriptParsed;
}
std::unique_ptr<ScriptParsed> ScriptParsed::Create(const EcmaVM *ecmaVm, const Local<JSValueRef> &params)
{
if (params.IsEmpty()) {
LOG(ERROR, DEBUGGER) << "ScriptParsed::Create params is nullptr";
return nullptr;
}
CString error;
auto scriptEvent = std::make_unique<ScriptParsed>();
Local<JSValueRef> result =
Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "scriptId")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsString()) {
scriptEvent->scriptId_ = static_cast<uint32_t>(DebuggerApi::StringToInt(result));
} else {
error += "'scriptId' should a String;";
}
} else {
error += "should contain 'scriptId';";
}
result = Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "url")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsString()) {
scriptEvent->url_ = DebuggerApi::ToCString(result);
} else {
error += "'url' should a String;";
}
} else {
error += "should contain 'url';";
}
result = Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "startLine")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsNumber()) {
scriptEvent->startLine_ = Local<NumberRef>(result)->Value();
} else {
error += "'startLine' should a Number;";
}
} else {
error += "should contain 'startLine';";
}
result = Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "startColumn")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsNumber()) {
scriptEvent->startColumn_ = Local<NumberRef>(result)->Value();
} else {
error += "'startColumn' should a Number;";
}
} else {
error += "should contain 'startColumn';";
}
result = Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "endLine")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsNumber()) {
scriptEvent->endLine_ = Local<NumberRef>(result)->Value();
} else {
error += "'endLine' should a Number;";
}
} else {
error += "should contain 'endLine';";
}
result = Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "endColumn")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsNumber()) {
scriptEvent->endColumn_ = Local<NumberRef>(result)->Value();
} else {
error += "'endColumn' should a Number;";
}
} else {
error += "should contain 'endColumn';";
}
result =
Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "executionContextId")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsNumber()) {
scriptEvent->executionContextId_ = static_cast<ExecutionContextId>(Local<NumberRef>(result)->Value());
} else {
error += "'executionContextId' should a Number;";
}
} else {
error += "should contain 'executionContextId';";
}
result = Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "hash")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsString()) {
scriptEvent->hash_ = DebuggerApi::ToCString(result);
} else {
error += "'hash' should a String;";
}
} else {
error += "should contain 'hash';";
}
result = Local<ObjectRef>(params)->Get(ecmaVm,
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "executionContextAuxData")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsObject()) {
scriptEvent->execContextAuxData_ = Local<ObjectRef>(result);
} else {
error += "'executionContextAuxData' should a Object;";
}
}
result = Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "isLiveEdit")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsBoolean()) {
scriptEvent->isLiveEdit_ = result->IsTrue();
} else {
error += "'isLiveEdit' should a Boolean;";
}
}
result = Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "sourceMapURL")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsString()) {
scriptEvent->sourceMapUrl_ = DebuggerApi::ToCString(result);
} else {
error += "'sourceMapURL' should a String;";
}
}
result = Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "hasSourceURL")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsBoolean()) {
scriptEvent->hasSourceUrl_ = result->IsTrue();
} else {
error += "'hasSourceURL' should a Boolean;";
}
}
result = Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "isModule")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsBoolean()) {
scriptEvent->isModule_ = result->IsTrue();
} else {
error += "'isModule' should a Boolean;";
}
}
result = Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "length")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsNumber()) {
scriptEvent->length_ = static_cast<uint32_t>(Local<NumberRef>(result)->Value());
} else {
error += "'length' should a Number;";
}
}
result = Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "codeOffset")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsNumber()) {
scriptEvent->codeOffset_ = static_cast<uint32_t>(Local<NumberRef>(result)->Value());
} else {
error += "'codeOffset' should a Number;";
}
}
result = Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "scriptLanguage")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsString()) {
scriptEvent->scriptLanguage_ = DebuggerApi::ToCString(result);
} else {
error += "'scriptLanguage' should a String;";
}
}
result = Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "embedderName")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsString()) {
scriptEvent->embedderName_ = DebuggerApi::ToCString(result);
} else {
error += "'embedderName' should a String;";
}
}
if (!error.empty()) {
LOG(ERROR, DEBUGGER) << "ScriptParsed::Create " << error;
return nullptr;
}
return scriptEvent;
}
Local<ObjectRef> ScriptParsed::ToObject(const EcmaVM *ecmaVm)
{
Local<ObjectRef> params = NewObject(ecmaVm);
params->Set(ecmaVm,
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "scriptId")),
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, std::to_string(scriptId_).c_str())));
params->Set(ecmaVm,
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "url")),
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, url_.c_str())));
params->Set(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "startLine")),
IntegerRef::New(ecmaVm, startLine_));
params->Set(ecmaVm,
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "startColumn")),
IntegerRef::New(ecmaVm, startColumn_));
params->Set(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "endLine")),
IntegerRef::New(ecmaVm, endLine_));
params->Set(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "endColumn")),
IntegerRef::New(ecmaVm, endColumn_));
params->Set(ecmaVm,
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "executionContextId")),
IntegerRef::New(ecmaVm, executionContextId_));
params->Set(ecmaVm,
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "hash")),
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, hash_.c_str())));
if (execContextAuxData_) {
params->Set(ecmaVm,
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "executionContextAuxData")),
Local<JSValueRef>(execContextAuxData_.value()));
}
if (isLiveEdit_) {
params->Set(ecmaVm,
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "isLiveEdit")),
BooleanRef::New(ecmaVm, isLiveEdit_.value()));
}
if (sourceMapUrl_) {
params->Set(ecmaVm,
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "sourceMapURL")),
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, sourceMapUrl_->c_str())));
}
if (hasSourceUrl_) {
params->Set(ecmaVm,
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "hasSourceURL")),
BooleanRef::New(ecmaVm, hasSourceUrl_.value()));
}
if (isModule_) {
params->Set(ecmaVm,
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "isModule")),
BooleanRef::New(ecmaVm, isModule_.value()));
}
if (length_) {
params->Set(ecmaVm,
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "length")),
IntegerRef::New(ecmaVm, length_.value()));
}
if (codeOffset_) {
params->Set(ecmaVm,
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "codeOffset")),
IntegerRef::New(ecmaVm, codeOffset_.value()));
}
if (scriptLanguage_) {
params->Set(ecmaVm,
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "scriptLanguage")),
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, scriptLanguage_->c_str())));
}
if (embedderName_) {
params->Set(ecmaVm,
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "embedderName")),
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, embedderName_->c_str())));
}
Local<ObjectRef> object = NewObject(ecmaVm);
object->Set(ecmaVm,
StringRef::NewFromUtf8(ecmaVm, "method"),
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, GetName().c_str())));
object->Set(ecmaVm, StringRef::NewFromUtf8(ecmaVm, "params"), Local<JSValueRef>(params));
return object;
}
std::unique_ptr<AddHeapSnapshotChunk> AddHeapSnapshotChunk::Create(char* data, int size)
{
auto addHeapSnapshotChunk = std::make_unique<AddHeapSnapshotChunk>();
addHeapSnapshotChunk->chunk_.resize(size);
for (int i = 0; i < size; ++i) {
addHeapSnapshotChunk->chunk_[i] = data[i];
}
return addHeapSnapshotChunk;
}
std::unique_ptr<AddHeapSnapshotChunk> AddHeapSnapshotChunk::Create(const EcmaVM *ecmaVm,
const Local<JSValueRef> &params)
{
if (params.IsEmpty()) {
LOG(ERROR, DEBUGGER) << "AddHeapSnapshotChunk::Create params is nullptr";
return nullptr;
}
CString error;
auto addHeapSnapshotChunk = std::make_unique<AddHeapSnapshotChunk>();
Local<JSValueRef> result =
Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "chunk")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsString()) {
addHeapSnapshotChunk->chunk_ = DebuggerApi::ToCString(result);
} else {
error += "'chunk' should a String;";
}
} else {
error += "should contain 'chunk';";
}
if (!error.empty()) {
LOG(ERROR, DEBUGGER) << "AddHeapSnapshotChunk::Create " << error;
return nullptr;
}
return addHeapSnapshotChunk;
}
Local<ObjectRef> AddHeapSnapshotChunk::ToObject(const EcmaVM *ecmaVm)
{
Local<ObjectRef> params = NewObject(ecmaVm);
params->Set(ecmaVm,
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "chunk")),
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, chunk_.c_str())));
Local<ObjectRef> object = NewObject(ecmaVm);
object->Set(ecmaVm,
StringRef::NewFromUtf8(ecmaVm, "method"),
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, GetName().c_str())));
object->Set(ecmaVm, StringRef::NewFromUtf8(ecmaVm, "params"), Local<JSValueRef>(params));
return object;
}
std::unique_ptr<ConsoleProfileFinished> ConsoleProfileFinished::Create(const EcmaVM *ecmaVm,
const Local<JSValueRef> &params)
{
if (params.IsEmpty()) {
LOG(ERROR, DEBUGGER) << "ConsoleProfileFinished::Create params is nullptr";
return nullptr;
}
CString error;
auto consoleProfileFinished = std::make_unique<ConsoleProfileFinished>();
Local<JSValueRef> result =
Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "id")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsString()) {
consoleProfileFinished->id_ = DebuggerApi::ToCString(result);
} else {
error += "'id' should a String;";
}
} else {
error += "should contain 'id';";
}
result = Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "location")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsObject()) {
std::unique_ptr<Location> location = Location::Create(ecmaVm, result);
if (location == nullptr) {
error += "'location' format error;";
} else {
consoleProfileFinished->location_ = std::move(location);
}
} else {
error += "'location' should a Object;";
}
} else {
error += "should contain 'location';";
}
result = Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "profile")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsObject()) {
std::unique_ptr<Profile> profile = Profile::Create(ecmaVm, result);
if (profile == nullptr) {
error += "'profile' format error;";
} else {
consoleProfileFinished->profile_ = std::move(profile);
}
} else {
error += "'profile' should a Object;";
}
} else {
error += "should contain 'profile';";
}
result = Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "title")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsString()) {
consoleProfileFinished->title_ = DebuggerApi::ToCString(result);
} else {
error += "'title' should a String;";
}
} else {
error += "should contain 'title';";
}
if (!error.empty()) {
LOG(ERROR, DEBUGGER) << "ConsoleProfileFinished::Create " << error;
return nullptr;
}
return consoleProfileFinished;
}
Local<ObjectRef> ConsoleProfileFinished::ToObject(const EcmaVM *ecmaVm)
{
Local<ObjectRef> params = NewObject(ecmaVm);
params->Set(ecmaVm,
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "id")),
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, id_.c_str())));
params->Set(ecmaVm,
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "location")),
Local<JSValueRef>(location_->ToObject(ecmaVm)));
params->Set(ecmaVm,
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "profile")),
Local<JSValueRef>(profile_->ToObject(ecmaVm)));
if (title_) {
params->Set(ecmaVm,
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "title")),
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, title_->c_str())));
}
Local<ObjectRef> object = NewObject(ecmaVm);
object->Set(ecmaVm,
StringRef::NewFromUtf8(ecmaVm, "method"),
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, GetName().c_str())));
object->Set(ecmaVm, StringRef::NewFromUtf8(ecmaVm, "params"), Local<JSValueRef>(params));
return object;
}
std::unique_ptr<ConsoleProfileStarted> ConsoleProfileStarted::Create(const EcmaVM *ecmaVm,
const Local<JSValueRef> &params)
{
if (params.IsEmpty()) {
LOG(ERROR, DEBUGGER) << "ConsoleProfileStarted::Create params is nullptr";
return nullptr;
}
CString error;
auto consoleProfileStarted = std::make_unique<ConsoleProfileStarted>();
Local<JSValueRef> result =
Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "id")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsString()) {
consoleProfileStarted->id_ = DebuggerApi::ToCString(result);
} else {
error += "'id' should a String;";
}
} else {
error += "should contain 'id';";
}
result = Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "location")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsObject()) {
std::unique_ptr<Location> location = Location::Create(ecmaVm, result);
if (location == nullptr) {
error += "'location' format error;";
} else {
consoleProfileStarted->location_ = std::move(location);
}
} else {
error += "'location' should a Object;";
}
} else {
error += "should contain 'location';";
}
result = Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "title")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsString()) {
consoleProfileStarted->title_ = DebuggerApi::ToCString(result);
} else {
error += "'title' should a String;";
}
} else {
error += "should contain 'title';";
}
if (!error.empty()) {
LOG(ERROR, DEBUGGER) << "ConsoleProfileStarted::Create " << error;
return nullptr;
}
return consoleProfileStarted;
}
Local<ObjectRef> ConsoleProfileStarted::ToObject(const EcmaVM *ecmaVm)
{
Local<ObjectRef> params = NewObject(ecmaVm);
params->Set(ecmaVm,
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "id")),
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, id_.c_str())));
params->Set(ecmaVm,
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "location")),
Local<JSValueRef>(location_->ToObject(ecmaVm)));
if (title_) {
params->Set(ecmaVm,
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "title")),
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, title_->c_str())));
}
Local<ObjectRef> object = NewObject(ecmaVm);
object->Set(ecmaVm,
StringRef::NewFromUtf8(ecmaVm, "method"),
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, GetName().c_str())));
object->Set(ecmaVm, StringRef::NewFromUtf8(ecmaVm, "params"), Local<JSValueRef>(params));
return object;
}
std::unique_ptr<PreciseCoverageDeltaUpdate> PreciseCoverageDeltaUpdate::Create(const EcmaVM *ecmaVm,
const Local<JSValueRef> &params)
{
if (params.IsEmpty()) {
LOG(ERROR, DEBUGGER) << "PreciseCoverageDeltaUpdate::Create params is nullptr";
return nullptr;
}
CString error;
auto preciseCoverageDeltaUpdate = std::make_unique<PreciseCoverageDeltaUpdate>();
Local<JSValueRef> result =
Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "timestamp")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsNumber()) {
preciseCoverageDeltaUpdate->timestamp_ = static_cast<size_t>(Local<NumberRef>(result)->Value());
} else {
error += "'timestamp' should a Number;";
}
} else {
error += "should contain 'timestamp';";
}
result = Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "occasion")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsString()) {
preciseCoverageDeltaUpdate->occasion_ = DebuggerApi::ToCString(result);
} else {
error += "'occasion' should a String;";
}
} else {
error += "should contain 'occasion';";
}
result = Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "result")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsArray(ecmaVm)) {
auto array = Local<ArrayRef>(result);
int32_t resultLen = array->Length(ecmaVm);
Local<JSValueRef> key = JSValueRef::Undefined(ecmaVm);
for (int32_t i = 0; i < resultLen; ++i) {
key = IntegerRef::New(ecmaVm, i);
Local<JSValueRef> resultValue = Local<ObjectRef>(array)->Get(ecmaVm, key->ToString(ecmaVm));
std::unique_ptr<ScriptCoverage> tmpResult = ScriptCoverage::Create(ecmaVm, resultValue);
preciseCoverageDeltaUpdate->result_.emplace_back(std::move(tmpResult));
}
} else {
error += "'result' should be an Array;";
}
} else {
error += "should contain 'result';";
}
if (!error.empty()) {
LOG(ERROR, DEBUGGER) << "PreciseCoverageDeltaUpdate::Create " << error;
return nullptr;
}
return preciseCoverageDeltaUpdate;
}
Local<ObjectRef> PreciseCoverageDeltaUpdate::ToObject(const EcmaVM *ecmaVm)
{
Local<ObjectRef> params = NewObject(ecmaVm);
params->Set(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "timestamp")),
IntegerRef::New(ecmaVm, timestamp_));
params->Set(ecmaVm,
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "occasion")),
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, occasion_.c_str())));
size_t len = result_.size();
Local<ArrayRef> values = ArrayRef::New(ecmaVm, len);
for (size_t i = 0; i < len; i++) {
Local<ObjectRef> result = result_[i]->ToObject(ecmaVm);
values->Set(ecmaVm, i, result);
}
params->Set(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "result")), values);
Local<ObjectRef> object = NewObject(ecmaVm);
object->Set(ecmaVm,
StringRef::NewFromUtf8(ecmaVm, "method"),
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, GetName().c_str())));
object->Set(ecmaVm, StringRef::NewFromUtf8(ecmaVm, "params"), Local<JSValueRef>(params));
return object;
}
std::unique_ptr<HeapStatsUpdate> HeapStatsUpdate::Create(const EcmaVM *ecmaVm, const Local<JSValueRef> &params)
{
if (params.IsEmpty()) {
LOG(ERROR, DEBUGGER) << "HeapStatsUpdate::Create params is nullptr";
return nullptr;
}
CString error;
auto heapStatsUpdate = std::make_unique<HeapStatsUpdate>();
Local<JSValueRef> result =
Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "statsUpdate")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsArray(ecmaVm)) {
auto array = Local<ArrayRef>(result);
int32_t resultLen = array->Length(ecmaVm);
Local<JSValueRef> key = JSValueRef::Undefined(ecmaVm);
for (int32_t i = 0; i < resultLen; ++i) {
key = IntegerRef::New(ecmaVm, i);
int32_t statsUpdate;
Local<JSValueRef> resultValue = Local<ObjectRef>(array)->Get(ecmaVm, key->ToString(ecmaVm));
statsUpdate = resultValue->Int32Value(ecmaVm);
heapStatsUpdate ->statsUpdate_[i] = statsUpdate;
}
} else {
error += "'statsUpdate' should be an Array;";
}
} else {
error += "should contain 'statsUpdate';";
}
if (!error.empty()) {
LOG(ERROR, DEBUGGER) << "HeapStatsUpdate::Create " << error;
return nullptr;
}
return heapStatsUpdate;
}
Local<ObjectRef> HeapStatsUpdate::ToObject(const EcmaVM *ecmaVm)
{
Local<ObjectRef> params = NewObject(ecmaVm);
size_t len = statsUpdate_.size();
Local<ArrayRef> values = ArrayRef::New(ecmaVm, len);
for (size_t i = 0; i < len; i++) {
Local<IntegerRef> elem = IntegerRef::New(ecmaVm, statsUpdate_[i]);
values->Set(ecmaVm, i, elem);
}
params->Set(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "statsUpdate")), values);
Local<ObjectRef> object = NewObject(ecmaVm);
object->Set(ecmaVm,
StringRef::NewFromUtf8(ecmaVm, "method"),
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, GetName().c_str())));
object->Set(ecmaVm, StringRef::NewFromUtf8(ecmaVm, "params"), Local<JSValueRef>(params));
return object;
}
std::unique_ptr<LastSeenObjectId> LastSeenObjectId::Create(const EcmaVM *ecmaVm, const Local<JSValueRef> &params)
{
if (params.IsEmpty()) {
LOG(ERROR, DEBUGGER) << "LastSeenObjectId::Create params is nullptr";
return nullptr;
}
CString error;
auto lastSeenObjectId = std::make_unique<LastSeenObjectId>();
Local<JSValueRef> result =
Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "timestamp")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsNumber()) {
lastSeenObjectId->timestamp_ = static_cast<size_t>(Local<NumberRef>(result)->Value());
} else {
error += "'timestamp' should a Number;";
}
} else {
error += "should contain 'timestamp';";
}
result =
Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "lastSeenObjectId")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsNumber()) {
lastSeenObjectId->lastSeenObjectId_ = Local<NumberRef>(result)->Value();
} else {
error += "'lastSeenObjectId' should a Number;";
}
} else {
error += "should contain 'lastSeenObjectId';";
}
if (!error.empty()) {
LOG(ERROR, DEBUGGER) << "LastSeenObjectId::Create " << error;
return nullptr;
}
return lastSeenObjectId;
}
Local<ObjectRef> LastSeenObjectId::ToObject(const EcmaVM *ecmaVm)
{
Local<ObjectRef> params = NewObject(ecmaVm);
params->Set(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "timestamp")),
IntegerRef::New(ecmaVm, timestamp_));
params->Set(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "lastSeenObjectId")),
IntegerRef::New(ecmaVm, lastSeenObjectId_));
Local<ObjectRef> object = NewObject(ecmaVm);
object->Set(ecmaVm,
StringRef::NewFromUtf8(ecmaVm, "method"),
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, GetName().c_str())));
object->Set(ecmaVm, StringRef::NewFromUtf8(ecmaVm, "params"), Local<JSValueRef>(params));
return object;
}
std::unique_ptr<ReportHeapSnapshotProgress> ReportHeapSnapshotProgress::Create(const EcmaVM *ecmaVm,
const Local<JSValueRef> &params)
{
if (params.IsEmpty()) {
LOG(ERROR, DEBUGGER) << "ReportHeapSnapshotProgress::Create params is nullptr";
return nullptr;
}
CString error;
auto reportHeapSnapshotProgress = std::make_unique<ReportHeapSnapshotProgress>();
Local<JSValueRef> result =
Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "done")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsNumber()) {
reportHeapSnapshotProgress->done_ = Local<NumberRef>(result)->Value();
} else {
error += "'done' should a Number;";
}
} else {
error += "should contain 'done';";
}
result = Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "total")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsNumber()) {
reportHeapSnapshotProgress->total_ = Local<NumberRef>(result)->Value();
} else {
error += "'total' should a Number;";
}
} else {
error += "should contain 'total';";
}
result = Local<ObjectRef>(params)->Get(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "finished")));
if (!result.IsEmpty() && !result->IsUndefined()) {
if (result->IsBoolean()) {
reportHeapSnapshotProgress->finished_ = result->IsTrue();
} else {
error += "'finished' should a Boolean;";
}
}
if (!error.empty()) {
LOG(ERROR, DEBUGGER) << "ReportHeapSnapshotProgress::Create " << error;
return nullptr;
}
return reportHeapSnapshotProgress;
}
Local<ObjectRef> ReportHeapSnapshotProgress::ToObject(const EcmaVM *ecmaVm)
{
Local<ObjectRef> params = NewObject(ecmaVm);
params->Set(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "done")),
IntegerRef::New(ecmaVm, done_));
params->Set(ecmaVm, Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "total")),
IntegerRef::New(ecmaVm, total_));
if (finished_) {
params->Set(ecmaVm,
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, "finished")),
BooleanRef::New(ecmaVm, finished_.value()));
}
Local<ObjectRef> object = NewObject(ecmaVm);
object->Set(ecmaVm,
StringRef::NewFromUtf8(ecmaVm, "method"),
Local<JSValueRef>(StringRef::NewFromUtf8(ecmaVm, GetName().c_str())));
object->Set(ecmaVm, StringRef::NewFromUtf8(ecmaVm, "params"), Local<JSValueRef>(params));
return object;
}
} // namespace panda::ecmascript::tooling
Reference in New Issue View Git Blame Copy Permalink