1 //===---------------------StructuredData.cpp ---------------------*- C++-*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 #include "lldb/Utility/StructuredData.h"
11 #include "lldb/Utility/DataBuffer.h"
12 #include "lldb/Utility/FileSpec.h"
13 #include "lldb/Utility/JSON.h"
14 #include "lldb/Utility/Status.h"
15 #include "lldb/Utility/Stream.h"
16 #include "lldb/Utility/StreamString.h"
17 #include "llvm/ADT/STLExtras.h"
18 #include "llvm/Support/MemoryBuffer.h"
19 #include <cerrno>
20 #include <cstdlib>
21 #include <inttypes.h>
22 #include <limits>
23
24 using namespace lldb_private;
25
26 //----------------------------------------------------------------------
27 // Functions that use a JSONParser to parse JSON into StructuredData
28 //----------------------------------------------------------------------
29 static StructuredData::ObjectSP ParseJSONValue(JSONParser &json_parser);
30 static StructuredData::ObjectSP ParseJSONObject(JSONParser &json_parser);
31 static StructuredData::ObjectSP ParseJSONArray(JSONParser &json_parser);
32
33 StructuredData::ObjectSP
ParseJSONFromFile(const FileSpec & input_spec,Status & error)34 StructuredData::ParseJSONFromFile(const FileSpec &input_spec, Status &error) {
35 StructuredData::ObjectSP return_sp;
36
37 auto buffer_or_error = llvm::MemoryBuffer::getFile(input_spec.GetPath());
38 if (!buffer_or_error) {
39 error.SetErrorStringWithFormatv("could not open input file: {0} - {1}.",
40 input_spec.GetPath(),
41 buffer_or_error.getError().message());
42 return return_sp;
43 }
44
45 JSONParser json_parser(buffer_or_error.get()->getBuffer());
46 return_sp = ParseJSONValue(json_parser);
47 return return_sp;
48 }
49
ParseJSONObject(JSONParser & json_parser)50 static StructuredData::ObjectSP ParseJSONObject(JSONParser &json_parser) {
51 // The "JSONParser::Token::ObjectStart" token should have already been
52 // consumed by the time this function is called
53 auto dict_up = llvm::make_unique<StructuredData::Dictionary>();
54
55 std::string value;
56 std::string key;
57 while (1) {
58 JSONParser::Token token = json_parser.GetToken(value);
59
60 if (token == JSONParser::Token::String) {
61 key.swap(value);
62 token = json_parser.GetToken(value);
63 if (token == JSONParser::Token::Colon) {
64 StructuredData::ObjectSP value_sp = ParseJSONValue(json_parser);
65 if (value_sp)
66 dict_up->AddItem(key, value_sp);
67 else
68 break;
69 }
70 } else if (token == JSONParser::Token::ObjectEnd) {
71 return StructuredData::ObjectSP(dict_up.release());
72 } else if (token == JSONParser::Token::Comma) {
73 continue;
74 } else {
75 break;
76 }
77 }
78 return StructuredData::ObjectSP();
79 }
80
ParseJSONArray(JSONParser & json_parser)81 static StructuredData::ObjectSP ParseJSONArray(JSONParser &json_parser) {
82 // The "JSONParser::Token::ObjectStart" token should have already been
83 // consumed by the time this function is called
84 auto array_up = llvm::make_unique<StructuredData::Array>();
85
86 std::string value;
87 std::string key;
88 while (1) {
89 StructuredData::ObjectSP value_sp = ParseJSONValue(json_parser);
90 if (value_sp)
91 array_up->AddItem(value_sp);
92 else
93 break;
94
95 JSONParser::Token token = json_parser.GetToken(value);
96 if (token == JSONParser::Token::Comma) {
97 continue;
98 } else if (token == JSONParser::Token::ArrayEnd) {
99 return StructuredData::ObjectSP(array_up.release());
100 } else {
101 break;
102 }
103 }
104 return StructuredData::ObjectSP();
105 }
106
ParseJSONValue(JSONParser & json_parser)107 static StructuredData::ObjectSP ParseJSONValue(JSONParser &json_parser) {
108 std::string value;
109 const JSONParser::Token token = json_parser.GetToken(value);
110 switch (token) {
111 case JSONParser::Token::ObjectStart:
112 return ParseJSONObject(json_parser);
113
114 case JSONParser::Token::ArrayStart:
115 return ParseJSONArray(json_parser);
116
117 case JSONParser::Token::Integer: {
118 uint64_t uval;
119 if (llvm::to_integer(value, uval, 0))
120 return std::make_shared<StructuredData::Integer>(uval);
121 } break;
122
123 case JSONParser::Token::Float: {
124 double val;
125 if (llvm::to_float(value, val))
126 return std::make_shared<StructuredData::Float>(val);
127 } break;
128
129 case JSONParser::Token::String:
130 return std::make_shared<StructuredData::String>(value);
131
132 case JSONParser::Token::True:
133 case JSONParser::Token::False:
134 return std::make_shared<StructuredData::Boolean>(token ==
135 JSONParser::Token::True);
136
137 case JSONParser::Token::Null:
138 return std::make_shared<StructuredData::Null>();
139
140 default:
141 break;
142 }
143 return StructuredData::ObjectSP();
144 }
145
ParseJSON(std::string json_text)146 StructuredData::ObjectSP StructuredData::ParseJSON(std::string json_text) {
147 JSONParser json_parser(json_text);
148 StructuredData::ObjectSP object_sp = ParseJSONValue(json_parser);
149 return object_sp;
150 }
151
152 StructuredData::ObjectSP
GetObjectForDotSeparatedPath(llvm::StringRef path)153 StructuredData::Object::GetObjectForDotSeparatedPath(llvm::StringRef path) {
154 if (this->GetType() == lldb::eStructuredDataTypeDictionary) {
155 std::pair<llvm::StringRef, llvm::StringRef> match = path.split('.');
156 std::string key = match.first.str();
157 ObjectSP value = this->GetAsDictionary()->GetValueForKey(key);
158 if (value.get()) {
159 // Do we have additional words to descend? If not, return the value
160 // we're at right now.
161 if (match.second.empty()) {
162 return value;
163 } else {
164 return value->GetObjectForDotSeparatedPath(match.second);
165 }
166 }
167 return ObjectSP();
168 }
169
170 if (this->GetType() == lldb::eStructuredDataTypeArray) {
171 std::pair<llvm::StringRef, llvm::StringRef> match = path.split('[');
172 if (match.second.empty()) {
173 return this->shared_from_this();
174 }
175 errno = 0;
176 uint64_t val = strtoul(match.second.str().c_str(), nullptr, 10);
177 if (errno == 0) {
178 return this->GetAsArray()->GetItemAtIndex(val);
179 }
180 return ObjectSP();
181 }
182
183 return this->shared_from_this();
184 }
185
DumpToStdout(bool pretty_print) const186 void StructuredData::Object::DumpToStdout(bool pretty_print) const {
187 StreamString stream;
188 Dump(stream, pretty_print);
189 llvm::outs() << stream.GetString();
190 }
191
Dump(Stream & s,bool pretty_print) const192 void StructuredData::Array::Dump(Stream &s, bool pretty_print) const {
193 bool first = true;
194 s << "[";
195 if (pretty_print) {
196 s << "\n";
197 s.IndentMore();
198 }
199 for (const auto &item_sp : m_items) {
200 if (first) {
201 first = false;
202 } else {
203 s << ",";
204 if (pretty_print)
205 s << "\n";
206 }
207
208 if (pretty_print)
209 s.Indent();
210 item_sp->Dump(s, pretty_print);
211 }
212 if (pretty_print) {
213 s.IndentLess();
214 s.EOL();
215 s.Indent();
216 }
217 s << "]";
218 }
219
Dump(Stream & s,bool pretty_print) const220 void StructuredData::Integer::Dump(Stream &s, bool pretty_print) const {
221 s.Printf("%" PRIu64, m_value);
222 }
223
Dump(Stream & s,bool pretty_print) const224 void StructuredData::Float::Dump(Stream &s, bool pretty_print) const {
225 s.Printf("%lg", m_value);
226 }
227
Dump(Stream & s,bool pretty_print) const228 void StructuredData::Boolean::Dump(Stream &s, bool pretty_print) const {
229 if (m_value)
230 s.PutCString("true");
231 else
232 s.PutCString("false");
233 }
234
Dump(Stream & s,bool pretty_print) const235 void StructuredData::String::Dump(Stream &s, bool pretty_print) const {
236 std::string quoted;
237 const size_t strsize = m_value.size();
238 for (size_t i = 0; i < strsize; ++i) {
239 char ch = m_value[i];
240 if (ch == '"' || ch == '\\')
241 quoted.push_back('\\');
242 quoted.push_back(ch);
243 }
244 s.Printf("\"%s\"", quoted.c_str());
245 }
246
Dump(Stream & s,bool pretty_print) const247 void StructuredData::Dictionary::Dump(Stream &s, bool pretty_print) const {
248 bool first = true;
249 s << "{";
250 if (pretty_print) {
251 s << "\n";
252 s.IndentMore();
253 }
254 for (const auto &pair : m_dict) {
255 if (first)
256 first = false;
257 else {
258 s << ",";
259 if (pretty_print)
260 s << "\n";
261 }
262 if (pretty_print)
263 s.Indent();
264 s << "\"" << pair.first.AsCString() << "\" : ";
265 pair.second->Dump(s, pretty_print);
266 }
267 if (pretty_print) {
268 s.IndentLess();
269 s.EOL();
270 s.Indent();
271 }
272 s << "}";
273 }
274
Dump(Stream & s,bool pretty_print) const275 void StructuredData::Null::Dump(Stream &s, bool pretty_print) const {
276 s << "null";
277 }
278
Dump(Stream & s,bool pretty_print) const279 void StructuredData::Generic::Dump(Stream &s, bool pretty_print) const {
280 s << "0x" << m_object;
281 }
282