| //===-- StructuredData.cpp ------------------------------------------------===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "lldb/Utility/StructuredData.h" |
| #include "lldb/Utility/FileSpec.h" |
| #include "lldb/Utility/Status.h" |
| #include "llvm/ADT/StringExtras.h" |
| #include "llvm/Support/MemoryBuffer.h" |
| #include <cerrno> |
| #include <cinttypes> |
| #include <cstdlib> |
| |
| using namespace lldb_private; |
| using namespace llvm; |
| |
| static StructuredData::ObjectSP ParseJSONValue(json::Value &value); |
| static StructuredData::ObjectSP ParseJSONObject(json::Object *object); |
| static StructuredData::ObjectSP ParseJSONArray(json::Array *array); |
| |
| StructuredData::ObjectSP StructuredData::ParseJSON(llvm::StringRef json_text) { |
| llvm::Expected<json::Value> value = json::parse(json_text); |
| if (!value) { |
| llvm::consumeError(value.takeError()); |
| return nullptr; |
| } |
| return ParseJSONValue(*value); |
| } |
| |
| StructuredData::ObjectSP |
| StructuredData::ParseJSONFromFile(const FileSpec &input_spec, Status &error) { |
| StructuredData::ObjectSP 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; |
| } |
| llvm::Expected<json::Value> value = |
| json::parse(buffer_or_error.get()->getBuffer().str()); |
| if (value) |
| return ParseJSONValue(*value); |
| error.SetErrorString(toString(value.takeError())); |
| return StructuredData::ObjectSP(); |
| } |
| |
| bool StructuredData::IsRecordType(const ObjectSP object_sp) { |
| return object_sp->GetType() == lldb::eStructuredDataTypeArray || |
| object_sp->GetType() == lldb::eStructuredDataTypeDictionary; |
| } |
| |
| static StructuredData::ObjectSP ParseJSONValue(json::Value &value) { |
| if (json::Object *O = value.getAsObject()) |
| return ParseJSONObject(O); |
| |
| if (json::Array *A = value.getAsArray()) |
| return ParseJSONArray(A); |
| |
| if (auto s = value.getAsString()) |
| return std::make_shared<StructuredData::String>(*s); |
| |
| if (auto b = value.getAsBoolean()) |
| return std::make_shared<StructuredData::Boolean>(*b); |
| |
| if (auto u = value.getAsUINT64()) |
| return std::make_shared<StructuredData::UnsignedInteger>(*u); |
| |
| if (auto i = value.getAsInteger()) |
| return std::make_shared<StructuredData::SignedInteger>(*i); |
| |
| if (auto d = value.getAsNumber()) |
| return std::make_shared<StructuredData::Float>(*d); |
| |
| if (auto n = value.getAsNull()) |
| return std::make_shared<StructuredData::Null>(); |
| |
| return StructuredData::ObjectSP(); |
| } |
| |
| static StructuredData::ObjectSP ParseJSONObject(json::Object *object) { |
| auto dict_up = std::make_unique<StructuredData::Dictionary>(); |
| for (auto &KV : *object) { |
| StringRef key = KV.first; |
| json::Value value = KV.second; |
| if (StructuredData::ObjectSP value_sp = ParseJSONValue(value)) |
| dict_up->AddItem(key, value_sp); |
| } |
| return std::move(dict_up); |
| } |
| |
| static StructuredData::ObjectSP ParseJSONArray(json::Array *array) { |
| auto array_up = std::make_unique<StructuredData::Array>(); |
| for (json::Value &value : *array) { |
| if (StructuredData::ObjectSP value_sp = ParseJSONValue(value)) |
| array_up->AddItem(value_sp); |
| } |
| return std::move(array_up); |
| } |
| |
| StructuredData::ObjectSP |
| StructuredData::Object::GetObjectForDotSeparatedPath(llvm::StringRef path) { |
| if (GetType() == lldb::eStructuredDataTypeDictionary) { |
| std::pair<llvm::StringRef, llvm::StringRef> match = path.split('.'); |
| llvm::StringRef key = match.first; |
| ObjectSP value = GetAsDictionary()->GetValueForKey(key); |
| if (!value) |
| return {}; |
| |
| // Do we have additional words to descend? If not, return the value |
| // we're at right now. |
| if (match.second.empty()) |
| return value; |
| |
| return value->GetObjectForDotSeparatedPath(match.second); |
| } |
| |
| if (GetType() == lldb::eStructuredDataTypeArray) { |
| std::pair<llvm::StringRef, llvm::StringRef> match = path.split('['); |
| if (match.second.empty()) |
| return shared_from_this(); |
| |
| uint64_t val = 0; |
| if (!llvm::to_integer(match.second, val, /* Base = */ 10)) |
| return {}; |
| |
| return GetAsArray()->GetItemAtIndex(val); |
| } |
| |
| return shared_from_this(); |
| } |
| |
| void StructuredData::Object::DumpToStdout(bool pretty_print) const { |
| json::OStream stream(llvm::outs(), pretty_print ? 2 : 0); |
| Serialize(stream); |
| } |
| |
| void StructuredData::Array::Serialize(json::OStream &s) const { |
| s.arrayBegin(); |
| for (const auto &item_sp : m_items) { |
| item_sp->Serialize(s); |
| } |
| s.arrayEnd(); |
| } |
| |
| void StructuredData::Float::Serialize(json::OStream &s) const { |
| s.value(m_value); |
| } |
| |
| void StructuredData::Boolean::Serialize(json::OStream &s) const { |
| s.value(m_value); |
| } |
| |
| void StructuredData::String::Serialize(json::OStream &s) const { |
| s.value(m_value); |
| } |
| |
| void StructuredData::Dictionary::Serialize(json::OStream &s) const { |
| s.objectBegin(); |
| |
| // To ensure the output format is always stable, we sort the dictionary by key |
| // first. |
| using Entry = std::pair<llvm::StringRef, ObjectSP>; |
| std::vector<Entry> sorted_entries; |
| for (const auto &pair : m_dict) |
| sorted_entries.push_back({pair.first(), pair.second}); |
| |
| llvm::sort(sorted_entries); |
| |
| for (const auto &pair : sorted_entries) { |
| s.attributeBegin(pair.first); |
| pair.second->Serialize(s); |
| s.attributeEnd(); |
| } |
| s.objectEnd(); |
| } |
| |
| void StructuredData::Null::Serialize(json::OStream &s) const { |
| s.value(nullptr); |
| } |
| |
| void StructuredData::Generic::Serialize(json::OStream &s) const { |
| s.value(llvm::formatv("{0:X}", m_object)); |
| } |
| |
| void StructuredData::Float::GetDescription(lldb_private::Stream &s) const { |
| s.Printf("%f", m_value); |
| } |
| |
| void StructuredData::Boolean::GetDescription(lldb_private::Stream &s) const { |
| s.Printf(m_value ? "True" : "False"); |
| } |
| |
| void StructuredData::String::GetDescription(lldb_private::Stream &s) const { |
| s.Printf("%s", m_value.empty() ? "\"\"" : m_value.c_str()); |
| } |
| |
| void StructuredData::Array::GetDescription(lldb_private::Stream &s) const { |
| size_t index = 0; |
| size_t indentation_level = s.GetIndentLevel(); |
| for (const auto &item_sp : m_items) { |
| // Sanitize. |
| if (!item_sp) |
| continue; |
| |
| // Reset original indentation level. |
| s.SetIndentLevel(indentation_level); |
| s.Indent(); |
| |
| // Print key |
| s.Printf("[%zu]:", index++); |
| |
| // Return to new line and increase indentation if value is record type. |
| // Otherwise add spacing. |
| bool should_indent = IsRecordType(item_sp); |
| if (should_indent) { |
| s.EOL(); |
| s.IndentMore(); |
| } else { |
| s.PutChar(' '); |
| } |
| |
| // Print value and new line if now last pair. |
| item_sp->GetDescription(s); |
| if (item_sp != *(--m_items.end())) |
| s.EOL(); |
| |
| // Reset indentation level if it was incremented previously. |
| if (should_indent) |
| s.IndentLess(); |
| } |
| } |
| |
| void StructuredData::Dictionary::GetDescription(lldb_private::Stream &s) const { |
| size_t indentation_level = s.GetIndentLevel(); |
| |
| // To ensure the output format is always stable, we sort the dictionary by key |
| // first. |
| using Entry = std::pair<llvm::StringRef, ObjectSP>; |
| std::vector<Entry> sorted_entries; |
| for (const auto &pair : m_dict) |
| sorted_entries.push_back({pair.first(), pair.second}); |
| |
| llvm::sort(sorted_entries); |
| |
| for (auto iter = sorted_entries.begin(); iter != sorted_entries.end(); |
| iter++) { |
| // Sanitize. |
| if (iter->first.empty() || !iter->second) |
| continue; |
| |
| // Reset original indentation level. |
| s.SetIndentLevel(indentation_level); |
| s.Indent(); |
| |
| // Print key. |
| s.Format("{0}:", iter->first); |
| |
| // Return to new line and increase indentation if value is record type. |
| // Otherwise add spacing. |
| bool should_indent = IsRecordType(iter->second); |
| if (should_indent) { |
| s.EOL(); |
| s.IndentMore(); |
| } else { |
| s.PutChar(' '); |
| } |
| |
| // Print value and new line if now last pair. |
| iter->second->GetDescription(s); |
| if (std::next(iter) != sorted_entries.end()) |
| s.EOL(); |
| |
| // Reset indentation level if it was incremented previously. |
| if (should_indent) |
| s.IndentLess(); |
| } |
| } |
| |
| void StructuredData::Null::GetDescription(lldb_private::Stream &s) const { |
| s.Printf("NULL"); |
| } |
| |
| void StructuredData::Generic::GetDescription(lldb_private::Stream &s) const { |
| s.Printf("%p", m_object); |
| } |