Line data Source code
1 : // Copyright 2016 the V8 project authors. All rights reserved.
2 : // Use of this source code is governed by a BSD-style license that can be
3 : // found in the LICENSE file.
4 :
5 : #include "src/tracing/traced-value.h"
6 :
7 : #include "src/base/platform/platform.h"
8 : #include "src/conversions.h"
9 :
10 : namespace v8 {
11 : namespace tracing {
12 :
13 : namespace {
14 :
15 : #define DCHECK_CURRENT_CONTAINER_IS(x) DCHECK_EQ(x, nesting_stack_.back())
16 : #define DCHECK_CONTAINER_STACK_DEPTH_EQ(x) DCHECK_EQ(x, nesting_stack_.size())
17 : #ifdef DEBUG
18 : const bool kStackTypeDict = false;
19 : const bool kStackTypeArray = true;
20 : #define DEBUG_PUSH_CONTAINER(x) nesting_stack_.push_back(x)
21 : #define DEBUG_POP_CONTAINER() nesting_stack_.pop_back()
22 : #else
23 : #define DEBUG_PUSH_CONTAINER(x) ((void)0)
24 : #define DEBUG_POP_CONTAINER() ((void)0)
25 : #endif
26 :
27 2866 : void EscapeAndAppendString(const char* value, std::string* result) {
28 : *result += '"';
29 : char number_buffer[10];
30 49096 : while (*value) {
31 46230 : char c = *value++;
32 46230 : switch (c) {
33 : case '\t':
34 : *result += "\\t";
35 : break;
36 : case '\n':
37 : *result += "\\n";
38 : break;
39 : case '\"':
40 : *result += "\\\"";
41 : break;
42 : case '\\':
43 : *result += "\\\\";
44 : break;
45 : default:
46 46160 : if (c < '\040') {
47 : base::OS::SNPrintF(
48 : number_buffer, arraysize(number_buffer), "\\u%04X",
49 210 : static_cast<unsigned>(static_cast<unsigned char>(c)));
50 : *result += number_buffer;
51 : } else {
52 : *result += c;
53 : }
54 : }
55 : }
56 : *result += '"';
57 2866 : }
58 :
59 : } // namespace
60 :
61 1741 : std::unique_ptr<TracedValue> TracedValue::Create() {
62 3482 : return std::unique_ptr<TracedValue>(new TracedValue());
63 : }
64 :
65 3482 : TracedValue::TracedValue() : first_item_(true) {
66 : DEBUG_PUSH_CONTAINER(kStackTypeDict);
67 0 : }
68 :
69 1741 : TracedValue::~TracedValue() {
70 : DCHECK_CURRENT_CONTAINER_IS(kStackTypeDict);
71 : DEBUG_POP_CONTAINER();
72 : DCHECK_CONTAINER_STACK_DEPTH_EQ(0u);
73 1741 : }
74 :
75 8374 : void TracedValue::SetInteger(const char* name, int value) {
76 : DCHECK_CURRENT_CONTAINER_IS(kStackTypeDict);
77 8374 : WriteName(name);
78 16748 : data_ += std::to_string(value);
79 8374 : }
80 :
81 1374 : void TracedValue::SetDouble(const char* name, double value) {
82 : DCHECK_CURRENT_CONTAINER_IS(kStackTypeDict);
83 1374 : WriteName(name);
84 : i::EmbeddedVector<char, 100> buffer;
85 1374 : data_ += DoubleToCString(value, buffer);
86 1374 : }
87 :
88 28 : void TracedValue::SetBoolean(const char* name, bool value) {
89 : DCHECK_CURRENT_CONTAINER_IS(kStackTypeDict);
90 28 : WriteName(name);
91 28 : data_ += value ? "true" : "false";
92 28 : }
93 :
94 2852 : void TracedValue::SetString(const char* name, const char* value) {
95 : DCHECK_CURRENT_CONTAINER_IS(kStackTypeDict);
96 2852 : WriteName(name);
97 2852 : EscapeAndAppendString(value, &data_);
98 2852 : }
99 :
100 2995 : void TracedValue::BeginDictionary(const char* name) {
101 : DCHECK_CURRENT_CONTAINER_IS(kStackTypeDict);
102 : DEBUG_PUSH_CONTAINER(kStackTypeDict);
103 2995 : WriteName(name);
104 2995 : data_ += '{';
105 2995 : first_item_ = true;
106 2995 : }
107 :
108 578 : void TracedValue::BeginArray(const char* name) {
109 : DCHECK_CURRENT_CONTAINER_IS(kStackTypeDict);
110 : DEBUG_PUSH_CONTAINER(kStackTypeArray);
111 578 : WriteName(name);
112 578 : data_ += '[';
113 578 : first_item_ = true;
114 578 : }
115 :
116 17049 : void TracedValue::AppendInteger(int value) {
117 : DCHECK_CURRENT_CONTAINER_IS(kStackTypeArray);
118 : WriteComma();
119 34098 : data_ += std::to_string(value);
120 17049 : }
121 :
122 0 : void TracedValue::AppendDouble(double value) {
123 : DCHECK_CURRENT_CONTAINER_IS(kStackTypeArray);
124 : WriteComma();
125 : i::EmbeddedVector<char, 100> buffer;
126 0 : data_ += DoubleToCString(value, buffer);
127 0 : }
128 :
129 7 : void TracedValue::AppendBoolean(bool value) {
130 : DCHECK_CURRENT_CONTAINER_IS(kStackTypeArray);
131 : WriteComma();
132 7 : data_ += value ? "true" : "false";
133 7 : }
134 :
135 14 : void TracedValue::AppendString(const char* value) {
136 : DCHECK_CURRENT_CONTAINER_IS(kStackTypeArray);
137 : WriteComma();
138 14 : EscapeAndAppendString(value, &data_);
139 14 : }
140 :
141 2649 : void TracedValue::BeginDictionary() {
142 : DCHECK_CURRENT_CONTAINER_IS(kStackTypeArray);
143 : DEBUG_PUSH_CONTAINER(kStackTypeDict);
144 : WriteComma();
145 2649 : data_ += '{';
146 2649 : first_item_ = true;
147 2649 : }
148 :
149 7 : void TracedValue::BeginArray() {
150 : DCHECK_CURRENT_CONTAINER_IS(kStackTypeArray);
151 : DEBUG_PUSH_CONTAINER(kStackTypeArray);
152 : WriteComma();
153 7 : data_ += '[';
154 7 : first_item_ = true;
155 7 : }
156 :
157 5644 : void TracedValue::EndDictionary() {
158 : DCHECK_CURRENT_CONTAINER_IS(kStackTypeDict);
159 : DEBUG_POP_CONTAINER();
160 5644 : data_ += '}';
161 5644 : first_item_ = false;
162 5644 : }
163 :
164 585 : void TracedValue::EndArray() {
165 : DCHECK_CURRENT_CONTAINER_IS(kStackTypeArray);
166 : DEBUG_POP_CONTAINER();
167 585 : data_ += ']';
168 585 : first_item_ = false;
169 585 : }
170 :
171 0 : void TracedValue::WriteComma() {
172 35927 : if (first_item_) {
173 7949 : first_item_ = false;
174 : } else {
175 27978 : data_ += ',';
176 : }
177 0 : }
178 :
179 16201 : void TracedValue::WriteName(const char* name) {
180 : WriteComma();
181 16201 : data_ += '"';
182 : data_ += name;
183 : data_ += "\":";
184 16201 : }
185 :
186 41 : void TracedValue::AppendAsTraceFormat(std::string* out) const {
187 : *out += '{';
188 41 : *out += data_;
189 : *out += '}';
190 41 : }
191 :
192 : } // namespace tracing
193 : } // namespace v8
|
