xref: /openbsd-src/gnu/llvm/lldb/tools/debugserver/source/JSON.cpp (revision 1ad61ae0a79a724d2d3ec69e69c8e1d1ff6b53a0) 
1 //===--------------------- JSON.cpp -----------------------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "JSON.h"
10 
11 // C includes
12 #include <cassert>
13 #include <climits>
14 
15 // C++ includes
16 #include "StringConvert.h"
17 #include <iomanip>
18 #include <sstream>
19 
20 std::string JSONString::json_string_quote_metachars(const std::string &s) {
21   if (s.find('"') == std::string::npos)
22     return s;
23 
24   std::string output;
25   const size_t s_size = s.size();
26   const char *s_chars = s.c_str();
27   for (size_t i = 0; i < s_size; i++) {
28     unsigned char ch = *(s_chars + i);
29     if (ch == '"') {
30       output.push_back('\\');
31     }
32     output.push_back(ch);
33   }
34   return output;
35 }
36 
37 JSONString::JSONString() : JSONValue(JSONValue::Kind::String), m_data() {}
38 
39 JSONString::JSONString(const char *s)
40     : JSONValue(JSONValue::Kind::String), m_data(s ? s : "") {}
41 
42 JSONString::JSONString(const std::string &s)
43     : JSONValue(JSONValue::Kind::String), m_data(s) {}
44 
45 void JSONString::Write(std::ostream &s) {
46   s << "\"" << json_string_quote_metachars(m_data).c_str() << "\"";
47 }
48 
49 uint64_t JSONNumber::GetAsUnsigned() const {
50   switch (m_data_type) {
51   case DataType::Unsigned:
52     return m_data.m_unsigned;
53   case DataType::Signed:
54     return (uint64_t)m_data.m_signed;
55   case DataType::Double:
56     return (uint64_t)m_data.m_double;
57   }
58 }
59 
60 int64_t JSONNumber::GetAsSigned() const {
61   switch (m_data_type) {
62   case DataType::Unsigned:
63     return (int64_t)m_data.m_unsigned;
64   case DataType::Signed:
65     return m_data.m_signed;
66   case DataType::Double:
67     return (int64_t)m_data.m_double;
68   }
69 }
70 
71 double JSONNumber::GetAsDouble() const {
72   switch (m_data_type) {
73   case DataType::Unsigned:
74     return (double)m_data.m_unsigned;
75   case DataType::Signed:
76     return (double)m_data.m_signed;
77   case DataType::Double:
78     return m_data.m_double;
79   }
80 }
81 
82 void JSONNumber::Write(std::ostream &s) {
83   switch (m_data_type) {
84   case DataType::Unsigned:
85     s << m_data.m_unsigned;
86     break;
87   case DataType::Signed:
88     s << m_data.m_signed;
89     break;
90   case DataType::Double:
91     // Set max precision to emulate %g.
92     s << std::setprecision(std::numeric_limits<double>::digits10 + 1);
93     s << m_data.m_double;
94     break;
95   }
96 }
97 
98 JSONTrue::JSONTrue() : JSONValue(JSONValue::Kind::True) {}
99 
100 void JSONTrue::Write(std::ostream &s) { s << "true"; }
101 
102 JSONFalse::JSONFalse() : JSONValue(JSONValue::Kind::False) {}
103 
104 void JSONFalse::Write(std::ostream &s) { s << "false"; }
105 
106 JSONNull::JSONNull() : JSONValue(JSONValue::Kind::Null) {}
107 
108 void JSONNull::Write(std::ostream &s) { s << "null"; }
109 
110 JSONObject::JSONObject() : JSONValue(JSONValue::Kind::Object) {}
111 
112 void JSONObject::Write(std::ostream &s) {
113   bool first = true;
114   s << '{';
115   auto iter = m_elements.begin(), end = m_elements.end();
116   for (; iter != end; iter++) {
117     if (first)
118       first = false;
119     else
120       s << ',';
121     JSONString key(iter->first);
122     JSONValue::SP value(iter->second);
123     key.Write(s);
124     s << ':';
125     value->Write(s);
126   }
127   s << '}';
128 }
129 
130 bool JSONObject::SetObject(const std::string &key, JSONValue::SP value) {
131   if (key.empty() || nullptr == value.get())
132     return false;
133   m_elements[key] = value;
134   return true;
135 }
136 
137 JSONValue::SP JSONObject::GetObject(const std::string &key) const {
138   auto iter = m_elements.find(key), end = m_elements.end();
139   if (iter == end)
140     return JSONValue::SP();
141   return iter->second;
142 }
143 
144 bool JSONObject::GetObjectAsBool(const std::string &key, bool &value) const {
145   auto value_sp = GetObject(key);
146   if (!value_sp) {
147     // The given key doesn't exist, so we have no value.
148     return false;
149   }
150 
151   if (JSONTrue::classof(value_sp.get())) {
152     // We have the value, and it is true.
153     value = true;
154     return true;
155   } else if (JSONFalse::classof(value_sp.get())) {
156     // We have the value, and it is false.
157     value = false;
158     return true;
159   } else {
160     // We don't have a valid bool value for the given key.
161     return false;
162   }
163 }
164 
165 bool JSONObject::GetObjectAsString(const std::string &key,
166                                    std::string &value) const {
167   auto value_sp = GetObject(key);
168   if (!value_sp) {
169     // The given key doesn't exist, so we have no value.
170     return false;
171   }
172 
173   if (!JSONString::classof(value_sp.get()))
174     return false;
175 
176   value = static_cast<JSONString *>(value_sp.get())->GetData();
177   return true;
178 }
179 
180 JSONArray::JSONArray() : JSONValue(JSONValue::Kind::Array) {}
181 
182 void JSONArray::Write(std::ostream &s) {
183   bool first = true;
184   s << '[';
185   auto iter = m_elements.begin(), end = m_elements.end();
186   for (; iter != end; iter++) {
187     if (first)
188       first = false;
189     else
190       s << ',';
191     (*iter)->Write(s);
192   }
193   s << ']';
194 }
195 
196 bool JSONArray::SetObject(Index i, JSONValue::SP value) {
197   if (value.get() == nullptr)
198     return false;
199   if (i < m_elements.size()) {
200     m_elements[i] = value;
201     return true;
202   }
203   if (i == m_elements.size()) {
204     m_elements.push_back(value);
205     return true;
206   }
207   return false;
208 }
209 
210 bool JSONArray::AppendObject(JSONValue::SP value) {
211   if (value.get() == nullptr)
212     return false;
213   m_elements.push_back(value);
214   return true;
215 }
216 
217 JSONValue::SP JSONArray::GetObject(Index i) {
218   if (i < m_elements.size())
219     return m_elements[i];
220   return JSONValue::SP();
221 }
222 
223 JSONArray::Size JSONArray::GetNumElements() { return m_elements.size(); }
224 
225 JSONParser::JSONParser(const char *cstr) : StdStringExtractor(cstr) {}
226 
227 JSONParser::Token JSONParser::GetToken(std::string &value) {
228   std::ostringstream error;
229 
230   value.clear();
231   SkipSpaces();
232   const uint64_t start_index = m_index;
233   const char ch = GetChar();
234   switch (ch) {
235   case '{':
236     return Token::ObjectStart;
237   case '}':
238     return Token::ObjectEnd;
239   case '[':
240     return Token::ArrayStart;
241   case ']':
242     return Token::ArrayEnd;
243   case ',':
244     return Token::Comma;
245   case ':':
246     return Token::Colon;
247   case '\0':
248     return Token::EndOfFile;
249   case 't':
250     if (GetChar() == 'r')
251       if (GetChar() == 'u')
252         if (GetChar() == 'e')
253           return Token::True;
254     break;
255 
256   case 'f':
257     if (GetChar() == 'a')
258       if (GetChar() == 'l')
259         if (GetChar() == 's')
260           if (GetChar() == 'e')
261             return Token::False;
262     break;
263 
264   case 'n':
265     if (GetChar() == 'u')
266       if (GetChar() == 'l')
267         if (GetChar() == 'l')
268           return Token::Null;
269     break;
270 
271   case '"': {
272     while (true) {
273       bool was_escaped = false;
274       int escaped_ch = GetEscapedChar(was_escaped);
275       if (escaped_ch == -1) {
276         error << "error: an error occurred getting a character from offset "
277               << start_index;
278         value = error.str();
279         return Token::Status;
280 
281       } else {
282         const bool is_end_quote = escaped_ch == '"';
283         const bool is_null = escaped_ch == 0;
284         if (was_escaped || (!is_end_quote && !is_null)) {
285           if (CHAR_MIN <= escaped_ch && escaped_ch <= CHAR_MAX) {
286             value.append(1, (char)escaped_ch);
287           } else {
288             error << "error: wide character support is needed for unicode "
289                      "character 0x"
290                   << std::setprecision(4) << std::hex << escaped_ch;
291             error << " at offset " << start_index;
292             value = error.str();
293             return Token::Status;
294           }
295         } else if (is_end_quote) {
296           return Token::String;
297         } else if (is_null) {
298           value = "error: missing end quote for string";
299           return Token::Status;
300         }
301       }
302     }
303   } break;
304 
305   case '-':
306   case '0':
307   case '1':
308   case '2':
309   case '3':
310   case '4':
311   case '5':
312   case '6':
313   case '7':
314   case '8':
315   case '9': {
316     bool done = false;
317     bool got_decimal_point = false;
318     uint64_t exp_index = 0;
319     bool got_int_digits = (ch >= '0') && (ch <= '9');
320     bool got_frac_digits = false;
321     bool got_exp_digits = false;
322     while (!done) {
323       const char next_ch = PeekChar();
324       switch (next_ch) {
325       case '0':
326       case '1':
327       case '2':
328       case '3':
329       case '4':
330       case '5':
331       case '6':
332       case '7':
333       case '8':
334       case '9':
335         if (exp_index != 0) {
336           got_exp_digits = true;
337         } else if (got_decimal_point) {
338           got_frac_digits = true;
339         } else {
340           got_int_digits = true;
341         }
342         ++m_index; // Skip this character
343         break;
344 
345       case '.':
346         if (got_decimal_point) {
347           error << "error: extra decimal point found at offset " << start_index;
348           value = error.str();
349           return Token::Status;
350         } else {
351           got_decimal_point = true;
352           ++m_index; // Skip this character
353         }
354         break;
355 
356       case 'e':
357       case 'E':
358         if (exp_index != 0) {
359           error << "error: extra exponent character found at offset "
360                 << start_index;
361           value = error.str();
362           return Token::Status;
363         } else {
364           exp_index = m_index;
365           ++m_index; // Skip this character
366         }
367         break;
368 
369       case '+':
370       case '-':
371         // The '+' and '-' can only come after an exponent character...
372         if (exp_index == m_index - 1) {
373           ++m_index; // Skip the exponent sign character
374         } else {
375           error << "error: unexpected " << next_ch << " character at offset "
376                 << start_index;
377           value = error.str();
378           return Token::Status;
379         }
380         break;
381 
382       default:
383         done = true;
384         break;
385       }
386     }
387 
388     if (m_index > start_index) {
389       value = m_packet.substr(start_index, m_index - start_index);
390       if (got_decimal_point) {
391         if (exp_index != 0) {
392           // We have an exponent, make sure we got exponent digits
393           if (got_exp_digits) {
394             return Token::Float;
395           } else {
396             error << "error: got exponent character but no exponent digits at "
397                      "offset in float value \""
398                   << value.c_str() << "\"";
399             value = error.str();
400             return Token::Status;
401           }
402         } else {
403           // No exponent, but we need at least one decimal after the decimal
404           // point
405           if (got_frac_digits) {
406             return Token::Float;
407           } else {
408             error << "error: no digits after decimal point \"" << value.c_str()
409                   << "\"";
410             value = error.str();
411             return Token::Status;
412           }
413         }
414       } else {
415         // No decimal point
416         if (got_int_digits) {
417           // We need at least some integer digits to make an integer
418           return Token::Integer;
419         } else {
420           error << "error: no digits negate sign \"" << value.c_str() << "\"";
421           value = error.str();
422           return Token::Status;
423         }
424       }
425     } else {
426       error << "error: invalid number found at offset " << start_index;
427       value = error.str();
428       return Token::Status;
429     }
430   } break;
431   default:
432     break;
433   }
434   error << "error: failed to parse token at offset " << start_index
435         << " (around character '" << ch << "')";
436   value = error.str();
437   return Token::Status;
438 }
439 
440 int JSONParser::GetEscapedChar(bool &was_escaped) {
441   was_escaped = false;
442   const char ch = GetChar();
443   if (ch == '\\') {
444     was_escaped = true;
445     const char ch2 = GetChar();
446     switch (ch2) {
447     case '"':
448     case '\\':
449     case '/':
450     default:
451       break;
452 
453     case 'b':
454       return '\b';
455     case 'f':
456       return '\f';
457     case 'n':
458       return '\n';
459     case 'r':
460       return '\r';
461     case 't':
462       return '\t';
463     case 'u': {
464       const int hi_byte = DecodeHexU8();
465       const int lo_byte = DecodeHexU8();
466       if (hi_byte >= 0 && lo_byte >= 0)
467         return hi_byte << 8 | lo_byte;
468       return -1;
469     } break;
470     }
471     return ch2;
472   }
473   return ch;
474 }
475 
476 JSONValue::SP JSONParser::ParseJSONObject() {
477   // The "JSONParser::Token::ObjectStart" token should have already been
478   // consumed
479   // by the time this function is called
480   std::unique_ptr<JSONObject> dict_up(new JSONObject());
481 
482   std::string value;
483   std::string key;
484   while (true) {
485     JSONParser::Token token = GetToken(value);
486 
487     if (token == JSONParser::Token::String) {
488       key.swap(value);
489       token = GetToken(value);
490       if (token == JSONParser::Token::Colon) {
491         JSONValue::SP value_sp = ParseJSONValue();
492         if (value_sp)
493           dict_up->SetObject(key, value_sp);
494         else
495           break;
496       }
497     } else if (token == JSONParser::Token::ObjectEnd) {
498       return JSONValue::SP(dict_up.release());
499     } else if (token == JSONParser::Token::Comma) {
500       continue;
501     } else {
502       break;
503     }
504   }
505   return JSONValue::SP();
506 }
507 
508 JSONValue::SP JSONParser::ParseJSONArray() {
509   // The "JSONParser::Token::ObjectStart" token should have already been
510   // consumed
511   // by the time this function is called
512   std::unique_ptr<JSONArray> array_up(new JSONArray());
513 
514   std::string value;
515   std::string key;
516   while (true) {
517     JSONParser::Token token = GetToken(value);
518     if (token == JSONParser::Token::ArrayEnd)
519       return JSONValue::SP(array_up.release());
520     JSONValue::SP value_sp = ParseJSONValue(value, token);
521     if (value_sp)
522       array_up->AppendObject(value_sp);
523     else
524       break;
525 
526     token = GetToken(value);
527     if (token == JSONParser::Token::Comma) {
528       continue;
529     } else if (token == JSONParser::Token::ArrayEnd) {
530       return JSONValue::SP(array_up.release());
531     } else {
532       break;
533     }
534   }
535   return JSONValue::SP();
536 }
537 
538 JSONValue::SP JSONParser::ParseJSONValue() {
539   std::string value;
540   const JSONParser::Token token = GetToken(value);
541   return ParseJSONValue(value, token);
542 }
543 
544 JSONValue::SP JSONParser::ParseJSONValue(const std::string &value,
545                                          const Token &token) {
546   switch (token) {
547   case JSONParser::Token::ObjectStart:
548     return ParseJSONObject();
549 
550   case JSONParser::Token::ArrayStart:
551     return ParseJSONArray();
552 
553   case JSONParser::Token::Integer: {
554     if (value.front() == '-') {
555       bool success = false;
556       int64_t sval = StringConvert::ToSInt64(value.c_str(), 0, 0, &success);
557       if (success)
558         return JSONValue::SP(new JSONNumber(sval));
559     } else {
560       bool success = false;
561       uint64_t uval = StringConvert::ToUInt64(value.c_str(), 0, 0, &success);
562       if (success)
563         return JSONValue::SP(new JSONNumber(uval));
564     }
565   } break;
566 
567   case JSONParser::Token::Float: {
568     bool success = false;
569     double val = StringConvert::ToDouble(value.c_str(), 0.0, &success);
570     if (success)
571       return JSONValue::SP(new JSONNumber(val));
572   } break;
573 
574   case JSONParser::Token::String:
575     return JSONValue::SP(new JSONString(value));
576 
577   case JSONParser::Token::True:
578     return JSONValue::SP(new JSONTrue());
579 
580   case JSONParser::Token::False:
581     return JSONValue::SP(new JSONFalse());
582 
583   case JSONParser::Token::Null:
584     return JSONValue::SP(new JSONNull());
585 
586   default:
587     break;
588   }
589   return JSONValue::SP();
590 }
591