Move StructuredData from Core to Utility

[labath]

Summary

It had a dependency on StringConvert and file reading code, which is not
in Utility. I've replaced that code by equivalent llvm operations.

I've added a unit test to demonstrate that parsing a file still works.

[labath]

Well, PluginProcessPOSIX does not seem to be using anything from Core directly,
although I doubt that is thanks to this patch. It will be a long time before
anything stops depending on Core (my goal here is to do it for Host, but even
that is a long way off).

lldb/trunk/include/lldb/Breakpoint/Breakpoint.h

 // Project includes
 #include "lldb/Breakpoint/BreakpointID.h"
 #include "lldb/Breakpoint/BreakpointLocationCollection.h"
 #include "lldb/Breakpoint/BreakpointLocationList.h"
 #include "lldb/Breakpoint/BreakpointOptions.h"
 #include "lldb/Breakpoint/Stoppoint.h"
 #include "lldb/Core/Event.h"
 #include "lldb/Core/SearchFilter.h"
-#include "lldb/Core/StructuredData.h"
 #include "lldb/Utility/StringList.h"
+#include "lldb/Utility/StructuredData.h"
 
 namespace lldb_private {
 
 //----------------------------------------------------------------------
 /// @class Breakpoint Breakpoint.h "lldb/Breakpoint/Breakpoint.h"
 /// @brief Class that manages logical breakpoint setting.
 //----------------------------------------------------------------------
 

lldb/trunk/include/lldb/Breakpoint/BreakpointOptions.h

 
 // C Includes
 // C++ Includes
 #include <memory>
 #include <string>
 
 // Other libraries and framework includes
 // Project includes
-#include "lldb/Core/StructuredData.h"
 #include "lldb/Utility/Baton.h"
 #include "lldb/Utility/StringList.h"
+#include "lldb/Utility/StructuredData.h"
 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
 
 //----------------------------------------------------------------------
 /// @class BreakpointOptions BreakpointOptions.h
 /// "lldb/Breakpoint/BreakpointOptions.h"
 /// @brief Class that manages the options on a breakpoint or breakpoint

lldb/trunk/include/lldb/Core/Event.h

 //===-- Event.h -------------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_Event_h_
 #define liblldb_Event_h_
 
 #include "lldb/Core/Broadcaster.h"
-#include "lldb/Core/StructuredData.h"
 #include "lldb/Host/Predicate.h"
 #include "lldb/Utility/ConstString.h"
+#include "lldb/Utility/StructuredData.h"
 #include "lldb/lldb-defines.h" // for DISALLOW_COPY_AND_ASSIGN
 #include "lldb/lldb-forward.h" // for EventDataSP, ProcessSP, Struct...
 
 #include "llvm/ADT/StringRef.h" // for StringRef
 
 #include <chrono>
 #include <memory>
 #include <string>

lldb/trunk/include/lldb/Core/SearchFilter.h

 //===-- SearchFilter.h ------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_SearchFilter_h_
 #define liblldb_SearchFilter_h_
 
 #include "lldb/Core/FileSpecList.h"
-#include "lldb/Core/StructuredData.h"
+#include "lldb/Utility/StructuredData.h"
 
 #include "lldb/Utility/FileSpec.h" // for FileSpec
 #include "lldb/lldb-forward.h"     // for SearchFilterSP, TargetSP, Modu...
 
 #include <stdint.h> // for uint32_t
 
 namespace lldb_private {
 class Address;

lldb/trunk/include/lldb/Core/StructuredData.h

-//===-- StructuredData.h ----------------------------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef liblldb_StructuredData_h_
-#define liblldb_StructuredData_h_
-
-#include "llvm/ADT/StringRef.h"
-
-#include "lldb/Utility/ConstString.h"
-#include "lldb/Utility/FileSpec.h"  // for FileSpec
-#include "lldb/lldb-enumerations.h" // for StructuredDataType
-
-#include <functional>
-#include <map>
-#include <memory>
-#include <string>
-#include <type_traits> // for move
-#include <utility>
-#include <vector>
-
-#include <assert.h> // for assert
-#include <stddef.h> // for size_t
-#include <stdint.h> // for uint64_t
-
-namespace lldb_private {
-class Status;
-}
-namespace lldb_private {
-class Stream;
-}
-
-namespace lldb_private {
-
-//----------------------------------------------------------------------
-/// @class StructuredData StructuredData.h "lldb/Core/StructuredData.h"
-/// @brief A class which can hold structured data
-///
-/// The StructuredData class is designed to hold the data from a JSON
-/// or plist style file -- a serialized data structure with dictionaries
-/// (maps, hashes), arrays, and concrete values like integers, floating
-/// point numbers, strings, booleans.
-///
-/// StructuredData does not presuppose any knowledge of the schema for
-/// the data it is holding; it can parse JSON data, for instance, and
-/// other parts of lldb can iterate through the parsed data set to find
-/// keys and values that may be present.
-//----------------------------------------------------------------------
-
-class StructuredData {
-public:
-  class Object;
-  class Array;
-  class Integer;
-  class Float;
-  class Boolean;
-  class String;
-  class Dictionary;
-  class Generic;
-
-  typedef std::shared_ptr<Object> ObjectSP;
-  typedef std::shared_ptr<Array> ArraySP;
-  typedef std::shared_ptr<Integer> IntegerSP;
-  typedef std::shared_ptr<Float> FloatSP;
-  typedef std::shared_ptr<Boolean> BooleanSP;
-  typedef std::shared_ptr<String> StringSP;
-  typedef std::shared_ptr<Dictionary> DictionarySP;
-  typedef std::shared_ptr<Generic> GenericSP;
-
-  class Object : public std::enable_shared_from_this<Object> {
-  public:
-    Object(lldb::StructuredDataType t = lldb::eStructuredDataTypeInvalid)
-        : m_type(t) {}
-
-    virtual ~Object() = default;
-
-    virtual bool IsValid() const { return true; }
-
-    virtual void Clear() { m_type = lldb::eStructuredDataTypeInvalid; }
-
-    lldb::StructuredDataType GetType() const { return m_type; }
-
-    void SetType(lldb::StructuredDataType t) { m_type = t; }
-
-    Array *GetAsArray() {
-      return ((m_type == lldb::eStructuredDataTypeArray)
-                  ? static_cast<Array *>(this)
-                  : nullptr);
-    }
-
-    Dictionary *GetAsDictionary() {
-      return (
-          (m_type == lldb::eStructuredDataTypeDictionary)
-              ? static_cast<Dictionary *>(this)
-              : nullptr);
-    }
-
-    Integer *GetAsInteger() {
-      return ((m_type == lldb::eStructuredDataTypeInteger)
-                  ? static_cast<Integer *>(this)
-                  : nullptr);
-    }
-
-    uint64_t GetIntegerValue(uint64_t fail_value = 0) {
-      Integer *integer = GetAsInteger();
-      return ((integer != nullptr) ? integer->GetValue() : fail_value);
-    }
-
-    Float *GetAsFloat() {
-      return ((m_type == lldb::eStructuredDataTypeFloat)
-                  ? static_cast<Float *>(this)
-                  : nullptr);
-    }
-
-    double GetFloatValue(double fail_value = 0.0) {
-      Float *f = GetAsFloat();
-      return ((f != nullptr) ? f->GetValue() : fail_value);
-    }
-
-    Boolean *GetAsBoolean() {
-      return ((m_type == lldb::eStructuredDataTypeBoolean)
-                  ? static_cast<Boolean *>(this)
-                  : nullptr);
-    }
-
-    bool GetBooleanValue(bool fail_value = false) {
-      Boolean *b = GetAsBoolean();
-      return ((b != nullptr) ? b->GetValue() : fail_value);
-    }
-
-    String *GetAsString() {
-      return ((m_type == lldb::eStructuredDataTypeString)
-                  ? static_cast<String *>(this)
-                  : nullptr);
-    }
-
-    llvm::StringRef GetStringValue(const char *fail_value = nullptr) {
-      String *s = GetAsString();
-      if (s)
-        return s->GetValue();
-
-      return fail_value;
-    }
-
-    Generic *GetAsGeneric() {
-      return ((m_type == lldb::eStructuredDataTypeGeneric)
-                  ? static_cast<Generic *>(this)
-                  : nullptr);
-    }
-
-    ObjectSP GetObjectForDotSeparatedPath(llvm::StringRef path);
-
-    void DumpToStdout(bool pretty_print = true) const;
-
-    virtual void Dump(Stream &s, bool pretty_print = true) const = 0;
-
-  private:
-    lldb::StructuredDataType m_type;
-  };
-
-  class Array : public Object {
-  public:
-    Array() : Object(lldb::eStructuredDataTypeArray) {}
-
-    ~Array() override = default;
-
-    bool
-    ForEach(std::function<bool(Object *object)> const &foreach_callback) const {
-      for (const auto &object_sp : m_items) {
-        if (foreach_callback(object_sp.get()) == false)
-          return false;
-      }
-      return true;
-    }
-
-    size_t GetSize() const { return m_items.size(); }
-
-    ObjectSP operator[](size_t idx) {
-      if (idx < m_items.size())
-        return m_items[idx];
-      return ObjectSP();
-    }
-
-    ObjectSP GetItemAtIndex(size_t idx) const {
-      assert(idx < GetSize());
-      if (idx < m_items.size())
-        return m_items[idx];
-      return ObjectSP();
-    }
-
-    template <class IntType>
-    bool GetItemAtIndexAsInteger(size_t idx, IntType &result) const {
-      ObjectSP value_sp = GetItemAtIndex(idx);
-      if (value_sp.get()) {
-        if (auto int_value = value_sp->GetAsInteger()) {
-          result = static_cast<IntType>(int_value->GetValue());
-          return true;
-        }
-      }
-      return false;
-    }
-
-    template <class IntType>
-    bool GetItemAtIndexAsInteger(size_t idx, IntType &result,
-                                 IntType default_val) const {
-      bool success = GetItemAtIndexAsInteger(idx, result);
-      if (!success)
-        result = default_val;
-      return success;
-    }
-
-    bool GetItemAtIndexAsString(size_t idx, llvm::StringRef &result) const {
-      ObjectSP value_sp = GetItemAtIndex(idx);
-      if (value_sp.get()) {
-        if (auto string_value = value_sp->GetAsString()) {
-          result = string_value->GetValue();
-          return true;
-        }
-      }
-      return false;
-    }
-
-    bool GetItemAtIndexAsString(size_t idx, llvm::StringRef &result,
-                                llvm::StringRef default_val) const {
-      bool success = GetItemAtIndexAsString(idx, result);
-      if (!success)
-        result = default_val;
-      return success;
-    }
-
-    bool GetItemAtIndexAsString(size_t idx, ConstString &result) const {
-      ObjectSP value_sp = GetItemAtIndex(idx);
-      if (value_sp.get()) {
-        if (auto string_value = value_sp->GetAsString()) {
-          result = ConstString(string_value->GetValue());
-          return true;
-        }
-      }
-      return false;
-    }
-
-    bool GetItemAtIndexAsString(size_t idx, ConstString &result,
-                                const char *default_val) const {
-      bool success = GetItemAtIndexAsString(idx, result);
-      if (!success)
-        result.SetCString(default_val);
-      return success;
-    }
-
-    bool GetItemAtIndexAsDictionary(size_t idx, Dictionary *&result) const {
-      result = nullptr;
-      ObjectSP value_sp = GetItemAtIndex(idx);
-      if (value_sp.get()) {
-        result = value_sp->GetAsDictionary();
-        return (result != nullptr);
-      }
-      return false;
-    }
-
-    bool GetItemAtIndexAsArray(size_t idx, Array *&result) const {
-      result = nullptr;
-      ObjectSP value_sp = GetItemAtIndex(idx);
-      if (value_sp.get()) {
-        result = value_sp->GetAsArray();
-        return (result != nullptr);
-      }
-      return false;
-    }
-
-    void Push(ObjectSP item) { m_items.push_back(item); }
-
-    void AddItem(ObjectSP item) { m_items.push_back(item); }
-
-    void Dump(Stream &s, bool pretty_print = true) const override;
-
-  protected:
-    typedef std::vector<ObjectSP> collection;
-    collection m_items;
-  };
-
-  class Integer : public Object {
-  public:
-    Integer(uint64_t i = 0)
-        : Object(lldb::eStructuredDataTypeInteger), m_value(i) {}
-
-    ~Integer() override = default;
-
-    void SetValue(uint64_t value) { m_value = value; }
-
-    uint64_t GetValue() { return m_value; }
-
-    void Dump(Stream &s, bool pretty_print = true) const override;
-
-  protected:
-    uint64_t m_value;
-  };
-
-  class Float : public Object {
-  public:
-    Float(double d = 0.0) : Object(lldb::eStructuredDataTypeFloat),
-          m_value(d) {}
-
-    ~Float() override = default;
-
-    void SetValue(double value) { m_value = value; }
-
-    double GetValue() { return m_value; }
-
-    void Dump(Stream &s, bool pretty_print = true) const override;
-
-  protected:
-    double m_value;
-  };
-
-  class Boolean : public Object {
-  public:
-    Boolean(bool b = false) : Object(lldb::eStructuredDataTypeBoolean),
-          m_value(b) {}
-
-    ~Boolean() override = default;
-
-    void SetValue(bool value) { m_value = value; }
-
-    bool GetValue() { return m_value; }
-
-    void Dump(Stream &s, bool pretty_print = true) const override;
-
-  protected:
-    bool m_value;
-  };
-
-  class String : public Object {
-  public:
-    String() : Object(lldb::eStructuredDataTypeString) {}
-    explicit String(llvm::StringRef S)
-        : Object(lldb::eStructuredDataTypeString),
-          m_value(S) {}
-
-    void SetValue(llvm::StringRef S) { m_value = S; }
-
-    llvm::StringRef GetValue() { return m_value; }
-
-    void Dump(Stream &s, bool pretty_print = true) const override;
-
-  protected:
-    std::string m_value;
-  };
-
-  class Dictionary : public Object {
-  public:
-    Dictionary() : Object(lldb::eStructuredDataTypeDictionary),
-          m_dict() {}
-
-    ~Dictionary() override = default;
-
-    size_t GetSize() const { return m_dict.size(); }
-
-    void ForEach(std::function<bool(ConstString key, Object *object)> const
-                     &callback) const {
-      for (const auto &pair : m_dict) {
-        if (callback(pair.first, pair.second.get()) == false)
-          break;
-      }
-    }
-
-    ObjectSP GetKeys() const {
-      auto object_sp = std::make_shared<Array>();
-      collection::const_iterator iter;
-      for (iter = m_dict.begin(); iter != m_dict.end(); ++iter) {
-        auto key_object_sp = std::make_shared<String>();
-        key_object_sp->SetValue(iter->first.AsCString());
-        object_sp->Push(key_object_sp);
-      }
-      return object_sp;
-    }
-
-    ObjectSP GetValueForKey(llvm::StringRef key) const {
-      ObjectSP value_sp;
-      if (!key.empty()) {
-        ConstString key_cs(key);
-        collection::const_iterator iter = m_dict.find(key_cs);
-        if (iter != m_dict.end())
-          value_sp = iter->second;
-      }
-      return value_sp;
-    }
-
-    bool GetValueForKeyAsBoolean(llvm::StringRef key, bool &result) const {
-      bool success = false;
-      ObjectSP value_sp = GetValueForKey(key);
-      if (value_sp.get()) {
-        Boolean *result_ptr = value_sp->GetAsBoolean();
-        if (result_ptr) {
-          result = result_ptr->GetValue();
-          success = true;
-        }
-      }
-      return success;
-    }
-    template <class IntType>
-    bool GetValueForKeyAsInteger(llvm::StringRef key, IntType &result) const {
-      ObjectSP value_sp = GetValueForKey(key);
-      if (value_sp) {
-        if (auto int_value = value_sp->GetAsInteger()) {
-          result = static_cast<IntType>(int_value->GetValue());
-          return true;
-        }
-      }
-      return false;
-    }
-
-    template <class IntType>
-    bool GetValueForKeyAsInteger(llvm::StringRef key, IntType &result,
-                                 IntType default_val) const {
-      bool success = GetValueForKeyAsInteger<IntType>(key, result);
-      if (!success)
-        result = default_val;
-      return success;
-    }
-
-    bool GetValueForKeyAsString(llvm::StringRef key,
-                                llvm::StringRef &result) const {
-      ObjectSP value_sp = GetValueForKey(key);
-      if (value_sp.get()) {
-        if (auto string_value = value_sp->GetAsString()) {
-          result = string_value->GetValue();
-          return true;
-        }
-      }
-      return false;
-    }
-
-    bool GetValueForKeyAsString(llvm::StringRef key, llvm::StringRef &result,
-                                const char *default_val) const {
-      bool success = GetValueForKeyAsString(key, result);
-      if (!success) {
-        if (default_val)
-          result = default_val;
-        else
-          result = llvm::StringRef();
-      }
-      return success;
-    }
-
-    bool GetValueForKeyAsString(llvm::StringRef key,
-                                ConstString &result) const {
-      ObjectSP value_sp = GetValueForKey(key);
-      if (value_sp.get()) {
-        if (auto string_value = value_sp->GetAsString()) {
-          result = ConstString(string_value->GetValue());
-          return true;
-        }
-      }
-      return false;
-    }
-
-    bool GetValueForKeyAsString(llvm::StringRef key, ConstString &result,
-                                const char *default_val) const {
-      bool success = GetValueForKeyAsString(key, result);
-      if (!success)
-        result.SetCString(default_val);
-      return success;
-    }
-
-    bool GetValueForKeyAsDictionary(llvm::StringRef key,
-                                    Dictionary *&result) const {
-      result = nullptr;
-      ObjectSP value_sp = GetValueForKey(key);
-      if (value_sp.get()) {
-        result = value_sp->GetAsDictionary();
-        return (result != nullptr);
-      }
-      return false;
-    }
-
-    bool GetValueForKeyAsArray(llvm::StringRef key, Array *&result) const {
-      result = nullptr;
-      ObjectSP value_sp = GetValueForKey(key);
-      if (value_sp.get()) {
-        result = value_sp->GetAsArray();
-        return (result != nullptr);
-      }
-      return false;
-    }
-
-    bool HasKey(llvm::StringRef key) const {
-      ConstString key_cs(key);
-      collection::const_iterator search = m_dict.find(key_cs);
-      return search != m_dict.end();
-    }
-
-    void AddItem(llvm::StringRef key, ObjectSP value_sp) {
-      ConstString key_cs(key);
-      m_dict[key_cs] = value_sp;
-    }
-
-    void AddIntegerItem(llvm::StringRef key, uint64_t value) {
-      AddItem(key, std::make_shared<Integer>(value));
-    }
-
-    void AddFloatItem(llvm::StringRef key, double value) {
-      AddItem(key, std::make_shared<Float>(value));
-    }
-
-    void AddStringItem(llvm::StringRef key, llvm::StringRef value) {
-      AddItem(key, std::make_shared<String>(std::move(value)));
-    }
-
-    void AddBooleanItem(llvm::StringRef key, bool value) {
-      AddItem(key, std::make_shared<Boolean>(value));
-    }
-
-    void Dump(Stream &s, bool pretty_print = true) const override;
-
-  protected:
-    typedef std::map<ConstString, ObjectSP> collection;
-    collection m_dict;
-  };
-
-  class Null : public Object {
-  public:
-    Null() : Object(lldb::eStructuredDataTypeNull) {}
-
-    ~Null() override = default;
-
-    bool IsValid() const override { return false; }
-
-    void Dump(Stream &s, bool pretty_print = true) const override;
-  };
-
-  class Generic : public Object {
-  public:
-    explicit Generic(void *object = nullptr)
-        : Object(lldb::eStructuredDataTypeGeneric), m_object(object) {}
-
-    void SetValue(void *value) { m_object = value; }
-
-    void *GetValue() const { return m_object; }
-
-    bool IsValid() const override { return m_object != nullptr; }
-
-    void Dump(Stream &s, bool pretty_print = true) const override;
-
-  private:
-    void *m_object;
-  };
-
-  static ObjectSP ParseJSON(std::string json_text);
-
-  static ObjectSP ParseJSONFromFile(const FileSpec &file, Status &error);
-};
-
-} // namespace lldb_private
-
-#endif // liblldb_StructuredData_h_

lldb/trunk/include/lldb/Core/StructuredDataImpl.h

 //===-- StructuredDataImpl.h ------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_StructuredDataImpl_h_
 #define liblldb_StructuredDataImpl_h_
 
 #include "lldb/Core/Event.h"
-#include "lldb/Core/StructuredData.h"
 #include "lldb/Target/StructuredDataPlugin.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"
+#include "lldb/Utility/StructuredData.h"
 #include "lldb/lldb-enumerations.h"
 #include "lldb/lldb-forward.h"
 #include "llvm/ADT/StringRef.h"
 
 #pragma mark--
 #pragma mark StructuredDataImpl
 
 namespace lldb_private {

lldb/trunk/include/lldb/Core/TraceOptions.h

 //===-- TraceOptions.h ------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_TraceOptions_h_
 #define liblldb_TraceOptions_h_
 
 #include "lldb/lldb-defines.h"
 #include "lldb/lldb-enumerations.h"
 
-#include "lldb/Core/StructuredData.h"
+#include "lldb/Utility/StructuredData.h"
 
 namespace lldb_private {
 class TraceOptions {
 public:
   TraceOptions() : m_trace_params(new StructuredData::Dictionary()) {}
 
   const StructuredData::DictionarySP &getTraceParams() const {
     return m_trace_params;

lldb/trunk/include/lldb/DataFormatters/TypeSummary.h

 #include <string>
 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/lldb-enumerations.h"
 #include "lldb/lldb-public.h"
 
 #include "lldb/Core/FormatEntity.h"
-#include "lldb/Core/StructuredData.h"
 #include "lldb/Utility/Status.h"
+#include "lldb/Utility/StructuredData.h"
 
 namespace lldb_private {
 class TypeSummaryOptions {
 public:
   TypeSummaryOptions();
   TypeSummaryOptions(const TypeSummaryOptions &rhs);
 
   ~TypeSummaryOptions() = default;

lldb/trunk/include/lldb/DataFormatters/TypeSynthetic.h

 #include <string>
 #include <vector>
 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/lldb-enumerations.h"
 #include "lldb/lldb-public.h"
 
-#include "lldb/Core/StructuredData.h"
 #include "lldb/Core/ValueObject.h"
+#include "lldb/Utility/StructuredData.h"
 
 namespace lldb_private {
 class SyntheticChildrenFrontEnd {
 protected:
   ValueObject &m_backend;
 
   void SetValid(bool valid) { m_valid = valid; }
 

lldb/trunk/include/lldb/Host/XML.h

 #include <functional>
 #include <string>
 #include <vector>
 
 // Other libraries and framework includes
 #include "llvm/ADT/StringRef.h"
 
 // Project includes
-#include "lldb/Core/StructuredData.h"
 #include "lldb/Utility/StreamString.h"
+#include "lldb/Utility/StructuredData.h"
 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
 
 #if defined(LIBXML2_DEFINED)
 typedef xmlNodePtr XMLNodeImpl;
 typedef xmlDocPtr XMLDocumentImpl;
 #else

lldb/trunk/include/lldb/Interpreter/ScriptInterpreter.h

 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/lldb-private.h"
 
 #include "lldb/Breakpoint/BreakpointOptions.h"
 #include "lldb/Core/Broadcaster.h"
 #include "lldb/Core/PluginInterface.h"
-#include "lldb/Core/StructuredData.h"
 #include "lldb/Utility/Status.h"
+#include "lldb/Utility/StructuredData.h"
 
 #include "lldb/Host/PseudoTerminal.h"
 
 namespace lldb_private {
 
 class ScriptInterpreterLocker {
 public:
   ScriptInterpreterLocker() = default;

lldb/trunk/include/lldb/Target/InstrumentationRuntime.h

 // C Includes
 // C++ Includes
 #include <map>
 #include <vector>
 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/PluginInterface.h"
-#include "lldb/Core/StructuredData.h"
+#include "lldb/Utility/StructuredData.h"
 #include "lldb/lldb-forward.h"
 #include "lldb/lldb-private.h"
 #include "lldb/lldb-types.h"
 
 namespace lldb_private {
 
 typedef std::map<lldb::InstrumentationRuntimeType,
                  lldb::InstrumentationRuntimeSP>

lldb/trunk/include/lldb/Target/InstrumentationRuntimeStopInfo.h

 #define liblldb_InstrumentationRuntimeStopInfo_h_
 
 // C Includes
 // C++ Includes
 #include <string>
 
 // Other libraries and framework includes
 // Project includes
-#include "lldb/Core/StructuredData.h"
 #include "lldb/Target/StopInfo.h"
+#include "lldb/Utility/StructuredData.h"
 
 namespace lldb_private {
 
 class InstrumentationRuntimeStopInfo : public StopInfo {
 public:
   ~InstrumentationRuntimeStopInfo() override {}
 
   lldb::StopReason GetStopReason() const override {

lldb/trunk/include/lldb/Target/Process.h

 #include "lldb/Breakpoint/BreakpointSiteList.h"
 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Core/Broadcaster.h"
 #include "lldb/Core/Communication.h"
 #include "lldb/Core/Event.h"
 #include "lldb/Core/Listener.h"
 #include "lldb/Core/LoadedModuleInfoList.h"
 #include "lldb/Core/PluginInterface.h"
-#include "lldb/Core/StructuredData.h"
 #include "lldb/Core/ThreadSafeValue.h"
 #include "lldb/Core/TraceOptions.h"
 #include "lldb/Core/UserSettingsController.h"
 #include "lldb/Host/HostThread.h"
 #include "lldb/Host/ProcessRunLock.h"
 #include "lldb/Interpreter/Options.h"
 #include "lldb/Target/ExecutionContextScope.h"
 #include "lldb/Target/InstrumentationRuntime.h"
 #include "lldb/Target/Memory.h"
 #include "lldb/Target/ProcessInfo.h"
 #include "lldb/Target/ProcessLaunchInfo.h"
 #include "lldb/Target/QueueList.h"
 #include "lldb/Target/ThreadList.h"
 #include "lldb/Utility/NameMatches.h"
 #include "lldb/Utility/Status.h"
+#include "lldb/Utility/StructuredData.h"
 #include "lldb/lldb-private.h"
 
 #include "llvm/ADT/ArrayRef.h"
 
 namespace lldb_private {
 
 template <typename B, typename S> struct Range;
 

lldb/trunk/include/lldb/Target/StopInfo.h

 #define liblldb_StopInfo_h_
 
 // C Includes
 // C++ Includes
 #include <string>
 
 // Other libraries and framework includes
 // Project includes
-#include "lldb/Core/StructuredData.h"
 #include "lldb/Target/Process.h"
+#include "lldb/Utility/StructuredData.h"
 #include "lldb/lldb-public.h"
 
 namespace lldb_private {
 
 class StopInfo {
   friend class Process::ProcessEventData;
   friend class ThreadPlanBase;
 

lldb/trunk/include/lldb/Target/StructuredDataPlugin.h

 //===-- StructuredDataPlugin.h ----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef StructuredDataPlugin_h
 #define StructuredDataPlugin_h
 
 #include "lldb/Core/PluginInterface.h"
-#include "lldb/Core/StructuredData.h"
+#include "lldb/Utility/StructuredData.h"
 
 namespace lldb_private {
 
 class CommandObjectMultiword;
 
 // -----------------------------------------------------------------------------
 /// Plugin that supports process-related structured data sent asynchronously
 /// from the debug monitor (e.g. debugserver, lldb-server, etc.)

lldb/trunk/include/lldb/Target/SystemRuntime.h

 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include <vector>
 
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/PluginInterface.h"
-#include "lldb/Core/StructuredData.h"
 #include "lldb/Target/QueueItem.h"
 #include "lldb/Target/QueueList.h"
 #include "lldb/Utility/ConstString.h"
+#include "lldb/Utility/StructuredData.h"
 #include "lldb/lldb-private.h"
 #include "lldb/lldb-public.h"
 
 namespace lldb_private {
 
 //----------------------------------------------------------------------
 /// @class SystemRuntime SystemRuntime.h "lldb/Target/SystemRuntime.h"
 /// @brief A plug-in interface definition class for system runtimes.

lldb/trunk/include/lldb/Target/Thread.h

 #include <mutex>
 #include <string>
 #include <vector>
 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/Broadcaster.h"
 #include "lldb/Core/Event.h"
-#include "lldb/Core/StructuredData.h"
 #include "lldb/Core/UserSettingsController.h"
 #include "lldb/Target/ExecutionContextScope.h"
 #include "lldb/Target/RegisterCheckpoint.h"
 #include "lldb/Target/StackFrameList.h"
+#include "lldb/Utility/StructuredData.h"
 #include "lldb/Utility/UserID.h"
 #include "lldb/lldb-private.h"
 
 #define LLDB_THREAD_MAX_STOP_EXC_DATA 8
 
 namespace lldb_private {
 
 class ThreadProperties : public Properties {

lldb/trunk/include/lldb/Target/ThreadPlanPython.h

 #define liblldb_ThreadPlan_Python_h_
 
 // C Includes
 // C++ Includes
 #include <string>
 
 // Other libraries and framework includes
 // Project includes
-#include "lldb/Core/StructuredData.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlan.h"
 #include "lldb/Target/ThreadPlanTracer.h"
+#include "lldb/Utility/StructuredData.h"
 #include "lldb/Utility/UserID.h"
 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
 
 //------------------------------------------------------------------
 //  ThreadPlanPython:
 //

lldb/trunk/include/lldb/Target/ThreadSpec.h

 //===-- ThreadSpec.h --------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_ThreadSpec_h_
 #define liblldb_ThreadSpec_h_
 
-// C Includes
-// C++ Includes
-#include <string>
-
-// Other libraries and framework includes
-// Project includes
+#include "lldb/Utility/StructuredData.h"
 #include "lldb/lldb-private.h"
+#include <string>
 
 namespace lldb_private {
 
 // Note: For now the thread spec has only fixed elements -
 //   Thread ID
 //   Thread Index
 //   Thread Name
 //   Thread Queue Name

lldb/trunk/include/lldb/Utility/JSON.h

enum Token {
     Integer,
     Float,
     True,
     False,
     Null,
     EndOfFile
   };
 
-  JSONParser(const char *cstr);
+  JSONParser(llvm::StringRef data);
 
   int GetEscapedChar(bool &was_escaped);
 
   Token GetToken(std::string &value);
 
   JSONValue::SP ParseJSONValue();
 
 protected:
   JSONValue::SP ParseJSONObject();
 
   JSONValue::SP ParseJSONArray();
 };
 } // namespace lldb_private
 
 #endif // utility_JSON_h_

lldb/trunk/include/lldb/Utility/StructuredData.h

+//===-- StructuredData.h ----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_StructuredData_h_
+#define liblldb_StructuredData_h_
+
+#include "llvm/ADT/StringRef.h"
+
+#include "lldb/Utility/ConstString.h"
+#include "lldb/Utility/FileSpec.h"  // for FileSpec
+#include "lldb/lldb-enumerations.h" // for StructuredDataType
+
+#include <cassert> // for assert
+#include <cstddef> // for size_t
+#include <cstdint> // for uint64_t
+#include <functional>
+#include <map>
+#include <memory>
+#include <string>
+#include <type_traits> // for move
+#include <utility>
+#include <vector>
+
+namespace lldb_private {
+class Status;
+}
+namespace lldb_private {
+class Stream;
+}
+
+namespace lldb_private {
+
+//----------------------------------------------------------------------
+/// @class StructuredData StructuredData.h "lldb/Utility/StructuredData.h"
+/// @brief A class which can hold structured data
+///
+/// The StructuredData class is designed to hold the data from a JSON
+/// or plist style file -- a serialized data structure with dictionaries
+/// (maps, hashes), arrays, and concrete values like integers, floating
+/// point numbers, strings, booleans.
+///
+/// StructuredData does not presuppose any knowledge of the schema for
+/// the data it is holding; it can parse JSON data, for instance, and
+/// other parts of lldb can iterate through the parsed data set to find
+/// keys and values that may be present.
+//----------------------------------------------------------------------
+
+class StructuredData {
+public:
+  class Object;
+  class Array;
+  class Integer;
+  class Float;
+  class Boolean;
+  class String;
+  class Dictionary;
+  class Generic;
+
+  typedef std::shared_ptr<Object> ObjectSP;
+  typedef std::shared_ptr<Array> ArraySP;
+  typedef std::shared_ptr<Integer> IntegerSP;
+  typedef std::shared_ptr<Float> FloatSP;
+  typedef std::shared_ptr<Boolean> BooleanSP;
+  typedef std::shared_ptr<String> StringSP;
+  typedef std::shared_ptr<Dictionary> DictionarySP;
+  typedef std::shared_ptr<Generic> GenericSP;
+
+  class Object : public std::enable_shared_from_this<Object> {
+  public:
+    Object(lldb::StructuredDataType t = lldb::eStructuredDataTypeInvalid)
+        : m_type(t) {}
+
+    virtual ~Object() = default;
+
+    virtual bool IsValid() const { return true; }
+
+    virtual void Clear() { m_type = lldb::eStructuredDataTypeInvalid; }
+
+    lldb::StructuredDataType GetType() const { return m_type; }
+
+    void SetType(lldb::StructuredDataType t) { m_type = t; }
+
+    Array *GetAsArray() {
+      return ((m_type == lldb::eStructuredDataTypeArray)
+                  ? static_cast<Array *>(this)
+                  : nullptr);
+    }
+
+    Dictionary *GetAsDictionary() {
+      return ((m_type == lldb::eStructuredDataTypeDictionary)
+                  ? static_cast<Dictionary *>(this)
+                  : nullptr);
+    }
+
+    Integer *GetAsInteger() {
+      return ((m_type == lldb::eStructuredDataTypeInteger)
+                  ? static_cast<Integer *>(this)
+                  : nullptr);
+    }
+
+    uint64_t GetIntegerValue(uint64_t fail_value = 0) {
+      Integer *integer = GetAsInteger();
+      return ((integer != nullptr) ? integer->GetValue() : fail_value);
+    }
+
+    Float *GetAsFloat() {
+      return ((m_type == lldb::eStructuredDataTypeFloat)
+                  ? static_cast<Float *>(this)
+                  : nullptr);
+    }
+
+    double GetFloatValue(double fail_value = 0.0) {
+      Float *f = GetAsFloat();
+      return ((f != nullptr) ? f->GetValue() : fail_value);
+    }
+
+    Boolean *GetAsBoolean() {
+      return ((m_type == lldb::eStructuredDataTypeBoolean)
+                  ? static_cast<Boolean *>(this)
+                  : nullptr);
+    }
+
+    bool GetBooleanValue(bool fail_value = false) {
+      Boolean *b = GetAsBoolean();
+      return ((b != nullptr) ? b->GetValue() : fail_value);
+    }
+
+    String *GetAsString() {
+      return ((m_type == lldb::eStructuredDataTypeString)
+                  ? static_cast<String *>(this)
+                  : nullptr);
+    }
+
+    llvm::StringRef GetStringValue(const char *fail_value = nullptr) {
+      String *s = GetAsString();
+      if (s)
+        return s->GetValue();
+
+      return fail_value;
+    }
+
+    Generic *GetAsGeneric() {
+      return ((m_type == lldb::eStructuredDataTypeGeneric)
+                  ? static_cast<Generic *>(this)
+                  : nullptr);
+    }
+
+    ObjectSP GetObjectForDotSeparatedPath(llvm::StringRef path);
+
+    void DumpToStdout(bool pretty_print = true) const;
+
+    virtual void Dump(Stream &s, bool pretty_print = true) const = 0;
+
+  private:
+    lldb::StructuredDataType m_type;
+  };
+
+  class Array : public Object {
+  public:
+    Array() : Object(lldb::eStructuredDataTypeArray) {}
+
+    ~Array() override = default;
+
+    bool
+    ForEach(std::function<bool(Object *object)> const &foreach_callback) const {
+      for (const auto &object_sp : m_items) {
+        if (foreach_callback(object_sp.get()) == false)
+          return false;
+      }
+      return true;
+    }
+
+    size_t GetSize() const { return m_items.size(); }
+
+    ObjectSP operator[](size_t idx) {
+      if (idx < m_items.size())
+        return m_items[idx];
+      return ObjectSP();
+    }
+
+    ObjectSP GetItemAtIndex(size_t idx) const {
+      assert(idx < GetSize());
+      if (idx < m_items.size())
+        return m_items[idx];
+      return ObjectSP();
+    }
+
+    template <class IntType>
+    bool GetItemAtIndexAsInteger(size_t idx, IntType &result) const {
+      ObjectSP value_sp = GetItemAtIndex(idx);
+      if (value_sp.get()) {
+        if (auto int_value = value_sp->GetAsInteger()) {
+          result = static_cast<IntType>(int_value->GetValue());
+          return true;
+        }
+      }
+      return false;
+    }
+
+    template <class IntType>
+    bool GetItemAtIndexAsInteger(size_t idx, IntType &result,
+                                 IntType default_val) const {
+      bool success = GetItemAtIndexAsInteger(idx, result);
+      if (!success)
+        result = default_val;
+      return success;
+    }
+
+    bool GetItemAtIndexAsString(size_t idx, llvm::StringRef &result) const {
+      ObjectSP value_sp = GetItemAtIndex(idx);
+      if (value_sp.get()) {
+        if (auto string_value = value_sp->GetAsString()) {
+          result = string_value->GetValue();
+          return true;
+        }
+      }
+      return false;
+    }
+
+    bool GetItemAtIndexAsString(size_t idx, llvm::StringRef &result,
+                                llvm::StringRef default_val) const {
+      bool success = GetItemAtIndexAsString(idx, result);
+      if (!success)
+        result = default_val;
+      return success;
+    }
+
+    bool GetItemAtIndexAsString(size_t idx, ConstString &result) const {
+      ObjectSP value_sp = GetItemAtIndex(idx);
+      if (value_sp.get()) {
+        if (auto string_value = value_sp->GetAsString()) {
+          result = ConstString(string_value->GetValue());
+          return true;
+        }
+      }
+      return false;
+    }
+
+    bool GetItemAtIndexAsString(size_t idx, ConstString &result,
+                                const char *default_val) const {
+      bool success = GetItemAtIndexAsString(idx, result);
+      if (!success)
+        result.SetCString(default_val);
+      return success;
+    }
+
+    bool GetItemAtIndexAsDictionary(size_t idx, Dictionary *&result) const {
+      result = nullptr;
+      ObjectSP value_sp = GetItemAtIndex(idx);
+      if (value_sp.get()) {
+        result = value_sp->GetAsDictionary();
+        return (result != nullptr);
+      }
+      return false;
+    }
+
+    bool GetItemAtIndexAsArray(size_t idx, Array *&result) const {
+      result = nullptr;
+      ObjectSP value_sp = GetItemAtIndex(idx);
+      if (value_sp.get()) {
+        result = value_sp->GetAsArray();
+        return (result != nullptr);
+      }
+      return false;
+    }
+
+    void Push(ObjectSP item) { m_items.push_back(item); }
+
+    void AddItem(ObjectSP item) { m_items.push_back(item); }
+
+    void Dump(Stream &s, bool pretty_print = true) const override;
+
+  protected:
+    typedef std::vector<ObjectSP> collection;
+    collection m_items;
+  };
+
+  class Integer : public Object {
+  public:
+    Integer(uint64_t i = 0)
+        : Object(lldb::eStructuredDataTypeInteger), m_value(i) {}
+
+    ~Integer() override = default;
+
+    void SetValue(uint64_t value) { m_value = value; }
+
+    uint64_t GetValue() { return m_value; }
+
+    void Dump(Stream &s, bool pretty_print = true) const override;
+
+  protected:
+    uint64_t m_value;
+  };
+
+  class Float : public Object {
+  public:
+    Float(double d = 0.0)
+        : Object(lldb::eStructuredDataTypeFloat), m_value(d) {}
+
+    ~Float() override = default;
+
+    void SetValue(double value) { m_value = value; }
+
+    double GetValue() { return m_value; }
+
+    void Dump(Stream &s, bool pretty_print = true) const override;
+
+  protected:
+    double m_value;
+  };
+
+  class Boolean : public Object {
+  public:
+    Boolean(bool b = false)
+        : Object(lldb::eStructuredDataTypeBoolean), m_value(b) {}
+
+    ~Boolean() override = default;
+
+    void SetValue(bool value) { m_value = value; }
+
+    bool GetValue() { return m_value; }
+
+    void Dump(Stream &s, bool pretty_print = true) const override;
+
+  protected:
+    bool m_value;
+  };
+
+  class String : public Object {
+  public:
+    String() : Object(lldb::eStructuredDataTypeString) {}
+    explicit String(llvm::StringRef S)
+        : Object(lldb::eStructuredDataTypeString), m_value(S) {}
+
+    void SetValue(llvm::StringRef S) { m_value = S; }
+
+    llvm::StringRef GetValue() { return m_value; }
+
+    void Dump(Stream &s, bool pretty_print = true) const override;
+
+  protected:
+    std::string m_value;
+  };
+
+  class Dictionary : public Object {
+  public:
+    Dictionary() : Object(lldb::eStructuredDataTypeDictionary), m_dict() {}
+
+    ~Dictionary() override = default;
+
+    size_t GetSize() const { return m_dict.size(); }
+
+    void ForEach(std::function<bool(ConstString key, Object *object)> const
+                     &callback) const {
+      for (const auto &pair : m_dict) {
+        if (callback(pair.first, pair.second.get()) == false)
+          break;
+      }
+    }
+
+    ObjectSP GetKeys() const {
+      auto object_sp = std::make_shared<Array>();
+      collection::const_iterator iter;
+      for (iter = m_dict.begin(); iter != m_dict.end(); ++iter) {
+        auto key_object_sp = std::make_shared<String>();
+        key_object_sp->SetValue(iter->first.AsCString());
+        object_sp->Push(key_object_sp);
+      }
+      return object_sp;
+    }
+
+    ObjectSP GetValueForKey(llvm::StringRef key) const {
+      ObjectSP value_sp;
+      if (!key.empty()) {
+        ConstString key_cs(key);
+        collection::const_iterator iter = m_dict.find(key_cs);
+        if (iter != m_dict.end())
+          value_sp = iter->second;
+      }
+      return value_sp;
+    }
+
+    bool GetValueForKeyAsBoolean(llvm::StringRef key, bool &result) const {
+      bool success = false;
+      ObjectSP value_sp = GetValueForKey(key);
+      if (value_sp.get()) {
+        Boolean *result_ptr = value_sp->GetAsBoolean();
+        if (result_ptr) {
+          result = result_ptr->GetValue();
+          success = true;
+        }
+      }
+      return success;
+    }
+    template <class IntType>
+    bool GetValueForKeyAsInteger(llvm::StringRef key, IntType &result) const {
+      ObjectSP value_sp = GetValueForKey(key);
+      if (value_sp) {
+        if (auto int_value = value_sp->GetAsInteger()) {
+          result = static_cast<IntType>(int_value->GetValue());
+          return true;
+        }
+      }
+      return false;
+    }
+
+    template <class IntType>
+    bool GetValueForKeyAsInteger(llvm::StringRef key, IntType &result,
+                                 IntType default_val) const {
+      bool success = GetValueForKeyAsInteger<IntType>(key, result);
+      if (!success)
+        result = default_val;
+      return success;
+    }
+
+    bool GetValueForKeyAsString(llvm::StringRef key,
+                                llvm::StringRef &result) const {
+      ObjectSP value_sp = GetValueForKey(key);
+      if (value_sp.get()) {
+        if (auto string_value = value_sp->GetAsString()) {
+          result = string_value->GetValue();
+          return true;
+        }
+      }
+      return false;
+    }
+
+    bool GetValueForKeyAsString(llvm::StringRef key, llvm::StringRef &result,
+                                const char *default_val) const {
+      bool success = GetValueForKeyAsString(key, result);
+      if (!success) {
+        if (default_val)
+          result = default_val;
+        else
+          result = llvm::StringRef();
+      }
+      return success;
+    }
+
+    bool GetValueForKeyAsString(llvm::StringRef key,
+                                ConstString &result) const {
+      ObjectSP value_sp = GetValueForKey(key);
+      if (value_sp.get()) {
+        if (auto string_value = value_sp->GetAsString()) {
+          result = ConstString(string_value->GetValue());
+          return true;
+        }
+      }
+      return false;
+    }
+
+    bool GetValueForKeyAsString(llvm::StringRef key, ConstString &result,
+                                const char *default_val) const {
+      bool success = GetValueForKeyAsString(key, result);
+      if (!success)
+        result.SetCString(default_val);
+      return success;
+    }
+
+    bool GetValueForKeyAsDictionary(llvm::StringRef key,
+                                    Dictionary *&result) const {
+      result = nullptr;
+      ObjectSP value_sp = GetValueForKey(key);
+      if (value_sp.get()) {
+        result = value_sp->GetAsDictionary();
+        return (result != nullptr);
+      }
+      return false;
+    }
+
+    bool GetValueForKeyAsArray(llvm::StringRef key, Array *&result) const {
+      result = nullptr;
+      ObjectSP value_sp = GetValueForKey(key);
+      if (value_sp.get()) {
+        result = value_sp->GetAsArray();
+        return (result != nullptr);
+      }
+      return false;
+    }
+
+    bool HasKey(llvm::StringRef key) const {
+      ConstString key_cs(key);
+      collection::const_iterator search = m_dict.find(key_cs);
+      return search != m_dict.end();
+    }
+
+    void AddItem(llvm::StringRef key, ObjectSP value_sp) {
+      ConstString key_cs(key);
+      m_dict[key_cs] = value_sp;
+    }
+
+    void AddIntegerItem(llvm::StringRef key, uint64_t value) {
+      AddItem(key, std::make_shared<Integer>(value));
+    }
+
+    void AddFloatItem(llvm::StringRef key, double value) {
+      AddItem(key, std::make_shared<Float>(value));
+    }
+
+    void AddStringItem(llvm::StringRef key, llvm::StringRef value) {
+      AddItem(key, std::make_shared<String>(std::move(value)));
+    }
+
+    void AddBooleanItem(llvm::StringRef key, bool value) {
+      AddItem(key, std::make_shared<Boolean>(value));
+    }
+
+    void Dump(Stream &s, bool pretty_print = true) const override;
+
+  protected:
+    typedef std::map<ConstString, ObjectSP> collection;
+    collection m_dict;
+  };
+
+  class Null : public Object {
+  public:
+    Null() : Object(lldb::eStructuredDataTypeNull) {}
+
+    ~Null() override = default;
+
+    bool IsValid() const override { return false; }
+
+    void Dump(Stream &s, bool pretty_print = true) const override;
+  };
+
+  class Generic : public Object {
+  public:
+    explicit Generic(void *object = nullptr)
+        : Object(lldb::eStructuredDataTypeGeneric), m_object(object) {}
+
+    void SetValue(void *value) { m_object = value; }
+
+    void *GetValue() const { return m_object; }
+
+    bool IsValid() const override { return m_object != nullptr; }
+
+    void Dump(Stream &s, bool pretty_print = true) const override;
+
+  private:
+    void *m_object;
+  };
+
+  static ObjectSP ParseJSON(std::string json_text);
+
+  static ObjectSP ParseJSONFromFile(const FileSpec &file, Status &error);
+};
+
+} // namespace lldb_private
+
+#endif // liblldb_StructuredData_h_

lldb/trunk/source/API/SBStructuredData.cpp

 //===-- SBStructuredData.cpp ------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBStructuredData.h"
 
 #include "lldb/API/SBStream.h"
 #include "lldb/Core/Event.h"
-#include "lldb/Core/StructuredData.h"
 #include "lldb/Core/StructuredDataImpl.h"
 #include "lldb/Target/StructuredDataPlugin.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"
+#include "lldb/Utility/StructuredData.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 #pragma mark--
 #pragma mark SBStructuredData
 
 SBStructuredData::SBStructuredData() : m_impl_up(new StructuredDataImpl()) {}

lldb/trunk/source/API/SBThread.cpp

 
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBSymbolContext.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/State.h"
 #include "lldb/Core/StreamFile.h"
-#include "lldb/Core/StructuredData.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Queue.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/SystemRuntime.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlan.h"
 #include "lldb/Target/ThreadPlanStepInRange.h"
 #include "lldb/Target/ThreadPlanStepInstruction.h"
 #include "lldb/Target/ThreadPlanStepOut.h"
 #include "lldb/Target/ThreadPlanStepRange.h"
 #include "lldb/Target/UnixSignals.h"
 #include "lldb/Utility/Stream.h"
+#include "lldb/Utility/StructuredData.h"
 
 #include "lldb/API/SBAddress.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBEvent.h"
 #include "lldb/API/SBFrame.h"
 #include "lldb/API/SBProcess.h"
 #include "lldb/API/SBThreadCollection.h"
 #include "lldb/API/SBThreadPlan.h"

lldb/trunk/source/API/SBThreadPlan.cpp

 
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBSymbolContext.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/State.h"
 #include "lldb/Core/StreamFile.h"
-#include "lldb/Core/StructuredData.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Queue.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/SystemRuntime.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlan.h"
 #include "lldb/Target/ThreadPlanPython.h"
 #include "lldb/Target/ThreadPlanStepInRange.h"
 #include "lldb/Target/ThreadPlanStepInstruction.h"
 #include "lldb/Target/ThreadPlanStepOut.h"
 #include "lldb/Target/ThreadPlanStepRange.h"
 #include "lldb/Utility/Stream.h"
+#include "lldb/Utility/StructuredData.h"
 
 #include "lldb/API/SBAddress.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBEvent.h"
 #include "lldb/API/SBFrame.h"
 #include "lldb/API/SBProcess.h"
 #include "lldb/API/SBThreadPlan.h"
 #include "lldb/API/SBValue.h"

lldb/trunk/source/Core/CMakeLists.txt

add_lldb_library(lldbCore
   RegisterValue.cpp
   Scalar.cpp
   SearchFilter.cpp
   Section.cpp
   SourceManager.cpp
   State.cpp
   StreamAsynchronousIO.cpp
   StreamFile.cpp
-  StructuredData.cpp
   Timer.cpp
   UserSettingsController.cpp
   Value.cpp
   ValueObject.cpp
   ValueObjectCast.cpp
   ValueObjectChild.cpp
   ValueObjectConstResult.cpp
   ValueObjectConstResultCast.cpp

lldb/trunk/source/Core/FormatEntity.cpp

 //===-- FormatEntity.cpp ----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/FormatEntity.h"
 
 #include "lldb/Core/Address.h"
 #include "lldb/Core/AddressRange.h" // for AddressRange
 #include "lldb/Core/ArchSpec.h"     // for ArchSpec
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
-#include "lldb/Core/RegisterValue.h"  // for RegisterValue
-#include "lldb/Core/StructuredData.h" // for StructuredData::O...
+#include "lldb/Core/RegisterValue.h" // for RegisterValue
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectVariable.h"
 #include "lldb/DataFormatters/DataVisualization.h"
 #include "lldb/DataFormatters/FormatClasses.h" // for TypeNameSpecifier...
 #include "lldb/DataFormatters/FormatManager.h"
 #include "lldb/DataFormatters/TypeSummary.h" // for TypeSummaryImpl::...
 #include "lldb/Expression/ExpressionVariable.h"
 #include "lldb/Interpreter/CommandInterpreter.h"

 #include "lldb/Utility/AnsiTerminal.h"
 #include "lldb/Utility/ConstString.h" // for ConstString, oper...
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"        // for Log
 #include "lldb/Utility/Logging.h"    // for GetLogIfAllCatego...
 #include "lldb/Utility/SharingPtr.h" // for SharingPtr
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StreamString.h"
-#include "lldb/Utility/StringList.h" // for StringList
-#include "lldb/lldb-defines.h"       // for LLDB_INVALID_ADDRESS
-#include "lldb/lldb-forward.h"       // for ValueObjectSP
+#include "lldb/Utility/StringList.h"     // for StringList
+#include "lldb/Utility/StructuredData.h" // for StructuredData::O...
+#include "lldb/lldb-defines.h"           // for LLDB_INVALID_ADDRESS
+#include "lldb/lldb-forward.h"           // for ValueObjectSP
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Triple.h"       // for Triple, Triple::O...
 #include "llvm/Support/Compiler.h" // for LLVM_FALLTHROUGH
 
 #include <ctype.h>     // for isxdigit
 #include <inttypes.h>  // for PRIu64, PRIx64
 #include <memory>      // for shared_ptr, opera...

lldb/trunk/source/Core/StructuredData.cpp

-//===---------------------StructuredData.cpp ---------------------*- C++-*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "lldb/Core/StructuredData.h"
-
-#include "lldb/Host/File.h"
-#include "lldb/Host/StringConvert.h"
-#include "lldb/Utility/DataBuffer.h"
-#include "lldb/Utility/FileSpec.h"
-#include "lldb/Utility/JSON.h"
-#include "lldb/Utility/Status.h"
-#include "lldb/Utility/Stream.h" // for Stream
-#include "lldb/Utility/StreamString.h"
-#include "lldb/lldb-enumerations.h" // for FilePermissions::eFilePermiss...
-#include "lldb/lldb-forward.h"      // for DataBufferSP
-
-#include "llvm/ADT/STLExtras.h" // for make_unique
-
-#include <limits> // for numeric_limits
-
-#include <errno.h>
-#include <inttypes.h>
-#include <stdio.h> // for printf
-#include <stdlib.h>
-#include <sys/types.h> // for off_t
-
-using namespace lldb_private;
-
-//----------------------------------------------------------------------
-// Functions that use a JSONParser to parse JSON into StructuredData
-//----------------------------------------------------------------------
-static StructuredData::ObjectSP ParseJSONValue(JSONParser &json_parser);
-static StructuredData::ObjectSP ParseJSONObject(JSONParser &json_parser);
-static StructuredData::ObjectSP ParseJSONArray(JSONParser &json_parser);
-
-StructuredData::ObjectSP
-StructuredData::ParseJSONFromFile(const FileSpec &input_spec, Status &error) {
-  StructuredData::ObjectSP return_sp;
-  if (!input_spec.Exists()) {
-    error.SetErrorStringWithFormat("input file %s does not exist.",
-                                   input_spec.GetPath().c_str());
-    return return_sp;
-  }
-
-  File input_file(nullptr, File::OpenOptions::eOpenOptionRead,
-                  lldb::eFilePermissionsUserRead);
-  std::string input_path = input_spec.GetPath();
-  error =
-      input_file.Open(input_path.c_str(), File::OpenOptions::eOpenOptionRead,
-                      lldb::eFilePermissionsUserRead);
-
-  if (!error.Success()) {
-    error.SetErrorStringWithFormat("could not open input file: %s - %s.",
-                                   input_spec.GetPath().c_str(),
-                                   error.AsCString());
-    return return_sp;
-  }
-
-  lldb::DataBufferSP input_data;
-  size_t num_bytes = std::numeric_limits<size_t>::max();
-  off_t offset = 0;
-  error = input_file.Read(num_bytes, offset, true, input_data);
-  if (!error.Success()) {
-    error.SetErrorStringWithFormat("could not read input file: %s - %s.",
-                                   input_spec.GetPath().c_str(),
-                                   error.AsCString());
-    return return_sp;
-  }
-  JSONParser json_parser((char *)input_data->GetBytes());
-  return_sp = ParseJSONValue(json_parser);
-  return return_sp;
-}
-
-static StructuredData::ObjectSP ParseJSONObject(JSONParser &json_parser) {
-  // The "JSONParser::Token::ObjectStart" token should have already been
-  // consumed by the time this function is called
-  auto dict_up = llvm::make_unique<StructuredData::Dictionary>();
-
-  std::string value;
-  std::string key;
-  while (1) {
-    JSONParser::Token token = json_parser.GetToken(value);
-
-    if (token == JSONParser::Token::String) {
-      key.swap(value);
-      token = json_parser.GetToken(value);
-      if (token == JSONParser::Token::Colon) {
-        StructuredData::ObjectSP value_sp = ParseJSONValue(json_parser);
-        if (value_sp)
-          dict_up->AddItem(key, value_sp);
-        else
-          break;
-      }
-    } else if (token == JSONParser::Token::ObjectEnd) {
-      return StructuredData::ObjectSP(dict_up.release());
-    } else if (token == JSONParser::Token::Comma) {
-      continue;
-    } else {
-      break;
-    }
-  }
-  return StructuredData::ObjectSP();
-}
-
-static StructuredData::ObjectSP ParseJSONArray(JSONParser &json_parser) {
-  // The "JSONParser::Token::ObjectStart" token should have already been
-  // consumed
-  // by the time this function is called
-  auto array_up = llvm::make_unique<StructuredData::Array>();
-
-  std::string value;
-  std::string key;
-  while (1) {
-    StructuredData::ObjectSP value_sp = ParseJSONValue(json_parser);
-    if (value_sp)
-      array_up->AddItem(value_sp);
-    else
-      break;
-
-    JSONParser::Token token = json_parser.GetToken(value);
-    if (token == JSONParser::Token::Comma) {
-      continue;
-    } else if (token == JSONParser::Token::ArrayEnd) {
-      return StructuredData::ObjectSP(array_up.release());
-    } else {
-      break;
-    }
-  }
-  return StructuredData::ObjectSP();
-}
-
-static StructuredData::ObjectSP ParseJSONValue(JSONParser &json_parser) {
-  std::string value;
-  const JSONParser::Token token = json_parser.GetToken(value);
-  switch (token) {
-  case JSONParser::Token::ObjectStart:
-    return ParseJSONObject(json_parser);
-
-  case JSONParser::Token::ArrayStart:
-    return ParseJSONArray(json_parser);
-
-  case JSONParser::Token::Integer: {
-    bool success = false;
-    uint64_t uval = StringConvert::ToUInt64(value.c_str(), 0, 0, &success);
-    if (success)
-      return std::make_shared<StructuredData::Integer>(uval);
-  } break;
-
-  case JSONParser::Token::Float: {
-    bool success = false;
-    double val = StringConvert::ToDouble(value.c_str(), 0.0, &success);
-    if (success)
-      return std::make_shared<StructuredData::Float>(val);
-  } break;
-
-  case JSONParser::Token::String:
-    return std::make_shared<StructuredData::String>(value);
-
-  case JSONParser::Token::True:
-  case JSONParser::Token::False:
-    return std::make_shared<StructuredData::Boolean>(token ==
-                                                     JSONParser::Token::True);
-
-  case JSONParser::Token::Null:
-    return std::make_shared<StructuredData::Null>();
-
-  default:
-    break;
-  }
-  return StructuredData::ObjectSP();
-}
-
-StructuredData::ObjectSP StructuredData::ParseJSON(std::string json_text) {
-  JSONParser json_parser(json_text.c_str());
-  StructuredData::ObjectSP object_sp = ParseJSONValue(json_parser);
-  return object_sp;
-}
-
-StructuredData::ObjectSP
-StructuredData::Object::GetObjectForDotSeparatedPath(llvm::StringRef path) {
-  if (this->GetType() == lldb::eStructuredDataTypeDictionary) {
-    std::pair<llvm::StringRef, llvm::StringRef> match = path.split('.');
-    std::string key = match.first.str();
-    ObjectSP value = this->GetAsDictionary()->GetValueForKey(key);
-    if (value.get()) {
-      // Do we have additional words to descend?  If not, return the
-      // value we're at right now.
-      if (match.second.empty()) {
-        return value;
-      } else {
-        return value->GetObjectForDotSeparatedPath(match.second);
-      }
-    }
-    return ObjectSP();
-  }
-
-  if (this->GetType() == lldb::eStructuredDataTypeArray) {
-    std::pair<llvm::StringRef, llvm::StringRef> match = path.split('[');
-    if (match.second.size() == 0) {
-      return this->shared_from_this();
-    }
-    errno = 0;
-    uint64_t val = strtoul(match.second.str().c_str(), NULL, 10);
-    if (errno == 0) {
-      return this->GetAsArray()->GetItemAtIndex(val);
-    }
-    return ObjectSP();
-  }
-
-  return this->shared_from_this();
-}
-
-void StructuredData::Object::DumpToStdout(bool pretty_print) const {
-  StreamString stream;
-  Dump(stream, pretty_print);
-  printf("%s\n", stream.GetData());
-}
-
-void StructuredData::Array::Dump(Stream &s, bool pretty_print) const {
-  bool first = true;
-  s << "[";
-  if (pretty_print) {
-    s << "\n";
-    s.IndentMore();
-  }
-  for (const auto &item_sp : m_items) {
-    if (first) {
-      first = false;
-    } else {
-      s << ",";
-      if (pretty_print)
-        s << "\n";
-    }
-
-    if (pretty_print)
-      s.Indent();
-    item_sp->Dump(s, pretty_print);
-  }
-  if (pretty_print) {
-    s.IndentLess();
-    s.EOL();
-    s.Indent();
-  }
-  s << "]";
-}
-
-void StructuredData::Integer::Dump(Stream &s, bool pretty_print) const {
-  s.Printf("%" PRIu64, m_value);
-}
-
-void StructuredData::Float::Dump(Stream &s, bool pretty_print) const {
-  s.Printf("%lg", m_value);
-}
-
-void StructuredData::Boolean::Dump(Stream &s, bool pretty_print) const {
-  if (m_value == true)
-    s.PutCString("true");
-  else
-    s.PutCString("false");
-}
-
-void StructuredData::String::Dump(Stream &s, bool pretty_print) const {
-  std::string quoted;
-  const size_t strsize = m_value.size();
-  for (size_t i = 0; i < strsize; ++i) {
-    char ch = m_value[i];
-    if (ch == '"' || ch == '\\')
-      quoted.push_back('\\');
-    quoted.push_back(ch);
-  }
-  s.Printf("\"%s\"", quoted.c_str());
-}
-
-void StructuredData::Dictionary::Dump(Stream &s, bool pretty_print) const {
-  bool first = true;
-  s << "{";
-  if (pretty_print) {
-    s << "\n";
-    s.IndentMore();
-  }
-  for (const auto &pair : m_dict) {
-    if (first)
-      first = false;
-    else {
-      s << ",";
-      if (pretty_print)
-        s << "\n";
-    }
-    if (pretty_print)
-      s.Indent();
-    s << "\"" << pair.first.AsCString() << "\" : ";
-    pair.second->Dump(s, pretty_print);
-  }
-  if (pretty_print) {
-    s.IndentLess();
-    s.EOL();
-    s.Indent();
-  }
-  s << "}";
-}
-
-void StructuredData::Null::Dump(Stream &s, bool pretty_print) const {
-  s << "null";
-}
-
-void StructuredData::Generic::Dump(Stream &s, bool pretty_print) const {
-  s << "0x" << m_object;
-}

lldb/trunk/source/Host/macosx/Host.mm

 #include <sys/types.h>
 #include <unistd.h>
 
 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Core/Communication.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/StreamFile.h"
-#include "lldb/Core/StructuredData.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/ThreadLauncher.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/CleanUp.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/NameMatches.h"
 #include "lldb/Utility/StreamString.h"
+#include "lldb/Utility/StructuredData.h"
 
 #include "llvm/Support/FileSystem.h"
 
 #include "cfcpp/CFCBundle.h"
 #include "cfcpp/CFCMutableArray.h"
 #include "cfcpp/CFCMutableDictionary.h"
 #include "cfcpp/CFCReleaser.h"
 #include "cfcpp/CFCString.h"

lldb/trunk/source/Host/windows/Host.cpp

 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Status.h"
 
 #include "lldb/Core/StreamFile.h"
-#include "lldb/Core/StructuredData.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
+#include "lldb/Utility/StructuredData.h"
 
 #include "llvm/Support/ConvertUTF.h"
 
 // Windows includes
 #include <tlhelp32.h>
 
 using namespace lldb;
 using namespace lldb_private;

lldb/trunk/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderDarwin.h

 // C Includes
 // C++ Includes
 #include <map>
 #include <mutex>
 #include <vector>
 
 // Other libraries and framework includes
 // Project includes
-#include "lldb/Core/StructuredData.h"
 #include "lldb/Target/DynamicLoader.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/SafeMachO.h"
+#include "lldb/Utility/StructuredData.h"
 #include "lldb/Utility/UUID.h"
 
 #include "llvm/ADT/Triple.h"
 
 namespace lldb_private {
 
 class DynamicLoaderDarwin : public lldb_private::DynamicLoader {
 public:

lldb/trunk/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOS.h

 
 // C Includes
 // C++ Includes
 #include <mutex>
 #include <vector>
 
 // Other libraries and framework includes
 // Project includes
-#include "lldb/Core/StructuredData.h"
 #include "lldb/Target/DynamicLoader.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/SafeMachO.h"
+#include "lldb/Utility/StructuredData.h"
 #include "lldb/Utility/UUID.h"
 
 #include "DynamicLoaderDarwin.h"
 
 class DynamicLoaderMacOS : public lldb_private::DynamicLoaderDarwin {
 public:
   DynamicLoaderMacOS(lldb_private::Process *process);
 

lldb/trunk/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.h

 
 // C Includes
 // C++ Includes
 #include <mutex>
 #include <vector>
 
 // Other libraries and framework includes
 // Project includes
-#include "lldb/Core/StructuredData.h"
 #include "lldb/Target/DynamicLoader.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/SafeMachO.h"
+#include "lldb/Utility/StructuredData.h"
 #include "lldb/Utility/UUID.h"
 
 #include "DynamicLoaderDarwin.h"
 
 class DynamicLoaderMacOSXDYLD : public lldb_private::DynamicLoaderDarwin {
 public:
   DynamicLoaderMacOSXDYLD(lldb_private::Process *process);
 

lldb/trunk/source/Plugins/InstrumentationRuntime/ASan/ASanRuntime.h

 //===-- AddressSanitizerRuntime.h -------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_AddressSanitizerRuntime_h_
 #define liblldb_AddressSanitizerRuntime_h_
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
-#include "lldb/Core/StructuredData.h"
 #include "lldb/Target/InstrumentationRuntime.h"
 #include "lldb/Target/Process.h"
+#include "lldb/Utility/StructuredData.h"
 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
 
 class AddressSanitizerRuntime : public lldb_private::InstrumentationRuntime {
 public:
   ~AddressSanitizerRuntime() override;
 

lldb/trunk/source/Plugins/InstrumentationRuntime/MainThreadChecker/MainThreadCheckerRuntime.h

 //===-- MainThreadCheckerRuntime.h ------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_MainThreadCheckerRuntime_h_
 #define liblldb_MainThreadCheckerRuntime_h_
 
-#include "lldb/Core/StructuredData.h"
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/InstrumentationRuntime.h"
+#include "lldb/Utility/StructuredData.h"
 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
   
   class MainThreadCheckerRuntime : public lldb_private::InstrumentationRuntime {
   public:
     ~MainThreadCheckerRuntime() override;
     

lldb/trunk/source/Plugins/InstrumentationRuntime/TSan/TSanRuntime.h

 //===-- ThreadSanitizerRuntime.h --------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_ThreadSanitizerRuntime_h_
 #define liblldb_ThreadSanitizerRuntime_h_
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
-#include "lldb/Core/StructuredData.h"
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/InstrumentationRuntime.h"
+#include "lldb/Utility/StructuredData.h"
 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
 
 class ThreadSanitizerRuntime : public lldb_private::InstrumentationRuntime {
 public:
   ~ThreadSanitizerRuntime() override;
 

lldb/trunk/source/Plugins/InstrumentationRuntime/UBSan/UBSanRuntime.h

 //===-- UndefinedBehaviorSanitizerRuntime.h ---------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_UndefinedBehaviorSanitizerRuntime_h_
 #define liblldb_UndefinedBehaviorSanitizerRuntime_h_
 
-#include "lldb/Core/StructuredData.h"
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/InstrumentationRuntime.h"
+#include "lldb/Utility/StructuredData.h"
 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
 
 class UndefinedBehaviorSanitizerRuntime
     : public lldb_private::InstrumentationRuntime {
 public:
   ~UndefinedBehaviorSanitizerRuntime() override;

lldb/trunk/source/Plugins/OperatingSystem/Python/OperatingSystemPython.h

 #define liblldb_OperatingSystemPython_h_
 
 #ifndef LLDB_DISABLE_PYTHON
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
-#include "lldb/Core/StructuredData.h"
 #include "lldb/Target/OperatingSystem.h"
+#include "lldb/Utility/StructuredData.h"
 
 class DynamicRegisterInfo;
 
 namespace lldb_private {
 class ScriptInterpreter;
 }
 
 class OperatingSystemPython : public lldb_private::OperatingSystem {

lldb/trunk/source/Plugins/OperatingSystem/Python/OperatingSystemPython.cpp

 #include "Plugins/Process/Utility/RegisterContextDummy.h"
 #include "Plugins/Process/Utility/RegisterContextMemory.h"
 #include "Plugins/Process/Utility/ThreadMemory.h"
 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/RegisterValue.h"
-#include "lldb/Core/StructuredData.h"
 #include "lldb/Core/ValueObjectVariable.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/ScriptInterpreter.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadList.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/StreamString.h"
+#include "lldb/Utility/StructuredData.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 void OperatingSystemPython::Initialize() {
   PluginManager::RegisterPlugin(GetPluginNameStatic(),
                                 GetPluginDescriptionStatic(), CreateInstance,
                                 nullptr);

lldb/trunk/source/Plugins/Process/POSIX/CMakeLists.txt

 include_directories(.)
 include_directories(../Utility)
 
 add_lldb_library(lldbPluginProcessPOSIX PLUGIN
   CrashReason.cpp
   ProcessMessage.cpp
   ProcessPOSIXLog.cpp
 
   LINK_LIBS
-    lldbCore
     lldbInterpreter
   LINK_COMPONENTS
     Support
   )

lldb/trunk/source/Plugins/Process/Utility/DynamicRegisterInfo.h

 
 // C Includes
 // C++ Includes
 #include <map>
 #include <vector>
 
 // Other libraries and framework includes
 // Project includes
-#include "lldb/Core/StructuredData.h"
 #include "lldb/Utility/ConstString.h"
+#include "lldb/Utility/StructuredData.h"
 #include "lldb/lldb-private.h"
 
 class DynamicRegisterInfo {
 public:
   DynamicRegisterInfo();
 
   DynamicRegisterInfo(const lldb_private::StructuredData::Dictionary &dict,
                       const lldb_private::ArchSpec &arch);

lldb/trunk/source/Plugins/Process/Utility/DynamicRegisterInfo.cpp

 #include "DynamicRegisterInfo.h"
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Core/StreamFile.h"
-#include "lldb/Core/StructuredData.h"
 #include "lldb/DataFormatters/FormatManager.h"
 #include "lldb/Host/StringConvert.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "lldb/Utility/StringExtractor.h"
+#include "lldb/Utility/StructuredData.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 DynamicRegisterInfo::DynamicRegisterInfo()
     : m_regs(), m_sets(), m_set_reg_nums(), m_set_names(), m_value_regs_map(),
       m_invalidate_regs_map(), m_dynamic_reg_size_map(),
       m_reg_data_byte_size(0), m_finalized(false) {}

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h

 #include <map>
 #include <mutex>
 #include <string>
 #include <vector>
 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/ArchSpec.h"
-#include "lldb/Core/StructuredData.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/StreamGDBRemote.h"
+#include "lldb/Utility/StructuredData.h"
 
 #include "llvm/ADT/Optional.h"
 
 namespace lldb_private {
 namespace process_gdb_remote {
 
 class GDBRemoteCommunicationClient : public GDBRemoteClientBase {
 public:

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.cpp

 #include <cstring>
 #include <mutex>
 #include <sstream>
 
 // Other libraries and framework includes
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Threading.h"
 
-#include "lldb/Core/StructuredData.h"
 #include "lldb/Host/Config.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Target/FileAction.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/UnixSignals.h"
 #include "lldb/Utility/JSON.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamGDBRemote.h"
 #include "lldb/Utility/StreamString.h"
+#include "lldb/Utility/StructuredData.h"
 #include "lldb/Utility/UriParser.h"
 
 // Project includes
 #include "Utility/StringExtractorGDBRemote.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::process_gdb_remote;

lldb/trunk/source/Plugins/Process/gdb-remote/ProcessGDBRemote.h

 #include <vector>
 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Core/Broadcaster.h"
 #include "lldb/Core/LoadedModuleInfoList.h"
 #include "lldb/Core/ModuleSpec.h"
-#include "lldb/Core/StructuredData.h"
 #include "lldb/Core/ThreadSafeValue.h"
 #include "lldb/Host/HostThread.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamGDBRemote.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/StringExtractor.h"
 #include "lldb/Utility/StringList.h"
+#include "lldb/Utility/StructuredData.h"
 #include "lldb/lldb-private-forward.h"
 
 #include "GDBRemoteCommunicationClient.h"
 #include "GDBRemoteRegisterContext.h"
 
 #include "llvm/ADT/DenseMap.h"
 
 namespace lldb_private {

lldb/trunk/source/Plugins/Process/gdb-remote/ThreadGDBRemote.h

 #define liblldb_ThreadGDBRemote_h_
 
 // C Includes
 // C++ Includes
 #include <string>
 
 // Other libraries and framework includes
 // Project includes
-#include "lldb/Core/StructuredData.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Thread.h"
+#include "lldb/Utility/StructuredData.h"
 
 class StringExtractor;
 
 namespace lldb_private {
 namespace process_gdb_remote {
 
 class ProcessGDBRemote;
 

lldb/trunk/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.h

 #include "lldb-python.h"
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Utility/Flags.h"
 
-#include "lldb/Core/StructuredData.h"
 #include "lldb/Host/File.h"
 #include "lldb/Interpreter/OptionValue.h"
 #include "lldb/Utility/ConstString.h"
+#include "lldb/Utility/StructuredData.h"
 #include "lldb/lldb-defines.h"
 
 #include "llvm/ADT/ArrayRef.h"
 
 namespace lldb_private {
 
 class PythonBytes;
 class PythonString;

lldb/trunk/source/Plugins/SystemRuntime/MacOSX/SystemRuntimeMacOSX.h

 // C++ Includes
 #include <mutex>
 #include <string>
 #include <vector>
 
 // Other libraries and framework include
 // Project includes
 #include "lldb/Core/ModuleList.h"
-#include "lldb/Core/StructuredData.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/QueueItem.h"
 #include "lldb/Target/SystemRuntime.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/FileSpec.h"
+#include "lldb/Utility/StructuredData.h"
 #include "lldb/Utility/UUID.h"
 
 #include "AppleGetItemInfoHandler.h"
 #include "AppleGetPendingItemsHandler.h"
 #include "AppleGetQueuesHandler.h"
 #include "AppleGetThreadItemInfoHandler.h"
 
 class SystemRuntimeMacOSX : public lldb_private::SystemRuntime {

lldb/trunk/source/Target/Platform.cpp

 // Project includes
 #include "lldb/Breakpoint/BreakpointIDList.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/StreamFile.h"
-#include "lldb/Core/StructuredData.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Interpreter/OptionValueProperties.h"
 #include "lldb/Interpreter/Property.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/ModuleCache.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/UnixSignals.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Status.h"
+#include "lldb/Utility/StructuredData.h"
 
 #include "llvm/Support/FileSystem.h"
 
 // Define these constants from POSIX mman.h rather than include the file
 // so that they will be correct even when compiled on Linux.
 #define MAP_PRIVATE 2
 #define MAP_ANON 0x1000
 

lldb/trunk/source/Target/ThreadSpec.cpp

 //===-- ThreadSpec.cpp ------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
-#include "lldb/Target/Thread.h"
-#include "lldb/Core/StructuredData.h"
 #include "lldb/Target/ThreadSpec.h"
+#include "lldb/Target/Thread.h"
+#include "lldb/Utility/StructuredData.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 const char *ThreadSpec::g_option_names[static_cast<uint32_t>(
     ThreadSpec::OptionNames::LastOptionName)]{"Index", "ID", "Name",
                                               "QueueName"};
 

lldb/trunk/source/Utility/CMakeLists.txt

add_lldb_library(lldbUtility
   Stream.cpp
   StreamCallback.cpp
   StreamGDBRemote.cpp
   StreamString.cpp
   StringExtractor.cpp
   StringExtractorGDBRemote.cpp
   StringLexer.cpp
   StringList.cpp
+  StructuredData.cpp
   TaskPool.cpp
   TildeExpressionResolver.cpp
   UserID.cpp
   UriParser.cpp
   UUID.cpp
   VASprintf.cpp
   VMRange.cpp
 
   LINK_LIBS
   # lldbUtility cannot have any dependencies
 
   LINK_COMPONENTS
     BinaryFormat
     Support
   )

lldb/trunk/source/Utility/JSON.cpp

 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) : StringExtractor(cstr) {}
+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();

lldb/trunk/source/Utility/StructuredData.cpp

+//===---------------------StructuredData.cpp ---------------------*- C++-*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Utility/StructuredData.h"
+#include "lldb/Utility/DataBuffer.h"
+#include "lldb/Utility/FileSpec.h"
+#include "lldb/Utility/JSON.h"
+#include "lldb/Utility/Status.h"
+#include "lldb/Utility/Stream.h" // for Stream
+#include "lldb/Utility/StreamString.h"
+#include "llvm/ADT/STLExtras.h" // for make_unique
+#include <cerrno>
+#include <cstdlib>
+#include <inttypes.h>
+#include <limits> // for numeric_limits
+
+using namespace lldb_private;
+
+//----------------------------------------------------------------------
+// Functions that use a JSONParser to parse JSON into StructuredData
+//----------------------------------------------------------------------
+static StructuredData::ObjectSP ParseJSONValue(JSONParser &json_parser);
+static StructuredData::ObjectSP ParseJSONObject(JSONParser &json_parser);
+static StructuredData::ObjectSP ParseJSONArray(JSONParser &json_parser);
+
+StructuredData::ObjectSP
+StructuredData::ParseJSONFromFile(const FileSpec &input_spec, Status &error) {
+  StructuredData::ObjectSP return_sp;
+  if (!input_spec.Exists()) {
+    error.SetErrorStringWithFormatv("input file {0} does not exist.",
+                                    input_spec);
+    return return_sp;
+  }
+
+  auto buffer_or_error = llvm::MemoryBuffer::getFile(input_spec.GetPath());
+  if (!buffer_or_error) {
+    error.SetErrorStringWithFormatv("could not open input file: {0} - {1}.",
+                                    input_spec.GetPath(),
+                                    buffer_or_error.getError().message());
+    return return_sp;
+  }
+
+  JSONParser json_parser(buffer_or_error.get()->getBuffer());
+  return_sp = ParseJSONValue(json_parser);
+  return return_sp;
+}
+
+static StructuredData::ObjectSP ParseJSONObject(JSONParser &json_parser) {
+  // The "JSONParser::Token::ObjectStart" token should have already been
+  // consumed by the time this function is called
+  auto dict_up = llvm::make_unique<StructuredData::Dictionary>();
+
+  std::string value;
+  std::string key;
+  while (1) {
+    JSONParser::Token token = json_parser.GetToken(value);
+
+    if (token == JSONParser::Token::String) {
+      key.swap(value);
+      token = json_parser.GetToken(value);
+      if (token == JSONParser::Token::Colon) {
+        StructuredData::ObjectSP value_sp = ParseJSONValue(json_parser);
+        if (value_sp)
+          dict_up->AddItem(key, value_sp);
+        else
+          break;
+      }
+    } else if (token == JSONParser::Token::ObjectEnd) {
+      return StructuredData::ObjectSP(dict_up.release());
+    } else if (token == JSONParser::Token::Comma) {
+      continue;
+    } else {
+      break;
+    }
+  }
+  return StructuredData::ObjectSP();
+}
+
+static StructuredData::ObjectSP ParseJSONArray(JSONParser &json_parser) {
+  // The "JSONParser::Token::ObjectStart" token should have already been
+  // consumed
+  // by the time this function is called
+  auto array_up = llvm::make_unique<StructuredData::Array>();
+
+  std::string value;
+  std::string key;
+  while (1) {
+    StructuredData::ObjectSP value_sp = ParseJSONValue(json_parser);
+    if (value_sp)
+      array_up->AddItem(value_sp);
+    else
+      break;
+
+    JSONParser::Token token = json_parser.GetToken(value);
+    if (token == JSONParser::Token::Comma) {
+      continue;
+    } else if (token == JSONParser::Token::ArrayEnd) {
+      return StructuredData::ObjectSP(array_up.release());
+    } else {
+      break;
+    }
+  }
+  return StructuredData::ObjectSP();
+}
+
+static StructuredData::ObjectSP ParseJSONValue(JSONParser &json_parser) {
+  std::string value;
+  const JSONParser::Token token = json_parser.GetToken(value);
+  switch (token) {
+  case JSONParser::Token::ObjectStart:
+    return ParseJSONObject(json_parser);
+
+  case JSONParser::Token::ArrayStart:
+    return ParseJSONArray(json_parser);
+
+  case JSONParser::Token::Integer: {
+    uint64_t uval;
+    if (llvm::to_integer(value, uval, 0))
+      return std::make_shared<StructuredData::Integer>(uval);
+  } break;
+
+  case JSONParser::Token::Float: {
+    double val;
+    if (llvm::to_float(value, val))
+      return std::make_shared<StructuredData::Float>(val);
+  } break;
+
+  case JSONParser::Token::String:
+    return std::make_shared<StructuredData::String>(value);
+
+  case JSONParser::Token::True:
+  case JSONParser::Token::False:
+    return std::make_shared<StructuredData::Boolean>(token ==
+                                                     JSONParser::Token::True);
+
+  case JSONParser::Token::Null:
+    return std::make_shared<StructuredData::Null>();
+
+  default:
+    break;
+  }
+  return StructuredData::ObjectSP();
+}
+
+StructuredData::ObjectSP StructuredData::ParseJSON(std::string json_text) {
+  JSONParser json_parser(json_text.c_str());
+  StructuredData::ObjectSP object_sp = ParseJSONValue(json_parser);
+  return object_sp;
+}
+
+StructuredData::ObjectSP
+StructuredData::Object::GetObjectForDotSeparatedPath(llvm::StringRef path) {
+  if (this->GetType() == lldb::eStructuredDataTypeDictionary) {
+    std::pair<llvm::StringRef, llvm::StringRef> match = path.split('.');
+    std::string key = match.first.str();
+    ObjectSP value = this->GetAsDictionary()->GetValueForKey(key);
+    if (value.get()) {
+      // Do we have additional words to descend?  If not, return the
+      // value we're at right now.
+      if (match.second.empty()) {
+        return value;
+      } else {
+        return value->GetObjectForDotSeparatedPath(match.second);
+      }
+    }
+    return ObjectSP();
+  }
+
+  if (this->GetType() == lldb::eStructuredDataTypeArray) {
+    std::pair<llvm::StringRef, llvm::StringRef> match = path.split('[');
+    if (match.second.size() == 0) {
+      return this->shared_from_this();
+    }
+    errno = 0;
+    uint64_t val = strtoul(match.second.str().c_str(), NULL, 10);
+    if (errno == 0) {
+      return this->GetAsArray()->GetItemAtIndex(val);
+    }
+    return ObjectSP();
+  }
+
+  return this->shared_from_this();
+}
+
+void StructuredData::Object::DumpToStdout(bool pretty_print) const {
+  StreamString stream;
+  Dump(stream, pretty_print);
+  llvm::outs() << stream.GetString();
+}
+
+void StructuredData::Array::Dump(Stream &s, bool pretty_print) const {
+  bool first = true;
+  s << "[";
+  if (pretty_print) {
+    s << "\n";
+    s.IndentMore();
+  }
+  for (const auto &item_sp : m_items) {
+    if (first) {
+      first = false;
+    } else {
+      s << ",";
+      if (pretty_print)
+        s << "\n";
+    }
+
+    if (pretty_print)
+      s.Indent();
+    item_sp->Dump(s, pretty_print);
+  }
+  if (pretty_print) {
+    s.IndentLess();
+    s.EOL();
+    s.Indent();
+  }
+  s << "]";
+}
+
+void StructuredData::Integer::Dump(Stream &s, bool pretty_print) const {
+  s.Printf("%" PRIu64, m_value);
+}
+
+void StructuredData::Float::Dump(Stream &s, bool pretty_print) const {
+  s.Printf("%lg", m_value);
+}
+
+void StructuredData::Boolean::Dump(Stream &s, bool pretty_print) const {
+  if (m_value == true)
+    s.PutCString("true");
+  else
+    s.PutCString("false");
+}
+
+void StructuredData::String::Dump(Stream &s, bool pretty_print) const {
+  std::string quoted;
+  const size_t strsize = m_value.size();
+  for (size_t i = 0; i < strsize; ++i) {
+    char ch = m_value[i];
+    if (ch == '"' || ch == '\\')
+      quoted.push_back('\\');
+    quoted.push_back(ch);
+  }
+  s.Printf("\"%s\"", quoted.c_str());
+}
+
+void StructuredData::Dictionary::Dump(Stream &s, bool pretty_print) const {
+  bool first = true;
+  s << "{";
+  if (pretty_print) {
+    s << "\n";
+    s.IndentMore();
+  }
+  for (const auto &pair : m_dict) {
+    if (first)
+      first = false;
+    else {
+      s << ",";
+      if (pretty_print)
+        s << "\n";
+    }
+    if (pretty_print)
+      s.Indent();
+    s << "\"" << pair.first.AsCString() << "\" : ";
+    pair.second->Dump(s, pretty_print);
+  }
+  if (pretty_print) {
+    s.IndentLess();
+    s.EOL();
+    s.Indent();
+  }
+  s << "}";
+}
+
+void StructuredData::Null::Dump(Stream &s, bool pretty_print) const {
+  s << "null";
+}
+
+void StructuredData::Generic::Dump(Stream &s, bool pretty_print) const {
+  s << "0x" << m_object;
+}

lldb/trunk/unittests/Core/CMakeLists.txt

 add_lldb_unittest(LLDBCoreTests
   ArchSpecTest.cpp
   BroadcasterTest.cpp
   DataExtractorTest.cpp
   ListenerTest.cpp
   ScalarTest.cpp
   StateTest.cpp
   StreamCallbackTest.cpp
-  StructuredDataTest.cpp
   TimerTest.cpp
 
   LINK_LIBS
     lldbCore
     lldbHost
   LINK_COMPONENTS
     Support
   )

lldb/trunk/unittests/Core/StructuredDataTest.cpp

-//===-- StructuredDataTest.cpp ----------------------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "gtest/gtest.h"
-
-#include "lldb/Core/StructuredData.h"
-#include "lldb/Utility/StreamString.h"
-
-#include "llvm/BinaryFormat/MachO.h"
-
-using namespace lldb;
-using namespace lldb_private;
-
-TEST(StructuredDataTest, StringDump) {
-  std::pair<llvm::StringRef, llvm::StringRef> TestCases[] = {
-    { R"(asdfg)", R"("asdfg")" },
-    { R"(as"df)", R"("as\"df")" },
-    { R"(as\df)", R"("as\\df")" },
-  };
-  for(auto P : TestCases) {
-    StreamString S;
-    const bool pretty_print = false;
-    StructuredData::String(P.first).Dump(S, pretty_print);
-    EXPECT_EQ(P.second, S.GetString());
-  }
-}

lldb/trunk/unittests/Process/gdb-remote/GDBRemoteCommunicationClientTest.cpp

 //===-- GDBRemoteCommunicationClientTest.cpp --------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 #include <future>
 
 #include "GDBRemoteTestUtils.h"
 
 #include "Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h"
 #include "lldb/Core/ModuleSpec.h"
-#include "lldb/Core/StructuredData.h"
 #include "lldb/Core/TraceOptions.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Utility/DataBuffer.h"
+#include "lldb/Utility/StructuredData.h"
 #include "lldb/lldb-enumerations.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Testing/Support/Error.h"
 
 using namespace lldb_private::process_gdb_remote;
 using namespace lldb_private;
 using namespace lldb;
 using namespace llvm;

lldb/trunk/unittests/Utility/CMakeLists.txt

 add_subdirectory(Mocks)
 
 add_lldb_unittest(UtilityTests
   ConstStringTest.cpp
   LogTest.cpp
   NameMatchesTest.cpp
   StatusTest.cpp
   StringExtractorTest.cpp
+  StructuredDataTest.cpp
   TaskPoolTest.cpp
   TildeExpressionResolverTest.cpp
   TimeoutTest.cpp
   UriParserTest.cpp
   VASprintfTest.cpp
 
   LINK_LIBS
       lldbUtility
       lldbUtilityMocks
   LINK_COMPONENTS
     Support
   )
+
+add_unittest_inputs(UtilityTests
+  StructuredData-basic.json
+  )

lldb/trunk/unittests/Utility/Inputs/StructuredData-basic.json

+[1, 2, 3]

lldb/trunk/unittests/Utility/StructuredDataTest.cpp

+//===-- StructuredDataTest.cpp ----------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "gtest/gtest.h"
+
+#include "lldb/Utility/Status.h"
+#include "lldb/Utility/StreamString.h"
+#include "lldb/Utility/StructuredData.h"
+#include "llvm/Support/Path.h"
+
+extern const char *TestMainArgv0;
+
+using namespace lldb;
+using namespace lldb_private;
+
+namespace {
+
+class StructuredDataTest : public testing::Test {
+public:
+  static void SetUpTestCase() {
+    s_inputs_folder = llvm::sys::path::parent_path(TestMainArgv0);
+    llvm::sys::path::append(s_inputs_folder, "Inputs");
+  }
+
+protected:
+  static llvm::SmallString<128> s_inputs_folder;
+};
+} // namespace
+
+llvm::SmallString<128> StructuredDataTest::s_inputs_folder;
+
+TEST_F(StructuredDataTest, StringDump) {
+  std::pair<llvm::StringRef, llvm::StringRef> TestCases[] = {
+      {R"(asdfg)", R"("asdfg")"},
+      {R"(as"df)", R"("as\"df")"},
+      {R"(as\df)", R"("as\\df")"},
+  };
+  for (auto P : TestCases) {
+    StreamString S;
+    const bool pretty_print = false;
+    StructuredData::String(P.first).Dump(S, pretty_print);
+    EXPECT_EQ(P.second, S.GetString());
+  }
+}
+
+TEST_F(StructuredDataTest, ParseJSONFromFile) {
+  Status status;
+  auto object_sp = StructuredData::ParseJSONFromFile(
+      FileSpec("non-existing-file.json", false), status);
+  EXPECT_EQ(nullptr, object_sp);
+
+  llvm::SmallString<128> input = s_inputs_folder;
+  llvm::sys::path::append(input, "StructuredData-basic.json");
+  object_sp = StructuredData::ParseJSONFromFile(FileSpec(input, false), status);
+  ASSERT_NE(nullptr, object_sp);
+
+  StreamString S;
+  object_sp->Dump(S, false);
+  EXPECT_EQ("[1,2,3]", S.GetString());
+}

lldb/trunk/unittests/tools/lldb-server/tests/MessageObjects.cpp

 //===-- MessageObjects.cpp --------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "MessageObjects.h"
-#include "lldb/Core/StructuredData.h"
+#include "lldb/Utility/StructuredData.h"
 #include "llvm/ADT/StringExtras.h"
 #include "gtest/gtest.h"
 
 using namespace lldb_private;
 using namespace llvm;
 using namespace llvm::support;
 namespace llgs_tests {