Then deal with all the fallout.
Differential Revision: https://reviews.llvm.org/D24847
llvm-svn: 282265
void AddOrReplaceEnvironmentVariable(const char *, const char *) = delete;
bool ContainsEnvironmentVariable(const char *,
size_t * = nullptr) const = delete;
+ static int64_t StringToOptionEnum(const char *, OptionEnumValueElement *,
+ int32_t, Error &) = delete;
//------------------------------------------------------------------
/// Insert the argument value at index \a idx to \a arg_cstr.
static char StringToChar(llvm::StringRef s, char fail_value,
bool *success_ptr);
- static int64_t StringToOptionEnum(const char *s,
+ static int64_t StringToOptionEnum(llvm::StringRef s,
OptionEnumValueElement *enum_values,
int32_t fail_value, Error &error);
llvm::ArrayRef<OptionDefinition> GetDefinitions() override;
- Error SetOptionValue(uint32_t option_idx, const char *option_value,
+ Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
ExecutionContext *execution_context) override;
+ Error SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
void OptionParsingStarting(ExecutionContext *execution_context) override;
return llvm::ArrayRef<OptionDefinition>(&m_option_definition, 1);
}
- Error SetOptionValue(uint32_t option_idx, const char *option_value,
+ Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
ExecutionContext *execution_context) override;
+ Error SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
void OptionParsingStarting(ExecutionContext *execution_context) override;
return llvm::ArrayRef<OptionDefinition>(&m_option_definition, 1);
}
- Error SetOptionValue(uint32_t option_idx, const char *option_value,
+ Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
ExecutionContext *execution_context) override;
+ Error SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
void OptionParsingStarting(ExecutionContext *execution_context) override;
return llvm::ArrayRef<OptionDefinition>(&m_option_definition, 1);
}
- Error SetOptionValue(uint32_t option_idx, const char *option_value,
+ Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
ExecutionContext *execution_context) override;
+ Error SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
void OptionParsingStarting(ExecutionContext *execution_context) override;
llvm::ArrayRef<OptionDefinition> GetDefinitions() override;
- Error SetOptionValue(uint32_t option_idx, const char *option_value,
+ Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
ExecutionContext *execution_context) override;
+ Error SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
void OptionParsingStarting(ExecutionContext *execution_context) override;
llvm::ArrayRef<OptionDefinition> GetDefinitions() override;
- Error SetOptionValue(uint32_t option_idx, const char *option_value,
+ Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
ExecutionContext *execution_context) override;
+ Error SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
void OptionParsingStarting(ExecutionContext *execution_context) override;
llvm::ArrayRef<OptionDefinition> GetDefinitions() override;
- Error SetOptionValue(uint32_t option_idx, const char *option_value,
+ Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
ExecutionContext *execution_context) override;
+ Error SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
void OptionParsingStarting(ExecutionContext *execution_context) override;
return llvm::ArrayRef<OptionDefinition>(&m_option_definition, 1);
}
- Error SetOptionValue(uint32_t option_idx, const char *option_value,
+ Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
ExecutionContext *execution_context) override;
+ Error SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
void OptionParsingStarting(ExecutionContext *execution_context) override;
return llvm::ArrayRef<OptionDefinition>(&m_option_definition, 1);
}
- Error SetOptionValue(uint32_t option_idx, const char *option_value,
+ Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
ExecutionContext *execution_context) override;
+ Error SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
void OptionParsingStarting(ExecutionContext *execution_context) override;
llvm::ArrayRef<OptionDefinition> GetDefinitions() override;
- Error SetOptionValue(uint32_t option_idx, const char *option_value,
+ Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
ExecutionContext *execution_context) override;
+ Error SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
void OptionParsingStarting(ExecutionContext *execution_context) override;
llvm::ArrayRef<OptionDefinition> GetDefinitions() override;
- Error SetOptionValue(uint32_t option_idx, const char *option_value,
+ Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
ExecutionContext *execution_context) override;
+ Error SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
void OptionParsingStarting(ExecutionContext *execution_context) override;
llvm::ArrayRef<OptionDefinition> GetDefinitions() override;
- Error SetOptionValue(uint32_t option_idx, const char *option_arg,
+ Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
ExecutionContext *execution_context) override;
+ Error SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
void OptionParsingStarting(ExecutionContext *execution_context) override;
llvm::ArrayRef<OptionDefinition> GetDefinitions() override;
- Error SetOptionValue(uint32_t option_idx, const char *option_arg,
+ Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
ExecutionContext *execution_context) override;
+ Error SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
void OptionParsingStarting(ExecutionContext *execution_context) override;
virtual Error
SetValueFromString(llvm::StringRef value,
VarSetOperationType op = eVarSetOperationAssign);
+ Error
+ SetValueFromString(const char *,
+ VarSetOperationType = eVarSetOperationAssign) = delete;
virtual bool Clear() = 0;
Error
SetValueFromString(llvm::StringRef value,
VarSetOperationType op = eVarSetOperationAssign) override;
+ Error
+ SetValueFromString(const char *,
+ VarSetOperationType = eVarSetOperationAssign) = delete;
bool Clear() override {
m_current_value = m_default_value;
Error
SetValueFromString(llvm::StringRef value,
VarSetOperationType op = eVarSetOperationAssign) override;
+ Error
+ SetValueFromString(const char *,
+ VarSetOperationType = eVarSetOperationAssign) = delete;
bool Clear() override {
m_values.clear();
Error
SetValueFromString(llvm::StringRef value,
VarSetOperationType op = eVarSetOperationAssign) override;
+ Error
+ SetValueFromString(const char *,
+ VarSetOperationType = eVarSetOperationAssign) = delete;
bool Clear() override {
m_current_value = m_default_value;
Error
SetValueFromString(llvm::StringRef value,
VarSetOperationType op = eVarSetOperationAssign) override;
+ Error
+ SetValueFromString(const char *,
+ VarSetOperationType = eVarSetOperationAssign) = delete;
bool Clear() override {
m_current_value = m_default_value;
Error
SetValueFromString(llvm::StringRef value,
VarSetOperationType op = eVarSetOperationAssign) override;
+ Error
+ SetValueFromString(const char *,
+ VarSetOperationType = eVarSetOperationAssign) = delete;
bool Clear() override {
m_values.clear();
Error SetSubValue(const ExecutionContext *exe_ctx, VarSetOperationType op,
const char *name, const char *value) override;
- //---------------------------------------------------------------------
- // String value getters and setters
- //---------------------------------------------------------------------
- const char *GetStringValueForKey(const ConstString &key);
-
- bool SetStringValueForKey(const ConstString &key, const char *value,
- bool can_replace = true);
-
bool SetValueForKey(const ConstString &key,
const lldb::OptionValueSP &value_sp,
bool can_replace = true);
Error
SetValueFromString(llvm::StringRef value,
VarSetOperationType op = eVarSetOperationAssign) override;
+ Error
+ SetValueFromString(const char *,
+ VarSetOperationType = eVarSetOperationAssign) = delete;
bool Clear() override {
m_current_value = m_default_value;
Error
SetValueFromString(llvm::StringRef value,
VarSetOperationType op = eVarSetOperationAssign) override;
+ Error
+ SetValueFromString(const char *,
+ VarSetOperationType = eVarSetOperationAssign) = delete;
bool Clear() override {
m_current_value = m_default_value;
Error
SetValueFromString(llvm::StringRef value,
VarSetOperationType op = eVarSetOperationAssign) override;
+ Error
+ SetValueFromString(const char *,
+ VarSetOperationType = eVarSetOperationAssign) = delete;
bool Clear() override {
m_current_value.Clear();
Error
SetValueFromString(llvm::StringRef value,
VarSetOperationType op = eVarSetOperationAssign) override;
+ Error
+ SetValueFromString(const char *,
+ VarSetOperationType = eVarSetOperationAssign) = delete;
bool Clear() override {
m_current_value = m_default_value;
Error
SetValueFromString(llvm::StringRef value,
VarSetOperationType op = eVarSetOperationAssign) override;
+ Error
+ SetValueFromString(const char *,
+ VarSetOperationType = eVarSetOperationAssign) = delete;
bool Clear() override;
Error
SetValueFromString(llvm::StringRef value,
VarSetOperationType op = eVarSetOperationAssign) override;
+ Error
+ SetValueFromString(const char *,
+ VarSetOperationType = eVarSetOperationAssign) = delete;
bool Clear() override {
m_current_value = m_default_value;
Error
SetValueFromString(llvm::StringRef value,
VarSetOperationType op = eVarSetOperationAssign) override;
+ Error
+ SetValueFromString(const char *,
+ VarSetOperationType = eVarSetOperationAssign) = delete;
bool Clear() override {
m_path_mappings.Clear(m_notify_changes);
Error
SetValueFromString(llvm::StringRef value,
VarSetOperationType op = eVarSetOperationAssign) override;
+ Error
+ SetValueFromString(const char *,
+ VarSetOperationType = eVarSetOperationAssign) = delete;
void DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
uint32_t dump_mask) override;
Error
SetValueFromString(llvm::StringRef value,
VarSetOperationType op = eVarSetOperationAssign) override;
+ Error
+ SetValueFromString(const char *,
+ VarSetOperationType = eVarSetOperationAssign) = delete;
bool Clear() override {
m_regex.Clear();
Error
SetValueFromString(llvm::StringRef value,
VarSetOperationType op = eVarSetOperationAssign) override;
+ Error
+ SetValueFromString(const char *,
+ VarSetOperationType = eVarSetOperationAssign) = delete;
bool Clear() override {
m_current_value = m_default_value;
Error
SetValueFromString(llvm::StringRef value,
VarSetOperationType op = eVarSetOperationAssign) override;
+ Error
+ SetValueFromString(const char *,
+ VarSetOperationType = eVarSetOperationAssign) = delete;
bool Clear() override {
m_current_value = m_default_value;
const Flags &GetOptions() const { return m_options; }
const char *operator=(const char *value) {
- SetCurrentValue(value);
+ SetCurrentValue(llvm::StringRef::withNullAsEmpty(value));
return m_current_value.c_str();
}
const char *GetDefaultValue() const { return m_default_value.c_str(); }
llvm::StringRef GetDefaultValueAsRef() const { return m_default_value; }
- Error SetCurrentValue(const char *value);
+ Error SetCurrentValue(const char *) = delete;
+ Error SetCurrentValue(llvm::StringRef value);
Error AppendToCurrentValue(const char *value);
// string isn't a uint64_t value or any other error occurs, return an
// empty lldb::OptionValueSP and fill error in with the correct stuff.
//---------------------------------------------------------------------
- static lldb::OptionValueSP Create(const char *value_cstr, Error &error);
+ static lldb::OptionValueSP Create(const char *, Error &) = delete;
+ static lldb::OptionValueSP Create(llvm::StringRef value_str, Error &error);
//---------------------------------------------------------------------
// Virtual subclass pure virtual overrides
//---------------------------------------------------------------------
Error
SetValueFromString(llvm::StringRef value,
VarSetOperationType op = eVarSetOperationAssign) override;
+ Error
+ SetValueFromString(const char *,
+ VarSetOperationType = eVarSetOperationAssign) = delete;
bool Clear() override {
m_current_value = m_default_value;
Error
SetValueFromString(llvm::StringRef value,
VarSetOperationType op = eVarSetOperationAssign) override;
+ Error
+ SetValueFromString(const char *,
+ VarSetOperationType = eVarSetOperationAssign) = delete;
bool Clear() override {
m_uuid.Clear();
virtual llvm::ArrayRef<OptionDefinition> GetDefinitions() = 0;
- virtual Error SetOptionValue(uint32_t option_idx, const char *option_value,
+ virtual Error SetOptionValue(uint32_t option_idx,
+ llvm::StringRef option_value,
ExecutionContext *execution_context) = 0;
+ Error SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
virtual void OptionParsingStarting(ExecutionContext *execution_context) = 0;
// These are accessors for general information about the Languages lldb knows
// about:
- static lldb::LanguageType GetLanguageTypeFromString(const char *string);
+ static lldb::LanguageType
+ GetLanguageTypeFromString(const char *string) = delete;
static lldb::LanguageType GetLanguageTypeFromString(llvm::StringRef string);
static const char *GetNameForLanguageType(lldb::LanguageType language);
~OptionGroupPlatformRSync() override = default;
lldb_private::Error
- SetOptionValue(uint32_t option_idx, const char *option_value,
+ SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
ExecutionContext *execution_context) override;
void OptionParsingStarting(ExecutionContext *execution_context) override;
~OptionGroupPlatformSSH() override = default;
lldb_private::Error
- SetOptionValue(uint32_t option_idx, const char *option_value,
+ SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
ExecutionContext *execution_context) override;
void OptionParsingStarting(ExecutionContext *execution_context) override;
~OptionGroupPlatformCaching() override = default;
lldb_private::Error
- SetOptionValue(uint32_t option_idx, const char *option_value,
+ SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
ExecutionContext *execution_context) override;
void OptionParsingStarting(ExecutionContext *execution_context) override;
lldb::LanguageType
SBLanguageRuntime::GetLanguageTypeFromString(const char *string) {
- return Language::GetLanguageTypeFromString(string);
+ return Language::GetLanguageTypeFromString(
+ llvm::StringRef::withNullAsEmpty(string));
}
const char *
break;
case 'E': {
- LanguageType language = Language::GetLanguageTypeFromString(option_arg);
+ LanguageType language =
+ Language::GetLanguageTypeFromString(option_strref);
switch (language) {
case eLanguageTypeC89:
}
case 'L':
- m_language = Language::GetLanguageTypeFromString(option_arg);
+ m_language = Language::GetLanguageTypeFromString(option_strref);
if (m_language == eLanguageTypeUnknown)
error.SetErrorStringWithFormat(
"Unknown language type: '%s' for breakpoint", option_arg);
return llvm::makeArrayRef(g_breakpoint_name_options);
}
- Error SetOptionValue(uint32_t option_idx, const char *option_value,
+ Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
ExecutionContext *execution_context) override {
Error error;
const int short_option = g_breakpoint_name_options[option_idx].short_option;
- llvm::StringRef option_strref(option_value ? option_value : "");
switch (short_option) {
case 'N':
- if (BreakpointID::StringIsBreakpointName(option_strref, error) &&
+ if (BreakpointID::StringIsBreakpointName(option_value, error) &&
error.Success())
- m_name.SetValueFromString(option_strref);
+ m_name.SetValueFromString(option_value);
break;
case 'B':
if (m_breakpoint.SetValueFromString(option_value).Fail())
error.SetErrorStringWithFormat(
- "unrecognized value \"%s\" for breakpoint", option_value);
+ "unrecognized value \"%s\" for breakpoint",
+ option_value.str().c_str());
break;
case 'D':
if (m_use_dummy.SetValueFromString(option_value).Fail())
error.SetErrorStringWithFormat(
- "unrecognized value \"%s\" for use-dummy", option_value);
+ "unrecognized value \"%s\" for use-dummy",
+ option_value.str().c_str());
break;
default:
}
return error;
}
+ Error SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
void OptionParsingStarting(ExecutionContext *execution_context) override {
m_name.Clear();
case 's':
m_script_language = (lldb::ScriptLanguage)Args::StringToOptionEnum(
- option_arg, g_breakpoint_add_options[option_idx].enum_values,
+ llvm::StringRef::withNullAsEmpty(option_arg),
+ g_breakpoint_add_options[option_idx].enum_values,
eScriptLanguageNone, error);
if (m_script_language == eScriptLanguagePython ||
ExecutionContext *execution_context) override {
Error error;
const int short_option = m_getopt_table[option_idx].val;
+ llvm::StringRef option_strref =
+ llvm::StringRef::withNullAsEmpty(option_arg);
switch (short_option) {
case 'c':
- error = m_count.SetValueFromString(option_arg, eVarSetOperationAssign);
+ error =
+ m_count.SetValueFromString(option_strref, eVarSetOperationAssign);
break;
case 's':
if (option_arg && strcmp("end", option_arg) == 0) {
m_start_idx.SetCurrentValue(UINT64_MAX);
m_start_idx.SetOptionWasSet();
} else
- error = m_start_idx.SetValueFromString(option_arg,
+ error = m_start_idx.SetValueFromString(option_strref,
eVarSetOperationAssign);
break;
case 'e':
- error =
- m_stop_idx.SetValueFromString(option_arg, eVarSetOperationAssign);
+ error = m_stop_idx.SetValueFromString(option_strref,
+ eVarSetOperationAssign);
break;
case 'C':
m_clear.SetCurrentValue(true);
ExecutionContext *execution_context) override {
Error error;
const int short_option = m_getopt_table[option_idx].val;
+ llvm::StringRef option_strref =
+ llvm::StringRef::withNullAsEmpty(option_arg);
switch (short_option) {
case 'e':
- error = m_stop_on_error.SetValueFromString(option_arg);
+ error = m_stop_on_error.SetValueFromString(option_strref);
break;
case 'c':
- error = m_stop_on_continue.SetValueFromString(option_arg);
+ error = m_stop_on_continue.SetValueFromString(option_strref);
break;
case 's':
- error = m_silent_run.SetValueFromString(option_arg);
+ error = m_silent_run.SetValueFromString(option_strref);
break;
default:
return llvm::makeArrayRef(g_alias_options);
}
- Error SetOptionValue(uint32_t option_idx, const char *option_value,
+ Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
ExecutionContext *execution_context) override {
Error error;
const int short_option = GetDefinitions()[option_idx].short_option;
+ std::string option_str(option_value);
switch (short_option) {
case 'h':
- m_help.SetCurrentValue(option_value);
+ m_help.SetCurrentValue(option_str);
m_help.SetOptionWasSet();
break;
case 'H':
- m_long_help.SetCurrentValue(option_value);
+ m_long_help.SetCurrentValue(option_str);
m_long_help.SetOptionWasSet();
break;
return error;
}
+ Error SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
void OptionParsingStarting(ExecutionContext *execution_context) override {
m_help.Clear();
case 's':
m_synchronicity =
(ScriptedCommandSynchronicity)Args::StringToOptionEnum(
- option_arg, GetDefinitions()[option_idx].enum_values, 0, error);
+ llvm::StringRef::withNullAsEmpty(option_arg),
+ GetDefinitions()[option_idx].enum_values, 0, error);
if (!error.Success())
error.SetErrorStringWithFormat(
"unrecognized value for synchronicity '%s'", option_arg);
};
Error CommandObjectExpression::CommandOptions::SetOptionValue(
- uint32_t option_idx, const char *option_arg,
+ uint32_t option_idx, llvm::StringRef option_arg,
ExecutionContext *execution_context) {
Error error;
- auto option_strref = llvm::StringRef::withNullAsEmpty(option_arg);
const int short_option = GetDefinitions()[option_idx].short_option;
switch (short_option) {
language = Language::GetLanguageTypeFromString(option_arg);
if (language == eLanguageTypeUnknown)
error.SetErrorStringWithFormat(
- "unknown language type: '%s' for expression", option_arg);
+ "unknown language type: '%s' for expression",
+ option_arg.str().c_str());
break;
case 'a': {
bool success;
bool result;
- result = Args::StringToBoolean(option_strref, true, &success);
+ result = Args::StringToBoolean(option_arg, true, &success);
if (!success)
error.SetErrorStringWithFormat(
- "invalid all-threads value setting: \"%s\"", option_arg);
+ "invalid all-threads value setting: \"%s\"",
+ option_arg.str().c_str());
else
try_all_threads = result;
} break;
case 'i': {
bool success;
- bool tmp_value = Args::StringToBoolean(option_strref, true, &success);
+ bool tmp_value = Args::StringToBoolean(option_arg, true, &success);
if (success)
ignore_breakpoints = tmp_value;
else
error.SetErrorStringWithFormat(
- "could not convert \"%s\" to a boolean value.", option_arg);
+ "could not convert \"%s\" to a boolean value.",
+ option_arg.str().c_str());
break;
}
case 'j': {
bool success;
- bool tmp_value = Args::StringToBoolean(option_strref, true, &success);
+ bool tmp_value = Args::StringToBoolean(option_arg, true, &success);
if (success)
allow_jit = tmp_value;
else
error.SetErrorStringWithFormat(
- "could not convert \"%s\" to a boolean value.", option_arg);
+ "could not convert \"%s\" to a boolean value.",
+ option_arg.str().c_str());
break;
}
- case 't': {
- bool success;
- uint32_t result;
- result = StringConvert::ToUInt32(option_arg, 0, 0, &success);
- if (success)
- timeout = result;
- else
+ case 't':
+ if (option_arg.getAsInteger(0, timeout)) {
+ timeout = 0;
error.SetErrorStringWithFormat("invalid timeout setting \"%s\"",
- option_arg);
- } break;
+ option_arg.str().c_str());
+ }
+ break;
case 'u': {
bool success;
- bool tmp_value = Args::StringToBoolean(option_strref, true, &success);
+ bool tmp_value = Args::StringToBoolean(option_arg, true, &success);
if (success)
unwind_on_error = tmp_value;
else
error.SetErrorStringWithFormat(
- "could not convert \"%s\" to a boolean value.", option_arg);
+ "could not convert \"%s\" to a boolean value.",
+ option_arg.str().c_str());
break;
}
case 'v':
- if (!option_arg) {
+ if (!option_arg.empty()) {
m_verbosity = eLanguageRuntimeDescriptionDisplayVerbosityFull;
break;
}
option_arg, GetDefinitions()[option_idx].enum_values, 0, error);
if (!error.Success())
error.SetErrorStringWithFormat(
- "unrecognized value for description-verbosity '%s'", option_arg);
+ "unrecognized value for description-verbosity '%s'",
+ option_arg.str().c_str());
break;
case 'g':
case 'X': {
bool success;
- bool tmp_value = Args::StringToBoolean(option_strref, true, &success);
+ bool tmp_value = Args::StringToBoolean(option_arg, true, &success);
if (success)
auto_apply_fixits = tmp_value ? eLazyBoolYes : eLazyBoolNo;
else
error.SetErrorStringWithFormat(
- "could not convert \"%s\" to a boolean value.", option_arg);
+ "could not convert \"%s\" to a boolean value.",
+ option_arg.str().c_str());
break;
}
llvm::ArrayRef<OptionDefinition> GetDefinitions() override;
- Error SetOptionValue(uint32_t option_idx, const char *option_value,
+ Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
ExecutionContext *execution_context) override;
+ Error SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
void OptionParsingStarting(ExecutionContext *execution_context) override;
return llvm::makeArrayRef(g_read_memory_options);
}
- Error SetOptionValue(uint32_t option_idx, const char *option_arg,
+ Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
ExecutionContext *execution_context) override {
Error error;
const int short_option = g_read_memory_options[option_idx].short_option;
switch (short_option) {
case 'l':
- error = m_num_per_line.SetValueFromString(option_arg);
+ error = m_num_per_line.SetValueFromString(option_value);
if (m_num_per_line.GetCurrentValue() == 0)
error.SetErrorStringWithFormat(
- "invalid value for --num-per-line option '%s'", option_arg);
+ "invalid value for --num-per-line option '%s'",
+ option_value.str().c_str());
break;
case 'b':
break;
case 't':
- error = m_view_as_type.SetValueFromString(option_arg);
+ error = m_view_as_type.SetValueFromString(option_value);
break;
case 'r':
break;
case 'E':
- error = m_offset.SetValueFromString(option_arg);
+ error = m_offset.SetValueFromString(option_value);
break;
default:
}
return error;
}
+ Error SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
void OptionParsingStarting(ExecutionContext *execution_context) override {
m_num_per_line.Clear();
return llvm::makeArrayRef(g_memory_find_option_table);
}
- Error SetOptionValue(uint32_t option_idx, const char *option_arg,
+ Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
ExecutionContext *execution_context) override {
Error error;
const int short_option =
switch (short_option) {
case 'e':
- m_expr.SetValueFromString(option_arg);
+ m_expr.SetValueFromString(option_value);
break;
case 's':
- m_string.SetValueFromString(option_arg);
+ m_string.SetValueFromString(option_value);
break;
case 'c':
- if (m_count.SetValueFromString(option_arg).Fail())
+ if (m_count.SetValueFromString(option_value).Fail())
error.SetErrorString("unrecognized value for count");
break;
case 'o':
- if (m_offset.SetValueFromString(option_arg).Fail())
+ if (m_offset.SetValueFromString(option_value).Fail())
error.SetErrorString("unrecognized value for dump-offset");
break;
}
return error;
}
+ Error SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
void OptionParsingStarting(ExecutionContext *execution_context) override {
m_expr.Clear();
return llvm::makeArrayRef(g_memory_write_option_table);
}
- Error SetOptionValue(uint32_t option_idx, const char *option_arg,
+ Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
ExecutionContext *execution_context) override {
Error error;
const int short_option =
switch (short_option) {
case 'i':
- m_infile.SetFile(option_arg, true);
+ m_infile.SetFile(option_value, true);
if (!m_infile.Exists()) {
m_infile.Clear();
error.SetErrorStringWithFormat("input file does not exist: '%s'",
- option_arg);
+ option_value.str().c_str());
}
break;
case 'o': {
- bool success;
- m_infile_offset = StringConvert::ToUInt64(option_arg, 0, 0, &success);
- if (!success) {
+ if (option_value.getAsInteger(0, m_infile_offset)) {
+ m_infile_offset = 0;
error.SetErrorStringWithFormat("invalid offset string '%s'",
- option_arg);
+ option_value.str().c_str());
}
} break;
}
return error;
}
+ Error SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
void OptionParsingStarting(ExecutionContext *execution_context) override {
m_infile.Clear();
using namespace lldb;
using namespace lldb_private;
-static mode_t ParsePermissionString(const char *permissions) {
- if (strlen(permissions) != 9)
+static mode_t ParsePermissionString(const char *) = delete;
+
+static mode_t ParsePermissionString(llvm::StringRef permissions) {
+ if (permissions.size() != 9)
return (mode_t)(-1);
bool user_r, user_w, user_x, group_r, group_w, group_x, world_r, world_w,
world_x;
// clang-format on
};
-class OptionPermissions : public lldb_private::OptionGroup {
+class OptionPermissions : public OptionGroup {
public:
OptionPermissions() {}
~OptionPermissions() override = default;
lldb_private::Error
- SetOptionValue(uint32_t option_idx, const char *option_arg,
+ SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
ExecutionContext *execution_context) override {
Error error;
char short_option = (char)GetDefinitions()[option_idx].short_option;
switch (short_option) {
case 'v': {
- bool ok;
- uint32_t perms = StringConvert::ToUInt32(option_arg, 777, 8, &ok);
- if (!ok)
+ if (option_arg.getAsInteger(8, m_permissions)) {
+ m_permissions = 0777;
error.SetErrorStringWithFormat("invalid value for permissions: %s",
- option_arg);
- else
- m_permissions = perms;
+ option_arg.str().c_str());
+ }
+
} break;
case 's': {
mode_t perms = ParsePermissionString(option_arg);
if (perms == (mode_t)-1)
error.SetErrorStringWithFormat("invalid value for permissions: %s",
- option_arg);
+ option_arg.str().c_str());
else
m_permissions = perms;
} break;
alternate_name.Clear();
}
- Error SetOptionValue(uint32_t option_idx, const char *option_value,
+ Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
ExecutionContext *execution_context) override {
Error error;
const int short_option = GetDefinitions()[option_idx].short_option;
}
return error;
}
+ Error SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
// Instance variables to hold the values for command options.
OptionValueArray set_indexes;
switch (short_option) {
case 's':
m_sort_order = (SortOrder)Args::StringToOptionEnum(
- option_arg, GetDefinitions()[option_idx].enum_values,
- eSortOrderNone, error);
+ llvm::StringRef::withNullAsEmpty(option_arg),
+ GetDefinitions()[option_idx].enum_values, eSortOrderNone, error);
break;
default:
OptionEnumValueElement *enum_values =
GetDefinitions()[option_idx].enum_values;
m_run_mode = (lldb::RunMode)Args::StringToOptionEnum(
- option_arg, enum_values, eOnlyDuringStepping, error);
+ option_strref, enum_values, eOnlyDuringStepping, error);
} break;
case 'e': {
OptionEnumValueElement *enum_values =
GetDefinitions()[option_idx].enum_values;
lldb::RunMode run_mode = (lldb::RunMode)Args::StringToOptionEnum(
- option_arg, enum_values, eOnlyDuringStepping, error);
+ llvm::StringRef::withNullAsEmpty(option_arg), enum_values,
+ eOnlyDuringStepping, error);
if (error.Success()) {
if (run_mode == eAllThreads)
m_custom_type_name.clear();
}
- Error SetOptionValue(uint32_t option_idx, const char *option_value,
+ Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
ExecutionContext *execution_context) override {
Error error;
const int short_option =
switch (short_option) {
case 'C':
- m_cascade = Args::StringToBoolean(
- llvm::StringRef::withNullAsEmpty(option_value), true, &success);
+ m_cascade = Args::StringToBoolean(option_value, true, &success);
if (!success)
error.SetErrorStringWithFormat("invalid value for cascade: %s",
- option_value);
+ option_value.str().c_str());
break;
case 'p':
m_skip_pointers = true;
return error;
}
+ Error SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
// Instance variables to hold the values for command options.
m_category = std::string(option_arg);
break;
case 'l':
- m_language = Language::GetLanguageTypeFromString(option_arg);
+ m_language = Language::GetLanguageTypeFromString(
+ llvm::StringRef::withNullAsEmpty(option_arg));
break;
default:
error.SetErrorStringWithFormat("unrecognized option '%c'",
ExecutionContext *execution_context) override {
Error error;
const int short_option = m_getopt_table[option_idx].val;
-
+ llvm::StringRef option_strref =
+ llvm::StringRef::withNullAsEmpty(option_arg);
switch (short_option) {
case 'w':
- m_category_regex.SetCurrentValue(option_arg);
+ m_category_regex.SetCurrentValue(option_strref);
m_category_regex.SetOptionWasSet();
break;
case 'l':
- error = m_category_language.SetValueFromString(option_arg);
+ error = m_category_language.SetValueFromString(option_strref);
if (error.Success())
m_category_language.SetOptionWasSet();
break;
switch (short_option) {
case 'e':
- m_define_enabled.SetValueFromString("true");
+ m_define_enabled.SetValueFromString(llvm::StringRef("true"));
break;
case 'l':
- error = m_cate_language.SetValueFromString(option_arg);
+ error = m_cate_language.SetValueFromString(
+ llvm::StringRef::withNullAsEmpty(option_arg));
break;
default:
error.SetErrorStringWithFormat("unrecognized option '%c'",
switch (short_option) {
case 'l':
if (option_arg) {
- m_language = Language::GetLanguageTypeFromString(option_arg);
+ m_language = Language::GetLanguageTypeFromString(
+ llvm::StringRef::withNullAsEmpty(option_arg));
if (m_language == lldb::eLanguageTypeUnknown)
error.SetErrorStringWithFormat("unrecognized language '%s'",
option_arg);
switch (short_option) {
case 'l':
if (option_arg) {
- m_language = Language::GetLanguageTypeFromString(option_arg);
+ m_language = Language::GetLanguageTypeFromString(
+ llvm::StringRef::withNullAsEmpty(option_arg));
if (m_language == lldb::eLanguageTypeUnknown)
error.SetErrorStringWithFormat("unrecognized language '%s'",
option_arg);
return llvm::makeArrayRef(g_type_lookup_options);
}
- Error SetOptionValue(uint32_t option_idx, const char *option_value,
+ Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
ExecutionContext *execution_context) override {
Error error;
return error;
}
+ Error SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
void OptionParsingStarting(ExecutionContext *execution_context) override {
m_show_help = false;
case 's':
m_script_language = (lldb::ScriptLanguage)Args::StringToOptionEnum(
- option_arg, GetDefinitions()[option_idx].enum_values,
- eScriptLanguageNone, error);
+ llvm::StringRef::withNullAsEmpty(option_arg),
+ GetDefinitions()[option_idx].enum_values, eScriptLanguageNone,
+ error);
m_use_script_language = (m_script_language == eScriptLanguagePython ||
m_script_language == eScriptLanguageDefault);
return safe_arg.c_str();
}
-int64_t Args::StringToOptionEnum(const char *s,
+int64_t Args::StringToOptionEnum(llvm::StringRef s,
OptionEnumValueElement *enum_values,
int32_t fail_value, Error &error) {
- if (enum_values) {
- if (s && s[0]) {
- for (int i = 0; enum_values[i].string_value != nullptr; i++) {
- if (strstr(enum_values[i].string_value, s) ==
- enum_values[i].string_value) {
- error.Clear();
- return enum_values[i].value;
- }
- }
- }
-
- StreamString strm;
- strm.PutCString("invalid enumeration value, valid values are: ");
- for (int i = 0; enum_values[i].string_value != nullptr; i++) {
- strm.Printf("%s\"%s\"", i > 0 ? ", " : "", enum_values[i].string_value);
- }
- error.SetErrorString(strm.GetData());
- } else {
+ error.Clear();
+ if (!enum_values) {
error.SetErrorString("invalid enumeration argument");
+ return fail_value;
+ }
+
+ if (s.empty()) {
+ error.SetErrorString("empty enumeration string");
+ return fail_value;
+ }
+
+ for (int i = 0; enum_values[i].string_value != nullptr; i++) {
+ llvm::StringRef this_enum(enum_values[i].string_value);
+ if (this_enum.startswith(s))
+ return enum_values[i].value;
+ }
+
+ StreamString strm;
+ strm.PutCString("invalid enumeration value, valid values are: ");
+ for (int i = 0; enum_values[i].string_value != nullptr; i++) {
+ strm.Printf("%s\"%s\"", i > 0 ? ", " : "", enum_values[i].string_value);
}
+ error.SetErrorString(strm.GetData());
return fail_value;
}
}
Error OptionGroupArchitecture::SetOptionValue(
- uint32_t option_idx, const char *option_arg,
+ uint32_t option_idx, llvm::StringRef option_arg,
ExecutionContext *execution_context) {
Error error;
const int short_option = g_option_table[option_idx].short_option;
OptionGroupBoolean::~OptionGroupBoolean() {}
Error OptionGroupBoolean::SetOptionValue(uint32_t option_idx,
- const char *option_arg,
+ llvm::StringRef option_value,
ExecutionContext *execution_context) {
Error error;
if (m_option_definition.option_has_arg == OptionParser::eNoArgument) {
m_value.SetCurrentValue(!m_value.GetDefaultValue());
m_value.SetOptionWasSet();
} else {
- error = m_value.SetValueFromString(option_arg);
+ error = m_value.SetValueFromString(option_value);
}
return error;
}
OptionGroupFile::~OptionGroupFile() {}
Error OptionGroupFile::SetOptionValue(uint32_t option_idx,
- const char *option_arg,
+ llvm::StringRef option_arg,
ExecutionContext *execution_context) {
Error error(m_file.SetValueFromString(option_arg));
return error;
OptionGroupFileList::~OptionGroupFileList() {}
Error OptionGroupFileList::SetOptionValue(uint32_t option_idx,
- const char *option_arg,
+ llvm::StringRef option_value,
ExecutionContext *execution_context) {
- Error error(m_file_list.SetValueFromString(option_arg));
+ Error error(m_file_list.SetValueFromString(option_value));
return error;
}
}
Error OptionGroupFormat::SetOptionValue(uint32_t option_idx,
- const char *option_arg,
+ llvm::StringRef option_arg,
ExecutionContext *execution_context) {
Error error;
const int short_option = g_option_table[option_idx].short_option;
error = m_count.SetValueFromString(option_arg);
if (m_count.GetCurrentValue() == 0)
error.SetErrorStringWithFormat("invalid --count option value '%s'",
- option_arg);
+ option_arg.str().c_str());
}
break;
error = m_byte_size.SetValueFromString(option_arg);
if (m_byte_size.GetCurrentValue() == 0)
error.SetErrorStringWithFormat("invalid --size option value '%s'",
- option_arg);
+ option_arg.str().c_str());
}
break;
case 'G': {
- char *end = nullptr;
- const char *gdb_format_cstr = option_arg;
uint64_t count = 0;
- if (::isdigit(gdb_format_cstr[0])) {
- count = strtoull(gdb_format_cstr, &end, 0);
-
- if (option_arg != end)
- gdb_format_cstr =
- end; // We have a valid count, advance the string position
- else
- count = 0;
- }
+ llvm::StringRef gdb_format_str = option_arg;
+ gdb_format_str.consumeInteger(0, count);
Format format = eFormatDefault;
uint32_t byte_size = 0;
- while (ParserGDBFormatLetter(execution_context, gdb_format_cstr[0], format,
+ while (!gdb_format_str.empty() &&
+ ParserGDBFormatLetter(execution_context, gdb_format_str[0], format,
byte_size)) {
- ++gdb_format_cstr;
+ gdb_format_str = gdb_format_str.drop_front();
}
- // We the first character of the "gdb_format_cstr" is not the
+ // We the first character of the "gdb_format_str" is not the
// NULL terminator, we didn't consume the entire string and
// something is wrong. Also, if none of the format, size or count
// was specified correctly, then abort.
- if (gdb_format_cstr[0] ||
+ if (!gdb_format_str.empty() ||
(format == eFormatInvalid && byte_size == 0 && count == 0)) {
// Nothing got set correctly
error.SetErrorStringWithFormat("invalid gdb format string '%s'",
- option_arg);
+ option_arg.str().c_str());
return error;
}
}
Error OptionGroupOutputFile::SetOptionValue(
- uint32_t option_idx, const char *option_arg,
+ uint32_t option_idx, llvm::StringRef option_arg,
ExecutionContext *execution_context) {
Error error;
const int short_option = g_option_table[option_idx].short_option;
}
Error OptionGroupPlatform::SetOptionValue(uint32_t option_idx,
- const char *option_arg,
+ llvm::StringRef option_arg,
ExecutionContext *execution_context) {
Error error;
if (!m_include_platform_option)
++option_idx;
const int short_option = g_option_table[option_idx].short_option;
- llvm::StringRef option_strref(option_arg ? option_arg : "");
switch (short_option) {
case 'p':
break;
case 'v':
- if (!Args::StringToVersion(option_strref, m_os_version_major,
+ if (!Args::StringToVersion(option_arg, m_os_version_major,
m_os_version_minor, m_os_version_update))
- error.SetErrorStringWithFormat("invalid version string '%s'", option_arg);
+ error.SetErrorStringWithFormat("invalid version string '%s'",
+ option_arg.str().c_str());
break;
case 'b':
- m_sdk_build.SetCString(option_arg);
+ m_sdk_build.SetString(option_arg);
break;
case 'S':
- m_sdk_sysroot.SetCString(option_arg);
+ m_sdk_sysroot.SetString(option_arg);
break;
default:
OptionGroupString::~OptionGroupString() {}
Error OptionGroupString::SetOptionValue(uint32_t option_idx,
- const char *option_arg,
+ llvm::StringRef option_arg,
ExecutionContext *execution_context) {
Error error(m_value.SetValueFromString(option_arg));
return error;
OptionGroupUInt64::~OptionGroupUInt64() {}
Error OptionGroupUInt64::SetOptionValue(uint32_t option_idx,
- const char *option_arg,
+ llvm::StringRef option_arg,
ExecutionContext *execution_context) {
Error error(m_value.SetValueFromString(option_arg));
return error;
}
Error OptionGroupUUID::SetOptionValue(uint32_t option_idx,
- const char *option_arg,
+ llvm::StringRef option_arg,
ExecutionContext *execution_context) {
Error error;
const int short_option = g_option_table[option_idx].short_option;
}
Error OptionGroupValueObjectDisplay::SetOptionValue(
- uint32_t option_idx, const char *option_arg,
+ uint32_t option_idx, llvm::StringRef option_arg,
ExecutionContext *execution_context) {
Error error;
const int short_option = g_option_table[option_idx].short_option;
bool success = false;
- auto option_strref = llvm::StringRef::withNullAsEmpty(option_arg);
-
switch (short_option) {
case 'd': {
int32_t result;
break;
case 'D':
- max_depth = StringConvert::ToUInt32(option_arg, UINT32_MAX, 0, &success);
- if (!success)
- error.SetErrorStringWithFormat("invalid max depth '%s'", option_arg);
+ if (option_arg.getAsInteger(0, max_depth)) {
+ max_depth = UINT32_MAX;
+ error.SetErrorStringWithFormat("invalid max depth '%s'",
+ option_arg.str().c_str());
+ }
break;
case 'Z':
- elem_count = StringConvert::ToUInt32(option_arg, UINT32_MAX, 0, &success);
- if (!success)
- error.SetErrorStringWithFormat("invalid element count '%s'", option_arg);
+ if (option_arg.getAsInteger(0, elem_count)) {
+ elem_count = UINT32_MAX;
+ error.SetErrorStringWithFormat("invalid element count '%s'",
+ option_arg.str().c_str());
+ }
break;
case 'P':
- ptr_depth = StringConvert::ToUInt32(option_arg, 0, 0, &success);
- if (!success)
- error.SetErrorStringWithFormat("invalid pointer depth '%s'", option_arg);
+ if (option_arg.getAsInteger(0, ptr_depth)) {
+ ptr_depth = 0;
+ error.SetErrorStringWithFormat("invalid pointer depth '%s'",
+ option_arg.str().c_str());
+ }
break;
case 'Y':
- if (option_arg) {
- no_summary_depth = StringConvert::ToUInt32(option_arg, 0, 0, &success);
- if (!success)
- error.SetErrorStringWithFormat("invalid pointer depth '%s'",
- option_arg);
- } else
+ if (option_arg.getAsInteger(0, no_summary_depth)) {
no_summary_depth = 1;
+ error.SetErrorStringWithFormat("invalid pointer depth '%s'",
+ option_arg.str().c_str());
+ }
break;
case 'S':
- use_synth = Args::StringToBoolean(option_strref, true, &success);
+ use_synth = Args::StringToBoolean(option_arg, true, &success);
if (!success)
- error.SetErrorStringWithFormat("invalid synthetic-type '%s'", option_arg);
+ error.SetErrorStringWithFormat("invalid synthetic-type '%s'",
+ option_arg.str().c_str());
break;
case 'V':
- run_validator = Args::StringToBoolean(option_strref, true, &success);
+ run_validator = Args::StringToBoolean(option_arg, true, &success);
if (!success)
- error.SetErrorStringWithFormat("invalid validate '%s'", option_arg);
+ error.SetErrorStringWithFormat("invalid validate '%s'",
+ option_arg.str().c_str());
break;
default:
OptionGroupVariable::~OptionGroupVariable() {}
Error OptionGroupVariable::SetOptionValue(uint32_t option_idx,
- const char *option_arg,
+ llvm::StringRef option_arg,
ExecutionContext *execution_context) {
Error error;
if (!include_frame_options)
OptionGroupWatchpoint::~OptionGroupWatchpoint() {}
Error OptionGroupWatchpoint::SetOptionValue(
- uint32_t option_idx, const char *option_arg,
+ uint32_t option_idx, llvm::StringRef option_arg,
ExecutionContext *execution_context) {
Error error;
const int short_option = g_option_table[option_idx].short_option;
bool OptionValue::SetStringValue(const char *new_value) {
OptionValueString *option_value = GetAsString();
if (option_value) {
- option_value->SetCurrentValue(new_value);
+ option_value->SetCurrentValue(llvm::StringRef::withNullAsEmpty(new_value));
return true;
}
return false;
}
if (value_sp)
- error = value_sp->SetValueFromString(value_cstr, eVarSetOperationAssign);
+ error = value_sp->SetValueFromString(
+ llvm::StringRef::withNullAsEmpty(value_cstr), eVarSetOperationAssign);
else
error.SetErrorString("unsupported type mask");
return value_sp;
} break;
default:
- error = OptionValue::SetValueFromString(value.str().c_str(), op);
+ error = OptionValue::SetValueFromString(value, op);
break;
}
return 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);
+ error = value_sp->SetValueFromString(
+ llvm::StringRef::withNullAsEmpty(value), op);
else {
if (error.AsCString() == nullptr)
error.SetErrorStringWithFormat("invalid value path '%s'", name);
return value_sp;
}
-const char *
-OptionValueDictionary::GetStringValueForKey(const ConstString &key) {
- collection::const_iterator pos = m_values.find(key);
- if (pos != m_values.end()) {
- OptionValueString *string_value = pos->second->GetAsString();
- if (string_value)
- return string_value->GetCurrentValue();
- }
- return nullptr;
-}
-
-bool OptionValueDictionary::SetStringValueForKey(const ConstString &key,
- const char *value,
- bool can_replace) {
- collection::const_iterator pos = m_values.find(key);
- if (pos != m_values.end()) {
- if (!can_replace)
- return false;
- if (pos->second->GetType() == OptionValue::eTypeString) {
- pos->second->SetValueFromString(value);
- return true;
- }
- }
- m_values[key] = OptionValueSP(new OptionValueString(value));
- return true;
-}
-
bool OptionValueDictionary::SetValueForKey(const ConstString &key,
const lldb::OptionValueSP &value_sp,
bool can_replace) {
if (m_options.Test(eOptionEncodeCharacterEscapeSequences)) {
Args::EncodeEscapeSequences(value_str.c_str(), m_current_value);
} else {
- SetCurrentValue(value_str.c_str());
+ SetCurrentValue(value_str);
}
NotifyValueChanged();
break;
return OptionValueSP(new OptionValueString(*this));
}
-Error OptionValueString::SetCurrentValue(const char *value) {
+Error OptionValueString::SetCurrentValue(llvm::StringRef value) {
if (m_validator) {
- Error error(m_validator(value, m_validator_baton));
+ Error error(m_validator(value.str().c_str(), m_validator_baton));
if (error.Fail())
return error;
}
- if (value && value[0])
- m_current_value.assign(value);
- else
- m_current_value.clear();
+ m_current_value.assign(value);
return Error();
}
using namespace lldb;
using namespace lldb_private;
-lldb::OptionValueSP OptionValueUInt64::Create(const char *value_cstr,
+lldb::OptionValueSP OptionValueUInt64::Create(llvm::StringRef value_str,
Error &error) {
lldb::OptionValueSP value_sp(new OptionValueUInt64());
- error = value_sp->SetValueFromString(value_cstr);
+ error = value_sp->SetValueFromString(value_str);
if (error.Fail())
value_sp.reset();
return value_sp;
Error error;
if (option_idx < m_option_infos.size()) {
error = m_option_infos[option_idx].option_group->SetOptionValue(
- m_option_infos[option_idx].option_index, option_value,
- execution_context);
+ m_option_infos[option_idx].option_index,
+ llvm::StringRef::withNullAsEmpty(option_value), execution_context);
} else {
error.SetErrorString("invalid option index"); // Shouldn't happen...
definition.enum_values, definition.default_uint_value);
m_value_sp.reset(enum_value);
if (definition.default_cstr_value) {
- if (enum_value->SetValueFromString(definition.default_cstr_value)
+ if (enum_value
+ ->SetValueFromString(
+ llvm::StringRef(definition.default_cstr_value))
.Success()) {
enum_value->SetDefaultValue(enum_value->GetCurrentValue());
// Call Clear() since we don't want the value to appear as
static uint32_t num_languages =
sizeof(language_names) / sizeof(struct language_name_pair);
-LanguageType Language::GetLanguageTypeFromString(const char *s) {
- return GetLanguageTypeFromString(llvm::StringRef(s ? s : ""));
-}
-
LanguageType Language::GetLanguageTypeFromString(llvm::StringRef string) {
for (const auto &L : language_names) {
if (string.equals_lower(L.name))
lldb_private::Error
OptionGroupPlatformRSync::SetOptionValue(uint32_t option_idx,
- const char *option_arg,
+ llvm::StringRef option_arg,
ExecutionContext *execution_context) {
Error error;
char short_option = (char)GetDefinitions()[option_idx].short_option;
lldb_private::Error
OptionGroupPlatformSSH::SetOptionValue(uint32_t option_idx,
- const char *option_arg,
+ llvm::StringRef option_arg,
ExecutionContext *execution_context) {
Error error;
char short_option = (char)GetDefinitions()[option_idx].short_option;
}
lldb_private::Error OptionGroupPlatformCaching::SetOptionValue(
- uint32_t option_idx, const char *option_arg,
+ uint32_t option_idx, llvm::StringRef option_arg,
ExecutionContext *execution_context) {
Error error;
char short_option = (char)GetDefinitions()[option_idx].short_option;