contrib/llvm/tools/lldb/source/Utility/StructuredData.cpp

   1 //===---------------------StructuredData.cpp ---------------------*- 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 #include "lldb/Utility/StructuredData.h"
  11 #include "lldb/Utility/DataBuffer.h"
  12 #include "lldb/Utility/FileSpec.h"
  13 #include "lldb/Utility/JSON.h"
  14 #include "lldb/Utility/Status.h"
  15 #include "lldb/Utility/Stream.h" // for Stream
  16 #include "lldb/Utility/StreamString.h"
  17 #include "llvm/ADT/STLExtras.h" // for make_unique
  18 #include "llvm/Support/MemoryBuffer.h"
  19 #include <cerrno>
  20 #include <cstdlib>
  21 #include <inttypes.h>
  22 #include <limits> // for numeric_limits
  23
  24 using namespace lldb_private;
  25
  26 //----------------------------------------------------------------------
  27 // Functions that use a JSONParser to parse JSON into StructuredData
  28 //----------------------------------------------------------------------
  29 static StructuredData::ObjectSP ParseJSONValue(JSONParser &json_parser);
  30 static StructuredData::ObjectSP ParseJSONObject(JSONParser &json_parser);
  31 static StructuredData::ObjectSP ParseJSONArray(JSONParser &json_parser);
  32
  33 StructuredData::ObjectSP
  34 StructuredData::ParseJSONFromFile(const FileSpec &input_spec, Status &error) {
  35   StructuredData::ObjectSP return_sp;
  36   if (!input_spec.Exists()) {
  37     error.SetErrorStringWithFormatv("input file {0} does not exist.",
  38                                     input_spec);
  39     return return_sp;
  40   }
  41
  42   auto buffer_or_error = llvm::MemoryBuffer::getFile(input_spec.GetPath());
  43   if (!buffer_or_error) {
  44     error.SetErrorStringWithFormatv("could not open input file: {0} - {1}.",
  45                                     input_spec.GetPath(),
  46                                     buffer_or_error.getError().message());
  47     return return_sp;
  48   }
  49
  50   JSONParser json_parser(buffer_or_error.get()->getBuffer());
  51   return_sp = ParseJSONValue(json_parser);
  52   return return_sp;
  53 }
  54
  55 static StructuredData::ObjectSP ParseJSONObject(JSONParser &json_parser) {
  56   // The "JSONParser::Token::ObjectStart" token should have already been
  57   // consumed by the time this function is called
  58   auto dict_up = llvm::make_unique<StructuredData::Dictionary>();
  59
  60   std::string value;
  61   std::string key;
  62   while (1) {
  63     JSONParser::Token token = json_parser.GetToken(value);
  64
  65     if (token == JSONParser::Token::String) {
  66       key.swap(value);
  67       token = json_parser.GetToken(value);
  68       if (token == JSONParser::Token::Colon) {
  69         StructuredData::ObjectSP value_sp = ParseJSONValue(json_parser);
  70         if (value_sp)
  71           dict_up->AddItem(key, value_sp);
  72         else
  73           break;
  74       }
  75     } else if (token == JSONParser::Token::ObjectEnd) {
  76       return StructuredData::ObjectSP(dict_up.release());
  77     } else if (token == JSONParser::Token::Comma) {
  78       continue;
  79     } else {
  80       break;
  81     }
  82   }
  83   return StructuredData::ObjectSP();
  84 }
  85
  86 static StructuredData::ObjectSP ParseJSONArray(JSONParser &json_parser) {
  87   // The "JSONParser::Token::ObjectStart" token should have already been
  88   // consumed
  89   // by the time this function is called
  90   auto array_up = llvm::make_unique<StructuredData::Array>();
  91
  92   std::string value;
  93   std::string key;
  94   while (1) {
  95     StructuredData::ObjectSP value_sp = ParseJSONValue(json_parser);
  96     if (value_sp)
  97       array_up->AddItem(value_sp);
  98     else
  99       break;
 100
 101     JSONParser::Token token = json_parser.GetToken(value);
 102     if (token == JSONParser::Token::Comma) {
 103       continue;
 104     } else if (token == JSONParser::Token::ArrayEnd) {
 105       return StructuredData::ObjectSP(array_up.release());
 106     } else {
 107       break;
 108     }
 109   }
 110   return StructuredData::ObjectSP();
 111 }
 112
 113 static StructuredData::ObjectSP ParseJSONValue(JSONParser &json_parser) {
 114   std::string value;
 115   const JSONParser::Token token = json_parser.GetToken(value);
 116   switch (token) {
 117   case JSONParser::Token::ObjectStart:
 118     return ParseJSONObject(json_parser);
 119
 120   case JSONParser::Token::ArrayStart:
 121     return ParseJSONArray(json_parser);
 122
 123   case JSONParser::Token::Integer: {
 124     uint64_t uval;
 125     if (llvm::to_integer(value, uval, 0))
 126       return std::make_shared<StructuredData::Integer>(uval);
 127   } break;
 128
 129   case JSONParser::Token::Float: {
 130     double val;
 131     if (llvm::to_float(value, val))
 132       return std::make_shared<StructuredData::Float>(val);
 133   } break;
 134
 135   case JSONParser::Token::String:
 136     return std::make_shared<StructuredData::String>(value);
 137
 138   case JSONParser::Token::True:
 139   case JSONParser::Token::False:
 140     return std::make_shared<StructuredData::Boolean>(token ==
 141                                                      JSONParser::Token::True);
 142
 143   case JSONParser::Token::Null:
 144     return std::make_shared<StructuredData::Null>();
 145
 146   default:
 147     break;
 148   }
 149   return StructuredData::ObjectSP();
 150 }
 151
 152 StructuredData::ObjectSP StructuredData::ParseJSON(std::string json_text) {
 153   JSONParser json_parser(json_text.c_str());
 154   StructuredData::ObjectSP object_sp = ParseJSONValue(json_parser);
 155   return object_sp;
 156 }
 157
 158 StructuredData::ObjectSP
 159 StructuredData::Object::GetObjectForDotSeparatedPath(llvm::StringRef path) {
 160   if (this->GetType() == lldb::eStructuredDataTypeDictionary) {
 161     std::pair<llvm::StringRef, llvm::StringRef> match = path.split('.');
 162     std::string key = match.first.str();
 163     ObjectSP value = this->GetAsDictionary()->GetValueForKey(key);
 164     if (value.get()) {
 165       // Do we have additional words to descend?  If not, return the
 166       // value we're at right now.
 167       if (match.second.empty()) {
 168         return value;
 169       } else {
 170         return value->GetObjectForDotSeparatedPath(match.second);
 171       }
 172     }
 173     return ObjectSP();
 174   }
 175
 176   if (this->GetType() == lldb::eStructuredDataTypeArray) {
 177     std::pair<llvm::StringRef, llvm::StringRef> match = path.split('[');
 178     if (match.second.size() == 0) {
 179       return this->shared_from_this();
 180     }
 181     errno = 0;
 182     uint64_t val = strtoul(match.second.str().c_str(), NULL, 10);
 183     if (errno == 0) {
 184       return this->GetAsArray()->GetItemAtIndex(val);
 185     }
 186     return ObjectSP();
 187   }
 188
 189   return this->shared_from_this();
 190 }
 191
 192 void StructuredData::Object::DumpToStdout(bool pretty_print) const {
 193   StreamString stream;
 194   Dump(stream, pretty_print);
 195   llvm::outs() << stream.GetString();
 196 }
 197
 198 void StructuredData::Array::Dump(Stream &s, bool pretty_print) const {
 199   bool first = true;
 200   s << "[";
 201   if (pretty_print) {
 202     s << "\n";
 203     s.IndentMore();
 204   }
 205   for (const auto &item_sp : m_items) {
 206     if (first) {
 207       first = false;
 208     } else {
 209       s << ",";
 210       if (pretty_print)
 211         s << "\n";
 212     }
 213
 214     if (pretty_print)
 215       s.Indent();
 216     item_sp->Dump(s, pretty_print);
 217   }
 218   if (pretty_print) {
 219     s.IndentLess();
 220     s.EOL();
 221     s.Indent();
 222   }
 223   s << "]";
 224 }
 225
 226 void StructuredData::Integer::Dump(Stream &s, bool pretty_print) const {
 227   s.Printf("%" PRIu64, m_value);
 228 }
 229
 230 void StructuredData::Float::Dump(Stream &s, bool pretty_print) const {
 231   s.Printf("%lg", m_value);
 232 }
 233
 234 void StructuredData::Boolean::Dump(Stream &s, bool pretty_print) const {
 235   if (m_value == true)
 236     s.PutCString("true");
 237   else
 238     s.PutCString("false");
 239 }
 240
 241 void StructuredData::String::Dump(Stream &s, bool pretty_print) const {
 242   std::string quoted;
 243   const size_t strsize = m_value.size();
 244   for (size_t i = 0; i < strsize; ++i) {
 245     char ch = m_value[i];
 246     if (ch == '"' || ch == '\\')
 247       quoted.push_back('\\');
 248     quoted.push_back(ch);
 249   }
 250   s.Printf("\"%s\"", quoted.c_str());
 251 }
 252
 253 void StructuredData::Dictionary::Dump(Stream &s, bool pretty_print) const {
 254   bool first = true;
 255   s << "{";
 256   if (pretty_print) {
 257     s << "\n";
 258     s.IndentMore();
 259   }
 260   for (const auto &pair : m_dict) {
 261     if (first)
 262       first = false;
 263     else {
 264       s << ",";
 265       if (pretty_print)
 266         s << "\n";
 267     }
 268     if (pretty_print)
 269       s.Indent();
 270     s << "\"" << pair.first.AsCString() << "\" : ";
 271     pair.second->Dump(s, pretty_print);
 272   }
 273   if (pretty_print) {
 274     s.IndentLess();
 275     s.EOL();
 276     s.Indent();
 277   }
 278   s << "}";
 279 }
 280
 281 void StructuredData::Null::Dump(Stream &s, bool pretty_print) const {
 282   s << "null";
 283 }
 284
 285 void StructuredData::Generic::Dump(Stream &s, bool pretty_print) const {
 286   s << "0x" << m_object;
 287 }