forked from OSchip/llvm-project
325 lines
10 KiB
C++
325 lines
10 KiB
C++
//===-- OptionValueDictionary.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/Interpreter/OptionValueDictionary.h"
|
|
|
|
#include "llvm/ADT/StringRef.h"
|
|
#include "lldb/DataFormatters/FormatManager.h"
|
|
#include "lldb/Interpreter/OptionValueString.h"
|
|
#include "lldb/Utility/Args.h"
|
|
#include "lldb/Utility/State.h"
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
void OptionValueDictionary::DumpValue(const ExecutionContext *exe_ctx,
|
|
Stream &strm, uint32_t dump_mask) {
|
|
const Type dict_type = ConvertTypeMaskToType(m_type_mask);
|
|
if (dump_mask & eDumpOptionType) {
|
|
if (m_type_mask != eTypeInvalid)
|
|
strm.Printf("(%s of %ss)", GetTypeAsCString(),
|
|
GetBuiltinTypeAsCString(dict_type));
|
|
else
|
|
strm.Printf("(%s)", GetTypeAsCString());
|
|
}
|
|
if (dump_mask & eDumpOptionValue) {
|
|
const bool one_line = dump_mask & eDumpOptionCommand;
|
|
if (dump_mask & eDumpOptionType)
|
|
strm.PutCString(" =");
|
|
|
|
collection::iterator pos, end = m_values.end();
|
|
|
|
if (!one_line)
|
|
strm.IndentMore();
|
|
|
|
for (pos = m_values.begin(); pos != end; ++pos) {
|
|
OptionValue *option_value = pos->second.get();
|
|
|
|
if (one_line)
|
|
strm << ' ';
|
|
else
|
|
strm.EOL();
|
|
|
|
strm.Indent(pos->first.GetStringRef());
|
|
|
|
const uint32_t extra_dump_options = m_raw_value_dump ? eDumpOptionRaw : 0;
|
|
switch (dict_type) {
|
|
default:
|
|
case eTypeArray:
|
|
case eTypeDictionary:
|
|
case eTypeProperties:
|
|
case eTypeFileSpecList:
|
|
case eTypePathMap:
|
|
strm.PutChar(' ');
|
|
option_value->DumpValue(exe_ctx, strm, dump_mask | extra_dump_options);
|
|
break;
|
|
|
|
case eTypeBoolean:
|
|
case eTypeChar:
|
|
case eTypeEnum:
|
|
case eTypeFileSpec:
|
|
case eTypeFormat:
|
|
case eTypeSInt64:
|
|
case eTypeString:
|
|
case eTypeUInt64:
|
|
case eTypeUUID:
|
|
// No need to show the type for dictionaries of simple items
|
|
strm.PutCString("=");
|
|
option_value->DumpValue(exe_ctx, strm,
|
|
(dump_mask & (~eDumpOptionType)) |
|
|
extra_dump_options);
|
|
break;
|
|
}
|
|
}
|
|
if (!one_line)
|
|
strm.IndentLess();
|
|
}
|
|
}
|
|
|
|
size_t OptionValueDictionary::GetArgs(Args &args) const {
|
|
args.Clear();
|
|
collection::const_iterator pos, end = m_values.end();
|
|
for (pos = m_values.begin(); pos != end; ++pos) {
|
|
StreamString strm;
|
|
strm.Printf("%s=", pos->first.GetCString());
|
|
pos->second->DumpValue(nullptr, strm, eDumpOptionValue | eDumpOptionRaw);
|
|
args.AppendArgument(strm.GetString());
|
|
}
|
|
return args.GetArgumentCount();
|
|
}
|
|
|
|
Status OptionValueDictionary::SetArgs(const Args &args,
|
|
VarSetOperationType op) {
|
|
Status error;
|
|
const size_t argc = args.GetArgumentCount();
|
|
switch (op) {
|
|
case eVarSetOperationClear:
|
|
Clear();
|
|
break;
|
|
|
|
case eVarSetOperationAppend:
|
|
case eVarSetOperationReplace:
|
|
case eVarSetOperationAssign:
|
|
if (argc == 0) {
|
|
error.SetErrorString(
|
|
"assign operation takes one or more key=value arguments");
|
|
return error;
|
|
}
|
|
for (const auto &entry : args) {
|
|
if (entry.ref().empty()) {
|
|
error.SetErrorString("empty argument");
|
|
return error;
|
|
}
|
|
if (!entry.ref().contains('=')) {
|
|
error.SetErrorString(
|
|
"assign operation takes one or more key=value arguments");
|
|
return error;
|
|
}
|
|
|
|
llvm::StringRef key, value;
|
|
std::tie(key, value) = entry.ref().split('=');
|
|
bool key_valid = false;
|
|
if (key.empty()) {
|
|
error.SetErrorString("empty dictionary key");
|
|
return error;
|
|
}
|
|
|
|
if (key.front() == '[') {
|
|
// Key name starts with '[', so the key value must be in single or
|
|
// double quotes like: ['<key>'] ["<key>"]
|
|
if ((key.size() > 2) && (key.back() == ']')) {
|
|
// Strip leading '[' and trailing ']'
|
|
key = key.substr(1, key.size() - 2);
|
|
const char quote_char = key.front();
|
|
if ((quote_char == '\'') || (quote_char == '"')) {
|
|
if ((key.size() > 2) && (key.back() == quote_char)) {
|
|
// Strip the quotes
|
|
key = key.substr(1, key.size() - 2);
|
|
key_valid = true;
|
|
}
|
|
} else {
|
|
// square brackets, no quotes
|
|
key_valid = true;
|
|
}
|
|
}
|
|
} else {
|
|
// No square brackets or quotes
|
|
key_valid = true;
|
|
}
|
|
if (!key_valid) {
|
|
error.SetErrorStringWithFormat(
|
|
"invalid key \"%s\", the key must be a bare string or "
|
|
"surrounded by brackets with optional quotes: [<key>] or "
|
|
"['<key>'] or [\"<key>\"]",
|
|
key.str().c_str());
|
|
return error;
|
|
}
|
|
|
|
lldb::OptionValueSP value_sp(CreateValueFromCStringForTypeMask(
|
|
value.str().c_str(), m_type_mask, error));
|
|
if (value_sp) {
|
|
if (error.Fail())
|
|
return error;
|
|
m_value_was_set = true;
|
|
SetValueForKey(ConstString(key), value_sp, true);
|
|
} else {
|
|
error.SetErrorString("dictionaries that can contain multiple types "
|
|
"must subclass OptionValueArray");
|
|
}
|
|
}
|
|
break;
|
|
|
|
case eVarSetOperationRemove:
|
|
if (argc > 0) {
|
|
for (size_t i = 0; i < argc; ++i) {
|
|
ConstString key(args.GetArgumentAtIndex(i));
|
|
if (!DeleteValueForKey(key)) {
|
|
error.SetErrorStringWithFormat(
|
|
"no value found named '%s', aborting remove operation",
|
|
key.GetCString());
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
error.SetErrorString("remove operation takes one or more key arguments");
|
|
}
|
|
break;
|
|
|
|
case eVarSetOperationInsertBefore:
|
|
case eVarSetOperationInsertAfter:
|
|
case eVarSetOperationInvalid:
|
|
error = OptionValue::SetValueFromString(llvm::StringRef(), op);
|
|
break;
|
|
}
|
|
return error;
|
|
}
|
|
|
|
Status OptionValueDictionary::SetValueFromString(llvm::StringRef value,
|
|
VarSetOperationType op) {
|
|
Args args(value.str());
|
|
Status error = SetArgs(args, op);
|
|
if (error.Success())
|
|
NotifyValueChanged();
|
|
return error;
|
|
}
|
|
|
|
lldb::OptionValueSP
|
|
OptionValueDictionary::GetSubValue(const ExecutionContext *exe_ctx,
|
|
llvm::StringRef name, bool will_modify,
|
|
Status &error) const {
|
|
lldb::OptionValueSP value_sp;
|
|
if (name.empty())
|
|
return nullptr;
|
|
|
|
llvm::StringRef left, temp;
|
|
std::tie(left, temp) = name.split('[');
|
|
if (left.size() == name.size()) {
|
|
error.SetErrorStringWithFormat("invalid value path '%s', %s values only "
|
|
"support '[<key>]' subvalues where <key> "
|
|
"a string value optionally delimited by "
|
|
"single or double quotes",
|
|
name.str().c_str(), GetTypeAsCString());
|
|
return nullptr;
|
|
}
|
|
assert(!temp.empty());
|
|
|
|
llvm::StringRef key, quote_char;
|
|
|
|
if (temp[0] == '\"' || temp[0] == '\'') {
|
|
quote_char = temp.take_front();
|
|
temp = temp.drop_front();
|
|
}
|
|
|
|
llvm::StringRef sub_name;
|
|
std::tie(key, sub_name) = temp.split(']');
|
|
|
|
if (!key.consume_back(quote_char) || key.empty()) {
|
|
error.SetErrorStringWithFormat("invalid value path '%s', "
|
|
"key names must be formatted as ['<key>'] where <key> "
|
|
"is a string that doesn't contain quotes and the quote"
|
|
" char is optional", name.str().c_str());
|
|
return nullptr;
|
|
}
|
|
|
|
value_sp = GetValueForKey(ConstString(key));
|
|
if (!value_sp) {
|
|
error.SetErrorStringWithFormat(
|
|
"dictionary does not contain a value for the key name '%s'",
|
|
key.str().c_str());
|
|
return nullptr;
|
|
}
|
|
|
|
if (sub_name.empty())
|
|
return value_sp;
|
|
return value_sp->GetSubValue(exe_ctx, sub_name, will_modify, error);
|
|
}
|
|
|
|
Status OptionValueDictionary::SetSubValue(const ExecutionContext *exe_ctx,
|
|
VarSetOperationType op,
|
|
llvm::StringRef name,
|
|
llvm::StringRef value) {
|
|
Status error;
|
|
const bool will_modify = true;
|
|
lldb::OptionValueSP value_sp(GetSubValue(exe_ctx, name, will_modify, error));
|
|
if (value_sp)
|
|
error = value_sp->SetValueFromString(value, op);
|
|
else {
|
|
if (error.AsCString() == nullptr)
|
|
error.SetErrorStringWithFormat("invalid value path '%s'", name.str().c_str());
|
|
}
|
|
return error;
|
|
}
|
|
|
|
lldb::OptionValueSP
|
|
OptionValueDictionary::GetValueForKey(ConstString key) const {
|
|
lldb::OptionValueSP value_sp;
|
|
collection::const_iterator pos = m_values.find(key);
|
|
if (pos != m_values.end())
|
|
value_sp = pos->second;
|
|
return value_sp;
|
|
}
|
|
|
|
bool OptionValueDictionary::SetValueForKey(ConstString key,
|
|
const lldb::OptionValueSP &value_sp,
|
|
bool can_replace) {
|
|
// Make sure the value_sp object is allowed to contain values of the type
|
|
// passed in...
|
|
if (value_sp && (m_type_mask & value_sp->GetTypeAsMask())) {
|
|
if (!can_replace) {
|
|
collection::const_iterator pos = m_values.find(key);
|
|
if (pos != m_values.end())
|
|
return false;
|
|
}
|
|
m_values[key] = value_sp;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool OptionValueDictionary::DeleteValueForKey(ConstString key) {
|
|
collection::iterator pos = m_values.find(key);
|
|
if (pos != m_values.end()) {
|
|
m_values.erase(pos);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
lldb::OptionValueSP OptionValueDictionary::DeepCopy() const {
|
|
OptionValueDictionary *copied_dict =
|
|
new OptionValueDictionary(m_type_mask, m_raw_value_dump);
|
|
lldb::OptionValueSP copied_value_sp(copied_dict);
|
|
collection::const_iterator pos, end = m_values.end();
|
|
for (pos = m_values.begin(); pos != end; ++pos) {
|
|
StreamString strm;
|
|
strm.Printf("%s=", pos->first.GetCString());
|
|
copied_dict->SetValueForKey(pos->first, pos->second->DeepCopy(), true);
|
|
}
|
|
return copied_value_sp;
|
|
}
|