1 files changed, 0 insertions, 585 deletions
diff --git a/tools/debugserver/source/JSON.cpp b/tools/debugserver/source/JSON.cpp
deleted file mode 100644
index 439918b6fcc4..000000000000
--- a/tools/debugserver/source/JSON.cpp
+++ /dev/null
@@ -1,585 +0,0 @@
-//===--------------------- 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();
-}