[JSON] Remove Utility/JSON.{h|cpp}

This patch is the final step in my quest to get rid of the JSON parser
in LLDB. Vedant's coverage report [1] shows that it was mostly untested.
Furthermore, the LLVM implementation has a much nicer API and using it
means one less thing to maintain for LLDB.

[1] http://lab.llvm.org:8080/coverage/coverage-reports/index.html

Differential revision: https://reviews.llvm.org/D68305

git-svn-id: https://llvm.org/svn/llvm-project/lldb/trunk@373501 91177308-0d34-0410-b5e6-96231b3b80d8

2 files changed, 0 insertions, 551 deletions

diff --git a/source/Utility/CMakeLists.txt b/source/Utility/CMakeLists.txt
index d86963fde..df486e2c0 100644
--- a/source/Utility/CMakeLists.txt
+++ b/source/Utility/CMakeLists.txt
@@ -27,7 +27,6 @@ add_lldb_library(lldbUtility
   FileSpec.cpp
   GDBRemote.cpp
   IOObject.cpp
-  JSON.cpp
   LLDBAssert.cpp
   Listener.cpp
   Log.cpp
diff --git a/source/Utility/JSON.cpp b/source/Utility/JSON.cpp
deleted file mode 100644
index 2c3f6229e..000000000
--- a/source/Utility/JSON.cpp
+++ /dev/null
@@ -1,550 +0,0 @@
-//===--------------------- JSON.cpp -----------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include "lldb/Utility/JSON.h"
-
-#include "lldb/Utility/Stream.h"
-#include "lldb/Utility/StreamString.h"
-#include "llvm/ADT/StringRef.h"
-#include "llvm/Support/ErrorHandling.h"
-
-#include <inttypes.h>
-#include <limits.h>
-#include <stddef.h>
-#include <utility>
-
-using namespace lldb_private;
-
-std::string JSONString::json_string_quote_metachars(const std::string &s) {
-  if (s.find_first_of("\\\n\"") == 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 == '"' || ch == '\\' || ch == '\n') {
-      output.push_back('\\');
-      if (ch == '\n') ch = 'n';
-    }
-    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(Stream &s) {
-  s.Printf("\"%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 static_cast<uint64_t>(m_data.m_signed);
-  case DataType::Double:
-    return static_cast<uint64_t>(m_data.m_double);
-  }
-  llvm_unreachable("Unhandled data type");
-}
-
-int64_t JSONNumber::GetAsSigned() const {
-  switch (m_data_type) {
-  case DataType::Unsigned:
-    return static_cast<int64_t>(m_data.m_unsigned);
-  case DataType::Signed:
-    return m_data.m_signed;
-  case DataType::Double:
-    return static_cast<int64_t>(m_data.m_double);
-  }
-  llvm_unreachable("Unhandled data type");
-}
-
-double JSONNumber::GetAsDouble() const {
-  switch (m_data_type) {
-  case DataType::Unsigned:
-    return static_cast<double>(m_data.m_unsigned);
-  case DataType::Signed:
-    return static_cast<double>(m_data.m_signed);
-  case DataType::Double:
-    return m_data.m_double;
-  }
-  llvm_unreachable("Unhandled data type");
-}
-
-void JSONNumber::Write(Stream &s) {
-  switch (m_data_type) {
-  case DataType::Unsigned:
-    s.Printf("%" PRIu64, m_data.m_unsigned);
-    break;
-  case DataType::Signed:
-    s.Printf("%" PRId64, m_data.m_signed);
-    break;
-  case DataType::Double:
-    s.Printf("%g", m_data.m_double);
-    break;
-  }
-}
-
-JSONTrue::JSONTrue() : JSONValue(JSONValue::Kind::True) {}
-
-void JSONTrue::Write(Stream &s) { s.Printf("true"); }
-
-JSONFalse::JSONFalse() : JSONValue(JSONValue::Kind::False) {}
-
-void JSONFalse::Write(Stream &s) { s.Printf("false"); }
-
-JSONNull::JSONNull() : JSONValue(JSONValue::Kind::Null) {}
-
-void JSONNull::Write(Stream &s) { s.Printf("null"); }
-
-JSONObject::JSONObject() : JSONValue(JSONValue::Kind::Object) {}
-
-void JSONObject::Write(Stream &s) {
-  bool first = true;
-  s.PutChar('{');
-  auto iter = m_elements.begin(), end = m_elements.end();
-  for (; iter != end; iter++) {
-    if (first)
-      first = false;
-    else
-      s.PutChar(',');
-    JSONString key(iter->first);
-    JSONValue::SP value(iter->second);
-    key.Write(s);
-    s.PutChar(':');
-    value->Write(s);
-  }
-  s.PutChar('}');
-}
-
-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) {
-  auto iter = m_elements.find(key), end = m_elements.end();
-  if (iter == end)
-    return JSONValue::SP();
-  return iter->second;
-}
-
-JSONArray::JSONArray() : JSONValue(JSONValue::Kind::Array) {}
-
-void JSONArray::Write(Stream &s) {
-  bool first = true;
-  s.PutChar('[');
-  auto iter = m_elements.begin(), end = m_elements.end();
-  for (; iter != end; iter++) {
-    if (first)
-      first = false;
-    else
-      s.PutChar(',');
-    (*iter)->Write(s);
-  }
-  s.PutChar(']');
-}
-
-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(llvm::StringRef data) : StringExtractor(data) {}
-
-JSONParser::Token JSONParser::GetToken(std::string &value) {
-  StreamString 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 (true) {
-      bool was_escaped = false;
-      int escaped_ch = GetEscapedChar(was_escaped);
-      if (escaped_ch == -1) {
-        error.Printf(
-            "error: an error occurred getting a character from offset %" PRIu64,
-            start_index);
-        value = std::move(error.GetString());
-        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, static_cast<char>(escaped_ch));
-          } else {
-            error.Printf("error: wide character support is needed for unicode "
-                         "character 0x%4.4x at offset %" PRIu64,
-                         escaped_ch, start_index);
-            value = std::move(error.GetString());
-            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.Printf("error: extra decimal point found at offset %" PRIu64,
-                       start_index);
-          value = std::move(error.GetString());
-          return Token::Status;
-        } else {
-          got_decimal_point = true;
-          ++m_index; // Skip this character
-        }
-        break;
-
-      case 'e':
-      case 'E':
-        if (exp_index != 0) {
-          error.Printf(
-              "error: extra exponent character found at offset %" PRIu64,
-              start_index);
-          value = std::move(error.GetString());
-          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.Printf("error: unexpected %c character at offset %" PRIu64,
-                       next_ch, start_index);
-          value = std::move(error.GetString());
-          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.Printf("error: got exponent character but no exponent digits "
-                         "at offset in float value \"%s\"",
-                         value.c_str());
-            value = std::move(error.GetString());
-            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.Printf("error: no digits after decimal point \"%s\"",
-                         value.c_str());
-            value = std::move(error.GetString());
-            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.Printf("error: no digits negate sign \"%s\"", value.c_str());
-          value = std::move(error.GetString());
-          return Token::Status;
-        }
-      }
-    } else {
-      error.Printf("error: invalid number found at offset %" PRIu64,
-                   start_index);
-      value = std::move(error.GetString());
-      return Token::Status;
-    }
-  } break;
-  default:
-    break;
-  }
-  error.Printf("error: failed to parse token at offset %" PRIu64
-               " (around character '%c')",
-               start_index, ch);
-  value = std::move(error.GetString());
-  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 (true) {
-    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 (true) {
-    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() == '-') {
-      int64_t sval = 0;
-      if (!llvm::StringRef(value).getAsInteger(0, sval))
-        return JSONValue::SP(new JSONNumber(sval));
-    } else {
-      uint64_t uval = 0;
-      if (!llvm::StringRef(value).getAsInteger(0, uval))
-        return JSONValue::SP(new JSONNumber(uval));
-    }
-  } break;
-
-  case JSONParser::Token::Float: {
-    double D;
-    if (!llvm::StringRef(value).getAsDouble(D))
-      return JSONValue::SP(new JSONNumber(D));
-  } 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();
-}