OSchip
/
llvm-project
mirror of https://github.com/THU-DSP-LAB/llvm-project.git
13
0
Fork 6
Code Issues Packages Projects Releases Wiki Activity
llvm-project/lldb/tools/debugserver/source/JSON.cpp

586 lines
15 KiB
C++
Raw Blame History

//===--------------------- JSON.cpp -----------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "JSON.h"
// C includes
#include <assert.h>
#include <limits.h>
// C++ includes
#include "lldb/Host/StringConvert.h"
#include <iomanip>
#include <sstream>
using namespace lldb_private;
std::string JSONString::json_string_quote_metachars(const std::string &s) {
if (s.find('"') == std::string::npos)
return s;
std::string output;
const size_t s_size = s.size();
const char *s_chars = s.c_str();
for (size_t i = 0; i < s_size; i++) {
unsigned char ch = *(s_chars + i);
if (ch == '"') {
output.push_back('\\');
}
output.push_back(ch);
}
return output;
}
JSONString::JSONString() : JSONValue(JSONValue::Kind::String), m_data() {}
JSONString::JSONString(const char *s)
: JSONValue(JSONValue::Kind::String), m_data(s ? s : "") {}
JSONString::JSONString(const std::string &s)
: JSONValue(JSONValue::Kind::String), m_data(s) {}
void JSONString::Write(std::ostream &s) {
s << "\"" << json_string_quote_metachars(m_data).c_str() << "\"";
}
uint64_t JSONNumber::GetAsUnsigned() const {
switch (m_data_type) {
case DataType::Unsigned:
return m_data.m_unsigned;
case DataType::Signed:
return (uint64_t)m_data.m_signed;
case DataType::Double:
return (uint64_t)m_data.m_double;
}
}
int64_t JSONNumber::GetAsSigned() const {
switch (m_data_type) {
case DataType::Unsigned:
return (int64_t)m_data.m_unsigned;
case DataType::Signed:
return m_data.m_signed;
case DataType::Double:
return (int64_t)m_data.m_double;
}
}
double JSONNumber::GetAsDouble() const {
switch (m_data_type) {
case DataType::Unsigned:
return (double)m_data.m_unsigned;
case DataType::Signed:
return (double)m_data.m_signed;
case DataType::Double:
return m_data.m_double;
}
}
void JSONNumber::Write(std::ostream &s) {
switch (m_data_type) {
case DataType::Unsigned:
s << m_data.m_unsigned;
break;
case DataType::Signed:
s << m_data.m_signed;
break;
case DataType::Double:
// Set max precision to emulate %g.
s << std::setprecision(std::numeric_limits<double>::digits10 + 1);
s << m_data.m_double;
break;
}
}
JSONTrue::JSONTrue() : JSONValue(JSONValue::Kind::True) {}
void JSONTrue::Write(std::ostream &s) { s << "true"; }
JSONFalse::JSONFalse() : JSONValue(JSONValue::Kind::False) {}
void JSONFalse::Write(std::ostream &s) { s << "false"; }
JSONNull::JSONNull() : JSONValue(JSONValue::Kind::Null) {}
void JSONNull::Write(std::ostream &s) { s << "null"; }
JSONObject::JSONObject() : JSONValue(JSONValue::Kind::Object) {}
void JSONObject::Write(std::ostream &s) {
bool first = true;
s << '{';
auto iter = m_elements.begin(), end = m_elements.end();
for (; iter != end; iter++) {
if (first)
first = false;
else
s << ',';
JSONString key(iter->first);
JSONValue::SP value(iter->second);
key.Write(s);
s << ':';
value->Write(s);
}
s << '}';
}
bool JSONObject::SetObject(const std::string &key, JSONValue::SP value) {
if (key.empty() || nullptr == value.get())
return false;
m_elements[key] = value;
return true;
}
JSONValue::SP JSONObject::GetObject(const std::string &key) const {
auto iter = m_elements.find(key), end = m_elements.end();
if (iter == end)
return JSONValue::SP();
return iter->second;
}
bool JSONObject::GetObjectAsBool(const std::string &key, bool &value) const {
auto value_sp = GetObject(key);
if (!value_sp) {
// The given key doesn't exist, so we have no value.
return false;
}
if (JSONTrue::classof(value_sp.get())) {
// We have the value, and it is true.
value = true;
return true;
} else if (JSONFalse::classof(value_sp.get())) {
// We have the value, and it is false.
value = false;
return true;
} else {
// We don't have a valid bool value for the given key.
return false;
}
}
bool JSONObject::GetObjectAsString(const std::string &key,
std::string &value) const {
auto value_sp = GetObject(key);
if (!value_sp) {
// The given key doesn't exist, so we have no value.
return false;
}
if (!JSONString::classof(value_sp.get()))
return false;
value = static_cast<JSONString *>(value_sp.get())->GetData();
return true;
}
JSONArray::JSONArray() : JSONValue(JSONValue::Kind::Array) {}
void JSONArray::Write(std::ostream &s) {
bool first = true;
s << '[';
auto iter = m_elements.begin(), end = m_elements.end();
for (; iter != end; iter++) {
if (first)
first = false;
else
s << ',';
(*iter)->Write(s);
}
s << ']';
}
bool JSONArray::SetObject(Index i, JSONValue::SP value) {
if (value.get() == nullptr)
return false;
if (i < m_elements.size()) {
m_elements[i] = value;
return true;
}
if (i == m_elements.size()) {
m_elements.push_back(value);
return true;
}
return false;
}
bool JSONArray::AppendObject(JSONValue::SP value) {
if (value.get() == nullptr)
return false;
m_elements.push_back(value);
return true;
}
JSONValue::SP JSONArray::GetObject(Index i) {
if (i < m_elements.size())
return m_elements[i];
return JSONValue::SP();
}
JSONArray::Size JSONArray::GetNumElements() { return m_elements.size(); }
JSONParser::JSONParser(const char *cstr) : StdStringExtractor(cstr) {}
JSONParser::Token JSONParser::GetToken(std::string &value) {
std::ostringstream error;
value.clear();
SkipSpaces();
const uint64_t start_index = m_index;
const char ch = GetChar();
switch (ch) {
case '{':
return Token::ObjectStart;
case '}':
return Token::ObjectEnd;
case '[':
return Token::ArrayStart;
case ']':
return Token::ArrayEnd;
case ',':
return Token::Comma;
case ':':
return Token::Colon;
case '\0':
return Token::EndOfFile;
case 't':
if (GetChar() == 'r')
if (GetChar() == 'u')
if (GetChar() == 'e')
return Token::True;
break;
case 'f':
if (GetChar() == 'a')
if (GetChar() == 'l')
if (GetChar() == 's')
if (GetChar() == 'e')
return Token::False;
break;
case 'n':
if (GetChar() == 'u')
if (GetChar() == 'l')
if (GetChar() == 'l')
return Token::Null;
break;
case '"': {
while (1) {
bool was_escaped = false;
int escaped_ch = GetEscapedChar(was_escaped);
if (escaped_ch == -1) {
error << "error: an error occurred getting a character from offset "
<< start_index;
value = error.str();
return Token::Status;
} else {
const bool is_end_quote = escaped_ch == '"';
const bool is_null = escaped_ch == 0;
if (was_escaped || (!is_end_quote && !is_null)) {
if (CHAR_MIN <= escaped_ch && escaped_ch <= CHAR_MAX) {
value.append(1, (char)escaped_ch);
} else {
error << "error: wide character support is needed for unicode "
"character 0x"
<< std::setprecision(4) << std::hex << escaped_ch;
error << " at offset " << start_index;
value = error.str();
return Token::Status;
}
} else if (is_end_quote) {
return Token::String;
} else if (is_null) {
value = "error: missing end quote for string";
return Token::Status;
}
}
}
} break;
case '-':
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9': {
bool done = false;
bool got_decimal_point = false;
uint64_t exp_index = 0;
bool got_int_digits = (ch >= '0') && (ch <= '9');
bool got_frac_digits = false;
bool got_exp_digits = false;
while (!done) {
const char next_ch = PeekChar();
switch (next_ch) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
if (exp_index != 0) {
got_exp_digits = true;
} else if (got_decimal_point) {
got_frac_digits = true;
} else {
got_int_digits = true;
}
++m_index; // Skip this character
break;
case '.':
if (got_decimal_point) {
error << "error: extra decimal point found at offset " << start_index;
value = error.str();
return Token::Status;
} else {
got_decimal_point = true;
++m_index; // Skip this character
}
break;
case 'e':
case 'E':
if (exp_index != 0) {
error << "error: extra exponent character found at offset "
<< start_index;
value = error.str();
return Token::Status;
} else {
exp_index = m_index;
++m_index; // Skip this character
}
break;
case '+':
case '-':
// The '+' and '-' can only come after an exponent character...
if (exp_index == m_index - 1) {
++m_index; // Skip the exponent sign character
} else {
error << "error: unexpected " << next_ch << " character at offset "
<< start_index;
value = error.str();
return Token::Status;
}
break;
default:
done = true;
break;
}
}
if (m_index > start_index) {
value = m_packet.substr(start_index, m_index - start_index);
if (got_decimal_point) {
if (exp_index != 0) {
// We have an exponent, make sure we got exponent digits
if (got_exp_digits) {
return Token::Float;
} else {
error << "error: got exponent character but no exponent digits at "
"offset in float value \""
<< value.c_str() << "\"";
value = error.str();
return Token::Status;
}
} else {
// No exponent, but we need at least one decimal after the decimal
// point
if (got_frac_digits) {
return Token::Float;
} else {
error << "error: no digits after decimal point \"" << value.c_str()
<< "\"";
value = error.str();
return Token::Status;
}
}
} else {
// No decimal point
if (got_int_digits) {
// We need at least some integer digits to make an integer
return Token::Integer;
} else {
error << "error: no digits negate sign \"" << value.c_str() << "\"";
value = error.str();
return Token::Status;
}
}
} else {
error << "error: invalid number found at offset " << start_index;
value = error.str();
return Token::Status;
}
} break;
default:
break;
}
error << "error: failed to parse token at offset " << start_index
<< " (around character '" << ch << "')";
value = error.str();
return Token::Status;
}
int JSONParser::GetEscapedChar(bool &was_escaped) {
was_escaped = false;
const char ch = GetChar();
if (ch == '\\') {
was_escaped = true;
const char ch2 = GetChar();
switch (ch2) {
case '"':
case '\\':
case '/':
default:
break;
case 'b':
return '\b';
case 'f':
return '\f';
case 'n':
return '\n';
case 'r':
return '\r';
case 't':
return '\t';
case 'u': {
const int hi_byte = DecodeHexU8();
const int lo_byte = DecodeHexU8();
if (hi_byte >= 0 && lo_byte >= 0)
return hi_byte << 8 | lo_byte;
return -1;
} break;
}
return ch2;
}
return ch;
}
JSONValue::SP JSONParser::ParseJSONObject() {
// The "JSONParser::Token::ObjectStart" token should have already been
// consumed
// by the time this function is called
std::unique_ptr<JSONObject> dict_up(new JSONObject());
std::string value;
std::string key;
while (1) {
JSONParser::Token token = GetToken(value);
if (token == JSONParser::Token::String) {
key.swap(value);
token = GetToken(value);
if (token == JSONParser::Token::Colon) {
JSONValue::SP value_sp = ParseJSONValue();
if (value_sp)
dict_up->SetObject(key, value_sp);
else
break;
}
} else if (token == JSONParser::Token::ObjectEnd) {
return JSONValue::SP(dict_up.release());
} else if (token == JSONParser::Token::Comma) {
continue;
} else {
break;
}
}
return JSONValue::SP();
}
JSONValue::SP JSONParser::ParseJSONArray() {
// The "JSONParser::Token::ObjectStart" token should have already been
// consumed
// by the time this function is called
std::unique_ptr<JSONArray> array_up(new JSONArray());
std::string value;
std::string key;
while (1) {
JSONValue::SP value_sp = ParseJSONValue();
if (value_sp)
array_up->AppendObject(value_sp);
else
break;
JSONParser::Token token = GetToken(value);
if (token == JSONParser::Token::Comma) {
continue;
} else if (token == JSONParser::Token::ArrayEnd) {
return JSONValue::SP(array_up.release());
} else {
break;
}
}
return JSONValue::SP();
}
JSONValue::SP JSONParser::ParseJSONValue() {
std::string value;
const JSONParser::Token token = GetToken(value);
switch (token) {
case JSONParser::Token::ObjectStart:
return ParseJSONObject();
case JSONParser::Token::ArrayStart:
return ParseJSONArray();
case JSONParser::Token::Integer: {
if (value.front() == '-') {
bool success = false;
int64_t sval = StringConvert::ToSInt64(value.c_str(), 0, 0, &success);
if (success)
return JSONValue::SP(new JSONNumber(sval));
} else {
bool success = false;
uint64_t uval = StringConvert::ToUInt64(value.c_str(), 0, 0, &success);
if (success)
return JSONValue::SP(new JSONNumber(uval));
}
} break;
case JSONParser::Token::Float: {
bool success = false;
double val = StringConvert::ToDouble(value.c_str(), 0.0, &success);
if (success)
return JSONValue::SP(new JSONNumber(val));
} break;
case JSONParser::Token::String:
return JSONValue::SP(new JSONString(value));
case JSONParser::Token::True:
return JSONValue::SP(new JSONTrue());
case JSONParser::Token::False:
return JSONValue::SP(new JSONFalse());
case JSONParser::Token::Null:
return JSONValue::SP(new JSONNull());
default:
break;
}
return JSONValue::SP();
}
Reference in New Issue View Git Blame Copy Permalink