1a6d7ab55d
Summary: We currently allow any completion handler to read and manipulate the list of matches we calculated so far. This leads to a few problems: Firstly, a completion handler's logic can now depend on previously calculated results by another handlers. No completion handler should have such an implicit dependency, but the current API makes it likely that this could happen (or already happens). Especially the fact that some completion handler deleted all previously calculated results can mess things up right now. Secondly, all completion handlers have knowledge about our internal data structures with this API. This makes refactoring this internal data structure much harder than it should be. Especially planned changes like the support of descriptions for completions are currently giant patches because we have to refactor every single completion handler. This patch narrows the contract the CompletionRequest has with the different handlers to: 1. A handler can suggest a completion. 2. A handler can ask how many suggestions we already have. Point 2 obviously means we still have a dependency left between the different handlers, but getting rid of this is too large to just append it to this patch. Otherwise this patch just completely hides the internal StringList to the different handlers. The CompletionRequest API now also ensures that the list of completions is unique and we don't suggest the same value multiple times to the user. This property has been so far only been ensured by the `Option` handler, but is now applied globally. This is part of this patch as the OptionHandler is no longer able to implement this functionality itself. Reviewers: jingham, davide, labath Reviewed By: davide Subscribers: lldb-commits Differential Revision: https://reviews.llvm.org/D49322 llvm-svn: 338151
623 lines
18 KiB
C++
623 lines
18 KiB
C++
//===-- OptionValue.cpp -----------------------------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "lldb/Interpreter/OptionValue.h"
|
|
|
|
// C Includes
|
|
// C++ Includes
|
|
// Other libraries and framework includes
|
|
// Project includes
|
|
#include "lldb/Interpreter/OptionValues.h"
|
|
#include "lldb/Utility/StringList.h"
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
//-------------------------------------------------------------------------
|
|
// Get this value as a uint64_t value if it is encoded as a boolean, uint64_t
|
|
// or int64_t. Other types will cause "fail_value" to be returned
|
|
//-------------------------------------------------------------------------
|
|
uint64_t OptionValue::GetUInt64Value(uint64_t fail_value, bool *success_ptr) {
|
|
if (success_ptr)
|
|
*success_ptr = true;
|
|
switch (GetType()) {
|
|
case OptionValue::eTypeBoolean:
|
|
return static_cast<OptionValueBoolean *>(this)->GetCurrentValue();
|
|
case OptionValue::eTypeSInt64:
|
|
return static_cast<OptionValueSInt64 *>(this)->GetCurrentValue();
|
|
case OptionValue::eTypeUInt64:
|
|
return static_cast<OptionValueUInt64 *>(this)->GetCurrentValue();
|
|
default:
|
|
break;
|
|
}
|
|
if (success_ptr)
|
|
*success_ptr = false;
|
|
return fail_value;
|
|
}
|
|
|
|
Status OptionValue::SetSubValue(const ExecutionContext *exe_ctx,
|
|
VarSetOperationType op, llvm::StringRef name,
|
|
llvm::StringRef value) {
|
|
Status error;
|
|
error.SetErrorStringWithFormat("SetSubValue is not supported");
|
|
return error;
|
|
}
|
|
|
|
OptionValueBoolean *OptionValue::GetAsBoolean() {
|
|
if (GetType() == OptionValue::eTypeBoolean)
|
|
return static_cast<OptionValueBoolean *>(this);
|
|
return nullptr;
|
|
}
|
|
|
|
const OptionValueBoolean *OptionValue::GetAsBoolean() const {
|
|
if (GetType() == OptionValue::eTypeBoolean)
|
|
return static_cast<const OptionValueBoolean *>(this);
|
|
return nullptr;
|
|
}
|
|
|
|
const OptionValueChar *OptionValue::GetAsChar() const {
|
|
if (GetType() == OptionValue::eTypeChar)
|
|
return static_cast<const OptionValueChar *>(this);
|
|
return nullptr;
|
|
}
|
|
|
|
OptionValueChar *OptionValue::GetAsChar() {
|
|
if (GetType() == OptionValue::eTypeChar)
|
|
return static_cast<OptionValueChar *>(this);
|
|
return nullptr;
|
|
}
|
|
|
|
OptionValueFileSpec *OptionValue::GetAsFileSpec() {
|
|
if (GetType() == OptionValue::eTypeFileSpec)
|
|
return static_cast<OptionValueFileSpec *>(this);
|
|
return nullptr;
|
|
}
|
|
|
|
const OptionValueFileSpec *OptionValue::GetAsFileSpec() const {
|
|
if (GetType() == OptionValue::eTypeFileSpec)
|
|
return static_cast<const OptionValueFileSpec *>(this);
|
|
return nullptr;
|
|
}
|
|
|
|
OptionValueFileSpecList *OptionValue::GetAsFileSpecList() {
|
|
if (GetType() == OptionValue::eTypeFileSpecList)
|
|
return static_cast<OptionValueFileSpecList *>(this);
|
|
return nullptr;
|
|
}
|
|
|
|
const OptionValueFileSpecList *OptionValue::GetAsFileSpecList() const {
|
|
if (GetType() == OptionValue::eTypeFileSpecList)
|
|
return static_cast<const OptionValueFileSpecList *>(this);
|
|
return nullptr;
|
|
}
|
|
|
|
OptionValueArch *OptionValue::GetAsArch() {
|
|
if (GetType() == OptionValue::eTypeArch)
|
|
return static_cast<OptionValueArch *>(this);
|
|
return nullptr;
|
|
}
|
|
|
|
const OptionValueArch *OptionValue::GetAsArch() const {
|
|
if (GetType() == OptionValue::eTypeArch)
|
|
return static_cast<const OptionValueArch *>(this);
|
|
return nullptr;
|
|
}
|
|
|
|
OptionValueArray *OptionValue::GetAsArray() {
|
|
if (GetType() == OptionValue::eTypeArray)
|
|
return static_cast<OptionValueArray *>(this);
|
|
return nullptr;
|
|
}
|
|
|
|
const OptionValueArray *OptionValue::GetAsArray() const {
|
|
if (GetType() == OptionValue::eTypeArray)
|
|
return static_cast<const OptionValueArray *>(this);
|
|
return nullptr;
|
|
}
|
|
|
|
OptionValueArgs *OptionValue::GetAsArgs() {
|
|
if (GetType() == OptionValue::eTypeArgs)
|
|
return static_cast<OptionValueArgs *>(this);
|
|
return nullptr;
|
|
}
|
|
|
|
const OptionValueArgs *OptionValue::GetAsArgs() const {
|
|
if (GetType() == OptionValue::eTypeArgs)
|
|
return static_cast<const OptionValueArgs *>(this);
|
|
return nullptr;
|
|
}
|
|
|
|
OptionValueDictionary *OptionValue::GetAsDictionary() {
|
|
if (GetType() == OptionValue::eTypeDictionary)
|
|
return static_cast<OptionValueDictionary *>(this);
|
|
return nullptr;
|
|
}
|
|
|
|
const OptionValueDictionary *OptionValue::GetAsDictionary() const {
|
|
if (GetType() == OptionValue::eTypeDictionary)
|
|
return static_cast<const OptionValueDictionary *>(this);
|
|
return nullptr;
|
|
}
|
|
|
|
OptionValueEnumeration *OptionValue::GetAsEnumeration() {
|
|
if (GetType() == OptionValue::eTypeEnum)
|
|
return static_cast<OptionValueEnumeration *>(this);
|
|
return nullptr;
|
|
}
|
|
|
|
const OptionValueEnumeration *OptionValue::GetAsEnumeration() const {
|
|
if (GetType() == OptionValue::eTypeEnum)
|
|
return static_cast<const OptionValueEnumeration *>(this);
|
|
return nullptr;
|
|
}
|
|
|
|
OptionValueFormat *OptionValue::GetAsFormat() {
|
|
if (GetType() == OptionValue::eTypeFormat)
|
|
return static_cast<OptionValueFormat *>(this);
|
|
return nullptr;
|
|
}
|
|
|
|
const OptionValueFormat *OptionValue::GetAsFormat() const {
|
|
if (GetType() == OptionValue::eTypeFormat)
|
|
return static_cast<const OptionValueFormat *>(this);
|
|
return nullptr;
|
|
}
|
|
|
|
OptionValueLanguage *OptionValue::GetAsLanguage() {
|
|
if (GetType() == OptionValue::eTypeLanguage)
|
|
return static_cast<OptionValueLanguage *>(this);
|
|
return NULL;
|
|
}
|
|
|
|
const OptionValueLanguage *OptionValue::GetAsLanguage() const {
|
|
if (GetType() == OptionValue::eTypeLanguage)
|
|
return static_cast<const OptionValueLanguage *>(this);
|
|
return NULL;
|
|
}
|
|
|
|
OptionValueFormatEntity *OptionValue::GetAsFormatEntity() {
|
|
if (GetType() == OptionValue::eTypeFormatEntity)
|
|
return static_cast<OptionValueFormatEntity *>(this);
|
|
return nullptr;
|
|
}
|
|
|
|
const OptionValueFormatEntity *OptionValue::GetAsFormatEntity() const {
|
|
if (GetType() == OptionValue::eTypeFormatEntity)
|
|
return static_cast<const OptionValueFormatEntity *>(this);
|
|
return nullptr;
|
|
}
|
|
|
|
OptionValuePathMappings *OptionValue::GetAsPathMappings() {
|
|
if (GetType() == OptionValue::eTypePathMap)
|
|
return static_cast<OptionValuePathMappings *>(this);
|
|
return nullptr;
|
|
}
|
|
|
|
const OptionValuePathMappings *OptionValue::GetAsPathMappings() const {
|
|
if (GetType() == OptionValue::eTypePathMap)
|
|
return static_cast<const OptionValuePathMappings *>(this);
|
|
return nullptr;
|
|
}
|
|
|
|
OptionValueProperties *OptionValue::GetAsProperties() {
|
|
if (GetType() == OptionValue::eTypeProperties)
|
|
return static_cast<OptionValueProperties *>(this);
|
|
return nullptr;
|
|
}
|
|
|
|
const OptionValueProperties *OptionValue::GetAsProperties() const {
|
|
if (GetType() == OptionValue::eTypeProperties)
|
|
return static_cast<const OptionValueProperties *>(this);
|
|
return nullptr;
|
|
}
|
|
|
|
OptionValueRegex *OptionValue::GetAsRegex() {
|
|
if (GetType() == OptionValue::eTypeRegex)
|
|
return static_cast<OptionValueRegex *>(this);
|
|
return nullptr;
|
|
}
|
|
|
|
const OptionValueRegex *OptionValue::GetAsRegex() const {
|
|
if (GetType() == OptionValue::eTypeRegex)
|
|
return static_cast<const OptionValueRegex *>(this);
|
|
return nullptr;
|
|
}
|
|
|
|
OptionValueSInt64 *OptionValue::GetAsSInt64() {
|
|
if (GetType() == OptionValue::eTypeSInt64)
|
|
return static_cast<OptionValueSInt64 *>(this);
|
|
return nullptr;
|
|
}
|
|
|
|
const OptionValueSInt64 *OptionValue::GetAsSInt64() const {
|
|
if (GetType() == OptionValue::eTypeSInt64)
|
|
return static_cast<const OptionValueSInt64 *>(this);
|
|
return nullptr;
|
|
}
|
|
|
|
OptionValueString *OptionValue::GetAsString() {
|
|
if (GetType() == OptionValue::eTypeString)
|
|
return static_cast<OptionValueString *>(this);
|
|
return nullptr;
|
|
}
|
|
|
|
const OptionValueString *OptionValue::GetAsString() const {
|
|
if (GetType() == OptionValue::eTypeString)
|
|
return static_cast<const OptionValueString *>(this);
|
|
return nullptr;
|
|
}
|
|
|
|
OptionValueUInt64 *OptionValue::GetAsUInt64() {
|
|
if (GetType() == OptionValue::eTypeUInt64)
|
|
return static_cast<OptionValueUInt64 *>(this);
|
|
return nullptr;
|
|
}
|
|
|
|
const OptionValueUInt64 *OptionValue::GetAsUInt64() const {
|
|
if (GetType() == OptionValue::eTypeUInt64)
|
|
return static_cast<const OptionValueUInt64 *>(this);
|
|
return nullptr;
|
|
}
|
|
|
|
OptionValueUUID *OptionValue::GetAsUUID() {
|
|
if (GetType() == OptionValue::eTypeUUID)
|
|
return static_cast<OptionValueUUID *>(this);
|
|
return nullptr;
|
|
}
|
|
|
|
const OptionValueUUID *OptionValue::GetAsUUID() const {
|
|
if (GetType() == OptionValue::eTypeUUID)
|
|
return static_cast<const OptionValueUUID *>(this);
|
|
return nullptr;
|
|
}
|
|
|
|
bool OptionValue::GetBooleanValue(bool fail_value) const {
|
|
const OptionValueBoolean *option_value = GetAsBoolean();
|
|
if (option_value)
|
|
return option_value->GetCurrentValue();
|
|
return fail_value;
|
|
}
|
|
|
|
bool OptionValue::SetBooleanValue(bool new_value) {
|
|
OptionValueBoolean *option_value = GetAsBoolean();
|
|
if (option_value) {
|
|
option_value->SetCurrentValue(new_value);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
char OptionValue::GetCharValue(char fail_value) const {
|
|
const OptionValueChar *option_value = GetAsChar();
|
|
if (option_value)
|
|
return option_value->GetCurrentValue();
|
|
return fail_value;
|
|
}
|
|
|
|
char OptionValue::SetCharValue(char new_value) {
|
|
OptionValueChar *option_value = GetAsChar();
|
|
if (option_value) {
|
|
option_value->SetCurrentValue(new_value);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
int64_t OptionValue::GetEnumerationValue(int64_t fail_value) const {
|
|
const OptionValueEnumeration *option_value = GetAsEnumeration();
|
|
if (option_value)
|
|
return option_value->GetCurrentValue();
|
|
return fail_value;
|
|
}
|
|
|
|
bool OptionValue::SetEnumerationValue(int64_t value) {
|
|
OptionValueEnumeration *option_value = GetAsEnumeration();
|
|
if (option_value) {
|
|
option_value->SetCurrentValue(value);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
FileSpec OptionValue::GetFileSpecValue() const {
|
|
const OptionValueFileSpec *option_value = GetAsFileSpec();
|
|
if (option_value)
|
|
return option_value->GetCurrentValue();
|
|
return FileSpec();
|
|
}
|
|
|
|
bool OptionValue::SetFileSpecValue(const FileSpec &file_spec) {
|
|
OptionValueFileSpec *option_value = GetAsFileSpec();
|
|
if (option_value) {
|
|
option_value->SetCurrentValue(file_spec, false);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
FileSpecList OptionValue::GetFileSpecListValue() const {
|
|
const OptionValueFileSpecList *option_value = GetAsFileSpecList();
|
|
if (option_value)
|
|
return option_value->GetCurrentValue();
|
|
return FileSpecList();
|
|
}
|
|
|
|
lldb::Format OptionValue::GetFormatValue(lldb::Format fail_value) const {
|
|
const OptionValueFormat *option_value = GetAsFormat();
|
|
if (option_value)
|
|
return option_value->GetCurrentValue();
|
|
return fail_value;
|
|
}
|
|
|
|
bool OptionValue::SetFormatValue(lldb::Format new_value) {
|
|
OptionValueFormat *option_value = GetAsFormat();
|
|
if (option_value) {
|
|
option_value->SetCurrentValue(new_value);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
lldb::LanguageType
|
|
OptionValue::GetLanguageValue(lldb::LanguageType fail_value) const {
|
|
const OptionValueLanguage *option_value = GetAsLanguage();
|
|
if (option_value)
|
|
return option_value->GetCurrentValue();
|
|
return fail_value;
|
|
}
|
|
|
|
bool OptionValue::SetLanguageValue(lldb::LanguageType new_language) {
|
|
OptionValueLanguage *option_value = GetAsLanguage();
|
|
if (option_value) {
|
|
option_value->SetCurrentValue(new_language);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
const FormatEntity::Entry *OptionValue::GetFormatEntity() const {
|
|
const OptionValueFormatEntity *option_value = GetAsFormatEntity();
|
|
if (option_value)
|
|
return &option_value->GetCurrentValue();
|
|
return nullptr;
|
|
}
|
|
|
|
const RegularExpression *OptionValue::GetRegexValue() const {
|
|
const OptionValueRegex *option_value = GetAsRegex();
|
|
if (option_value)
|
|
return option_value->GetCurrentValue();
|
|
return nullptr;
|
|
}
|
|
|
|
int64_t OptionValue::GetSInt64Value(int64_t fail_value) const {
|
|
const OptionValueSInt64 *option_value = GetAsSInt64();
|
|
if (option_value)
|
|
return option_value->GetCurrentValue();
|
|
return fail_value;
|
|
}
|
|
|
|
bool OptionValue::SetSInt64Value(int64_t new_value) {
|
|
OptionValueSInt64 *option_value = GetAsSInt64();
|
|
if (option_value) {
|
|
option_value->SetCurrentValue(new_value);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
llvm::StringRef OptionValue::GetStringValue(llvm::StringRef fail_value) const {
|
|
const OptionValueString *option_value = GetAsString();
|
|
if (option_value)
|
|
return option_value->GetCurrentValueAsRef();
|
|
return fail_value;
|
|
}
|
|
|
|
bool OptionValue::SetStringValue(llvm::StringRef new_value) {
|
|
OptionValueString *option_value = GetAsString();
|
|
if (option_value) {
|
|
option_value->SetCurrentValue(new_value);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
uint64_t OptionValue::GetUInt64Value(uint64_t fail_value) const {
|
|
const OptionValueUInt64 *option_value = GetAsUInt64();
|
|
if (option_value)
|
|
return option_value->GetCurrentValue();
|
|
return fail_value;
|
|
}
|
|
|
|
bool OptionValue::SetUInt64Value(uint64_t new_value) {
|
|
OptionValueUInt64 *option_value = GetAsUInt64();
|
|
if (option_value) {
|
|
option_value->SetCurrentValue(new_value);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
UUID OptionValue::GetUUIDValue() const {
|
|
const OptionValueUUID *option_value = GetAsUUID();
|
|
if (option_value)
|
|
return option_value->GetCurrentValue();
|
|
return UUID();
|
|
}
|
|
|
|
bool OptionValue::SetUUIDValue(const UUID &uuid) {
|
|
OptionValueUUID *option_value = GetAsUUID();
|
|
if (option_value) {
|
|
option_value->SetCurrentValue(uuid);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
const char *OptionValue::GetBuiltinTypeAsCString(Type t) {
|
|
switch (t) {
|
|
case eTypeInvalid:
|
|
return "invalid";
|
|
case eTypeArch:
|
|
return "arch";
|
|
case eTypeArgs:
|
|
return "arguments";
|
|
case eTypeArray:
|
|
return "array";
|
|
case eTypeBoolean:
|
|
return "boolean";
|
|
case eTypeChar:
|
|
return "char";
|
|
case eTypeDictionary:
|
|
return "dictionary";
|
|
case eTypeEnum:
|
|
return "enum";
|
|
case eTypeFileSpec:
|
|
return "file";
|
|
case eTypeFileSpecList:
|
|
return "file-list";
|
|
case eTypeFormat:
|
|
return "format";
|
|
case eTypeFormatEntity:
|
|
return "format-string";
|
|
case eTypeLanguage:
|
|
return "language";
|
|
case eTypePathMap:
|
|
return "path-map";
|
|
case eTypeProperties:
|
|
return "properties";
|
|
case eTypeRegex:
|
|
return "regex";
|
|
case eTypeSInt64:
|
|
return "int";
|
|
case eTypeString:
|
|
return "string";
|
|
case eTypeUInt64:
|
|
return "unsigned";
|
|
case eTypeUUID:
|
|
return "uuid";
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
lldb::OptionValueSP OptionValue::CreateValueFromCStringForTypeMask(
|
|
const char *value_cstr, uint32_t type_mask, Status &error) {
|
|
// If only 1 bit is set in the type mask for a dictionary or array then we
|
|
// know how to decode a value from a cstring
|
|
lldb::OptionValueSP value_sp;
|
|
switch (type_mask) {
|
|
case 1u << eTypeArch:
|
|
value_sp.reset(new OptionValueArch());
|
|
break;
|
|
case 1u << eTypeBoolean:
|
|
value_sp.reset(new OptionValueBoolean(false));
|
|
break;
|
|
case 1u << eTypeChar:
|
|
value_sp.reset(new OptionValueChar('\0'));
|
|
break;
|
|
case 1u << eTypeFileSpec:
|
|
value_sp.reset(new OptionValueFileSpec());
|
|
break;
|
|
case 1u << eTypeFormat:
|
|
value_sp.reset(new OptionValueFormat(eFormatInvalid));
|
|
break;
|
|
case 1u << eTypeFormatEntity:
|
|
value_sp.reset(new OptionValueFormatEntity(NULL));
|
|
break;
|
|
case 1u << eTypeLanguage:
|
|
value_sp.reset(new OptionValueLanguage(eLanguageTypeUnknown));
|
|
break;
|
|
case 1u << eTypeSInt64:
|
|
value_sp.reset(new OptionValueSInt64());
|
|
break;
|
|
case 1u << eTypeString:
|
|
value_sp.reset(new OptionValueString());
|
|
break;
|
|
case 1u << eTypeUInt64:
|
|
value_sp.reset(new OptionValueUInt64());
|
|
break;
|
|
case 1u << eTypeUUID:
|
|
value_sp.reset(new OptionValueUUID());
|
|
break;
|
|
}
|
|
|
|
if (value_sp)
|
|
error = value_sp->SetValueFromString(
|
|
llvm::StringRef::withNullAsEmpty(value_cstr), eVarSetOperationAssign);
|
|
else
|
|
error.SetErrorString("unsupported type mask");
|
|
return value_sp;
|
|
}
|
|
|
|
bool OptionValue::DumpQualifiedName(Stream &strm) const {
|
|
bool dumped_something = false;
|
|
lldb::OptionValueSP m_parent_sp(m_parent_wp.lock());
|
|
if (m_parent_sp) {
|
|
if (m_parent_sp->DumpQualifiedName(strm))
|
|
dumped_something = true;
|
|
}
|
|
ConstString name(GetName());
|
|
if (name) {
|
|
if (dumped_something)
|
|
strm.PutChar('.');
|
|
else
|
|
dumped_something = true;
|
|
strm << name;
|
|
}
|
|
return dumped_something;
|
|
}
|
|
|
|
size_t OptionValue::AutoComplete(CommandInterpreter &interpreter,
|
|
CompletionRequest &request) {
|
|
request.SetWordComplete(false);
|
|
return request.GetNumberOfMatches();
|
|
}
|
|
|
|
Status OptionValue::SetValueFromString(llvm::StringRef value,
|
|
VarSetOperationType op) {
|
|
Status error;
|
|
switch (op) {
|
|
case eVarSetOperationReplace:
|
|
error.SetErrorStringWithFormat(
|
|
"%s objects do not support the 'replace' operation",
|
|
GetTypeAsCString());
|
|
break;
|
|
case eVarSetOperationInsertBefore:
|
|
error.SetErrorStringWithFormat(
|
|
"%s objects do not support the 'insert-before' operation",
|
|
GetTypeAsCString());
|
|
break;
|
|
case eVarSetOperationInsertAfter:
|
|
error.SetErrorStringWithFormat(
|
|
"%s objects do not support the 'insert-after' operation",
|
|
GetTypeAsCString());
|
|
break;
|
|
case eVarSetOperationRemove:
|
|
error.SetErrorStringWithFormat(
|
|
"%s objects do not support the 'remove' operation", GetTypeAsCString());
|
|
break;
|
|
case eVarSetOperationAppend:
|
|
error.SetErrorStringWithFormat(
|
|
"%s objects do not support the 'append' operation", GetTypeAsCString());
|
|
break;
|
|
case eVarSetOperationClear:
|
|
error.SetErrorStringWithFormat(
|
|
"%s objects do not support the 'clear' operation", GetTypeAsCString());
|
|
break;
|
|
case eVarSetOperationAssign:
|
|
error.SetErrorStringWithFormat(
|
|
"%s objects do not support the 'assign' operation", GetTypeAsCString());
|
|
break;
|
|
case eVarSetOperationInvalid:
|
|
error.SetErrorStringWithFormat("invalid operation performed on a %s object",
|
|
GetTypeAsCString());
|
|
break;
|
|
}
|
|
return error;
|
|
}
|