1 /*
2 * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "pt_types.h"
17
18 namespace panda::ecmascript::tooling {
19 using ObjectType = RemoteObject::TypeName;
20 using ObjectSubType = RemoteObject::SubTypeName;
21 using ObjectClassName = RemoteObject::ClassName;
22
23 const std::string ObjectType::Object = "object"; // NOLINT (readability-identifier-naming)
24 const std::string ObjectType::Function = "function"; // NOLINT (readability-identifier-naming)
25 const std::string ObjectType::Undefined = "undefined"; // NOLINT (readability-identifier-naming)
26 const std::string ObjectType::String = "string"; // NOLINT (readability-identifier-naming)
27 const std::string ObjectType::Number = "number"; // NOLINT (readability-identifier-naming)
28 const std::string ObjectType::Boolean = "boolean"; // NOLINT (readability-identifier-naming)
29 const std::string ObjectType::Symbol = "symbol"; // NOLINT (readability-identifier-naming)
30 const std::string ObjectType::Bigint = "bigint"; // NOLINT (readability-identifier-naming)
31 const std::string ObjectType::Wasm = "wasm"; // NOLINT (readability-identifier-naming)
32
33 const std::string ObjectSubType::Array = "array"; // NOLINT (readability-identifier-naming)
34 const std::string ObjectSubType::Null = "null"; // NOLINT (readability-identifier-naming)
35 const std::string ObjectSubType::Node = "node"; // NOLINT (readability-identifier-naming)
36 const std::string ObjectSubType::Regexp = "regexp"; // NOLINT (readability-identifier-naming)
37 const std::string ObjectSubType::Date = "date"; // NOLINT (readability-identifier-naming)
38 const std::string ObjectSubType::Map = "map"; // NOLINT (readability-identifier-naming)
39 const std::string ObjectSubType::Set = "set"; // NOLINT (readability-identifier-naming)
40 const std::string ObjectSubType::Weakmap = "weakmap"; // NOLINT (readability-identifier-naming)
41 const std::string ObjectSubType::Weakset = "weakset"; // NOLINT (readability-identifier-naming)
42 const std::string ObjectSubType::Iterator = "iterator"; // NOLINT (readability-identifier-naming)
43 const std::string ObjectSubType::Generator = "generator"; // NOLINT (readability-identifier-naming)
44 const std::string ObjectSubType::Error = "error"; // NOLINT (readability-identifier-naming)
45 const std::string ObjectSubType::Proxy = "proxy"; // NOLINT (readability-identifier-naming)
46 const std::string ObjectSubType::Promise = "promise"; // NOLINT (readability-identifier-naming)
47 const std::string ObjectSubType::Typedarray = "typedarray"; // NOLINT (readability-identifier-naming)
48 const std::string ObjectSubType::Arraybuffer = "arraybuffer"; // NOLINT (readability-identifier-naming)
49 const std::string ObjectSubType::Dataview = "dataview"; // NOLINT (readability-identifier-naming)
50 const std::string ObjectSubType::I32 = "i32"; // NOLINT (readability-identifier-naming)
51 const std::string ObjectSubType::I64 = "i64"; // NOLINT (readability-identifier-naming)
52 const std::string ObjectSubType::F32 = "f32"; // NOLINT (readability-identifier-naming)
53 const std::string ObjectSubType::F64 = "f64"; // NOLINT (readability-identifier-naming)
54 const std::string ObjectSubType::V128 = "v128"; // NOLINT (readability-identifier-naming)
55 const std::string ObjectSubType::Externref = "externref"; // NOLINT (readability-identifier-naming)
56
57 const std::string ObjectClassName::Object = "Object"; // NOLINT (readability-identifier-naming)
58 const std::string ObjectClassName::Function = "Function"; // NOLINT (readability-identifier-naming)
59 const std::string ObjectClassName::Array = "Array"; // NOLINT (readability-identifier-naming)
60 const std::string ObjectClassName::Regexp = "RegExp"; // NOLINT (readability-identifier-naming)
61 const std::string ObjectClassName::Date = "Date"; // NOLINT (readability-identifier-naming)
62 const std::string ObjectClassName::Map = "Map"; // NOLINT (readability-identifier-naming)
63 const std::string ObjectClassName::Set = "Set"; // NOLINT (readability-identifier-naming)
64 const std::string ObjectClassName::Weakmap = "Weakmap"; // NOLINT (readability-identifier-naming)
65 const std::string ObjectClassName::Weakset = "Weakset"; // NOLINT (readability-identifier-naming)
66 const std::string ObjectClassName::Dataview = "Dataview"; // NOLINT (readability-identifier-naming)
67 const std::string ObjectClassName::ArrayIterator = "ArrayIterator"; // NOLINT (readability-identifier-naming)
68 const std::string ObjectClassName::StringIterator = "StringIterator"; // NOLINT (readability-identifier-naming)
69 const std::string ObjectClassName::SetIterator = "SetIterator"; // NOLINT (readability-identifier-naming)
70 const std::string ObjectClassName::MapIterator = "MapIterator"; // NOLINT (readability-identifier-naming)
71 const std::string ObjectClassName::Iterator = "Iterator"; // NOLINT (readability-identifier-naming)
72 const std::string ObjectClassName::Error = "Error"; // NOLINT (readability-identifier-naming)
73 const std::string ObjectClassName::Proxy = "Object"; // NOLINT (readability-identifier-naming)
74 const std::string ObjectClassName::Promise = "Promise"; // NOLINT (readability-identifier-naming)
75 const std::string ObjectClassName::Typedarray = "Typedarray"; // NOLINT (readability-identifier-naming)
76 const std::string ObjectClassName::Arraybuffer = "Arraybuffer"; // NOLINT (readability-identifier-naming)
77 const std::string ObjectClassName::Global = "global"; // NOLINT (readability-identifier-naming)
78 const std::string ObjectClassName::Generator = "Generator"; // NOLINT (readability-identifier-naming)
79
80 const std::string RemoteObject::ObjectDescription = "Object"; // NOLINT (readability-identifier-naming)
81 const std::string RemoteObject::GlobalDescription = "global"; // NOLINT (readability-identifier-naming)
82 const std::string RemoteObject::ProxyDescription = "Proxy"; // NOLINT (readability-identifier-naming)
83 const std::string RemoteObject::PromiseDescription = "Promise"; // NOLINT (readability-identifier-naming)
84 const std::string RemoteObject::ArrayIteratorDescription = // NOLINT (readability-identifier-naming)
85 "ArrayIterator";
86 const std::string RemoteObject::StringIteratorDescription = // NOLINT (readability-identifier-naming)
87 "StringIterator";
88 const std::string RemoteObject::SetIteratorDescription = "SetIterator"; // NOLINT (readability-identifier-naming)
89 const std::string RemoteObject::MapIteratorDescription = "MapIterator"; // NOLINT (readability-identifier-naming)
90 const std::string RemoteObject::WeakRefDescription = "WeakRef"; // NOLINT (readability-identifier-naming)
91 const std::string RemoteObject::WeakMapDescription = "WeakMap"; // NOLINT (readability-identifier-naming)
92 const std::string RemoteObject::WeakSetDescription = "WeakSet"; // NOLINT (readability-identifier-naming)
93 const std::string RemoteObject::DataViewDescription = "DataView"; // NOLINT (readability-identifier-naming)
94 const std::string RemoteObject::JSPrimitiveNumberDescription = // NOLINT (readability-identifier-naming)
95 "Number";
96 const std::string RemoteObject::JSPrimitiveBooleanDescription = // NOLINT (readability-identifier-naming)
97 "Boolean";
98 const std::string RemoteObject::JSPrimitiveStringDescription = // NOLINT (readability-identifier-naming)
99 "String";
100 const std::string RemoteObject::JSPrimitiveSymbolDescription = // NOLINT (readability-identifier-naming)
101 "Symbol";
102 const std::string RemoteObject::DateTimeFormatDescription = // NOLINT (readability-identifier-naming)
103 "DateTimeFormat";
104 const std::string RemoteObject::JSIntlDescription = "Intl"; // NOLINT (readability-identifier-naming)
105 const std::string RemoteObject::NumberFormatDescription = "NumberFormat"; // NOLINT (readability-identifier-naming)
106 const std::string RemoteObject::CollatorDescription = "Collator"; // NOLINT (readability-identifier-naming)
107 const std::string RemoteObject::PluralRulesDescription = "PluralRules"; // NOLINT (readability-identifier-naming)
108 const std::string RemoteObject::JSLocaleDescription = "Locale"; // NOLINT (readability-identifier-naming)
109 const std::string RemoteObject::JSListFormatDescription = "ListFormat"; // NOLINT (readability-identifier-naming)
110 const std::string RemoteObject::JSRelativeTimeFormatDescription = // NOLINT (readability-identifier-naming)
111 "RelativeTimeFormat";
112
FromTagged(const EcmaVM * ecmaVm,Local<JSValueRef> tagged)113 std::unique_ptr<RemoteObject> RemoteObject::FromTagged(const EcmaVM *ecmaVm, Local<JSValueRef> tagged)
114 {
115 if (tagged->IsNull() || tagged->IsUndefined() ||
116 tagged->IsBoolean() || tagged->IsNumber() ||
117 tagged->IsBigInt()) {
118 return std::make_unique<PrimitiveRemoteObject>(ecmaVm, tagged);
119 }
120 if (tagged->IsString()) {
121 return std::make_unique<StringRemoteObject>(ecmaVm, Local<StringRef>(tagged));
122 }
123 if (tagged->IsSymbol()) {
124 return std::make_unique<SymbolRemoteObject>(ecmaVm, Local<SymbolRef>(tagged));
125 }
126 // proxy must be placed in front of all object types
127 if (tagged->IsProxy()) {
128 return std::make_unique<ObjectRemoteObject>(ecmaVm, tagged, ObjectClassName::Proxy, ObjectSubType::Proxy);
129 }
130 if (tagged->IsGeneratorFunction()) {
131 return std::make_unique<GeneratorFunctionRemoteObject>(ecmaVm, Local<SymbolRef>(tagged));
132 }
133 if (tagged->IsFunction()) {
134 return std::make_unique<FunctionRemoteObject>(ecmaVm, tagged);
135 }
136 if (tagged->IsArray(ecmaVm)) {
137 return std::make_unique<ObjectRemoteObject>(ecmaVm, tagged, ObjectClassName::Array, ObjectSubType::Array);
138 }
139 if (tagged->IsRegExp()) {
140 return std::make_unique<ObjectRemoteObject>(ecmaVm, tagged, ObjectClassName::Regexp, ObjectSubType::Regexp);
141 }
142 if (tagged->IsDate()) {
143 return std::make_unique<ObjectRemoteObject>(ecmaVm, tagged, ObjectClassName::Date, ObjectSubType::Date);
144 }
145 if (tagged->IsMap()) {
146 return std::make_unique<ObjectRemoteObject>(ecmaVm, tagged, ObjectClassName::Map, ObjectSubType::Map);
147 }
148 if (tagged->IsWeakMap()) {
149 return std::make_unique<ObjectRemoteObject>(ecmaVm, tagged, ObjectClassName::Weakmap, ObjectSubType::Weakmap);
150 }
151 if (tagged->IsSet()) {
152 return std::make_unique<ObjectRemoteObject>(ecmaVm, tagged, ObjectClassName::Set, ObjectSubType::Set);
153 }
154 if (tagged->IsWeakSet()) {
155 return std::make_unique<ObjectRemoteObject>(ecmaVm, tagged, ObjectClassName::Weakset, ObjectSubType::Weakset);
156 }
157 if (tagged->IsDataView()) {
158 return std::make_unique<ObjectRemoteObject>(ecmaVm, tagged, ObjectClassName::Dataview, ObjectSubType::Dataview);
159 }
160 if (tagged->IsError()) {
161 return std::make_unique<ObjectRemoteObject>(ecmaVm, tagged, ObjectClassName::Error, ObjectSubType::Error);
162 }
163 if (tagged->IsPromise()) {
164 return std::make_unique<ObjectRemoteObject>(ecmaVm, tagged, ObjectClassName::Promise, ObjectSubType::Promise);
165 }
166 if (tagged->IsArrayBuffer()) {
167 return std::make_unique<ObjectRemoteObject>(ecmaVm, tagged, ObjectClassName::Arraybuffer,
168 ObjectSubType::Arraybuffer);
169 }
170 if (tagged->IsArrayIterator()) {
171 return std::make_unique<ObjectRemoteObject>(ecmaVm, tagged, ObjectClassName::ArrayIterator);
172 }
173 if (tagged->IsStringIterator()) {
174 return std::make_unique<ObjectRemoteObject>(ecmaVm, tagged, ObjectClassName::StringIterator);
175 }
176 if (tagged->IsSetIterator()) {
177 return std::make_unique<ObjectRemoteObject>(ecmaVm, tagged, ObjectClassName::SetIterator,
178 ObjectSubType::Iterator);
179 }
180 if (tagged->IsMapIterator()) {
181 return std::make_unique<ObjectRemoteObject>(ecmaVm, tagged, ObjectClassName::MapIterator,
182 ObjectSubType::Iterator);
183 }
184 if (tagged->IsArrayList()) {
185 return std::make_unique<ObjectRemoteObject>(ecmaVm, tagged, ObjectClassName::Object);
186 }
187 if (tagged->IsDeque()) {
188 return std::make_unique<ObjectRemoteObject>(ecmaVm, tagged, ObjectClassName::Object);
189 }
190 if (tagged->IsHashMap()) {
191 return std::make_unique<ObjectRemoteObject>(ecmaVm, tagged, ObjectClassName::Object);
192 }
193 if (tagged->IsHashSet()) {
194 return std::make_unique<ObjectRemoteObject>(ecmaVm, tagged, ObjectClassName::Object);
195 }
196 if (tagged->IsLightWeightMap()) {
197 return std::make_unique<ObjectRemoteObject>(ecmaVm, tagged, ObjectClassName::Object);
198 }
199 if (tagged->IsLightWeightSet()) {
200 return std::make_unique<ObjectRemoteObject>(ecmaVm, tagged, ObjectClassName::Object);
201 }
202 if (tagged->IsLinkedList()) {
203 return std::make_unique<ObjectRemoteObject>(ecmaVm, tagged, ObjectClassName::Object);
204 }
205 if (tagged->IsList()) {
206 return std::make_unique<ObjectRemoteObject>(ecmaVm, tagged, ObjectClassName::Object);
207 }
208 if (tagged->IsPlainArray()) {
209 return std::make_unique<ObjectRemoteObject>(ecmaVm, tagged, ObjectClassName::Object);
210 }
211 if (tagged->IsQueue()) {
212 return std::make_unique<ObjectRemoteObject>(ecmaVm, tagged, ObjectClassName::Object);
213 }
214 if (tagged->IsStack()) {
215 return std::make_unique<ObjectRemoteObject>(ecmaVm, tagged, ObjectClassName::Object);
216 }
217 if (tagged->IsTreeMap()) {
218 return std::make_unique<ObjectRemoteObject>(ecmaVm, tagged, ObjectClassName::Object);
219 }
220 if (tagged->IsTreeSet()) {
221 return std::make_unique<ObjectRemoteObject>(ecmaVm, tagged, ObjectClassName::Object);
222 }
223 if (tagged->IsVector()) {
224 return std::make_unique<ObjectRemoteObject>(ecmaVm, tagged, ObjectClassName::Object);
225 }
226 if (tagged->IsObject()) {
227 return std::make_unique<ObjectRemoteObject>(ecmaVm, tagged, ObjectClassName::Object);
228 }
229 std::unique_ptr<RemoteObject> object = std::make_unique<RemoteObject>();
230 object->SetType(ObjectType::Undefined);
231 return object;
232 }
233
PrimitiveRemoteObject(const EcmaVM * ecmaVm,Local<JSValueRef> tagged)234 PrimitiveRemoteObject::PrimitiveRemoteObject(const EcmaVM *ecmaVm, Local<JSValueRef> tagged)
235 {
236 if (tagged->IsNull()) {
237 SetType(ObjectType::Object).SetSubType(ObjectSubType::Null);
238 } else if (tagged->IsBoolean()) {
239 std::string description = tagged->IsTrue() ? "true" : "false";
240 SetType(ObjectType::Boolean)
241 .SetValue(tagged)
242 .SetUnserializableValue(description)
243 .SetDescription(description);
244 } else if (tagged->IsUndefined()) {
245 SetType(ObjectType::Undefined);
246 } else if (tagged->IsNumber()) {
247 std::string description = tagged->ToString(ecmaVm)->ToString();
248 SetType(ObjectType::Number)
249 .SetValue(tagged)
250 .SetUnserializableValue(description)
251 .SetDescription(description);
252 } else if (tagged->IsBigInt()) {
253 std::string description = tagged->ToString(ecmaVm)->ToString() + "n"; // n : BigInt literal postfix
254 SetType(ObjectType::Bigint)
255 .SetValue(tagged)
256 .SetUnserializableValue(description)
257 .SetDescription(description);
258 }
259 }
260
StringRemoteObject(const EcmaVM * ecmaVm,Local<StringRef> tagged)261 StringRemoteObject::StringRemoteObject([[maybe_unused]] const EcmaVM *ecmaVm, Local<StringRef> tagged)
262 {
263 std::string description = tagged->ToString();
264 SetType(RemoteObject::TypeName::String)
265 .SetValue(tagged)
266 .SetUnserializableValue(description)
267 .SetDescription(description);
268 }
269
SymbolRemoteObject(const EcmaVM * ecmaVm,Local<SymbolRef> tagged)270 SymbolRemoteObject::SymbolRemoteObject(const EcmaVM *ecmaVm, Local<SymbolRef> tagged)
271 {
272 std::string description = DescriptionForSymbol(ecmaVm, tagged);
273 SetType(RemoteObject::TypeName::Symbol)
274 .SetValue(tagged)
275 .SetUnserializableValue(description)
276 .SetDescription(description);
277 }
278
FunctionRemoteObject(const EcmaVM * ecmaVm,Local<JSValueRef> tagged)279 FunctionRemoteObject::FunctionRemoteObject(const EcmaVM *ecmaVm, Local<JSValueRef> tagged)
280 {
281 std::string description = DescriptionForFunction(ecmaVm, tagged);
282 SetType(RemoteObject::TypeName::Function)
283 .SetClassName(RemoteObject::ClassName::Function)
284 .SetValue(tagged)
285 .SetUnserializableValue(description)
286 .SetDescription(description);
287 }
288
GeneratorFunctionRemoteObject(const EcmaVM * ecmaVm,Local<JSValueRef> tagged)289 GeneratorFunctionRemoteObject::GeneratorFunctionRemoteObject(const EcmaVM *ecmaVm, Local<JSValueRef> tagged)
290 {
291 std::string description = DescriptionForGeneratorFunction(ecmaVm, tagged);
292 SetType(RemoteObject::TypeName::Function)
293 .SetClassName(RemoteObject::ClassName::Generator)
294 .SetValue(tagged)
295 .SetUnserializableValue(description)
296 .SetDescription(description);
297 }
298
ObjectRemoteObject(const EcmaVM * ecmaVm,Local<JSValueRef> tagged,const std::string & classname)299 ObjectRemoteObject::ObjectRemoteObject(const EcmaVM *ecmaVm, Local<JSValueRef> tagged,
300 const std::string &classname)
301 {
302 std::string description = DescriptionForObject(ecmaVm, tagged);
303 SetType(RemoteObject::TypeName::Object)
304 .SetClassName(classname)
305 .SetValue(tagged)
306 .SetUnserializableValue(description)
307 .SetDescription(description);
308 }
309
ObjectRemoteObject(const EcmaVM * ecmaVm,Local<JSValueRef> tagged,const std::string & classname,const std::string & subtype)310 ObjectRemoteObject::ObjectRemoteObject(const EcmaVM *ecmaVm, Local<JSValueRef> tagged,
311 const std::string &classname, const std::string &subtype)
312 {
313 std::string description = DescriptionForObject(ecmaVm, tagged);
314 SetType(RemoteObject::TypeName::Object)
315 .SetSubType(subtype)
316 .SetClassName(classname)
317 .SetValue(tagged)
318 .SetUnserializableValue(description)
319 .SetDescription(description);
320 }
321
DescriptionForObject(const EcmaVM * ecmaVm,Local<JSValueRef> tagged)322 std::string ObjectRemoteObject::DescriptionForObject(const EcmaVM *ecmaVm, Local<JSValueRef> tagged)
323 {
324 // proxy must be placed in front of all object types
325 if (tagged->IsProxy()) {
326 return RemoteObject::ProxyDescription;
327 }
328 if (tagged->IsArray(ecmaVm)) {
329 return DescriptionForArray(ecmaVm, Local<ArrayRef>(tagged));
330 }
331 if (tagged->IsRegExp()) {
332 return DescriptionForRegexp(ecmaVm, Local<RegExpRef>(tagged));
333 }
334 if (tagged->IsDate()) {
335 return DescriptionForDate(ecmaVm, Local<DateRef>(tagged));
336 }
337 if (tagged->IsMap()) {
338 return DescriptionForMap(ecmaVm, Local<MapRef>(tagged));
339 }
340 if (tagged->IsWeakMap()) {
341 return DescriptionForWeakMap(ecmaVm, Local<WeakMapRef>(tagged));
342 }
343 if (tagged->IsSet()) {
344 return DescriptionForSet(ecmaVm, Local<SetRef>(tagged));
345 }
346 if (tagged->IsWeakSet()) {
347 return DescriptionForWeakSet(ecmaVm, Local<WeakSetRef>(tagged));
348 }
349 if (tagged->IsDataView()) {
350 return DescriptionForDataView(Local<DataViewRef>(tagged));
351 }
352 if (tagged->IsError()) {
353 return DescriptionForError(ecmaVm, tagged);
354 }
355 if (tagged->IsPromise()) {
356 return RemoteObject::PromiseDescription;
357 }
358 if (tagged->IsArrayIterator()) {
359 return DescriptionForArrayIterator();
360 }
361 if (tagged->IsStringIterator()) {
362 return RemoteObject::StringIteratorDescription;
363 }
364 if (tagged->IsSetIterator()) {
365 return DescriptionForSetIterator();
366 }
367 if (tagged->IsMapIterator()) {
368 return DescriptionForMapIterator();
369 }
370 if (tagged->IsArrayBuffer()) {
371 return DescriptionForArrayBuffer(ecmaVm, Local<ArrayBufferRef>(tagged));
372 }
373 if (tagged->IsSharedArrayBuffer()) {
374 return DescriptionForSharedArrayBuffer(ecmaVm, Local<ArrayBufferRef>(tagged));
375 }
376 if (tagged->IsUint8Array()) {
377 return DescriptionForUint8Array(ecmaVm, Local<TypedArrayRef>(tagged));
378 }
379 if (tagged->IsInt8Array()) {
380 return DescriptionForInt8Array(ecmaVm, Local<TypedArrayRef>(tagged));
381 }
382 if (tagged->IsInt16Array()) {
383 return DescriptionForInt16Array(ecmaVm, Local<TypedArrayRef>(tagged));
384 }
385 if (tagged->IsInt32Array()) {
386 return DescriptionForInt32Array(ecmaVm, Local<TypedArrayRef>(tagged));
387 }
388 if (tagged->IsJSPrimitiveRef() && tagged->IsJSPrimitiveNumber()) {
389 return DescriptionForPrimitiveNumber(ecmaVm, tagged);
390 }
391 if (tagged->IsJSPrimitiveRef() && tagged->IsJSPrimitiveString()) {
392 return DescriptionForPrimitiveString(ecmaVm, tagged);
393 }
394 if (tagged->IsJSPrimitiveRef() && tagged->IsJSPrimitiveBoolean()) {
395 return DescriptionForPrimitiveBoolean(ecmaVm, tagged);
396 }
397 if (tagged->IsGeneratorObject()) {
398 return DescriptionForGeneratorObject(ecmaVm, tagged);
399 }
400 if (tagged->IsWeakRef()) {
401 return DescriptionForWeakRef();
402 }
403 if (tagged->IsJSLocale()) {
404 return DescriptionForJSLocale();
405 }
406 if (tagged->IsJSDateTimeFormat()) {
407 return DescriptionForDateTimeFormat();
408 }
409 if (tagged->IsJSRelativeTimeFormat()) {
410 return DescriptionForJSRelativeTimeFormat();
411 }
412 if (tagged->IsJSIntl()) {
413 return RemoteObject::JSIntlDescription;
414 }
415 if (tagged->IsJSNumberFormat()) {
416 return DescriptionForNumberFormat();
417 }
418 if (tagged->IsJSCollator()) {
419 return DescriptionForCollator();
420 }
421 if (tagged->IsJSPluralRules()) {
422 return DescriptionForPluralRules();
423 }
424 if (tagged->IsJSListFormat()) {
425 return DescriptionForJSListFormat();
426 }
427 if (tagged->IsArrayList()) {
428 return DescriptionForArrayList();
429 }
430 if (tagged->IsDeque()) {
431 return DescriptionForDeque();
432 }
433 if (tagged->IsHashMap()) {
434 return DescriptionForHashMap();
435 }
436 if (tagged->IsHashSet()) {
437 return DescriptionForHashSet();
438 }
439 if (tagged->IsLightWeightMap()) {
440 return DescriptionForLightWeightMap();
441 }
442 if (tagged->IsLightWeightSet()) {
443 return DescriptionForLightWeightSet();
444 }
445 if (tagged->IsLinkedList()) {
446 return DescriptionForLinkedList();
447 }
448 if (tagged->IsList()) {
449 return DescriptionForList();
450 }
451 if (tagged->IsPlainArray()) {
452 return DescriptionForPlainArray();
453 }
454 if (tagged->IsQueue()) {
455 return DescriptionForQueue();
456 }
457 if (tagged->IsStack()) {
458 return DescriptionForStack();
459 }
460 if (tagged->IsTreeMap()) {
461 return DescriptionForTreeMap();
462 }
463 if (tagged->IsTreeSet()) {
464 return DescriptionForTreeSet();
465 }
466 if (tagged->IsVector()) {
467 return DescriptionForVector();
468 }
469 return RemoteObject::ObjectDescription;
470 }
471
DescriptionForArray(const EcmaVM * ecmaVm,Local<ArrayRef> tagged)472 std::string ObjectRemoteObject::DescriptionForArray(const EcmaVM *ecmaVm, Local<ArrayRef> tagged)
473 {
474 std::string description = "Array(" + std::to_string(tagged->Length(ecmaVm)) + ")";
475 return description;
476 }
477
DescriptionForRegexp(const EcmaVM * ecmaVm,Local<RegExpRef> tagged)478 std::string ObjectRemoteObject::DescriptionForRegexp(const EcmaVM *ecmaVm, Local<RegExpRef> tagged)
479 {
480 std::string regExpSource = tagged->GetOriginalSource(ecmaVm)->ToString();
481 std::string regExpFlags = tagged->GetOriginalFlags();
482 return "/" + regExpSource + "/" + regExpFlags;
483 }
484
DescriptionForDate(const EcmaVM * ecmaVm,Local<DateRef> tagged)485 std::string ObjectRemoteObject::DescriptionForDate(const EcmaVM *ecmaVm, Local<DateRef> tagged)
486 {
487 std::string description = tagged->ToString(ecmaVm)->ToString();
488 return description;
489 }
490
DescriptionForMap(const EcmaVM * ecmaVm,Local<MapRef> tagged)491 std::string ObjectRemoteObject::DescriptionForMap(const EcmaVM *ecmaVm, Local<MapRef> tagged)
492 {
493 int32_t len = tagged->GetTotalElements();
494 int32_t index = 0;
495 std::string description = "Map(" + std::to_string(tagged->GetSize()) + ")";
496 if (!len) {
497 return description;
498 }
499 description += " {";
500 char cPre = '\'';
501 for (int32_t i = 0; i < len; ++i) {
502 // add Key
503 Local<JSValueRef> jsVKey = tagged->GetKey(ecmaVm, i);
504 if (jsVKey->IsHole()) {
505 continue;
506 }
507
508 Local<JSValueRef> jsVValue = tagged->GetValue(ecmaVm, i);
509 if (jsVKey->IsObject()) {
510 description += "Object";
511 } else if (jsVKey->IsString()) {
512 description += cPre + jsVKey->ToString(ecmaVm)->ToString() + cPre;
513 } else {
514 description += jsVKey->ToString(ecmaVm)->ToString();
515 }
516
517 description += " => ";
518 // add Value
519 if (jsVValue->IsObject()) {
520 description += "Object";
521 } else if (jsVValue->IsString()) {
522 description += cPre + jsVValue->ToString(ecmaVm)->ToString() + cPre;
523 } else {
524 description += jsVValue->ToString(ecmaVm)->ToString();
525 }
526 if (index == tagged->GetSize() - 1 || index >= 4) { // 4:The count of elements
527 description += tagged->GetSize() > 5 ? ", ..." : ""; // 5:The count of elements
528 break;
529 }
530 description += ", ";
531 index++;
532 }
533 description += "}";
534 return description;
535 }
536
DescriptionForWeakMap(const EcmaVM * ecmaVm,Local<WeakMapRef> tagged)537 std::string ObjectRemoteObject::DescriptionForWeakMap(const EcmaVM *ecmaVm, Local<WeakMapRef> tagged)
538 {
539 int32_t len = tagged->GetTotalElements();
540 int32_t index = 0;
541 std::string description = "WeakMap(" + std::to_string(tagged->GetSize()) + ")";
542 if (!len) {
543 return description;
544 }
545 description += " {";
546 char cPre = '\'';
547 for (int32_t i = 0; i < len; ++i) {
548 Local<JSValueRef> jsVKey = tagged->GetKey(ecmaVm, i);
549 if (jsVKey->IsHole()) {
550 continue;
551 }
552 Local<JSValueRef> jsVValue = tagged->GetValue(ecmaVm, i);
553 if (jsVKey->IsObject()) {
554 description += "Object";
555 } else if (jsVKey->IsString()) {
556 description += cPre + jsVKey->ToString(ecmaVm)->ToString() + cPre;
557 } else {
558 description += jsVKey->ToString(ecmaVm)->ToString();
559 }
560
561 description += " => ";
562
563 if (jsVValue->IsObject()) {
564 description += "Object";
565 } else if (jsVValue->IsString()) {
566 description += cPre + jsVValue->ToString(ecmaVm)->ToString() + cPre;
567 } else {
568 description += jsVValue->ToString(ecmaVm)->ToString();
569 }
570 if (index == tagged->GetSize() - 1 || index >= 4) { // 4:The count of elements
571 description += tagged->GetSize() > 5 ? ", ..." : ""; // 5:The count of elements
572 break;
573 }
574 description += ", ";
575 index++;
576 }
577 description += "}";
578 return description;
579 }
580
DescriptionForSet(const EcmaVM * ecmaVm,Local<SetRef> tagged)581 std::string ObjectRemoteObject::DescriptionForSet(const EcmaVM *ecmaVm, Local<SetRef> tagged)
582 {
583 int32_t len = tagged->GetTotalElements();
584 int32_t index = 0;
585 std::string description = ("Set(" + std::to_string(tagged->GetSize()) + ")");
586 if (!len) {
587 return description;
588 }
589 description += " {";
590 char cPre = '\'';
591 for (int32_t i = 0; i < len; ++i) {
592 // add Key
593 Local<JSValueRef> jsValue = tagged->GetValue(ecmaVm, i);
594 if (jsValue->IsHole()) {
595 continue;
596 }
597 // add Value
598 if (jsValue->IsObject()) {
599 description += "Object";
600 } else if (jsValue->IsString()) {
601 description += cPre + jsValue->ToString(ecmaVm)->ToString() + cPre;
602 } else {
603 description += jsValue->ToString(ecmaVm)->ToString();
604 }
605 if (index == tagged->GetSize() - 1 || index >= 4) { // 4:The count of elements
606 description += tagged->GetSize() > 5 ? ", ..." : ""; // 5:The count of elements
607 break;
608 }
609 description += ", ";
610 index++;
611 }
612 description += "}";
613 return description;
614 }
615
DescriptionForWeakSet(const EcmaVM * ecmaVm,Local<WeakSetRef> tagged)616 std::string ObjectRemoteObject::DescriptionForWeakSet(const EcmaVM *ecmaVm, Local<WeakSetRef> tagged)
617 {
618 int32_t len = tagged->GetTotalElements();
619 int32_t index = 0;
620 std::string description = ("WeakSet(" + std::to_string(tagged->GetSize()) + ")");
621 if (!len) {
622 return description;
623 }
624 description += " {";
625 char cPre = '\'';
626 for (int32_t i = 0; i < len; ++i) {
627 Local<JSValueRef> jsValue = tagged->GetValue(ecmaVm, i);
628 if (jsValue->IsHole()) {
629 continue;
630 }
631 if (jsValue->IsObject()) {
632 description += "Object";
633 } else if (jsValue->IsString()) {
634 description += cPre + jsValue->ToString(ecmaVm)->ToString() + cPre;
635 } else {
636 description += jsValue->ToString(ecmaVm)->ToString();
637 }
638 if (index == tagged->GetSize() - 1 || index >= 4) { // 4:The count of elements
639 description += tagged->GetSize() > 5 ? ", ..." : ""; // 5:The count of elements
640 break;
641 }
642 description += ", ";
643 index++;
644 }
645 description += "}";
646 return description;
647 }
648
DescriptionForDataView(Local<DataViewRef> tagged)649 std::string ObjectRemoteObject::DescriptionForDataView(Local<DataViewRef> tagged)
650 {
651 std::string description = ("DataView(" + std::to_string(tagged->ByteLength()) + ")");
652 return description;
653 }
654
DescriptionForError(const EcmaVM * ecmaVm,Local<JSValueRef> tagged)655 std::string ObjectRemoteObject::DescriptionForError(const EcmaVM *ecmaVm, Local<JSValueRef> tagged)
656 {
657 // add name
658 Local<JSValueRef> name = StringRef::NewFromUtf8(ecmaVm, "name");
659 std::string strName = Local<ObjectRef>(tagged)->Get(ecmaVm, name)->ToString(ecmaVm)->ToString();
660 // add message
661 Local<JSValueRef> message = StringRef::NewFromUtf8(ecmaVm, "message");
662 std::string strMessage = Local<ObjectRef>(tagged)->Get(ecmaVm, message)->ToString(ecmaVm)->ToString();
663 if (strMessage.empty()) {
664 return strName;
665 } else {
666 return strName + ": " + strMessage;
667 }
668 }
669
DescriptionForArrayIterator()670 std::string ObjectRemoteObject::DescriptionForArrayIterator()
671 {
672 std::string description = RemoteObject::ArrayIteratorDescription + "{}";
673 return description;
674 }
675
DescriptionForSetIterator()676 std::string ObjectRemoteObject::DescriptionForSetIterator()
677 {
678 std::string description = RemoteObject::SetIteratorDescription + "{}";
679 return description;
680 }
681
DescriptionForMapIterator()682 std::string ObjectRemoteObject::DescriptionForMapIterator()
683 {
684 std::string description = RemoteObject::MapIteratorDescription + "{}";
685 return description;
686 }
687
DescriptionForArrayBuffer(const EcmaVM * ecmaVm,Local<ArrayBufferRef> tagged)688 std::string ObjectRemoteObject::DescriptionForArrayBuffer(const EcmaVM *ecmaVm, Local<ArrayBufferRef> tagged)
689 {
690 int32_t len = tagged->ByteLength(ecmaVm);
691 std::string description = ("ArrayBuffer(" + std::to_string(len) + ")");
692 return description;
693 }
694
DescriptionForSharedArrayBuffer(const EcmaVM * ecmaVm,Local<ArrayBufferRef> tagged)695 std::string ObjectRemoteObject::DescriptionForSharedArrayBuffer(const EcmaVM *ecmaVm, Local<ArrayBufferRef> tagged)
696 {
697 int32_t len = tagged->ByteLength(ecmaVm);
698 std::string description = ("SharedArrayBuffer(" + std::to_string(len) + ")");
699 return description;
700 }
701
DescriptionForUint8Array(const EcmaVM * ecmaVm,Local<TypedArrayRef> tagged)702 std::string ObjectRemoteObject::DescriptionForUint8Array(const EcmaVM *ecmaVm, Local<TypedArrayRef> tagged)
703 {
704 int32_t len = static_cast<int32_t>(tagged->ByteLength(ecmaVm));
705 std::string description = ("Uint8Array(" + std::to_string(len) + ")");
706 return description;
707 }
708
DescriptionForInt8Array(const EcmaVM * ecmaVm,Local<TypedArrayRef> tagged)709 std::string ObjectRemoteObject::DescriptionForInt8Array(const EcmaVM *ecmaVm, Local<TypedArrayRef> tagged)
710 {
711 int32_t len = static_cast<int32_t>(tagged->ByteLength(ecmaVm));
712 std::string description = ("Int8Array(" + std::to_string(len) + ")");
713 return description;
714 }
715
DescriptionForInt16Array(const EcmaVM * ecmaVm,Local<TypedArrayRef> tagged)716 std::string ObjectRemoteObject::DescriptionForInt16Array(const EcmaVM *ecmaVm, Local<TypedArrayRef> tagged)
717 {
718 int32_t len = tagged->ByteLength(ecmaVm) / static_cast<int32_t>(NumberSize::BYTES_OF_16BITS);
719 std::string description = ("Int16Array(" + std::to_string(len) + ")");
720 return description;
721 }
722
DescriptionForInt32Array(const EcmaVM * ecmaVm,Local<TypedArrayRef> tagged)723 std::string ObjectRemoteObject::DescriptionForInt32Array(const EcmaVM *ecmaVm, Local<TypedArrayRef> tagged)
724 {
725 int32_t len = tagged->ByteLength(ecmaVm) / static_cast<int32_t>(NumberSize::BYTES_OF_32BITS);
726 std::string description = ("Int32Array(" + std::to_string(len) + ")");
727 return description;
728 }
729
DescriptionForPrimitiveNumber(const EcmaVM * ecmaVm,const Local<JSValueRef> & tagged)730 std::string ObjectRemoteObject::DescriptionForPrimitiveNumber(const EcmaVM *ecmaVm, const Local<JSValueRef> &tagged)
731 {
732 std::string strValue = tagged->ToString(ecmaVm)->ToString();
733 std::string description = RemoteObject::JSPrimitiveNumberDescription + "{[[PrimitiveValue]]: " + strValue + "}";
734 return description;
735 }
736
DescriptionForPrimitiveString(const EcmaVM * ecmaVm,const Local<JSValueRef> & tagged)737 std::string ObjectRemoteObject::DescriptionForPrimitiveString(const EcmaVM *ecmaVm, const Local<JSValueRef> &tagged)
738 {
739 std::string strValue = tagged->ToString(ecmaVm)->ToString();
740 std::string description = RemoteObject::JSPrimitiveStringDescription + "{[[PrimitiveValue]]: " + strValue + "}";
741 return description;
742 }
743
DescriptionForPrimitiveBoolean(const EcmaVM * ecmaVm,const Local<JSValueRef> & tagged)744 std::string ObjectRemoteObject::DescriptionForPrimitiveBoolean(const EcmaVM *ecmaVm, const Local<JSValueRef> &tagged)
745 {
746 std::string strValue = tagged->ToString(ecmaVm)->ToString();
747 std::string description = RemoteObject::JSPrimitiveBooleanDescription + "{[[PrimitiveValue]]: " + strValue + "}";
748 return description;
749 }
750
DescriptionForGeneratorObject(const EcmaVM * ecmaVm,const Local<JSValueRef> & tagged)751 std::string ObjectRemoteObject::DescriptionForGeneratorObject(const EcmaVM *ecmaVm, const Local<JSValueRef> &tagged)
752 {
753 Local<GeneratorObjectRef> genObjectRef = tagged->ToObject(ecmaVm);
754 // add Status
755 Local<JSValueRef> jsValueRef = genObjectRef->GetGeneratorState(ecmaVm);
756 std::string strState = genObjectRef->GetGeneratorState(ecmaVm)->ToString(ecmaVm)->ToString();
757 // add FuncName
758 jsValueRef = genObjectRef->GetGeneratorFunction(ecmaVm);
759 Local<JSValueRef> name = StringRef::NewFromUtf8(ecmaVm, "name");
760 std::string strFuncName = Local<ObjectRef>(jsValueRef)->Get(ecmaVm, name)->ToString(ecmaVm)->ToString();
761
762 std::string description = strFuncName + " {<" + strState + ">}";
763 return description;
764 }
765
DescriptionForWeakRef()766 std::string ObjectRemoteObject::DescriptionForWeakRef()
767 {
768 std::string description = RemoteObject::WeakRefDescription + " {}";
769 return description;
770 }
771
DescriptionForDateTimeFormat()772 std::string ObjectRemoteObject::DescriptionForDateTimeFormat()
773 {
774 std::string description = RemoteObject::DateTimeFormatDescription + " {}";
775 return description;
776 }
777
DescriptionForNumberFormat()778 std::string ObjectRemoteObject::DescriptionForNumberFormat()
779 {
780 std::string description = RemoteObject::NumberFormatDescription + " {}";
781 return description;
782 }
783
DescriptionForCollator()784 std::string ObjectRemoteObject::DescriptionForCollator()
785 {
786 std::string description = RemoteObject::CollatorDescription + " {}";
787 return description;
788 }
789
DescriptionForPluralRules()790 std::string ObjectRemoteObject::DescriptionForPluralRules()
791 {
792 std::string description = RemoteObject::PluralRulesDescription + " {}";
793 return description;
794 }
795
DescriptionForJSLocale()796 std::string ObjectRemoteObject::DescriptionForJSLocale()
797 {
798 std::string description = RemoteObject::JSLocaleDescription + " {}";
799 return description;
800 }
801
DescriptionForJSRelativeTimeFormat()802 std::string ObjectRemoteObject::DescriptionForJSRelativeTimeFormat()
803 {
804 std::string description = RemoteObject::JSRelativeTimeFormatDescription + " {}";
805 return description;
806 }
807
DescriptionForJSListFormat()808 std::string ObjectRemoteObject::DescriptionForJSListFormat()
809 {
810 std::string description = RemoteObject::JSListFormatDescription + " {}";
811 return description;
812 }
813
DescriptionForArrayList()814 std::string ObjectRemoteObject::DescriptionForArrayList()
815 {
816 std::string description = "ArrayList";
817 return description;
818 }
819
DescriptionForDeque()820 std::string ObjectRemoteObject::DescriptionForDeque()
821 {
822 std::string description = "Deque";
823 return description;
824 }
825
DescriptionForHashMap()826 std::string ObjectRemoteObject::DescriptionForHashMap()
827 {
828 std::string description = "HashMap";
829 return description;
830 }
831
DescriptionForHashSet()832 std::string ObjectRemoteObject::DescriptionForHashSet()
833 {
834 std::string description = "HashSet";
835 return description;
836 }
837
DescriptionForLightWeightMap()838 std::string ObjectRemoteObject::DescriptionForLightWeightMap()
839 {
840 std::string description = "LightWeightMap";
841 return description;
842 }
843
DescriptionForLightWeightSet()844 std::string ObjectRemoteObject::DescriptionForLightWeightSet()
845 {
846 std::string description = "LightWeightSet";
847 return description;
848 }
849
DescriptionForLinkedList()850 std::string ObjectRemoteObject::DescriptionForLinkedList()
851 {
852 std::string description = "LinkedList";
853 return description;
854 }
855
DescriptionForList()856 std::string ObjectRemoteObject::DescriptionForList()
857 {
858 std::string description = "List";
859 return description;
860 }
861
DescriptionForPlainArray()862 std::string ObjectRemoteObject::DescriptionForPlainArray()
863 {
864 std::string description = "PlainArray";
865 return description;
866 }
867
DescriptionForQueue()868 std::string ObjectRemoteObject::DescriptionForQueue()
869 {
870 std::string description = "Queue";
871 return description;
872 }
873
DescriptionForStack()874 std::string ObjectRemoteObject::DescriptionForStack()
875 {
876 std::string description = "Stack";
877 return description;
878 }
879
DescriptionForTreeMap()880 std::string ObjectRemoteObject::DescriptionForTreeMap()
881 {
882 std::string description = "TreeMap";
883 return description;
884 }
885
DescriptionForTreeSet()886 std::string ObjectRemoteObject::DescriptionForTreeSet()
887 {
888 std::string description = "TreeSet";
889 return description;
890 }
891
DescriptionForVector()892 std::string ObjectRemoteObject::DescriptionForVector()
893 {
894 std::string description = "Vector";
895 return description;
896 }
897
DescriptionForSymbol(const EcmaVM * ecmaVm,Local<SymbolRef> tagged) const898 std::string SymbolRemoteObject::DescriptionForSymbol(const EcmaVM *ecmaVm, Local<SymbolRef> tagged) const
899 {
900 std::string description = "Symbol(" + tagged->GetDescription(ecmaVm)->ToString() + ")";
901 return description;
902 }
903
DescriptionForFunction(const EcmaVM * ecmaVm,Local<FunctionRef> tagged) const904 std::string FunctionRemoteObject::DescriptionForFunction(const EcmaVM *ecmaVm, Local<FunctionRef> tagged) const
905 {
906 std::string sourceCode;
907 if (tagged->IsNative(ecmaVm)) {
908 sourceCode = "[native code]";
909 } else {
910 sourceCode = "[js code]";
911 }
912 Local<StringRef> name = tagged->GetName(ecmaVm);
913 std::string description = "function " + name->ToString() + "( { " + sourceCode + " }";
914 return description;
915 }
916
DescriptionForGeneratorFunction(const EcmaVM * ecmaVm,Local<FunctionRef> tagged) const917 std::string GeneratorFunctionRemoteObject::DescriptionForGeneratorFunction(const EcmaVM *ecmaVm,
918 Local<FunctionRef> tagged) const
919 {
920 std::string sourceCode;
921 if (tagged->IsNative(ecmaVm)) {
922 sourceCode = "[native code]";
923 } else {
924 sourceCode = "[js code]";
925 }
926 Local<StringRef> name = tagged->GetName(ecmaVm);
927 std::string description = "function* " + name->ToString() + "( { " + sourceCode + " }";
928 return description;
929 }
930
Create(const PtJson & params)931 std::unique_ptr<RemoteObject> RemoteObject::Create(const PtJson ¶ms)
932 {
933 std::string error;
934 auto remoteObject = std::make_unique<RemoteObject>();
935 Result ret;
936
937 std::string type;
938 ret = params.GetString("type", &type);
939 if (ret == Result::SUCCESS) {
940 if (ObjectType::Valid(type)) {
941 remoteObject->type_ = std::move(type);
942 } else {
943 error += "'type' is invalid;";
944 }
945 } else {
946 error += "Unknown 'type';";
947 }
948
949 std::string subType;
950 ret = params.GetString("subtype", &subType);
951 if (ret == Result::SUCCESS) {
952 if (ObjectSubType::Valid(subType)) {
953 remoteObject->subType_ = std::move(subType);
954 } else {
955 error += "'subtype' is invalid;";
956 }
957 } else if (ret == Result::TYPE_ERROR) {
958 error += "Unknown 'subtype';";
959 }
960
961 std::string className;
962 ret = params.GetString("className", &className);
963 if (ret == Result::SUCCESS) {
964 remoteObject->className_ = std::move(className);
965 } else if (ret == Result::TYPE_ERROR) {
966 error += "Unknown 'className';";
967 }
968
969 std::string unserializableValue;
970 ret = params.GetString("unserializableValue", &unserializableValue);
971 if (ret == Result::SUCCESS) {
972 remoteObject->unserializableValue_ = std::move(unserializableValue);
973 } else if (ret == Result::TYPE_ERROR) {
974 error += "Unknown 'unserializableValue';";
975 }
976
977 std::string description;
978 ret = params.GetString("description", &description);
979 if (ret == Result::SUCCESS) {
980 remoteObject->description_ = std::move(description);
981 } else if (ret == Result::TYPE_ERROR) {
982 error += "Unknown 'description';";
983 }
984
985 std::string objectId;
986 ret = params.GetString("objectId", &objectId);
987 if (ret == Result::SUCCESS) {
988 remoteObject->objectId_ = std::stoi(objectId);
989 } else if (ret == Result::TYPE_ERROR) {
990 error += "Unknown 'objectId';";
991 }
992
993 if (!error.empty()) {
994 LOG_DEBUGGER(ERROR) << "RemoteObject::Create " << error;
995 return nullptr;
996 }
997
998 return remoteObject;
999 }
1000
ToJson() const1001 std::unique_ptr<PtJson> RemoteObject::ToJson() const
1002 {
1003 std::unique_ptr<PtJson> result = PtJson::CreateObject();
1004
1005 result->Add("type", type_.c_str());
1006 if (subType_) {
1007 result->Add("subtype", subType_->c_str());
1008 }
1009 if (className_) {
1010 result->Add("className", className_->c_str());
1011 }
1012 if (unserializableValue_) {
1013 result->Add("unserializableValue", unserializableValue_->c_str());
1014 }
1015 if (description_) {
1016 result->Add("description", description_->c_str());
1017 }
1018 if (objectId_) {
1019 result->Add("objectId", std::to_string(objectId_.value()).c_str());
1020 }
1021
1022 return result;
1023 }
1024
Create(const PtJson & params)1025 std::unique_ptr<ExceptionDetails> ExceptionDetails::Create(const PtJson ¶ms)
1026 {
1027 std::string error;
1028 auto exceptionDetails = std::make_unique<ExceptionDetails>();
1029 Result ret;
1030
1031 int32_t exceptionId;
1032 ret = params.GetInt("exceptionId", &exceptionId);
1033 if (ret == Result::SUCCESS) {
1034 exceptionDetails->exceptionId_ = exceptionId;
1035 } else {
1036 error += "Unknown 'exceptionId';";
1037 }
1038
1039 std::string text;
1040 ret = params.GetString("text", &text);
1041 if (ret == Result::SUCCESS) {
1042 exceptionDetails->text_ = std::move(text);
1043 } else {
1044 error += "Unknown 'text';";
1045 }
1046
1047 int32_t lineNumber;
1048 ret = params.GetInt("lineNumber", &lineNumber);
1049 if (ret == Result::SUCCESS) {
1050 exceptionDetails->lineNumber_ = lineNumber;
1051 } else {
1052 error += "Unknown 'lineNumber';";
1053 }
1054
1055 int32_t columnNumber;
1056 ret = params.GetInt("columnNumber", &columnNumber);
1057 if (ret == Result::SUCCESS) {
1058 exceptionDetails->columnNumber_ = columnNumber;
1059 } else {
1060 error += "Unknown 'columnNumber';";
1061 }
1062
1063 std::string scriptId;
1064 ret = params.GetString("scriptId", &scriptId);
1065 if (ret == Result::SUCCESS) {
1066 exceptionDetails->scriptId_ = std::stoi(scriptId);
1067 } else if (ret == Result::TYPE_ERROR) {
1068 error += "Unknown 'scriptId';";
1069 }
1070
1071 std::string url;
1072 ret = params.GetString("url", &url);
1073 if (ret == Result::SUCCESS) {
1074 exceptionDetails->url_ = std::move(url);
1075 } else if (ret == Result::TYPE_ERROR) {
1076 error += "Unknown 'url';";
1077 }
1078
1079 std::unique_ptr<PtJson> exception;
1080 ret = params.GetObject("exception", &exception);
1081 if (ret == Result::SUCCESS) {
1082 std::unique_ptr<RemoteObject> obj = RemoteObject::Create(*exception);
1083 if (obj == nullptr) {
1084 error += "'exception' format error;";
1085 } else {
1086 exceptionDetails->exception_ = std::move(obj);
1087 }
1088 } else if (ret == Result::TYPE_ERROR) {
1089 error += "Unknown 'exception';";
1090 }
1091
1092 int32_t executionContextId;
1093 ret = params.GetInt("executionContextId", &executionContextId);
1094 if (ret == Result::SUCCESS) {
1095 exceptionDetails->executionContextId_ = executionContextId;
1096 } else if (ret == Result::TYPE_ERROR) {
1097 error += "Unknown 'executionContextId';";
1098 }
1099
1100 if (!error.empty()) {
1101 LOG_DEBUGGER(ERROR) << "ExceptionDetails::Create " << error;
1102 return nullptr;
1103 }
1104
1105 return exceptionDetails;
1106 }
1107
ToJson() const1108 std::unique_ptr<PtJson> ExceptionDetails::ToJson() const
1109 {
1110 std::unique_ptr<PtJson> result = PtJson::CreateObject();
1111
1112 result->Add("exceptionId", exceptionId_);
1113 result->Add("text", text_.c_str());
1114 result->Add("lineNumber", lineNumber_);
1115 result->Add("columnNumber", columnNumber_);
1116
1117 if (scriptId_) {
1118 result->Add("scriptId", std::to_string(scriptId_.value()).c_str());
1119 }
1120 if (url_) {
1121 result->Add("url", url_->c_str());
1122 }
1123 if (exception_) {
1124 ASSERT(exception_.value() != nullptr);
1125 result->Add("exception", exception_.value()->ToJson());
1126 }
1127 if (executionContextId_) {
1128 result->Add("executionContextId", executionContextId_.value());
1129 }
1130
1131 return result;
1132 }
1133
Create(const PtJson & params)1134 std::unique_ptr<InternalPropertyDescriptor> InternalPropertyDescriptor::Create(const PtJson ¶ms)
1135 {
1136 std::string error;
1137 auto internalPropertyDescriptor = std::make_unique<InternalPropertyDescriptor>();
1138 Result ret;
1139
1140 std::string name;
1141 ret = params.GetString("name", &name);
1142 if (ret == Result::SUCCESS) {
1143 internalPropertyDescriptor->name_ = std::move(name);
1144 } else {
1145 error += "Unknown 'name';";
1146 }
1147
1148 std::unique_ptr<PtJson> value;
1149 ret = params.GetObject("value", &value);
1150 if (ret == Result::SUCCESS) {
1151 std::unique_ptr<RemoteObject> obj = RemoteObject::Create(*value);
1152 if (obj == nullptr) {
1153 error += "'value' format error;";
1154 } else {
1155 internalPropertyDescriptor->value_ = std::move(obj);
1156 }
1157 } else if (ret == Result::TYPE_ERROR) {
1158 error += "Unknown 'value';";
1159 }
1160
1161 if (!error.empty()) {
1162 LOG_DEBUGGER(ERROR) << "InternalPropertyDescriptor::Create " << error;
1163 return nullptr;
1164 }
1165
1166 return internalPropertyDescriptor;
1167 }
1168
ToJson() const1169 std::unique_ptr<PtJson> InternalPropertyDescriptor::ToJson() const
1170 {
1171 std::unique_ptr<PtJson> result = PtJson::CreateObject();
1172
1173 result->Add("name", name_.c_str());
1174 if (value_) {
1175 ASSERT(value_.value() != nullptr);
1176 result->Add("value", value_.value()->ToJson());
1177 }
1178
1179 return result;
1180 }
1181
Create(const PtJson & params)1182 std::unique_ptr<PrivatePropertyDescriptor> PrivatePropertyDescriptor::Create(const PtJson ¶ms)
1183 {
1184 std::string error;
1185 auto privatePropertyDescriptor = std::make_unique<PrivatePropertyDescriptor>();
1186 Result ret;
1187
1188 std::string name;
1189 ret = params.GetString("name", &name);
1190 if (ret == Result::SUCCESS) {
1191 privatePropertyDescriptor->name_ = std::move(name);
1192 } else {
1193 error += "Unknown 'name';";
1194 }
1195
1196 std::unique_ptr<PtJson> value;
1197 ret = params.GetObject("value", &value);
1198 std::unique_ptr<RemoteObject> obj;
1199 if (ret == Result::SUCCESS) {
1200 obj = RemoteObject::Create(*value);
1201 if (obj == nullptr) {
1202 error += "'value' format error;";
1203 } else {
1204 privatePropertyDescriptor->value_ = std::move(obj);
1205 }
1206 } else if (ret == Result::TYPE_ERROR) {
1207 error += "Unknown 'value';";
1208 }
1209
1210 std::unique_ptr<PtJson> get;
1211 ret = params.GetObject("get", &get);
1212 if (ret == Result::SUCCESS) {
1213 obj = RemoteObject::Create(*get);
1214 if (obj == nullptr) {
1215 error += "'get' format error;";
1216 } else {
1217 privatePropertyDescriptor->get_ = std::move(obj);
1218 }
1219 } else if (ret == Result::TYPE_ERROR) {
1220 error += "Unknown 'get';";
1221 }
1222
1223 std::unique_ptr<PtJson> set;
1224 ret = params.GetObject("set", &set);
1225 if (ret == Result::SUCCESS) {
1226 obj = RemoteObject::Create(*set);
1227 if (obj == nullptr) {
1228 error += "'set' format error;";
1229 } else {
1230 privatePropertyDescriptor->set_ = std::move(obj);
1231 }
1232 } else if (ret == Result::TYPE_ERROR) {
1233 error += "Unknown 'set';";
1234 }
1235
1236 if (!error.empty()) {
1237 LOG_DEBUGGER(ERROR) << "PrivatePropertyDescriptor::Create " << error;
1238 return nullptr;
1239 }
1240
1241 return privatePropertyDescriptor;
1242 }
1243
ToJson() const1244 std::unique_ptr<PtJson> PrivatePropertyDescriptor::ToJson() const
1245 {
1246 std::unique_ptr<PtJson> result = PtJson::CreateObject();
1247
1248 result->Add("name", name_.c_str());
1249 if (value_) {
1250 ASSERT(value_.value() != nullptr);
1251 result->Add("value", value_.value()->ToJson());
1252 }
1253 if (get_) {
1254 ASSERT(get_.value() != nullptr);
1255 result->Add("get", get_.value()->ToJson());
1256 }
1257 if (set_) {
1258 ASSERT(set_.value() != nullptr);
1259 result->Add("set", set_.value()->ToJson());
1260 }
1261
1262 return result;
1263 }
1264
FromProperty(const EcmaVM * ecmaVm,Local<JSValueRef> name,const PropertyAttribute & property)1265 std::unique_ptr<PropertyDescriptor> PropertyDescriptor::FromProperty(const EcmaVM *ecmaVm,
1266 Local<JSValueRef> name, const PropertyAttribute &property)
1267 {
1268 std::unique_ptr<PropertyDescriptor> debuggerProperty = std::make_unique<PropertyDescriptor>();
1269
1270 std::string nameStr;
1271 if (name->IsSymbol()) {
1272 Local<SymbolRef> symbol(name);
1273 nameStr = "Symbol(" + Local<SymbolRef>(name)->GetDescription(ecmaVm)->ToString() + ")";
1274 debuggerProperty->symbol_ = RemoteObject::FromTagged(ecmaVm, name);
1275 } else {
1276 nameStr = name->ToString(ecmaVm)->ToString();
1277 }
1278
1279 debuggerProperty->name_ = nameStr;
1280 if (property.HasValue()) {
1281 debuggerProperty->value_ = RemoteObject::FromTagged(ecmaVm, property.GetValue(ecmaVm));
1282 }
1283 if (property.HasWritable()) {
1284 debuggerProperty->writable_ = property.IsWritable();
1285 }
1286 if (property.HasGetter()) {
1287 debuggerProperty->get_ = RemoteObject::FromTagged(ecmaVm, property.GetGetter(ecmaVm));
1288 }
1289 if (property.HasSetter()) {
1290 debuggerProperty->set_ = RemoteObject::FromTagged(ecmaVm, property.GetSetter(ecmaVm));
1291 }
1292 debuggerProperty->configurable_ = property.IsConfigurable();
1293 debuggerProperty->enumerable_ = property.IsEnumerable();
1294 debuggerProperty->isOwn_ = true;
1295
1296 return debuggerProperty;
1297 }
1298
Create(const PtJson & params)1299 std::unique_ptr<PropertyDescriptor> PropertyDescriptor::Create(const PtJson ¶ms)
1300 {
1301 std::string error;
1302 auto propertyDescriptor = std::make_unique<PropertyDescriptor>();
1303 Result ret;
1304
1305 std::string name;
1306 ret = params.GetString("name", &name);
1307 if (ret == Result::SUCCESS) {
1308 propertyDescriptor->name_ = std::move(name);
1309 } else {
1310 error += "Unknown 'name';";
1311 }
1312
1313 std::unique_ptr<PtJson> value;
1314 std::unique_ptr<RemoteObject> obj;
1315 ret = params.GetObject("value", &value);
1316 if (ret == Result::SUCCESS) {
1317 obj = RemoteObject::Create(*value);
1318 if (obj == nullptr) {
1319 error += "'value' format error;";
1320 } else {
1321 propertyDescriptor->value_ = std::move(obj);
1322 }
1323 } else if (ret == Result::TYPE_ERROR) {
1324 error += "Unknown 'value';";
1325 }
1326
1327 bool writable = false;
1328 ret = params.GetBool("writable", &writable);
1329 if (ret == Result::SUCCESS) {
1330 propertyDescriptor->writable_ = writable;
1331 } else if (ret == Result::TYPE_ERROR) {
1332 error += "Unknown 'writable';";
1333 }
1334
1335 std::unique_ptr<PtJson> get;
1336 ret = params.GetObject("get", &get);
1337 if (ret == Result::SUCCESS) {
1338 obj = RemoteObject::Create(*get);
1339 if (obj == nullptr) {
1340 error += "'get' format error;";
1341 } else {
1342 propertyDescriptor->get_ = std::move(obj);
1343 }
1344 } else if (ret == Result::TYPE_ERROR) {
1345 error += "Unknown 'get';";
1346 }
1347
1348 std::unique_ptr<PtJson> set;
1349 ret = params.GetObject("set", &set);
1350 if (ret == Result::SUCCESS) {
1351 obj = RemoteObject::Create(*set);
1352 if (obj == nullptr) {
1353 error += "'set' format error;";
1354 } else {
1355 propertyDescriptor->set_ = std::move(obj);
1356 }
1357 } else if (ret == Result::TYPE_ERROR) {
1358 error += "Unknown 'set';";
1359 }
1360
1361 bool configurable = false;
1362 ret = params.GetBool("configurable", &configurable);
1363 if (ret == Result::SUCCESS) {
1364 propertyDescriptor->configurable_ = configurable;
1365 } else if (ret == Result::TYPE_ERROR) {
1366 error += "Unknown 'configurable';";
1367 }
1368
1369 bool enumerable = false;
1370 ret = params.GetBool("enumerable", &enumerable);
1371 if (ret == Result::SUCCESS) {
1372 propertyDescriptor->enumerable_ = enumerable;
1373 } else if (ret == Result::TYPE_ERROR) {
1374 error += "Unknown 'enumerable';";
1375 }
1376
1377 bool wasThrown = false;
1378 ret = params.GetBool("wasThrown", &wasThrown);
1379 if (ret == Result::SUCCESS) {
1380 propertyDescriptor->wasThrown_ = wasThrown;
1381 } else if (ret == Result::TYPE_ERROR) {
1382 error += "Unknown 'wasThrown';";
1383 }
1384
1385 bool isOwn = false;
1386 ret = params.GetBool("isOwn", &isOwn);
1387 if (ret == Result::SUCCESS) {
1388 propertyDescriptor->isOwn_ = isOwn;
1389 } else if (ret == Result::TYPE_ERROR) {
1390 error += "Unknown 'isOwn';";
1391 }
1392
1393 std::unique_ptr<PtJson> symbol;
1394 ret = params.GetObject("symbol", &symbol);
1395 if (ret == Result::SUCCESS) {
1396 obj = RemoteObject::Create(*symbol);
1397 if (obj == nullptr) {
1398 error += "'symbol' format error;";
1399 } else {
1400 propertyDescriptor->symbol_ = std::move(obj);
1401 }
1402 } else if (ret == Result::TYPE_ERROR) {
1403 error += "Unknown 'symbol';";
1404 }
1405
1406 if (!error.empty()) {
1407 LOG_DEBUGGER(ERROR) << "PropertyDescriptor::Create " << error;
1408 return nullptr;
1409 }
1410
1411 return propertyDescriptor;
1412 }
1413
ToJson() const1414 std::unique_ptr<PtJson> PropertyDescriptor::ToJson() const
1415 {
1416 std::unique_ptr<PtJson> result = PtJson::CreateObject();
1417
1418 result->Add("name", name_.c_str());
1419 if (value_) {
1420 ASSERT(value_.value() != nullptr);
1421 result->Add("value", value_.value()->ToJson());
1422 }
1423 if (writable_) {
1424 result->Add("writable", writable_.value());
1425 }
1426 if (get_) {
1427 ASSERT(get_.value() != nullptr);
1428 result->Add("get", get_.value()->ToJson());
1429 }
1430 if (set_) {
1431 ASSERT(set_.value() != nullptr);
1432 result->Add("set", set_.value()->ToJson());
1433 }
1434 result->Add("configurable", configurable_);
1435 result->Add("enumerable", enumerable_);
1436 if (wasThrown_) {
1437 result->Add("wasThrown", wasThrown_.value());
1438 }
1439 if (isOwn_) {
1440 result->Add("isOwn", isOwn_.value());
1441 }
1442 if (symbol_) {
1443 ASSERT(symbol_.value() != nullptr);
1444 result->Add("symbol", symbol_.value()->ToJson());
1445 }
1446
1447 return result;
1448 }
1449
Create(const PtJson & params)1450 std::unique_ptr<CallArgument> CallArgument::Create(const PtJson ¶ms)
1451 {
1452 auto callArgument = std::make_unique<CallArgument>();
1453 std::string error;
1454 Result ret;
1455
1456 std::string unserializableValue;
1457 ret = params.GetString("unserializableValue", &unserializableValue);
1458 if (ret == Result::SUCCESS) {
1459 callArgument->unserializableValue_ = std::move(unserializableValue);
1460 } else if (ret == Result::TYPE_ERROR) { // optional value
1461 error += "Unknown 'unserializableValue';";
1462 }
1463 std::string objectId;
1464 ret = params.GetString("objectId", &objectId);
1465 if (ret == Result::SUCCESS) {
1466 callArgument->objectId_ = std::stoi(objectId);
1467 } else if (ret == Result::TYPE_ERROR) { // optional value
1468 error += "Unknown 'objectId';";
1469 }
1470
1471 if (!error.empty()) {
1472 LOG_DEBUGGER(ERROR) << "CallArgument::Create " << error;
1473 return nullptr;
1474 }
1475
1476 return callArgument;
1477 }
1478
ToJson() const1479 std::unique_ptr<PtJson> CallArgument::ToJson() const
1480 {
1481 std::unique_ptr<PtJson> result = PtJson::CreateObject();
1482
1483 if (unserializableValue_) {
1484 result->Add("unserializableValue", unserializableValue_->c_str());
1485 }
1486 if (objectId_) {
1487 result->Add("objectId", std::to_string(objectId_.value()).c_str());
1488 }
1489
1490 return result;
1491 }
1492
Create(const PtJson & params)1493 std::unique_ptr<Location> Location::Create(const PtJson ¶ms)
1494 {
1495 auto location = std::make_unique<Location>();
1496 std::string error;
1497 Result ret;
1498
1499 std::string scriptId;
1500 ret = params.GetString("scriptId", &scriptId);
1501 if (ret == Result::SUCCESS) {
1502 location->scriptId_ = std::stoi(scriptId);
1503 } else {
1504 error += "Unknown 'scriptId';";
1505 }
1506 int32_t lineNumber;
1507 ret = params.GetInt("lineNumber", &lineNumber);
1508 if (ret == Result::SUCCESS) {
1509 location->lineNumber_ = lineNumber;
1510 } else {
1511 error += "Unknown 'lineNumber';";
1512 }
1513 int32_t columnNumber;
1514 ret = params.GetInt("columnNumber", &columnNumber);
1515 if (ret == Result::SUCCESS) {
1516 location->columnNumber_ = columnNumber;
1517 } else if (ret == Result::TYPE_ERROR) { // optional value
1518 error += "Unknown 'columnNumber';";
1519 }
1520
1521 if (!error.empty()) {
1522 LOG_DEBUGGER(ERROR) << "Location::Create " << error;
1523 return nullptr;
1524 }
1525
1526 return location;
1527 }
1528
ToJson() const1529 std::unique_ptr<PtJson> Location::ToJson() const
1530 {
1531 std::unique_ptr<PtJson> result = PtJson::CreateObject();
1532
1533 result->Add("scriptId", std::to_string(scriptId_).c_str());
1534 result->Add("lineNumber", lineNumber_);
1535 if (columnNumber_) {
1536 result->Add("columnNumber", columnNumber_.value());
1537 }
1538
1539 return result;
1540 }
1541
Create(const PtJson & params)1542 std::unique_ptr<ScriptPosition> ScriptPosition::Create(const PtJson ¶ms)
1543 {
1544 auto scriptPosition = std::make_unique<ScriptPosition>();
1545 std::string error;
1546 Result ret;
1547
1548 int32_t lineNumber;
1549 ret = params.GetInt("lineNumber", &lineNumber);
1550 if (ret == Result::SUCCESS) {
1551 scriptPosition->lineNumber_ = lineNumber;
1552 } else {
1553 error += "Unknown 'lineNumber';";
1554 }
1555 int32_t columnNumber;
1556 ret = params.GetInt("columnNumber", &columnNumber);
1557 if (ret == Result::SUCCESS) {
1558 scriptPosition->columnNumber_ = columnNumber;
1559 } else {
1560 error += "Unknown 'columnNumber';";
1561 }
1562
1563 if (!error.empty()) {
1564 LOG_DEBUGGER(ERROR) << "ScriptPosition::Create " << error;
1565 return nullptr;
1566 }
1567
1568 return scriptPosition;
1569 }
1570
ToJson() const1571 std::unique_ptr<PtJson> ScriptPosition::ToJson() const
1572 {
1573 std::unique_ptr<PtJson> result = PtJson::CreateObject();
1574
1575 result->Add("lineNumber", lineNumber_);
1576 result->Add("columnNumber", columnNumber_);
1577
1578 return result;
1579 }
1580
Create(const PtJson & params)1581 std::unique_ptr<SearchMatch> SearchMatch::Create(const PtJson ¶ms)
1582 {
1583 std::string error;
1584 auto locationSearch = std::make_unique<SearchMatch>();
1585 Result ret;
1586
1587 int32_t lineNumber;
1588 ret = params.GetInt("lineNumber", &lineNumber);
1589 if (ret == Result::SUCCESS) {
1590 locationSearch->lineNumber_ = lineNumber;
1591 } else {
1592 error += "Unknown 'lineNumber';";
1593 }
1594
1595 std::string lineContent;
1596 ret = params.GetString("lineContent", &lineContent);
1597 if (ret == Result::SUCCESS) {
1598 locationSearch->lineContent_ = std::move(lineContent);
1599 } else {
1600 error += "Unknown 'lineContent';";
1601 }
1602
1603 if (!error.empty()) {
1604 LOG_DEBUGGER(ERROR) << "SearchMatch::Create " << error;
1605 return nullptr;
1606 }
1607
1608 return locationSearch;
1609 }
1610
ToJson() const1611 std::unique_ptr<PtJson> SearchMatch::ToJson() const
1612 {
1613 std::unique_ptr<PtJson> result = PtJson::CreateObject();
1614
1615 result->Add("lineNumber", lineNumber_);
1616 result->Add("lineContent", lineContent_.c_str());
1617
1618 return result;
1619 }
1620
Create(const PtJson & params)1621 std::unique_ptr<LocationRange> LocationRange::Create(const PtJson ¶ms)
1622 {
1623 std::string error;
1624 auto locationRange = std::make_unique<LocationRange>();
1625 Result ret;
1626
1627 std::string scriptId;
1628 ret = params.GetString("scriptId", &scriptId);
1629 if (ret == Result::SUCCESS) {
1630 locationRange->scriptId_ = std::stoi(scriptId);
1631 } else {
1632 error += "Unknown 'scriptId';";
1633 }
1634
1635 std::unique_ptr<PtJson> start;
1636 std::unique_ptr<ScriptPosition> obj;
1637 ret = params.GetObject("start", &start);
1638 if (ret == Result::SUCCESS) {
1639 obj = ScriptPosition::Create(*start);
1640 if (obj == nullptr) {
1641 error += "'start' format error;";
1642 } else {
1643 locationRange->start_ = std::move(obj);
1644 }
1645 } else {
1646 error += "Unknown 'start';";
1647 }
1648
1649 std::unique_ptr<PtJson> end;
1650 ret = params.GetObject("end", &end);
1651 if (ret == Result::SUCCESS) {
1652 obj = ScriptPosition::Create(*end);
1653 if (obj == nullptr) {
1654 error += "'end' format error;";
1655 } else {
1656 locationRange->end_ = std::move(obj);
1657 }
1658 } else {
1659 error += "Unknown 'end';";
1660 }
1661
1662 if (!error.empty()) {
1663 LOG_DEBUGGER(ERROR) << "LocationRange::Create " << error;
1664 return nullptr;
1665 }
1666
1667 return locationRange;
1668 }
1669
ToJson() const1670 std::unique_ptr<PtJson> LocationRange::ToJson() const
1671 {
1672 std::unique_ptr<PtJson> result = PtJson::CreateObject();
1673
1674 result->Add("scriptId", std::to_string(scriptId_).c_str());
1675 ASSERT(start_ != nullptr);
1676 result->Add("start", start_->ToJson());
1677 ASSERT(end_ != nullptr);
1678 result->Add("end", end_->ToJson());
1679
1680 return result;
1681 }
1682
Create(const PtJson & params)1683 std::unique_ptr<BreakLocation> BreakLocation::Create(const PtJson ¶ms)
1684 {
1685 std::string error;
1686 auto breakLocation = std::make_unique<BreakLocation>();
1687 Result ret;
1688
1689 std::string scriptId;
1690 ret = params.GetString("scriptId", &scriptId);
1691 if (ret == Result::SUCCESS) {
1692 breakLocation->scriptId_ = std::stoi(scriptId);
1693 } else {
1694 error += "Unknown 'scriptId';";
1695 }
1696
1697 int32_t lineNumber;
1698 ret = params.GetInt("lineNumber", &lineNumber);
1699 if (ret == Result::SUCCESS) {
1700 breakLocation->lineNumber_ = lineNumber;
1701 } else {
1702 error += "Unknown 'lineNumber';";
1703 }
1704
1705 int32_t columnNumber;
1706 ret = params.GetInt("columnNumber", &columnNumber);
1707 if (ret == Result::SUCCESS) {
1708 breakLocation->columnNumber_ = columnNumber;
1709 } else if (ret == Result::TYPE_ERROR) {
1710 error += "Unknown 'columnNumber';";
1711 }
1712
1713 std::string type;
1714 ret = params.GetString("type", &type);
1715 if (ret == Result::SUCCESS) {
1716 if (BreakType::Valid(type)) {
1717 breakLocation->type_ = std::move(type);
1718 } else {
1719 error += "'type' is invalid;";
1720 }
1721 } else if (ret == Result::TYPE_ERROR) {
1722 error += "type 'scriptId';";
1723 }
1724
1725 if (!error.empty()) {
1726 LOG_DEBUGGER(ERROR) << "Location::Create " << error;
1727 return nullptr;
1728 }
1729
1730 return breakLocation;
1731 }
1732
ToJson() const1733 std::unique_ptr<PtJson> BreakLocation::ToJson() const
1734 {
1735 std::unique_ptr<PtJson> result = PtJson::CreateObject();
1736
1737 result->Add("scriptId", std::to_string(scriptId_).c_str());
1738 result->Add("lineNumber", lineNumber_);
1739 if (columnNumber_) {
1740 result->Add("columnNumber", columnNumber_.value());
1741 }
1742 if (type_) {
1743 result->Add("type", type_->c_str());
1744 }
1745
1746 return result;
1747 }
1748
Create(const PtJson & params)1749 std::unique_ptr<Scope> Scope::Create(const PtJson ¶ms)
1750 {
1751 std::string error;
1752 auto scope = std::make_unique<Scope>();
1753 Result ret;
1754
1755 std::string type;
1756 ret = params.GetString("type", &type);
1757 if (ret == Result::SUCCESS) {
1758 if (Scope::Type::Valid(type)) {
1759 scope->type_ = std::move(type);
1760 } else {
1761 error += "'type' is invalid;";
1762 }
1763 } else {
1764 error += "Unknown 'type';";
1765 }
1766
1767 std::unique_ptr<PtJson> object;
1768 std::unique_ptr<RemoteObject> remoteObject;
1769 ret = params.GetObject("object", &object);
1770 if (ret == Result::SUCCESS) {
1771 remoteObject = RemoteObject::Create(*object);
1772 if (remoteObject == nullptr) {
1773 error += "'object' format error;";
1774 } else {
1775 scope->object_ = std::move(remoteObject);
1776 }
1777 } else {
1778 error += "Unknown 'object';";
1779 }
1780
1781 std::string name;
1782 ret = params.GetString("name", &name);
1783 if (ret == Result::SUCCESS) {
1784 scope->name_ = std::move(name);
1785 } else if (ret == Result::TYPE_ERROR) {
1786 error += "Unknown 'name';";
1787 }
1788
1789 std::unique_ptr<PtJson> startLocation;
1790 std::unique_ptr<Location> obj;
1791 ret = params.GetObject("startLocation", &startLocation);
1792 if (ret == Result::SUCCESS) {
1793 obj = Location::Create(*startLocation);
1794 if (obj == nullptr) {
1795 error += "'startLocation' format error;";
1796 } else {
1797 scope->startLocation_ = std::move(obj);
1798 }
1799 } else if (ret == Result::TYPE_ERROR) {
1800 error += "Unknown 'startLocation';";
1801 }
1802
1803 std::unique_ptr<PtJson> endLocation;
1804 ret = params.GetObject("endLocation", &endLocation);
1805 if (ret == Result::SUCCESS) {
1806 obj = Location::Create(*endLocation);
1807 if (obj == nullptr) {
1808 error += "'endLocation' format error;";
1809 } else {
1810 scope->endLocation_ = std::move(obj);
1811 }
1812 } else if (ret == Result::TYPE_ERROR) {
1813 error += "Unknown 'endLocation';";
1814 }
1815
1816 if (!error.empty()) {
1817 LOG_DEBUGGER(ERROR) << "Location::Create " << error;
1818 return nullptr;
1819 }
1820
1821 return scope;
1822 }
1823
ToJson() const1824 std::unique_ptr<PtJson> Scope::ToJson() const
1825 {
1826 std::unique_ptr<PtJson> result = PtJson::CreateObject();
1827
1828 result->Add("type", type_.c_str());
1829 ASSERT(object_ != nullptr);
1830 result->Add("object", object_->ToJson());
1831 if (name_) {
1832 result->Add("name", name_->c_str());
1833 }
1834 if (startLocation_) {
1835 ASSERT(startLocation_.value() != nullptr);
1836 result->Add("startLocation", startLocation_.value()->ToJson());
1837 }
1838 if (endLocation_) {
1839 ASSERT(endLocation_.value() != nullptr);
1840 result->Add("endLocation", endLocation_.value()->ToJson());
1841 }
1842
1843 return result;
1844 }
1845
Create(const PtJson & params)1846 std::unique_ptr<CallFrame> CallFrame::Create(const PtJson ¶ms)
1847 {
1848 std::string error;
1849 auto callFrame = std::make_unique<CallFrame>();
1850 Result ret;
1851
1852 std::string callFrameId;
1853 ret = params.GetString("callFrameId", &callFrameId);
1854 if (ret == Result::SUCCESS) {
1855 callFrame->callFrameId_ = std::stoi(callFrameId);
1856 } else {
1857 error += "Unknown 'callFrameId';";
1858 }
1859
1860 std::string functionName;
1861 ret = params.GetString("functionName", &functionName);
1862 if (ret == Result::SUCCESS) {
1863 callFrame->functionName_ = std::move(functionName);
1864 } else {
1865 error += "Unknown 'functionName';";
1866 }
1867
1868 std::unique_ptr<PtJson> functionLocation;
1869 std::unique_ptr<Location> obj;
1870 ret = params.GetObject("functionLocation", &functionLocation);
1871 if (ret == Result::SUCCESS) {
1872 obj = Location::Create(*functionLocation);
1873 if (obj == nullptr) {
1874 error += "'functionLocation' format error;";
1875 } else {
1876 callFrame->functionLocation_ = std::move(obj);
1877 }
1878 } else if (ret == Result::TYPE_ERROR) {
1879 error += "Unknown 'functionLocation';";
1880 }
1881
1882 std::unique_ptr<PtJson> location;
1883 ret = params.GetObject("location", &location);
1884 if (ret == Result::SUCCESS) {
1885 obj = Location::Create(*location);
1886 if (obj == nullptr) {
1887 error += "'location' format error;";
1888 } else {
1889 callFrame->location_ = std::move(obj);
1890 }
1891 } else {
1892 error += "Unknown 'location';";
1893 }
1894
1895 std::string url;
1896 ret = params.GetString("url", &url);
1897 if (ret == Result::SUCCESS) {
1898 callFrame->url_ = std::move(url);
1899 } else {
1900 error += "Unknown 'url';";
1901 }
1902
1903 std::unique_ptr<PtJson> scopeChain;
1904 ret = params.GetArray("scopeChain", &scopeChain);
1905 if (ret == Result::SUCCESS) {
1906 int32_t len = scopeChain->GetSize();
1907 for (int32_t i = 0; i < len; ++i) {
1908 std::unique_ptr<PtJson> arrayEle = scopeChain->Get(i);
1909 ASSERT(arrayEle != nullptr);
1910 std::unique_ptr<Scope> scope = Scope::Create(*arrayEle);
1911 if (scope == nullptr) {
1912 error += "'scopeChain' format error;";
1913 } else {
1914 callFrame->scopeChain_.emplace_back(std::move(scope));
1915 }
1916 }
1917 } else {
1918 error += "Unknown 'scopeChain';";
1919 }
1920
1921 std::unique_ptr<PtJson> thisObj;
1922 std::unique_ptr<RemoteObject> remoteObject;
1923 ret = params.GetObject("this", &thisObj);
1924 if (ret == Result::SUCCESS) {
1925 remoteObject = RemoteObject::Create(*thisObj);
1926 if (remoteObject == nullptr) {
1927 error += "'this' format error;";
1928 } else {
1929 callFrame->this_ = std::move(remoteObject);
1930 }
1931 } else {
1932 error += "Unknown 'this';";
1933 }
1934
1935 std::unique_ptr<PtJson> returnValue;
1936 ret = params.GetObject("returnValue", &returnValue);
1937 if (ret == Result::SUCCESS) {
1938 remoteObject = RemoteObject::Create(*returnValue);
1939 if (remoteObject == nullptr) {
1940 error += "'returnValue' format error;";
1941 } else {
1942 callFrame->returnValue_ = std::move(remoteObject);
1943 }
1944 } else if (ret == Result::TYPE_ERROR) {
1945 error += "Unknown 'returnValue';";
1946 }
1947
1948 if (!error.empty()) {
1949 LOG_DEBUGGER(ERROR) << "CallFrame::Create " << error;
1950 return nullptr;
1951 }
1952
1953 return callFrame;
1954 }
1955
ToJson() const1956 std::unique_ptr<PtJson> CallFrame::ToJson() const
1957 {
1958 std::unique_ptr<PtJson> result = PtJson::CreateObject();
1959
1960 result->Add("callFrameId", std::to_string(callFrameId_).c_str());
1961 result->Add("functionName", functionName_.c_str());
1962
1963 if (functionLocation_) {
1964 ASSERT(functionLocation_.value() != nullptr);
1965 result->Add("functionLocation", functionLocation_.value()->ToJson());
1966 }
1967 ASSERT(location_ != nullptr);
1968 result->Add("location", location_->ToJson());
1969 result->Add("url", url_.c_str());
1970
1971 size_t len = scopeChain_.size();
1972 std::unique_ptr<PtJson> values = PtJson::CreateArray();
1973 for (size_t i = 0; i < len; i++) {
1974 ASSERT(scopeChain_[i] != nullptr);
1975 std::unique_ptr<PtJson> scope = scopeChain_[i]->ToJson();
1976 values->Push(scope);
1977 }
1978 result->Add("scopeChain", values);
1979
1980 ASSERT(this_ != nullptr);
1981 result->Add("this", this_->ToJson());
1982 if (returnValue_) {
1983 ASSERT(returnValue_.value() != nullptr);
1984 result->Add("returnValue", returnValue_.value()->ToJson());
1985 }
1986
1987 return result;
1988 }
1989
Create(const PtJson & params)1990 std::unique_ptr<SamplingHeapProfileSample> SamplingHeapProfileSample::Create(const PtJson ¶ms)
1991 {
1992 std::string error;
1993 auto samplingHeapProfileSample = std::make_unique<SamplingHeapProfileSample>();
1994 Result ret;
1995
1996 int32_t size;
1997 ret = params.GetInt("size", &size);
1998 if (ret == Result::SUCCESS) {
1999 samplingHeapProfileSample->size_ = size;
2000 } else {
2001 error += "Unknown 'size';";
2002 }
2003 int32_t nodeId;
2004 ret = params.GetInt("nodeId", &nodeId);
2005 if (ret == Result::SUCCESS) {
2006 samplingHeapProfileSample->nodeId_ = nodeId;
2007 } else {
2008 error += "Unknown 'nodeId';";
2009 }
2010 int32_t ordinal;
2011 ret = params.GetInt("ordinal", &ordinal);
2012 if (ret == Result::SUCCESS) {
2013 samplingHeapProfileSample->ordinal_ = ordinal;
2014 } else {
2015 error += "Unknown 'ordinal';";
2016 }
2017 if (!error.empty()) {
2018 LOG_DEBUGGER(ERROR) << "SamplingHeapProfileSample::Create " << error;
2019 return nullptr;
2020 }
2021
2022 return samplingHeapProfileSample;
2023 }
2024
ToJson() const2025 std::unique_ptr<PtJson> SamplingHeapProfileSample::ToJson() const
2026 {
2027 std::unique_ptr<PtJson> result = PtJson::CreateObject();
2028
2029 result->Add("size", size_);
2030 result->Add("nodeId", nodeId_);
2031 result->Add("ordinal", ordinal_);
2032
2033 return result;
2034 }
2035
Create(const PtJson & params)2036 std::unique_ptr<RuntimeCallFrame> RuntimeCallFrame::Create(const PtJson ¶ms)
2037 {
2038 std::string error;
2039 auto runtimeCallFrame = std::make_unique<RuntimeCallFrame>();
2040 Result ret;
2041
2042 std::string functionName;
2043 ret = params.GetString("functionName", &functionName);
2044 if (ret == Result::SUCCESS) {
2045 runtimeCallFrame->functionName_ = std::move(functionName);
2046 } else {
2047 error += "Unknown 'functionName';";
2048 }
2049
2050 std::string moduleName;
2051 ret = params.GetString("moduleName", &moduleName);
2052 if (ret == Result::SUCCESS) {
2053 runtimeCallFrame->moduleName_ = std::move(moduleName);
2054 } else {
2055 error += "Unknown 'moduleName';";
2056 }
2057
2058 std::string scriptId;
2059 ret = params.GetString("scriptId", &scriptId);
2060 if (ret == Result::SUCCESS) {
2061 runtimeCallFrame->scriptId_ = std::move(scriptId);
2062 } else {
2063 error += "Unknown 'scriptId';";
2064 }
2065
2066 std::string url;
2067 ret = params.GetString("url", &url);
2068 if (ret == Result::SUCCESS) {
2069 runtimeCallFrame->url_ = std::move(url);
2070 } else {
2071 error += "Unknown 'url';";
2072 }
2073
2074 int32_t lineNumber;
2075 ret = params.GetInt("lineNumber", &lineNumber);
2076 if (ret == Result::SUCCESS) {
2077 runtimeCallFrame->lineNumber_ = lineNumber;
2078 } else {
2079 error += "Unknown 'lineNumber';";
2080 }
2081
2082 int32_t columnNumber;
2083 ret = params.GetInt("columnNumber", &columnNumber);
2084 if (ret == Result::SUCCESS) {
2085 runtimeCallFrame->columnNumber_ = columnNumber;
2086 } else {
2087 error += "Unknown 'columnNumber';";
2088 }
2089 if (!error.empty()) {
2090 LOG_DEBUGGER(ERROR) << "RuntimeCallFrame::Create " << error;
2091 return nullptr;
2092 }
2093
2094 return runtimeCallFrame;
2095 }
2096
FromFrameInfo(const FrameInfo & cpuFrameInfo)2097 std::unique_ptr<RuntimeCallFrame> RuntimeCallFrame::FromFrameInfo(const FrameInfo &cpuFrameInfo)
2098 {
2099 auto runtimeCallFrame = std::make_unique<RuntimeCallFrame>();
2100 runtimeCallFrame->SetFunctionName(cpuFrameInfo.functionName);
2101 runtimeCallFrame->SetModuleName(cpuFrameInfo.moduleName);
2102 runtimeCallFrame->SetScriptId(std::to_string(cpuFrameInfo.scriptId));
2103 runtimeCallFrame->SetColumnNumber(cpuFrameInfo.columnNumber);
2104 runtimeCallFrame->SetLineNumber(cpuFrameInfo.lineNumber);
2105 runtimeCallFrame->SetUrl(cpuFrameInfo.url);
2106 return runtimeCallFrame;
2107 }
2108
ToJson() const2109 std::unique_ptr<PtJson> RuntimeCallFrame::ToJson() const
2110 {
2111 std::unique_ptr<PtJson> result = PtJson::CreateObject();
2112
2113 result->Add("functionName", functionName_.c_str());
2114 result->Add("moduleName", moduleName_.c_str());
2115 result->Add("scriptId", scriptId_.c_str());
2116 result->Add("url", url_.c_str());
2117 result->Add("lineNumber", lineNumber_);
2118 result->Add("columnNumber", columnNumber_);
2119
2120 return result;
2121 }
2122
Create(const PtJson & params)2123 std::unique_ptr<SamplingHeapProfileNode> SamplingHeapProfileNode::Create(const PtJson ¶ms)
2124 {
2125 std::string error;
2126 auto samplingHeapProfileNode = std::make_unique<SamplingHeapProfileNode>();
2127 Result ret;
2128
2129 std::unique_ptr<PtJson> callFrame;
2130 ret = params.GetObject("callFrame", &callFrame);
2131 if (ret == Result::SUCCESS) {
2132 std::unique_ptr<RuntimeCallFrame> runtimeCallFrame = RuntimeCallFrame::Create(*callFrame);
2133 if (runtimeCallFrame == nullptr) {
2134 error += "'callFrame' format invalid;";
2135 } else {
2136 samplingHeapProfileNode->callFrame_ = std::move(runtimeCallFrame);
2137 }
2138 } else {
2139 error += "Unknown 'callFrame';";
2140 }
2141
2142 int32_t selfSize;
2143 ret = params.GetInt("selfSize", &selfSize);
2144 if (ret == Result::SUCCESS) {
2145 samplingHeapProfileNode->selfSize_ = selfSize;
2146 } else {
2147 error += "Unknown 'selfSize';";
2148 }
2149
2150 int32_t id;
2151 ret = params.GetInt("id", &id);
2152 if (ret == Result::SUCCESS) {
2153 samplingHeapProfileNode->id_ = id;
2154 } else {
2155 error += "Unknown 'id';";
2156 }
2157
2158 std::unique_ptr<PtJson> children;
2159 ret = params.GetArray("children", &children);
2160 if (ret == Result::SUCCESS) {
2161 int32_t len = children->GetSize();
2162 for (int32_t i = 0; i < len; ++i) {
2163 std::unique_ptr<PtJson> arrayEle = children->Get(i);
2164 ASSERT(arrayEle != nullptr);
2165 std::unique_ptr<SamplingHeapProfileNode> node = SamplingHeapProfileNode::Create(*arrayEle);
2166 if (node == nullptr) {
2167 error += "'children' format invalid;";
2168 } else {
2169 samplingHeapProfileNode->children_.emplace_back(std::move(node));
2170 }
2171 }
2172 } else {
2173 error += "Unknown 'children';";
2174 }
2175
2176 if (!error.empty()) {
2177 LOG_DEBUGGER(ERROR) << "SamplingHeapProfileNode::Create " << error;
2178 return nullptr;
2179 }
2180
2181 return samplingHeapProfileNode;
2182 }
2183
ToJson() const2184 std::unique_ptr<PtJson> SamplingHeapProfileNode::ToJson() const
2185 {
2186 std::unique_ptr<PtJson> result = PtJson::CreateObject();
2187 ASSERT(callFrame_ != nullptr);
2188 result->Add("callFrame", callFrame_->ToJson());
2189 result->Add("selfSize", selfSize_);
2190 result->Add("id", id_);
2191
2192 std::unique_ptr<PtJson> childrens = PtJson::CreateArray();
2193 size_t len = children_.size();
2194 for (size_t i = 0; i < len; i++) {
2195 ASSERT(children_[i] != nullptr);
2196 childrens->Push(children_[i]->ToJson());
2197 }
2198 result->Add("children", childrens);
2199
2200 return result;
2201 }
2202
Create(const PtJson & params)2203 std::unique_ptr<SamplingHeapProfile> SamplingHeapProfile::Create(const PtJson ¶ms)
2204 {
2205 std::string error;
2206 auto samplingHeapProfile = std::make_unique<SamplingHeapProfile>();
2207 Result ret;
2208
2209 std::unique_ptr<PtJson> head;
2210 ret = params.GetObject("head", &head);
2211 if (ret == Result::SUCCESS) {
2212 std::unique_ptr<SamplingHeapProfileNode> pHead = SamplingHeapProfileNode::Create(*head);
2213 if (pHead == nullptr) {
2214 error += "'sample' format invalid;";
2215 } else {
2216 samplingHeapProfile->head_ = std::move(pHead);
2217 }
2218 } else {
2219 error += "Unknown 'head';";
2220 }
2221
2222 std::unique_ptr<PtJson> samples;
2223 ret = params.GetArray("samples", &samples);
2224 if (ret == Result::SUCCESS) {
2225 int32_t len = samples->GetSize();
2226 for (int32_t i = 0; i < len; ++i) {
2227 std::unique_ptr<PtJson> arrayEle = samples->Get(i);
2228 ASSERT(arrayEle != nullptr);
2229 std::unique_ptr<SamplingHeapProfileSample> pSample = SamplingHeapProfileSample::Create(*arrayEle);
2230 if (pSample == nullptr) {
2231 error += "'sample' format invalid;";
2232 } else {
2233 samplingHeapProfile->samples_.emplace_back(std::move(pSample));
2234 }
2235 }
2236 } else {
2237 error += "Unknown 'samples';";
2238 }
2239
2240 if (!error.empty()) {
2241 LOG_DEBUGGER(ERROR) << "SamplingHeapProfile::Create " << error;
2242 return nullptr;
2243 }
2244
2245 return samplingHeapProfile;
2246 }
2247
ToJson() const2248 std::unique_ptr<PtJson> SamplingHeapProfile::ToJson() const
2249 {
2250 std::unique_ptr<PtJson> result = PtJson::CreateObject();
2251
2252 ASSERT(head_ != nullptr);
2253 result->Add("head", head_->ToJson());
2254
2255 std::unique_ptr<PtJson> samples = PtJson::CreateArray();
2256 size_t len = samples_.size();
2257 for (size_t i = 0; i < len; i++) {
2258 ASSERT(samples_[i] != nullptr);
2259 samples->Push(samples_[i]->ToJson());
2260 }
2261 result->Add("samples", samples);
2262 return result;
2263 }
2264
FromSamplingInfo(const SamplingInfo * samplingInfo)2265 std::unique_ptr<SamplingHeapProfile> SamplingHeapProfile::FromSamplingInfo(
2266 const SamplingInfo *samplingInfo)
2267 {
2268 std::unique_ptr<SamplingHeapProfile> profile = std::make_unique<SamplingHeapProfile>();
2269 auto node = TransferHead(&(samplingInfo->head_));
2270 profile->head_ = std::move(node);
2271 const CVector<struct Sample> &samples = samplingInfo->samples_;
2272 for (const auto &sample : samples) {
2273 std::unique_ptr<SamplingHeapProfileSample> sampleTemp = std::make_unique<SamplingHeapProfileSample>();
2274 sampleTemp->SetSize(sample.size_ * sample.count_);
2275 sampleTemp->SetNodeId(sample.nodeId_);
2276 sampleTemp->SetOrdinal(sample.ordinal_);
2277 profile->samples_.emplace_back(std::move(sampleTemp));
2278 }
2279 return profile;
2280 }
2281
TransferHead(const SamplingNode * samplingNode)2282 std::unique_ptr<SamplingHeapProfileNode> SamplingHeapProfile::TransferHead(const SamplingNode *samplingNode)
2283 {
2284 std::unique_ptr<SamplingHeapProfileNode> node = std::make_unique<SamplingHeapProfileNode>();
2285 node->SetSelfSize(samplingNode->selfSize_);
2286 node->SetId(samplingNode->id_);
2287 std::unique_ptr<RuntimeCallFrame> callFrame = std::make_unique<RuntimeCallFrame>();
2288 callFrame->SetFunctionName(samplingNode->callFrameInfo_.functionName_);
2289 callFrame->SetScriptId(std::to_string(samplingNode->callFrameInfo_.scriptId_));
2290 callFrame->SetUrl(samplingNode->callFrameInfo_.url_);
2291 callFrame->SetLineNumber(samplingNode->callFrameInfo_.lineNumber_);
2292 callFrame->SetColumnNumber(samplingNode->callFrameInfo_.columnNumber_);
2293 node->SetCallFrame(std::move(callFrame));
2294 std::vector<std::unique_ptr<SamplingHeapProfileNode>> profileNode;
2295 for (const auto &it : samplingNode->children_) {
2296 auto proNode = TransferHead(it.second.get());
2297 profileNode.push_back(std::move(proNode));
2298 }
2299 node->SetChildren(std::move(profileNode));
2300 return node;
2301 }
2302
Create(const PtJson & params)2303 std::unique_ptr<PositionTickInfo> PositionTickInfo::Create(const PtJson ¶ms)
2304 {
2305 std::string error;
2306 auto positionTickInfo = std::make_unique<PositionTickInfo>();
2307 Result ret;
2308
2309 int32_t line;
2310 ret = params.GetInt("line", &line);
2311 if (ret == Result::SUCCESS) {
2312 positionTickInfo->line_ = line;
2313 } else {
2314 error += "Unknown 'line';";
2315 }
2316
2317 int32_t ticks;
2318 ret = params.GetInt("ticks", &ticks);
2319 if (ret == Result::SUCCESS) {
2320 positionTickInfo->ticks_ = ticks;
2321 } else {
2322 error += "Unknown 'ticks';";
2323 }
2324
2325 if (!error.empty()) {
2326 LOG_DEBUGGER(ERROR) << "PositionTickInfo::Create " << error;
2327 return nullptr;
2328 }
2329
2330 return positionTickInfo;
2331 }
2332
ToJson() const2333 std::unique_ptr<PtJson> PositionTickInfo::ToJson() const
2334 {
2335 std::unique_ptr<PtJson> result = PtJson::CreateObject();
2336
2337 result->Add("line", line_);
2338 result->Add("ticks", ticks_);
2339
2340 return result;
2341 }
2342
Create(const PtJson & params)2343 std::unique_ptr<ProfileNode> ProfileNode::Create(const PtJson ¶ms)
2344 {
2345 std::string error;
2346 auto profileNode = std::make_unique<ProfileNode>();
2347 Result ret;
2348
2349 int32_t id;
2350 ret = params.GetInt("id", &id);
2351 if (ret == Result::SUCCESS) {
2352 profileNode->id_ = id;
2353 } else {
2354 error += "Unknown 'id';";
2355 }
2356
2357 std::unique_ptr<PtJson> callFrame;
2358 ret = params.GetObject("callFrame", &callFrame);
2359 if (ret == Result::SUCCESS) {
2360 std::unique_ptr<RuntimeCallFrame> runtimeCallFrame = RuntimeCallFrame::Create(*callFrame);
2361 if (runtimeCallFrame == nullptr) {
2362 error += "'callFrame' format invalid;";
2363 } else {
2364 profileNode->callFrame_ = std::move(runtimeCallFrame);
2365 }
2366 } else {
2367 error += "Unknown 'callFrame';";
2368 }
2369
2370 int32_t hitCount;
2371 ret = params.GetInt("hitCount", &hitCount);
2372 if (ret == Result::SUCCESS) {
2373 profileNode->hitCount_ = hitCount;
2374 } else if (ret == Result::TYPE_ERROR) {
2375 error += "Unknown 'hitCount';";
2376 }
2377
2378 std::unique_ptr<PtJson> children;
2379 ret = params.GetArray("children", &children);
2380 if (ret == Result::SUCCESS) {
2381 int32_t childrenLen = children->GetSize();
2382 for (int32_t i = 0; i < childrenLen; ++i) {
2383 int32_t pChildren = children->Get(i)->GetInt();
2384 profileNode->children_.value().emplace_back(pChildren);
2385 }
2386 } else if (ret == Result::TYPE_ERROR) {
2387 error += "Unknown 'children';";
2388 }
2389
2390 std::unique_ptr<PtJson> positionTicks;
2391 ret = params.GetArray("positionTicks", &positionTicks);
2392 if (ret == Result::SUCCESS) {
2393 int32_t positionTicksLen = positionTicks->GetSize();
2394 for (int32_t i = 0; i < positionTicksLen; ++i) {
2395 std::unique_ptr<PtJson> arrayEle = positionTicks->Get(i);
2396 ASSERT(arrayEle != nullptr);
2397 std::unique_ptr<PositionTickInfo> tmpPositionTicks = PositionTickInfo::Create(*arrayEle);
2398 if (tmpPositionTicks == nullptr) {
2399 error += "'positionTicks' format invalid;";
2400 } else {
2401 profileNode->positionTicks_.value().emplace_back(std::move(tmpPositionTicks));
2402 }
2403 }
2404 } else if (ret == Result::TYPE_ERROR) {
2405 error += "Unknown 'positionTicks';";
2406 }
2407
2408 std::string deoptReason;
2409 ret = params.GetString("deoptReason", &deoptReason);
2410 if (ret == Result::SUCCESS) {
2411 profileNode->deoptReason_ = std::move(deoptReason);
2412 } else if (ret == Result::TYPE_ERROR) {
2413 error += "Unknown 'deoptReason';";
2414 }
2415
2416 if (!error.empty()) {
2417 LOG_DEBUGGER(ERROR) << "ProfileNode::Create " << error;
2418 return nullptr;
2419 }
2420
2421 return profileNode;
2422 }
2423
FromCpuProfileNode(const CpuProfileNode & cpuProfileNode)2424 std::unique_ptr<ProfileNode> ProfileNode::FromCpuProfileNode(const CpuProfileNode &cpuProfileNode)
2425 {
2426 auto profileNode = std::make_unique<ProfileNode>();
2427 profileNode->SetId(cpuProfileNode.id);
2428 profileNode->SetHitCount(cpuProfileNode.hitCount);
2429
2430 size_t childrenLen = cpuProfileNode.children.size();
2431 std::vector<int32_t> tmpChildren;
2432 tmpChildren.reserve(childrenLen);
2433 for (size_t i = 0; i < childrenLen; ++i) {
2434 tmpChildren.push_back(cpuProfileNode.children[i]);
2435 }
2436 profileNode->SetChildren(tmpChildren);
2437 profileNode->SetCallFrame(RuntimeCallFrame::FromFrameInfo(cpuProfileNode.codeEntry));
2438 return profileNode;
2439 }
2440
ToJson() const2441 std::unique_ptr<PtJson> ProfileNode::ToJson() const
2442 {
2443 std::unique_ptr<PtJson> result = PtJson::CreateObject();
2444
2445 result->Add("id", id_);
2446 ASSERT(callFrame_ != nullptr);
2447 result->Add("callFrame", callFrame_->ToJson());
2448 if (hitCount_) {
2449 result->Add("hitCount", hitCount_.value());
2450 }
2451 if (children_) {
2452 std::unique_ptr<PtJson> childrens = PtJson::CreateArray();
2453 size_t len = children_->size();
2454 for (size_t i = 0; i < len; i++) {
2455 childrens->Push(children_.value()[i]);
2456 }
2457 result->Add("children", childrens);
2458 }
2459 if (positionTicks_) {
2460 std::unique_ptr<PtJson> positionTicks = PtJson::CreateArray();
2461 size_t len = positionTicks_->size();
2462 for (size_t i = 0; i < len; i++) {
2463 ASSERT(positionTicks_.value()[i] != nullptr);
2464 positionTicks->Push(positionTicks_.value()[i]->ToJson());
2465 }
2466 result->Add("positionTicks", positionTicks);
2467 }
2468
2469 if (deoptReason_) {
2470 result->Add("deoptReason", deoptReason_.value().c_str());
2471 }
2472
2473 return result;
2474 }
2475
Create(const PtJson & params)2476 std::unique_ptr<Profile> Profile::Create(const PtJson ¶ms)
2477 {
2478 std::string error;
2479 auto profile = std::make_unique<Profile>();
2480 Result ret;
2481
2482 std::unique_ptr<PtJson> nodes;
2483 ret = params.GetArray("nodes", &nodes);
2484 if (ret == Result::SUCCESS) {
2485 int32_t nodesLen = nodes->GetSize();
2486 for (int32_t i = 0; i < nodesLen; ++i) {
2487 std::unique_ptr<PtJson> arrayEle = nodes->Get(i);
2488 ASSERT(arrayEle != nullptr);
2489 std::unique_ptr<ProfileNode> profileNode = ProfileNode::Create(*arrayEle);
2490 if (profileNode == nullptr) {
2491 error += "'nodes' format invalid;";
2492 } else {
2493 profile->nodes_.emplace_back(std::move(profileNode));
2494 }
2495 }
2496 } else {
2497 error += "Unknown 'nodes';";
2498 }
2499
2500 int64_t tid;
2501 ret = params.GetInt64("tid", &tid);
2502 if (ret == Result::SUCCESS) {
2503 profile->tid_ = tid;
2504 } else {
2505 error += "Unknown 'tid';";
2506 }
2507
2508 int64_t startTime;
2509 ret = params.GetInt64("startTime", &startTime);
2510 if (ret == Result::SUCCESS) {
2511 profile->startTime_ = startTime;
2512 } else {
2513 error += "Unknown 'startTime';";
2514 }
2515
2516 int64_t endTime;
2517 ret = params.GetInt64("endTime", &endTime);
2518 if (ret == Result::SUCCESS) {
2519 profile->endTime_ = endTime;
2520 } else {
2521 error += "Unknown 'endTime';";
2522 }
2523
2524 int64_t gcTime;
2525 ret = params.GetInt64("gcTime", &gcTime);
2526 if (ret == Result::SUCCESS) {
2527 profile->gcTime_ = gcTime;
2528 } else {
2529 error += "Unknown 'gcTime';";
2530 }
2531
2532 int64_t cInterpreterTime;
2533 ret = params.GetInt64("cInterpreterTime", &cInterpreterTime);
2534 if (ret == Result::SUCCESS) {
2535 profile->cInterpreterTime_ = cInterpreterTime;
2536 } else {
2537 error += "Unknown 'cInterpreterTime';";
2538 }
2539
2540 int64_t asmInterpreterTime;
2541 ret = params.GetInt64("asmInterpreterTime", &asmInterpreterTime);
2542 if (ret == Result::SUCCESS) {
2543 profile->asmInterpreterTime_ = asmInterpreterTime;
2544 } else {
2545 error += "Unknown 'asmInterpreterTime';";
2546 }
2547
2548 int64_t aotTime;
2549 ret = params.GetInt64("aotTime", &aotTime);
2550 if (ret == Result::SUCCESS) {
2551 profile->aotTime_ = aotTime;
2552 } else {
2553 error += "Unknown 'aotTime';";
2554 }
2555
2556 int64_t builtinTime;
2557 ret = params.GetInt64("builtinTime", &builtinTime);
2558 if (ret == Result::SUCCESS) {
2559 profile->builtinTime_ = builtinTime;
2560 } else {
2561 error += "Unknown 'builtinTime';";
2562 }
2563
2564 int64_t napiTime;
2565 ret = params.GetInt64("napiTime", &napiTime);
2566 if (ret == Result::SUCCESS) {
2567 profile->napiTime_ = napiTime;
2568 } else {
2569 error += "Unknown 'napiTime';";
2570 }
2571
2572 int64_t arkuiEngineTime;
2573 ret = params.GetInt64("arkuiEngineTime", &arkuiEngineTime);
2574 if (ret == Result::SUCCESS) {
2575 profile->arkuiEngineTime_ = arkuiEngineTime;
2576 } else {
2577 error += "Unknown 'arkuiEngineTime';";
2578 }
2579
2580 int64_t runtimeTime;
2581 ret = params.GetInt64("runtimeTime", &runtimeTime);
2582 if (ret == Result::SUCCESS) {
2583 profile->runtimeTime_ = runtimeTime;
2584 } else {
2585 error += "Unknown 'runtimeTime';";
2586 }
2587
2588 int64_t otherTime;
2589 ret = params.GetInt64("otherTime", &otherTime);
2590 if (ret == Result::SUCCESS) {
2591 profile->otherTime_ = otherTime;
2592 } else {
2593 error += "Unknown 'otherTime';";
2594 }
2595
2596 std::unique_ptr<PtJson> samples;
2597 ret = params.GetArray("samples", &samples);
2598 if (ret == Result::SUCCESS) {
2599 int32_t samplesLen = samples->GetSize();
2600 for (int32_t i = 0; i < samplesLen; ++i) {
2601 int32_t pSamples = samples->Get(i)->GetInt();
2602 profile->samples_.value().emplace_back(pSamples);
2603 }
2604 } else if (ret == Result::TYPE_ERROR) {
2605 error += "Unknown 'samples';";
2606 }
2607
2608 std::unique_ptr<PtJson> timeDeltas;
2609 ret = params.GetArray("timeDeltas", &timeDeltas);
2610 if (ret == Result::SUCCESS) {
2611 int32_t timeDeltasLen = timeDeltas->GetSize();
2612 for (int32_t i = 0; i < timeDeltasLen; ++i) {
2613 int32_t pTimeDeltas = timeDeltas->Get(i)->GetInt();
2614 profile->timeDeltas_.value().emplace_back(pTimeDeltas);
2615 }
2616 } else if (ret == Result::TYPE_ERROR) {
2617 error += "Unknown 'timeDeltas';";
2618 }
2619
2620 if (!error.empty()) {
2621 LOG_DEBUGGER(ERROR) << "Profile::Create " << error;
2622 return nullptr;
2623 }
2624
2625 return profile;
2626 }
2627
FromProfileInfo(const ProfileInfo & profileInfo)2628 std::unique_ptr<Profile> Profile::FromProfileInfo(const ProfileInfo &profileInfo)
2629 {
2630 auto profile = std::make_unique<Profile>();
2631 profile->SetTid(static_cast<int64_t>(profileInfo.tid));
2632 profile->SetStartTime(static_cast<int64_t>(profileInfo.startTime));
2633 profile->SetEndTime(static_cast<int64_t>(profileInfo.stopTime));
2634 profile->SetGcTime(static_cast<int64_t>(profileInfo.gcTime));
2635 profile->SetCInterpreterTime(static_cast<int64_t>(profileInfo.cInterpreterTime));
2636 profile->SetAsmInterpreterTime(static_cast<int64_t>(profileInfo.asmInterpreterTime));
2637 profile->SetAotTime(static_cast<int64_t>(profileInfo.aotTime));
2638 profile->SetBuiltinTime(static_cast<int64_t>(profileInfo.builtinTime));
2639 profile->SetNapiTime(static_cast<int64_t>(profileInfo.napiTime));
2640 profile->SetArkuiEngineTime(static_cast<int64_t>(profileInfo.arkuiEngineTime));
2641 profile->SetRuntimeTime(static_cast<int64_t>(profileInfo.runtimeTime));
2642 profile->SetOtherTime(static_cast<int64_t>(profileInfo.otherTime));
2643 size_t samplesLen = profileInfo.samples.size();
2644 std::vector<int32_t> tmpSamples;
2645 tmpSamples.reserve(samplesLen);
2646 for (size_t i = 0; i < samplesLen; ++i) {
2647 tmpSamples.push_back(profileInfo.samples[i]);
2648 }
2649 profile->SetSamples(tmpSamples);
2650
2651 size_t timeDeltasLen = profileInfo.timeDeltas.size();
2652 std::vector<int32_t> tmpTimeDeltas;
2653 tmpTimeDeltas.reserve(timeDeltasLen);
2654 for (size_t i = 0; i < timeDeltasLen; ++i) {
2655 tmpTimeDeltas.push_back(profileInfo.timeDeltas[i]);
2656 }
2657 profile->SetTimeDeltas(tmpTimeDeltas);
2658
2659 std::vector<std::unique_ptr<ProfileNode>> profileNode;
2660 size_t nodesLen = profileInfo.nodeCount;
2661 for (size_t i = 0; i < nodesLen; ++i) {
2662 const auto &cpuProfileNode = profileInfo.nodes[i];
2663 profileNode.push_back(ProfileNode::FromCpuProfileNode(cpuProfileNode));
2664 }
2665 profile->SetNodes(std::move(profileNode));
2666 return profile;
2667 }
2668
ToJson() const2669 std::unique_ptr<PtJson> Profile::ToJson() const
2670 {
2671 std::unique_ptr<PtJson> result = PtJson::CreateObject();
2672
2673 result->Add("tid", tid_);
2674 result->Add("startTime", startTime_);
2675 result->Add("endTime", endTime_);
2676 result->Add("gcTime", gcTime_);
2677 result->Add("cInterpreterTime", cInterpreterTime_);
2678 result->Add("asmInterpreterTime", asmInterpreterTime_);
2679 result->Add("aotTime", aotTime_);
2680 result->Add("builtinTime", builtinTime_);
2681 result->Add("napiTime", napiTime_);
2682 result->Add("arkuiEngineTime", arkuiEngineTime_);
2683 result->Add("runtimeTime", runtimeTime_);
2684 result->Add("otherTime", otherTime_);
2685
2686 std::unique_ptr<PtJson> nodes = PtJson::CreateArray();
2687 size_t nodesLen = nodes_.size();
2688 for (size_t i = 0; i < nodesLen; i++) {
2689 ASSERT(nodes_[i] != nullptr);
2690 nodes->Push(nodes_[i]->ToJson());
2691 }
2692 result->Add("nodes", nodes);
2693
2694 if (samples_) {
2695 std::unique_ptr<PtJson> samples = PtJson::CreateArray();
2696 size_t samplesLen = samples_->size();
2697 for (size_t i = 0; i < samplesLen; i++) {
2698 samples->Push(samples_.value()[i]);
2699 }
2700 result->Add("samples", samples);
2701 }
2702
2703 if (timeDeltas_) {
2704 std::unique_ptr<PtJson> timeDeltas = PtJson::CreateArray();
2705 size_t timeDeltasLen = timeDeltas_->size();
2706 for (size_t i = 0; i < timeDeltasLen; i++) {
2707 timeDeltas->Push(timeDeltas_.value()[i]);
2708 }
2709 result->Add("timeDeltas", timeDeltas);
2710 }
2711
2712 return result;
2713 }
2714
Create(const PtJson & params)2715 std::unique_ptr<Coverage> Coverage::Create(const PtJson ¶ms)
2716 {
2717 std::string error;
2718 auto coverage = std::make_unique<Coverage>();
2719 Result ret;
2720
2721 int32_t startOffset;
2722 ret = params.GetInt("startOffset", &startOffset);
2723 if (ret == Result::SUCCESS) {
2724 coverage->startOffset_ = startOffset;
2725 } else {
2726 error += "Unknown 'startOffset';";
2727 }
2728
2729 int32_t endOffset;
2730 ret = params.GetInt("endOffset", &endOffset);
2731 if (ret == Result::SUCCESS) {
2732 coverage->endOffset_ = endOffset;
2733 } else {
2734 error += "Unknown 'endOffset';";
2735 }
2736
2737 int32_t count;
2738 ret = params.GetInt("count", &count);
2739 if (ret == Result::SUCCESS) {
2740 coverage->count_ = count;
2741 } else {
2742 error += "Unknown 'count';";
2743 }
2744
2745 if (!error.empty()) {
2746 LOG_DEBUGGER(ERROR) << "Coverage::Create " << error;
2747 return nullptr;
2748 }
2749
2750 return coverage;
2751 }
2752
ToJson() const2753 std::unique_ptr<PtJson> Coverage::ToJson() const
2754 {
2755 std::unique_ptr<PtJson> result = PtJson::CreateObject();
2756
2757 result->Add("startOffset", startOffset_);
2758 result->Add("endOffset", endOffset_);
2759 result->Add("count", count_);
2760
2761 return result;
2762 }
2763
Create(const PtJson & params)2764 std::unique_ptr<FunctionCoverage> FunctionCoverage::Create(const PtJson ¶ms)
2765 {
2766 std::string error;
2767 auto functionCoverage = std::make_unique<FunctionCoverage>();
2768 Result ret;
2769
2770 std::string functionName;
2771 ret = params.GetString("functionName", &functionName);
2772 if (ret == Result::SUCCESS) {
2773 functionCoverage->functionName_ = std::move(functionName);
2774 } else {
2775 error += "Unknown 'functionName';";
2776 }
2777
2778 std::unique_ptr<PtJson> ranges;
2779 ret = params.GetArray("ranges", &ranges);
2780 if (ret == Result::SUCCESS) {
2781 int32_t len = ranges->GetSize();
2782 for (int32_t i = 0; i < len; ++i) {
2783 std::unique_ptr<PtJson> arrayEle = ranges->Get(i);
2784 ASSERT(arrayEle != nullptr);
2785 std::unique_ptr<Coverage> pRanges = Coverage::Create(*arrayEle);
2786 if (pRanges == nullptr) {
2787 error += "'ranges' format invalid;";
2788 } else {
2789 functionCoverage->ranges_.emplace_back(std::move(pRanges));
2790 }
2791 }
2792 } else {
2793 error += "Unknown 'ranges';";
2794 }
2795
2796 bool isBlockCoverage = false;
2797 ret = params.GetBool("isBlockCoverage", &isBlockCoverage);
2798 if (ret == Result::SUCCESS) {
2799 functionCoverage->isBlockCoverage_ = isBlockCoverage;
2800 } else {
2801 error += "Unknown 'isBlockCoverage';";
2802 }
2803
2804 if (!error.empty()) {
2805 LOG_DEBUGGER(ERROR) << "FunctionCoverage::Create " << error;
2806 return nullptr;
2807 }
2808
2809 return functionCoverage;
2810 }
2811
ToJson() const2812 std::unique_ptr<PtJson> FunctionCoverage::ToJson() const
2813 {
2814 std::unique_ptr<PtJson> result = PtJson::CreateObject();
2815
2816 result->Add("functionName", functionName_.c_str());
2817
2818 std::unique_ptr<PtJson> ranges = PtJson::CreateArray();
2819 size_t len = ranges_.size();
2820 for (size_t i = 0; i < len; i++) {
2821 ASSERT(ranges_[i] != nullptr);
2822 ranges->Push(ranges_[i]->ToJson());
2823 }
2824 result->Add("ranges", ranges);
2825
2826 result->Add("isBlockCoverage", isBlockCoverage_);
2827
2828 return result;
2829 }
2830
Create(const PtJson & params)2831 std::unique_ptr<ScriptCoverage> ScriptCoverage::Create(const PtJson ¶ms)
2832 {
2833 std::string error;
2834 auto scriptCoverage = std::make_unique<ScriptCoverage>();
2835 Result ret;
2836
2837 std::string scriptId;
2838 ret = params.GetString("scriptId", &scriptId);
2839 if (ret == Result::SUCCESS) {
2840 scriptCoverage->scriptId_ = std::move(scriptId);
2841 } else {
2842 error += "Unknown 'scriptId';";
2843 }
2844
2845 std::string url;
2846 ret = params.GetString("url", &url);
2847 if (ret == Result::SUCCESS) {
2848 scriptCoverage->url_ = std::move(url);
2849 } else {
2850 error += "Unknown 'url';";
2851 }
2852
2853 std::unique_ptr<PtJson> functions;
2854 ret = params.GetArray("functions", &functions);
2855 if (ret == Result::SUCCESS) {
2856 int32_t len = functions->GetSize();
2857 for (int32_t i = 0; i < len; ++i) {
2858 std::unique_ptr<PtJson> arrayEle = functions->Get(i);
2859 ASSERT(arrayEle != nullptr);
2860 std::unique_ptr<FunctionCoverage> pFunctions = FunctionCoverage::Create(*arrayEle);
2861 if (pFunctions == nullptr) {
2862 error += "'functions' format invalid;";
2863 } else {
2864 scriptCoverage->functions_.emplace_back(std::move(pFunctions));
2865 }
2866 }
2867 } else {
2868 error += "Unknown 'functions';";
2869 }
2870
2871 if (!error.empty()) {
2872 LOG_DEBUGGER(ERROR) << "ScriptCoverage::Create " << error;
2873 return nullptr;
2874 }
2875
2876 return scriptCoverage;
2877 }
2878
ToJson() const2879 std::unique_ptr<PtJson> ScriptCoverage::ToJson() const
2880 {
2881 std::unique_ptr<PtJson> result = PtJson::CreateObject();
2882
2883 result->Add("scriptId", scriptId_.c_str());
2884 result->Add("url", url_.c_str());
2885
2886 std::unique_ptr<PtJson> functions = PtJson::CreateArray();
2887 size_t len = functions_.size();
2888 for (size_t i = 0; i < len; i++) {
2889 ASSERT(functions_[i] != nullptr);
2890 functions->Push(functions_[i]->ToJson());
2891 }
2892 result->Add("functions", functions);
2893
2894 return result;
2895 }
2896
Create(const PtJson & params)2897 std::unique_ptr<TypeObject> TypeObject::Create(const PtJson ¶ms)
2898 {
2899 std::string error;
2900 auto typeObject = std::make_unique<TypeObject>();
2901 Result ret;
2902
2903 std::string name;
2904 ret = params.GetString("name", &name);
2905 if (ret == Result::SUCCESS) {
2906 typeObject->name_ = std::move(name);
2907 } else {
2908 error += "Unknown 'name';";
2909 }
2910
2911 if (!error.empty()) {
2912 LOG_DEBUGGER(ERROR) << "TypeObject::Create " << error;
2913 return nullptr;
2914 }
2915
2916 return typeObject;
2917 }
2918
ToJson() const2919 std::unique_ptr<PtJson> TypeObject::ToJson() const
2920 {
2921 std::unique_ptr<PtJson> result = PtJson::CreateObject();
2922
2923 result->Add("name", name_.c_str());
2924
2925 return result;
2926 }
2927
Create(const PtJson & params)2928 std::unique_ptr<TypeProfileEntry> TypeProfileEntry::Create(const PtJson ¶ms)
2929 {
2930 std::string error;
2931 auto typeProfileEntry = std::make_unique<TypeProfileEntry>();
2932 Result ret;
2933
2934 int32_t offset;
2935 ret = params.GetInt("offset", &offset);
2936 if (ret == Result::SUCCESS) {
2937 typeProfileEntry->offset_ = offset;
2938 } else {
2939 error += "Unknown 'offset';";
2940 }
2941
2942 std::unique_ptr<PtJson> types;
2943 ret = params.GetArray("types", &types);
2944 if (ret == Result::SUCCESS) {
2945 int32_t len = types->GetSize();
2946 for (int32_t i = 0; i < len; ++i) {
2947 std::unique_ptr<PtJson> arrayEle = types->Get(i);
2948 ASSERT(arrayEle != nullptr);
2949 std::unique_ptr<TypeObject> pTypes = TypeObject::Create(*arrayEle);
2950 if (pTypes == nullptr) {
2951 error += "'types' format invalid;";
2952 } else {
2953 typeProfileEntry->types_.emplace_back(std::move(pTypes));
2954 }
2955 }
2956 } else {
2957 error += "Unknown 'types';";
2958 }
2959
2960 if (!error.empty()) {
2961 LOG_DEBUGGER(ERROR) << "TypeProfileEntry::Create " << error;
2962 return nullptr;
2963 }
2964
2965 return typeProfileEntry;
2966 }
2967
ToJson() const2968 std::unique_ptr<PtJson> TypeProfileEntry::ToJson() const
2969 {
2970 std::unique_ptr<PtJson> result = PtJson::CreateObject();
2971
2972 result->Add("offset", offset_);
2973
2974 std::unique_ptr<PtJson> types = PtJson::CreateArray();
2975 size_t len = types_.size();
2976 for (size_t i = 0; i < len; i++) {
2977 ASSERT(types_[i] != nullptr);
2978 types->Push(types_[i]->ToJson());
2979 }
2980 result->Add("types", types);
2981
2982 return result;
2983 }
2984
Create(const PtJson & params)2985 std::unique_ptr<ScriptTypeProfile> ScriptTypeProfile::Create(const PtJson ¶ms)
2986 {
2987 std::string error;
2988 auto scriptTypeProfile = std::make_unique<ScriptTypeProfile>();
2989 Result ret;
2990
2991 std::string scriptId;
2992 ret = params.GetString("scriptId", &scriptId);
2993 if (ret == Result::SUCCESS) {
2994 scriptTypeProfile->scriptId_ = std::move(scriptId);
2995 } else {
2996 error += "Unknown 'scriptId';";
2997 }
2998
2999 std::string url;
3000 ret = params.GetString("url", &url);
3001 if (ret == Result::SUCCESS) {
3002 scriptTypeProfile->url_ = std::move(url);
3003 } else {
3004 error += "Unknown 'url';";
3005 }
3006
3007 std::unique_ptr<PtJson> entries;
3008 ret = params.GetArray("entries", &entries);
3009 if (ret == Result::SUCCESS) {
3010 int32_t len = entries->GetSize();
3011 for (int32_t i = 0; i < len; ++i) {
3012 std::unique_ptr<PtJson> arrayEle = entries->Get(i);
3013 ASSERT(arrayEle != nullptr);
3014 std::unique_ptr<TypeProfileEntry> pEntries = TypeProfileEntry::Create(*arrayEle);
3015 if (pEntries == nullptr) {
3016 error += "'entries' format invalid;";
3017 } else {
3018 scriptTypeProfile->entries_.emplace_back(std::move(pEntries));
3019 }
3020 }
3021 } else {
3022 error += "Unknown 'entries';";
3023 }
3024
3025 if (!error.empty()) {
3026 LOG_DEBUGGER(ERROR) << "ScriptTypeProfile::Create " << error;
3027 return nullptr;
3028 }
3029
3030 return scriptTypeProfile;
3031 }
3032
ToJson() const3033 std::unique_ptr<PtJson> ScriptTypeProfile::ToJson() const
3034 {
3035 std::unique_ptr<PtJson> result = PtJson::CreateObject();
3036
3037 result->Add("scriptId", scriptId_.c_str());
3038 result->Add("url", url_.c_str());
3039
3040 std::unique_ptr<PtJson> entries = PtJson::CreateArray();
3041 size_t len = entries_.size();
3042 for (size_t i = 0; i < len; i++) {
3043 ASSERT(entries_[i] != nullptr);
3044 entries->Push(entries_[i]->ToJson());
3045 }
3046 result->Add("entries", entries);
3047
3048 return result;
3049 }
3050
Create(const PtJson & params)3051 std::unique_ptr<TraceConfig> TraceConfig::Create(const PtJson ¶ms)
3052 {
3053 std::string error;
3054 auto traceConfig = std::make_unique<TraceConfig>();
3055 Result ret;
3056
3057 std::string recordMode;
3058 ret = params.GetString("recordMode", &recordMode);
3059 if (ret == Result::SUCCESS) {
3060 if (TraceConfig::RecordModeValues::Valid(recordMode)) {
3061 traceConfig->recordMode_ = std::move(recordMode);
3062 } else {
3063 error += "'recordMode' is invalid;";
3064 }
3065 } else if (ret == Result::TYPE_ERROR) {
3066 error += "Unknown 'recordMode';";
3067 }
3068
3069 bool enableSampling = false;
3070 ret = params.GetBool("enableSampling", &enableSampling);
3071 if (ret == Result::SUCCESS) {
3072 traceConfig->enableSampling_ = enableSampling;
3073 } else if (ret == Result::TYPE_ERROR) {
3074 error += "Unknown 'enableSampling';";
3075 }
3076
3077 bool enableSystrace = false;
3078 ret = params.GetBool("enableSystrace", &enableSystrace);
3079 if (ret == Result::SUCCESS) {
3080 traceConfig->enableSystrace_ = enableSystrace;
3081 } else if (ret == Result::TYPE_ERROR) {
3082 error += "Unknown 'enableSystrace';";
3083 }
3084
3085 bool enableArgumentFilter = false;
3086 ret = params.GetBool("enableArgumentFilter", &enableArgumentFilter);
3087 if (ret == Result::SUCCESS) {
3088 traceConfig->enableArgumentFilter_ = enableArgumentFilter;
3089 } else if (ret == Result::TYPE_ERROR) {
3090 error += "Unknown 'enableArgumentFilter';";
3091 }
3092
3093 std::unique_ptr<PtJson> includedCategories;
3094 ret = params.GetArray("includedCategories", &includedCategories);
3095 if (ret == Result::SUCCESS) {
3096 int32_t includedCategoriesLen = includedCategories->GetSize();
3097 for (int32_t i = 0; i < includedCategoriesLen; ++i) {
3098 std::string pIncludedCategories = includedCategories->Get(i)->GetString();
3099 traceConfig->includedCategories_.value().emplace_back(pIncludedCategories);
3100 }
3101 } else if (ret == Result::TYPE_ERROR) {
3102 error += "Unknown 'includedCategories';";
3103 }
3104
3105 std::unique_ptr<PtJson> excludedCategories;
3106 ret = params.GetArray("excludedCategories", &excludedCategories);
3107 if (ret == Result::SUCCESS) {
3108 int32_t excludedCategoriesLen = excludedCategories->GetSize();
3109 for (int32_t i = 0; i < excludedCategoriesLen; ++i) {
3110 std::string pExcludedCategories = excludedCategories->Get(i)->GetString();
3111 traceConfig->excludedCategories_.value().emplace_back(pExcludedCategories);
3112 }
3113 } else if (ret == Result::TYPE_ERROR) {
3114 error += "Unknown 'excludedCategories';";
3115 }
3116
3117 std::unique_ptr<PtJson> syntheticDelays;
3118 ret = params.GetArray("syntheticDelays", &syntheticDelays);
3119 if (ret == Result::SUCCESS) {
3120 int32_t syntheticDelaysLen = includedCategories->GetSize();
3121 for (int32_t i = 0; i < syntheticDelaysLen; ++i) {
3122 std::string pSyntheticDelays = syntheticDelays->Get(i)->GetString();
3123 traceConfig->syntheticDelays_.value().emplace_back(pSyntheticDelays);
3124 }
3125 } else if (ret == Result::TYPE_ERROR) {
3126 error += "Unknown 'syntheticDelays';";
3127 }
3128
3129 std::unique_ptr<PtJson> memoryDumpConfig;
3130 ret = params.GetObject("memoryDumpConfig", &memoryDumpConfig);
3131 if (ret == Result::SUCCESS) {
3132 std::unique_ptr<MemoryDumpConfig> tmpMemory = std::move(memoryDumpConfig);
3133 if (tmpMemory == nullptr) {
3134 error += "'memoryDumpConfig' format error;";
3135 } else {
3136 traceConfig->memoryDumpConfig_ = std::move(tmpMemory);
3137 }
3138 } else if (ret == Result::TYPE_ERROR) {
3139 error += "Unknown 'memoryDumpConfig';";
3140 }
3141
3142 if (!error.empty()) {
3143 LOG_DEBUGGER(ERROR) << "TraceConfig::Create " << error;
3144 return nullptr;
3145 }
3146
3147 return traceConfig;
3148 }
3149
ToJson() const3150 std::unique_ptr<PtJson> TraceConfig::ToJson() const
3151 {
3152 std::unique_ptr<PtJson> result = PtJson::CreateObject();
3153
3154 if (recordMode_) {
3155 result->Add("recordMode", recordMode_.value().c_str());
3156 }
3157
3158 if (enableSampling_) {
3159 result->Add("enableSampling", enableSampling_.value());
3160 }
3161
3162 if (enableSystrace_) {
3163 result->Add("enableSystrace", enableSystrace_.value());
3164 }
3165
3166 if (enableArgumentFilter_) {
3167 result->Add("enableArgumentFilter", enableArgumentFilter_.value());
3168 }
3169
3170 if (includedCategories_) {
3171 std::unique_ptr<PtJson> includedCategories = PtJson::CreateArray();
3172 size_t includedCategoriesLen = includedCategories_->size();
3173 for (size_t i = 0; i < includedCategoriesLen; i++) {
3174 includedCategories->Push(includedCategories_.value()[i].c_str());
3175 }
3176 result->Add("includedCategories", includedCategories);
3177 }
3178
3179 if (excludedCategories_) {
3180 std::unique_ptr<PtJson> excludedCategories = PtJson::CreateArray();
3181 size_t excludedCategoriesLen = excludedCategories_->size();
3182 for (size_t i = 0; i < excludedCategoriesLen; i++) {
3183 excludedCategories->Push(excludedCategories_.value()[i].c_str());
3184 }
3185 result->Add("excludedCategories", excludedCategories);
3186 }
3187
3188 if (syntheticDelays_) {
3189 std::unique_ptr<PtJson> syntheticDelays = PtJson::CreateArray();
3190 size_t syntheticDelaysLen = syntheticDelays_->size();
3191 for (size_t i = 0; i < syntheticDelaysLen; i++) {
3192 syntheticDelays->Push(syntheticDelays_.value()[i].c_str());
3193 }
3194 result->Add("syntheticDelays", syntheticDelays);
3195 }
3196
3197 if (memoryDumpConfig_) {
3198 result->Add("functionLocation", memoryDumpConfig_.value());
3199 }
3200
3201 return result;
3202 }
3203
Create(const PtJson & params)3204 std::unique_ptr<BreakpointInfo> BreakpointInfo::Create(const PtJson ¶ms)
3205 {
3206 auto paramsObject = std::make_unique<BreakpointInfo>();
3207 std::string error;
3208 Result ret;
3209 // lineNumber
3210 int32_t lineNumber;
3211 ret = params.GetInt("lineNumber", &lineNumber);
3212 if (ret == Result::SUCCESS) {
3213 paramsObject->lineNumber_ = lineNumber;
3214 } else {
3215 error += "Unknown 'lineNumber';";
3216 }
3217 // url
3218 std::string url;
3219 ret = params.GetString("url", &url);
3220 if (ret == Result::SUCCESS) {
3221 paramsObject->url_ = std::move(url);
3222 } else if (ret == Result::TYPE_ERROR) {
3223 error += "Unknown 'url';";
3224 }
3225 // columnNumber
3226 int32_t columnNumber;
3227 ret = params.GetInt("columnNumber", &columnNumber);
3228 if (ret == Result::SUCCESS) {
3229 paramsObject->columnNumber_ = columnNumber;
3230 } else if (ret == Result::TYPE_ERROR) {
3231 error += "Unknown 'columnNumber';";
3232 }
3233 // condition
3234 std::string condition;
3235 ret = params.GetString("condition", &condition);
3236 if (ret == Result::SUCCESS) {
3237 paramsObject->condition_ = std::move(condition);
3238 } else if (ret == Result::TYPE_ERROR) {
3239 error += "Unknown 'condition';";
3240 }
3241 // urlRegex
3242 std::string urlRegex;
3243 ret = params.GetString("urlRegex", &urlRegex);
3244 if (ret == Result::SUCCESS) {
3245 paramsObject->urlRegex_ = std::move(urlRegex);
3246 } else if (ret == Result::TYPE_ERROR) {
3247 error += "Unknown 'urlRegex';";
3248 }
3249 // scriptHash
3250 std::string scriptHash;
3251 ret = params.GetString("scriptHash", &scriptHash);
3252 if (ret == Result::SUCCESS) {
3253 paramsObject->scriptHash_ = std::move(scriptHash);
3254 } else if (ret == Result::TYPE_ERROR) {
3255 error += "Unknown 'scriptHash';";
3256 }
3257 // restrictToFunction
3258 bool restrictToFunction = false;
3259 ret = params.GetBool("restrictToFunction", &restrictToFunction);
3260 if (ret == Result::SUCCESS) {
3261 paramsObject->restrictToFunction_ = restrictToFunction;
3262 } else if (ret == Result::TYPE_ERROR) { // optional value
3263 error += "Unknown 'restrictToFunction';";
3264 }
3265
3266 if (!error.empty()) {
3267 LOG_DEBUGGER(ERROR) << "BreakpointInfo::Create " << error;
3268 return nullptr;
3269 }
3270 return paramsObject;
3271 }
3272
ToJson() const3273 std::unique_ptr<PtJson> BreakpointInfo::ToJson() const
3274 {
3275 std::unique_ptr<PtJson> result = PtJson::CreateObject();
3276 result->Add("lineNumber", lineNumber_);
3277 result->Add("columnNumber", columnNumber_);
3278 result->Add("url", url_.c_str());
3279 if (condition_) {
3280 result->Add("condition", condition_.value().c_str());
3281 }
3282 if (urlRegex_) {
3283 result->Add("urlRegex", urlRegex_.value().c_str());
3284 }
3285 if (scriptHash_) {
3286 result->Add("scriptHash", scriptHash_.value().c_str());
3287 }
3288 if (restrictToFunction_) {
3289 result->Add("restrictToFunction", restrictToFunction_.value());
3290 }
3291
3292 return result;
3293 }
3294
Create(const PtJson & params)3295 std::unique_ptr<BreakpointReturnInfo> BreakpointReturnInfo::Create(const PtJson ¶ms)
3296 {
3297 auto paramsObject = std::make_unique<BreakpointReturnInfo>();
3298 std::string error;
3299 Result ret;
3300 // lineNumber
3301 int32_t lineNumber;
3302 ret = params.GetInt("lineNumber", &lineNumber);
3303 if (ret == Result::SUCCESS) {
3304 paramsObject->lineNumber_ = lineNumber;
3305 } else {
3306 error += "Unknown 'lineNumber';";
3307 }
3308 // columnNumber
3309 int32_t columnNumber;
3310 ret = params.GetInt("columnNumber", &columnNumber);
3311 if (ret == Result::SUCCESS) {
3312 paramsObject->columnNumber_ = columnNumber;
3313 } else if (ret == Result::TYPE_ERROR) {
3314 error += "Unknown 'columnNumber';";
3315 }
3316 // id
3317 std::string id;
3318 ret = params.GetString("id", &id);
3319 if (ret == Result::SUCCESS) {
3320 paramsObject->id_ = std::move(id);
3321 } else if (ret == Result::TYPE_ERROR) {
3322 error += "Unknown 'id';";
3323 }
3324 // scriptId
3325 int32_t scriptId;
3326 ret = params.GetInt("scriptId", &scriptId);
3327 if (ret == Result::SUCCESS) {
3328 paramsObject->scriptId_ = scriptId;
3329 } else if (ret == Result::TYPE_ERROR) {
3330 error += "Unknown 'scriptId';";
3331 }
3332
3333 if (!error.empty()) {
3334 LOG_DEBUGGER(ERROR) << "BreakpointReturnInfo::Create " << error;
3335 return nullptr;
3336 }
3337
3338 return paramsObject;
3339 }
3340
ToJson() const3341 std::unique_ptr<PtJson> BreakpointReturnInfo::ToJson() const
3342 {
3343 std::unique_ptr<PtJson> result = PtJson::CreateObject();
3344 result->Add("lineNumber", lineNumber_);
3345 result->Add("columnNumber", columnNumber_);
3346 result->Add("id", id_.c_str());
3347 result->Add("scriptId", scriptId_);
3348
3349 return result;
3350 }
3351 } // namespace panda::ecmascript::tooling
3352