tools/debugserver/source/JSON.h

   1 //===---------------------JSON.h --------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #ifndef utility_JSON_h_
  11 #define utility_JSON_h_
  12
  13 #include "StdStringExtractor.h"
  14
  15 // C includes
  16 #include <inttypes.h>
  17 #include <stdint.h>
  18
  19 // C++ includes
  20 #include <map>
  21 #include <memory>
  22 #include <ostream>
  23 #include <string>
  24 #include <vector>
  25
  26 class JSONValue {
  27 public:
  28   virtual void Write(std::ostream &s) = 0;
  29
  30   typedef std::shared_ptr<JSONValue> SP;
  31
  32   enum class Kind { String, Number, True, False, Null, Object, Array };
  33
  34   JSONValue(Kind k) : m_kind(k) {}
  35
  36   Kind GetKind() const { return m_kind; }
  37
  38   virtual ~JSONValue() = default;
  39
  40 private:
  41   const Kind m_kind;
  42 };
  43
  44 class JSONString : public JSONValue {
  45 public:
  46   JSONString();
  47   JSONString(const char *s);
  48   JSONString(const std::string &s);
  49
  50   JSONString(const JSONString &s) = delete;
  51   JSONString &operator=(const JSONString &s) = delete;
  52
  53   void Write(std::ostream &s) override;
  54
  55   typedef std::shared_ptr<JSONString> SP;
  56
  57   std::string GetData() { return m_data; }
  58
  59   static bool classof(const JSONValue *V) {
  60     return V->GetKind() == JSONValue::Kind::String;
  61   }
  62
  63   ~JSONString() override = default;
  64
  65 private:
  66   static std::string json_string_quote_metachars(const std::string &);
  67
  68   std::string m_data;
  69 };
  70
  71 class JSONNumber : public JSONValue {
  72 public:
  73   typedef std::shared_ptr<JSONNumber> SP;
  74
  75   // We cretae a constructor for all integer and floating point type with using
  76   // templates and
  77   // SFINAE to avoid having ambiguous overloads because of the implicit type
  78   // promotion. If we
  79   // would have constructors only with int64_t, uint64_t and double types then
  80   // constructing a
  81   // JSONNumber from an int32_t (or any other similar type) would fail to
  82   // compile.
  83
  84   template <typename T, typename std::enable_if<
  85                             std::is_integral<T>::value &&
  86                             std::is_unsigned<T>::value>::type * = nullptr>
  87   explicit JSONNumber(T u)
  88       : JSONValue(JSONValue::Kind::Number), m_data_type(DataType::Unsigned) {
  89     m_data.m_unsigned = u;
  90   }
  91
  92   template <typename T,
  93             typename std::enable_if<std::is_integral<T>::value &&
  94                                     std::is_signed<T>::value>::type * = nullptr>
  95   explicit JSONNumber(T s)
  96       : JSONValue(JSONValue::Kind::Number), m_data_type(DataType::Signed) {
  97     m_data.m_signed = s;
  98   }
  99
 100   template <typename T, typename std::enable_if<
 101                             std::is_floating_point<T>::value>::type * = nullptr>
 102   explicit JSONNumber(T d)
 103       : JSONValue(JSONValue::Kind::Number), m_data_type(DataType::Double) {
 104     m_data.m_double = d;
 105   }
 106
 107   ~JSONNumber() override = default;
 108
 109   JSONNumber(const JSONNumber &s) = delete;
 110   JSONNumber &operator=(const JSONNumber &s) = delete;
 111
 112   void Write(std::ostream &s) override;
 113
 114   uint64_t GetAsUnsigned() const;
 115
 116   int64_t GetAsSigned() const;
 117
 118   double GetAsDouble() const;
 119
 120   static bool classof(const JSONValue *V) {
 121     return V->GetKind() == JSONValue::Kind::Number;
 122   }
 123
 124 private:
 125   enum class DataType : uint8_t { Unsigned, Signed, Double } m_data_type;
 126
 127   union {
 128     uint64_t m_unsigned;
 129     int64_t m_signed;
 130     double m_double;
 131   } m_data;
 132 };
 133
 134 class JSONTrue : public JSONValue {
 135 public:
 136   JSONTrue();
 137
 138   JSONTrue(const JSONTrue &s) = delete;
 139   JSONTrue &operator=(const JSONTrue &s) = delete;
 140
 141   void Write(std::ostream &s) override;
 142
 143   typedef std::shared_ptr<JSONTrue> SP;
 144
 145   static bool classof(const JSONValue *V) {
 146     return V->GetKind() == JSONValue::Kind::True;
 147   }
 148
 149   ~JSONTrue() override = default;
 150 };
 151
 152 class JSONFalse : public JSONValue {
 153 public:
 154   JSONFalse();
 155
 156   JSONFalse(const JSONFalse &s) = delete;
 157   JSONFalse &operator=(const JSONFalse &s) = delete;
 158
 159   void Write(std::ostream &s) override;
 160
 161   typedef std::shared_ptr<JSONFalse> SP;
 162
 163   static bool classof(const JSONValue *V) {
 164     return V->GetKind() == JSONValue::Kind::False;
 165   }
 166
 167   ~JSONFalse() override = default;
 168 };
 169
 170 class JSONNull : public JSONValue {
 171 public:
 172   JSONNull();
 173
 174   JSONNull(const JSONNull &s) = delete;
 175   JSONNull &operator=(const JSONNull &s) = delete;
 176
 177   void Write(std::ostream &s) override;
 178
 179   typedef std::shared_ptr<JSONNull> SP;
 180
 181   static bool classof(const JSONValue *V) {
 182     return V->GetKind() == JSONValue::Kind::Null;
 183   }
 184
 185   ~JSONNull() override = default;
 186 };
 187
 188 class JSONObject : public JSONValue {
 189 public:
 190   JSONObject();
 191
 192   JSONObject(const JSONObject &s) = delete;
 193   JSONObject &operator=(const JSONObject &s) = delete;
 194
 195   void Write(std::ostream &s) override;
 196
 197   typedef std::shared_ptr<JSONObject> SP;
 198
 199   static bool classof(const JSONValue *V) {
 200     return V->GetKind() == JSONValue::Kind::Object;
 201   }
 202
 203   bool SetObject(const std::string &key, JSONValue::SP value);
 204
 205   JSONValue::SP GetObject(const std::string &key) const;
 206
 207   // -------------------------------------------------------------------------
 208   /// Return keyed value as bool
 209   ///
 210   /// @param[in] key
 211   ///     The value of the key to lookup
 212   ///
 213   /// @param[out] value
 214   ///     The value of the key as a bool.  Undefined if the key doesn't
 215   ///     exist or if the key is not either true or false.
 216   ///
 217   /// @return
 218   ///     true if the key existed as was a bool value; false otherwise.
 219   ///     Note the return value is *not* the value of the bool, use
 220   ///     \b value for that.
 221   // -------------------------------------------------------------------------
 222   bool GetObjectAsBool(const std::string &key, bool &value) const;
 223
 224   bool GetObjectAsString(const std::string &key, std::string &value) const;
 225
 226   ~JSONObject() override = default;
 227
 228 private:
 229   typedef std::map<std::string, JSONValue::SP> Map;
 230   typedef Map::iterator Iterator;
 231   Map m_elements;
 232 };
 233
 234 class JSONArray : public JSONValue {
 235 public:
 236   JSONArray();
 237
 238   JSONArray(const JSONArray &s) = delete;
 239   JSONArray &operator=(const JSONArray &s) = delete;
 240
 241   void Write(std::ostream &s) override;
 242
 243   typedef std::shared_ptr<JSONArray> SP;
 244
 245   static bool classof(const JSONValue *V) {
 246     return V->GetKind() == JSONValue::Kind::Array;
 247   }
 248
 249 private:
 250   typedef std::vector<JSONValue::SP> Vector;
 251   typedef Vector::iterator Iterator;
 252   typedef Vector::size_type Index;
 253   typedef Vector::size_type Size;
 254
 255 public:
 256   bool SetObject(Index i, JSONValue::SP value);
 257
 258   bool AppendObject(JSONValue::SP value);
 259
 260   JSONValue::SP GetObject(Index i);
 261
 262   Size GetNumElements();
 263
 264   ~JSONArray() override = default;
 265
 266   Vector m_elements;
 267 };
 268
 269 class JSONParser : public StdStringExtractor {
 270 public:
 271   enum Token {
 272     Invalid,
 273     Error,
 274     ObjectStart,
 275     ObjectEnd,
 276     ArrayStart,
 277     ArrayEnd,
 278     Comma,
 279     Colon,
 280     String,
 281     Integer,
 282     Float,
 283     True,
 284     False,
 285     Null,
 286     EndOfFile
 287   };
 288
 289   JSONParser(const char *cstr);
 290
 291   int GetEscapedChar(bool &was_escaped);
 292
 293   Token GetToken(std::string &value);
 294
 295   JSONValue::SP ParseJSONValue();
 296
 297 protected:
 298   JSONValue::SP ParseJSONObject();
 299
 300   JSONValue::SP ParseJSONArray();
 301 };
 302
 303 #endif // utility_JSON_h_