Revert "Reduced packet counts to the remote GDB server where possible."

This reverts commit 0cc0745ea9c68d7fdcadc9904cee3f13c96dae60.

Due to breakage on Linux build bot:

http://lab.llvm.org:8011/builders/lldb-x86_64-ubuntu-14.04-cmake/builds/3436

llvm-svn: 240371

1 files changed, 0 insertions, 490 deletions

diff --git a/lldb/tools/debugserver/source/JSONGenerator.h b/lldb/tools/debugserver/source/JSONGenerator.h
deleted file mode 100644
index 423b2bd5792..00000000000
--- a/lldb/tools/debugserver/source/JSONGenerator.h
+++ /dev/null
@@ -1,490 +0,0 @@
-//===-- JSONGenerator.h ----------------------------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef __JSONGenerator_h_
-#define __JSONGenerator_h_
-
-// C Includes
-// C++ Includes
-
-#include <iomanip>
-#include <sstream>
-#include <string>
-#include <utility>
-#include <vector>
-
-//----------------------------------------------------------------------
-/// @class JSONGenerator JSONGenerator.h
-/// @brief A class which can construct structured data for the sole purpose
-/// of printing it in JSON format.
-///
-/// A stripped down version of lldb's StructuredData objects which are much
-/// general purpose.  This variant is intended only for assembling information
-/// and printing it as a JSON string.
-//----------------------------------------------------------------------
-
-class JSONGenerator
-{
-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;
-
-    enum class Type
-    {
-        eTypeInvalid = -1,
-        eTypeNull = 0,
-        eTypeGeneric,
-        eTypeArray,
-        eTypeInteger,
-        eTypeFloat,
-        eTypeBoolean,
-        eTypeString,
-        eTypeDictionary
-    };
-
-    class Object :
-        public std::enable_shared_from_this<Object>
-    {
-    public:
-
-        Object (Type t = Type::eTypeInvalid) :
-            m_type (t)
-        {
-        }
-
-        virtual ~Object ()
-        {
-        }
-
-        virtual bool
-        IsValid() const
-        {
-            return true;
-        }
-
-        virtual void
-        Clear ()
-        {
-            m_type = Type::eTypeInvalid;
-        }
-
-        Type
-        GetType () const
-        {
-            return m_type;
-        }
-
-        void
-        SetType (Type t)
-        {
-            m_type = t;
-        }
-
-        Array *
-        GetAsArray ()
-        {
-            if (m_type == Type::eTypeArray)
-                return (Array *)this;
-            return NULL;
-        }
-
-        Dictionary *
-        GetAsDictionary ()
-        {
-            if (m_type == Type::eTypeDictionary)
-                return (Dictionary *)this;
-            return NULL;
-        }
-
-        Integer *
-        GetAsInteger ()
-        {
-            if (m_type == Type::eTypeInteger)
-                return (Integer *)this;
-            return NULL;
-        }
-
-        Float *
-        GetAsFloat ()
-        {
-            if (m_type == Type::eTypeFloat)
-                return (Float *)this;
-            return NULL;
-        }
-
-        Boolean *
-        GetAsBoolean ()
-        {
-            if (m_type == Type::eTypeBoolean)
-                return (Boolean *)this;
-            return NULL;
-        }
-
-        String *
-        GetAsString ()
-        {
-            if (m_type == Type::eTypeString)
-                return (String *)this;
-            return NULL;
-        }
-
-        Generic *
-        GetAsGeneric()
-        {
-            if (m_type == Type::eTypeGeneric)
-                return (Generic *)this;
-            return NULL;
-        }
-
-        virtual void
-        Dump (std::ostream &s) const = 0; 
-
-    private:
-        Type m_type;
-    };
-
-    class Array : public Object
-    {
-    public:
-        Array () :
-            Object (Type::eTypeArray)
-        {
-        }
-
-        virtual
-        ~Array()
-        {
-        }
-
-        void
-        AddItem(ObjectSP item)
-        {
-            m_items.push_back(item);
-        }
-
-        void Dump(std::ostream &s) const override
-        {
-            s << "[";
-            const size_t arrsize = m_items.size();
-            for (size_t i = 0; i < arrsize; ++i)
-            {
-                m_items[i]->Dump(s);
-                if (i + 1 < arrsize)
-                    s << ",";
-            }
-            s << "]";
-        }
-
-    protected:
-        typedef std::vector<ObjectSP> collection;
-        collection m_items;
-    };
-
-
-    class Integer  : public Object
-    {
-    public:
-        Integer (uint64_t value = 0) :
-            Object (Type::eTypeInteger),
-            m_value (value)
-        {
-        }
-
-        virtual ~Integer()
-        {
-        }
-
-        void
-        SetValue (uint64_t value)
-        {
-            m_value = value;
-        }
-
-        void Dump(std::ostream &s) const override
-        {
-            s << m_value;
-        }
-
-    protected:
-        uint64_t m_value;
-    };
-
-    class Float  : public Object
-    {
-    public:
-        Float (double d = 0.0) :
-            Object (Type::eTypeFloat),
-            m_value (d)
-        {
-        }
-
-        virtual ~Float()
-        {
-        }
-
-        void
-        SetValue (double value)
-        {
-            m_value = value;
-        }
-
-        void Dump(std::ostream &s) const override
-        {
-            s << m_value;
-        }
-
-    protected:
-        double m_value;
-    };
-
-    class Boolean  : public Object
-    {
-    public:
-        Boolean (bool b = false) :
-            Object (Type::eTypeBoolean),
-            m_value (b)
-        {
-        }
-
-        virtual ~Boolean()
-        {
-        }
-
-        void
-        SetValue (bool value)
-        {
-            m_value = value;
-        }
-
-        void Dump(std::ostream &s) const override
-        {
-            if (m_value == true)
-                s << "true";
-            else
-                s << "false";
-        }
-
-    protected:
-        bool m_value;
-    };
-
-
-
-    class String  : public Object
-    {
-    public:
-        String () :
-            Object (Type::eTypeString),
-            m_value ()
-        {
-        }
-
-        String (const std::string &s) :
-            Object (Type::eTypeString),
-            m_value (s)
-        {
-        }
-
-        String (const std::string &&s) :
-            Object (Type::eTypeString),
-            m_value (s)
-        {
-        }
-
-        void
-        SetValue (const std::string &string)
-        {
-            m_value = string;
-        }
-
-        void Dump(std::ostream &s) const override
-        {
-            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 == '"')
-                    quoted.push_back ('\\');
-                quoted.push_back (ch);
-            }
-            s << '"' << quoted.c_str() << '"';
-        }
-
-    protected:
-        std::string m_value;
-    };
-
-    class Dictionary : public Object
-    {
-    public:
-        Dictionary () :
-            Object (Type::eTypeDictionary),
-            m_dict ()
-        {
-        }
-
-        virtual ~Dictionary()
-        {
-        }
-
-        void
-        AddItem (std::string key, ObjectSP value)
-        {
-            m_dict.push_back(Pair(key, value));
-        }
-
-        void
-        AddIntegerItem (std::string key, uint64_t value)
-        {
-            AddItem (key, ObjectSP (new Integer(value)));
-        }
-
-        void
-        AddFloatItem (std::string key, double value)
-        {
-            AddItem (key, ObjectSP (new Float(value)));
-        }
-
-        void
-        AddStringItem (std::string key, std::string value)
-        {
-            AddItem (key, ObjectSP (new String(std::move(value))));
-        }
-
-        void
-        AddBytesAsHexASCIIString (std::string key, const uint8_t *src, size_t src_len)
-        {
-            if (src && src_len)
-            {
-                std::ostringstream strm;
-                for (size_t i = 0; i < src_len; i++)
-                    strm << std::setfill('0') << std::hex << std::right << std::setw(2) << ((uint32_t)(src[i]));
-                AddItem (key, ObjectSP (new String(std::move(strm.str()))));
-            }
-            else
-            {
-                AddItem (key, ObjectSP (new String()));
-            }
-        }
-
-        void
-        AddBooleanItem (std::string key, bool value)
-        {
-            AddItem (key, ObjectSP (new Boolean(value)));
-        }
-
-        void Dump(std::ostream &s) const override
-        {
-            bool have_printed_one_elem = false;
-            s << "{";
-            for (collection::const_iterator iter = m_dict.begin(); iter != m_dict.end(); ++iter)
-            {
-                if (have_printed_one_elem == false)
-                {
-                    have_printed_one_elem = true;
-                }
-                else
-                {
-                    s << ",";
-                }
-                s << "\"" << iter->first.c_str() << "\":";
-                iter->second->Dump(s);
-            }
-            s << "}";
-        }
-
-    protected:
-        // Keep the dictionary as a vector so the dictionary doesn't reorder itself when you dump it
-        // We aren't accessing keys by name, so this won't affect performance
-        typedef std::pair<std::string, ObjectSP> Pair;
-        typedef std::vector<Pair> collection;
-        collection m_dict;
-    };
-
-    class Null : public Object
-    {
-    public:
-        Null () :
-            Object (Type::eTypeNull)
-        {
-        }
-
-        virtual ~Null()
-        {
-        }
-
-        bool
-        IsValid() const override
-        {
-            return false;
-        }
-
-        void Dump(std::ostream &s) const override
-        {
-            s << "null";
-        }
-
-    protected:
-    };
-
-    class Generic : public Object
-    {
-      public:
-        explicit Generic(void *object = nullptr)
-            : Object(Type::eTypeGeneric)
-            , 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(std::ostream &s) const override;
-
-      private:
-        void *m_object;
-    };
-
-};  // class JSONGenerator
-
-
-
-#endif  // __JSONGenerator_h_