return result.Succeeded();
}
- if (sub_command.equals_lower("help")) {
+ if (sub_command.equals_insensitive("help")) {
this->CommandObject::GenerateHelpText(result);
return result.Succeeded();
}
for (uint32_t reg = start_idx; reg < num_registers; ++reg) {
const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg);
- if (reg_name.equals_lower(reg_info->name) ||
- reg_name.equals_lower(reg_info->alt_name))
+ if (reg_name.equals_insensitive(reg_info->name) ||
+ reg_name.equals_insensitive(reg_info->alt_name))
return reg_info;
}
return nullptr;
const char *hide_console_var =
getenv("LLDB_LAUNCH_INFERIORS_WITHOUT_CONSOLE");
if (hide_console_var &&
- llvm::StringRef(hide_console_var).equals_lower("true")) {
+ llvm::StringRef(hide_console_var).equals_insensitive("true")) {
startupinfo.dwFlags |= STARTF_USESHOWWINDOW;
startupinfo.wShowWindow = SW_HIDE;
}
#if defined(_WIN32)
const char *disable_crash_dialog_var = getenv("LLDB_DISABLE_CRASH_DIALOG");
if (disable_crash_dialog_var &&
- llvm::StringRef(disable_crash_dialog_var).equals_lower("true")) {
+ llvm::StringRef(disable_crash_dialog_var).equals_insensitive("true")) {
// This will prevent Windows from displaying a dialog box requiring user
// interaction when
// LLDB crashes. This is mostly useful when automating LLDB, for example
const bool search_long_help = false;
const bool search_syntax = false;
const bool search_options = false;
- if (command_name.contains_lower(search_word) ||
+ if (command_name.contains_insensitive(search_word) ||
cmd_obj->HelpTextContainsWord(search_word, search_short_help,
search_long_help, search_syntax,
search_options)) {
llvm::StringRef long_help = GetHelpLong();
llvm::StringRef syntax_help = GetSyntax();
- if (search_short_help && short_help.contains_lower(search_word))
+ if (search_short_help && short_help.contains_insensitive(search_word))
found_word = true;
- else if (search_long_help && long_help.contains_lower(search_word))
+ else if (search_long_help && long_help.contains_insensitive(search_word))
found_word = true;
- else if (search_syntax && syntax_help.contains_lower(search_word))
+ else if (search_syntax && syntax_help.contains_insensitive(search_word))
found_word = true;
if (!found_word && search_options && GetOptions() != nullptr) {
GetCommandInterpreter().GetDebugger().GetTerminalWidth());
if (!usage_help.Empty()) {
llvm::StringRef usage_text = usage_help.GetString();
- if (usage_text.contains_lower(search_word))
+ if (usage_text.contains_insensitive(search_word))
found_word = true;
}
}
if (success_ptr)
*success_ptr = true;
ref = ref.trim();
- if (ref.equals_lower("false") || ref.equals_lower("off") ||
- ref.equals_lower("no") || ref.equals_lower("0")) {
+ if (ref.equals_insensitive("false") || ref.equals_insensitive("off") ||
+ ref.equals_insensitive("no") || ref.equals_insensitive("0")) {
return false;
- } else if (ref.equals_lower("true") || ref.equals_lower("on") ||
- ref.equals_lower("yes") || ref.equals_lower("1")) {
+ } else if (ref.equals_insensitive("true") || ref.equals_insensitive("on") ||
+ ref.equals_insensitive("yes") || ref.equals_insensitive("1")) {
return true;
}
if (success_ptr)
if (success_ptr)
*success_ptr = true;
- if (s.equals_lower("python"))
+ if (s.equals_insensitive("python"))
return eScriptLanguagePython;
- if (s.equals_lower("lua"))
+ if (s.equals_insensitive("lua"))
return eScriptLanguageLua;
- if (s.equals_lower("default"))
+ if (s.equals_insensitive("default"))
return eScriptLanguageDefault;
- if (s.equals_lower("none"))
+ if (s.equals_insensitive("none"))
return eScriptLanguageNone;
if (success_ptr)
} else {
bool match = false;
llvm::StringRef name = property->GetName();
- if (name.contains_lower(keyword))
+ if (name.contains_insensitive(keyword))
match = true;
else {
llvm::StringRef desc = property->GetDescription();
- if (desc.contains_lower(keyword))
+ if (desc.contains_insensitive(keyword))
match = true;
}
if (match) {
lldb::ScriptLanguage
ScriptInterpreter::StringToLanguage(const llvm::StringRef &language) {
- if (language.equals_lower(LanguageToString(eScriptLanguageNone)))
+ if (language.equals_insensitive(LanguageToString(eScriptLanguageNone)))
return eScriptLanguageNone;
- if (language.equals_lower(LanguageToString(eScriptLanguagePython)))
+ if (language.equals_insensitive(LanguageToString(eScriptLanguagePython)))
return eScriptLanguagePython;
- if (language.equals_lower(LanguageToString(eScriptLanguageLua)))
+ if (language.equals_insensitive(LanguageToString(eScriptLanguageLua)))
return eScriptLanguageLua;
return eScriptLanguageUnknown;
}
const auto suffixes = {".cpp", ".cxx", ".c++", ".cc", ".c",
".h", ".hh", ".hpp", ".hxx", ".h++"};
for (auto suffix : suffixes) {
- if (file_path.endswith_lower(suffix))
+ if (file_path.endswith_insensitive(suffix))
return true;
}
bool ObjCLanguage::IsSourceFile(llvm::StringRef file_path) const {
const auto suffixes = {".h", ".m", ".M"};
for (auto suffix : suffixes) {
- if (file_path.endswith_lower(suffix))
+ if (file_path.endswith_insensitive(suffix))
return true;
}
return false;
bool ObjCPlusPlusLanguage::IsSourceFile(llvm::StringRef file_path) const {
const auto suffixes = {".h", ".mm"};
for (auto suffix : suffixes) {
- if (file_path.endswith_lower(suffix))
+ if (file_path.endswith_insensitive(suffix))
return true;
}
return false;
static bool ShouldUseLLDBServer() {
llvm::StringRef use_lldb_server = ::getenv("LLDB_USE_LLDB_SERVER");
- return use_lldb_server.equals_lower("on") ||
- use_lldb_server.equals_lower("yes") ||
- use_lldb_server.equals_lower("1") ||
- use_lldb_server.equals_lower("true");
+ return use_lldb_server.equals_insensitive("on") ||
+ use_lldb_server.equals_insensitive("yes") ||
+ use_lldb_server.equals_insensitive("1") ||
+ use_lldb_server.equals_insensitive("true");
}
void ProcessWindows::Initialize() {
// check if the process is wow64 - a 32 bit windows process running on a
// 64 bit windows
- if (llvm::StringRef(name).endswith_lower("wow64.dll")) {
+ if (llvm::StringRef(name).endswith_insensitive("wow64.dll")) {
m_is_wow64 = true;
}
llvm::SmallString<64> normalized(other);
llvm::sys::path::native(normalized);
- return main.equals_lower(normalized);
+ return main.equals_insensitive(normalized);
}
static void ParseCompile3(const CVSymbol &sym, CompilandIndexItem &cci) {
auto it = llvm::find_if(
register_names,
[®_name](const llvm::EnumEntry<uint16_t> ®ister_entry) {
- return reg_name.compare_lower(register_entry.Name) == 0;
+ return reg_name.compare_insensitive(register_entry.Name) == 0;
});
if (it == register_names.end())
static bool ShouldUseNativeReader() {
#if defined(_WIN32)
llvm::StringRef use_native = ::getenv("LLDB_USE_NATIVE_PDB_READER");
- return use_native.equals_lower("on") || use_native.equals_lower("yes") ||
- use_native.equals_lower("1") || use_native.equals_lower("true");
+ return use_native.equals_insensitive("on") ||
+ use_native.equals_insensitive("yes") ||
+ use_native.equals_insensitive("1") ||
+ use_native.equals_insensitive("true");
#else
return true;
#endif
LanguageType Language::GetLanguageTypeFromString(llvm::StringRef string) {
for (const auto &L : language_names) {
- if (string.equals_lower(L.name))
+ if (string.equals_insensitive(L.name))
return static_cast<LanguageType>(L.type);
}
for (uint32_t reg = start_idx; reg < num_registers; ++reg) {
const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg);
- if (reg_name.equals_lower(reg_info->name) ||
- reg_name.equals_lower(reg_info->alt_name))
+ if (reg_name.equals_insensitive(reg_info->name) ||
+ reg_name.equals_insensitive(reg_info->alt_name))
return reg_info;
}
return nullptr;
// Get an architecture definition by name.
static const CoreDefinition *FindCoreDefinition(llvm::StringRef name) {
for (unsigned int i = 0; i < llvm::array_lengthof(g_core_definitions); ++i) {
- if (name.equals_lower(g_core_definitions[i].name))
+ if (name.equals_insensitive(g_core_definitions[i].name))
return &g_core_definitions[i];
}
return nullptr;
// perform case insensitive equality test
llvm::StringRef lhs_string_ref(lhs.GetStringRef());
llvm::StringRef rhs_string_ref(rhs.GetStringRef());
- return lhs_string_ref.equals_lower(rhs_string_ref);
+ return lhs_string_ref.equals_insensitive(rhs_string_ref);
}
int ConstString::Compare(ConstString lhs, ConstString rhs,
if (case_sensitive) {
return lhs_string_ref.compare(rhs_string_ref);
} else {
- return lhs_string_ref.compare_lower(rhs_string_ref);
+ return lhs_string_ref.compare_insensitive(rhs_string_ref);
}
}
void llvm::format_provider<FileSpec>::format(const FileSpec &F,
raw_ostream &Stream,
StringRef Style) {
- assert(
- (Style.empty() || Style.equals_lower("F") || Style.equals_lower("D")) &&
- "Invalid FileSpec style!");
+ assert((Style.empty() || Style.equals_insensitive("F") ||
+ Style.equals_insensitive("D")) &&
+ "Invalid FileSpec style!");
StringRef dir = F.GetDirectory().GetStringRef();
StringRef file = F.GetFilename().GetStringRef();
return;
}
- if (Style.equals_lower("F")) {
+ if (Style.equals_insensitive("F")) {
Stream << (file.empty() ? "(empty)" : file);
return;
}
Stream << GetPreferredPathSeparator(F.GetPathStyle());
}
- if (Style.equals_lower("D")) {
+ if (Style.equals_insensitive("D")) {
// We only want to print the directory, so now just exit.
if (dir.empty())
Stream << "(empty)";
bool list_categories = false;
uint32_t flags = 0;
for (const char *category : categories) {
- if (llvm::StringRef("all").equals_lower(category)) {
+ if (llvm::StringRef("all").equals_insensitive(category)) {
flags |= UINT32_MAX;
continue;
}
- if (llvm::StringRef("default").equals_lower(category)) {
+ if (llvm::StringRef("default").equals_insensitive(category)) {
flags |= entry.second.m_channel.default_flags;
continue;
}
- auto cat = llvm::find_if(
- entry.second.m_channel.categories,
- [&](const Log::Category &c) { return c.name.equals_lower(category); });
+ auto cat = llvm::find_if(entry.second.m_channel.categories,
+ [&](const Log::Category &c) {
+ return c.name.equals_insensitive(category);
+ });
if (cat != entry.second.m_channel.categories.end()) {
flags |= cat->flag;
continue;