++MaxEditDistance;
llvm::StringRef Res;
for (const llvm::StringRef &Item : Allowed) {
- if (Item.equals_lower(Search)) {
+ if (Item.equals_insensitive(Search)) {
assert(!Item.equals(Search) && "This should be handled earlier on.");
MaxEditDistance = 1;
Res = Item;
auto NoPrefix = Item;
if (!NoPrefix.consume_front(DropPrefix))
continue;
- if (NoPrefix.equals_lower(Search)) {
+ if (NoPrefix.equals_insensitive(Search)) {
if (NoPrefix.equals(Search))
return Item.str();
MaxEditDistance = 1;
return llvm::any_of(
CONVENTIONAL_CONDITIONS,
[ConditionName](const llvm::StringLiteral &Conventional) {
- return ConditionName.contains_lower(Conventional);
+ return ConditionName.contains_insensitive(Conventional);
});
});
}
}
static bool isRetain(const FunctionDecl *FD, StringRef FName) {
- return FName.startswith_lower("retain") || FName.endswith_lower("retain");
+ return FName.startswith_insensitive("retain") ||
+ FName.endswith_insensitive("retain");
}
static bool isRelease(const FunctionDecl *FD, StringRef FName) {
- return FName.startswith_lower("release") || FName.endswith_lower("release");
+ return FName.startswith_insensitive("release") ||
+ FName.endswith_insensitive("release");
}
static bool isAutorelease(const FunctionDecl *FD, StringRef FName) {
- return FName.startswith_lower("autorelease") ||
- FName.endswith_lower("autorelease");
+ return FName.startswith_insensitive("autorelease") ||
+ FName.endswith_insensitive("autorelease");
}
static bool isMakeCollectable(StringRef FName) {
- return FName.contains_lower("MakeCollectable");
+ return FName.contains_insensitive("MakeCollectable");
}
/// A function is OSObject related if it is declared on a subclass
if (S.isKeywordSelector()) {
for (unsigned i = 0, e = S.getNumArgs(); i != e; ++i) {
StringRef Slot = S.getNameForSlot(i);
- if (Slot.substr(Slot.size() - 8).equals_lower("delegate")) {
+ if (Slot.substr(Slot.size() - 8).equals_insensitive("delegate")) {
if (ResultEff == ObjCInitRetE)
ResultEff = RetEffect::MakeNoRetHard();
else
// Stat("C:") does not recognize "C:" as a valid directory
std::string DirNameStr;
if (DirName.size() > 1 && DirName.back() == ':' &&
- DirName.equals_lower(llvm::sys::path::root_name(DirName))) {
+ DirName.equals_insensitive(llvm::sys::path::root_name(DirName))) {
DirNameStr = DirName.str() + '.';
DirName = DirNameStr;
}
bool Quote = (Lib.find(' ') != StringRef::npos);
std::string ArgStr = Quote ? "\"" : "";
ArgStr += Lib;
- if (!Lib.endswith_lower(".lib") && !Lib.endswith_lower(".a"))
+ if (!Lib.endswith_insensitive(".lib") && !Lib.endswith_insensitive(".a"))
ArgStr += ".lib";
ArgStr += Quote ? "\"" : "";
return ArgStr;
A = Args.getLastArg(options::OPT_march_EQ);
if (A && Target.isRISCV()) {
StringRef ArchName = A->getValue();
- if (ArchName.startswith_lower("rv32"))
+ if (ArchName.startswith_insensitive("rv32"))
Target.setArch(llvm::Triple::riscv32);
- else if (ArchName.startswith_lower("rv64"))
+ else if (ArchName.startswith_insensitive("rv64"))
Target.setArch(llvm::Triple::riscv64);
}
// case-insensitive sorting for consistency with the -help option
// which prints out options in the case-insensitive alphabetical order.
llvm::sort(SuggestedCompletions, [](StringRef A, StringRef B) {
- if (int X = A.compare_lower(B))
+ if (int X = A.compare_insensitive(B))
return X < 0;
return A.compare(B) > 0;
});
if (Args.hasArg(options::OPT_emit_llvm))
Diag(clang::diag::err_drv_emit_llvm_link);
if (IsCLMode() && LTOMode != LTOK_None &&
- !Args.getLastArgValue(options::OPT_fuse_ld_EQ).equals_lower("lld"))
+ !Args.getLastArgValue(options::OPT_fuse_ld_EQ)
+ .equals_insensitive("lld"))
Diag(clang::diag::err_drv_lto_without_lld);
}
case llvm::Triple::MSVC:
case llvm::Triple::UnknownEnvironment:
if (Args.getLastArgValue(options::OPT_fuse_ld_EQ)
- .startswith_lower("bfd"))
+ .startswith_insensitive("bfd"))
TC = std::make_unique<toolchains::CrossWindowsToolChain>(
*this, Target, Args);
else
// rv64* -> lp64
StringRef MArch = getRISCVArch(Args, Triple);
- if (MArch.startswith_lower("rv32")) {
+ if (MArch.startswith_insensitive("rv32")) {
// FIXME: parse `March` to find `D` extension properly
- if (MArch.substr(4).contains_lower("d") || MArch.startswith_lower("rv32g"))
+ if (MArch.substr(4).contains_insensitive("d") ||
+ MArch.startswith_insensitive("rv32g"))
return "ilp32d";
- else if (MArch.startswith_lower("rv32e"))
+ else if (MArch.startswith_insensitive("rv32e"))
return "ilp32e";
else
return "ilp32";
- } else if (MArch.startswith_lower("rv64")) {
+ } else if (MArch.startswith_insensitive("rv64")) {
// FIXME: parse `March` to find `D` extension properly
- if (MArch.substr(4).contains_lower("d") || MArch.startswith_lower("rv64g"))
+ if (MArch.substr(4).contains_insensitive("d") ||
+ MArch.startswith_insensitive("rv64g"))
return "lp64d";
else
return "lp64";
if (const Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
StringRef MABI = A->getValue();
- if (MABI.equals_lower("ilp32e"))
+ if (MABI.equals_insensitive("ilp32e"))
return "rv32e";
- else if (MABI.startswith_lower("ilp32"))
+ else if (MABI.startswith_insensitive("ilp32"))
return "rv32imafdc";
- else if (MABI.startswith_lower("lp64"))
+ else if (MABI.startswith_insensitive("lp64"))
return "rv64imafdc";
}
D.Diag(diag::warn_drv_unsupported_sdata);
}
} else if (Args.getLastArgValue(options::OPT_mcmodel_EQ)
- .equals_lower("large") &&
+ .equals_insensitive("large") &&
(Triple.getArch() == llvm::Triple::riscv64)) {
// Not support linker relaxation for RV64 with large code model.
SmallDataLimit = "0";
// -finput_charset=UTF-8 is default. Reject others
if (Arg *inputCharset = Args.getLastArg(options::OPT_finput_charset_EQ)) {
StringRef value = inputCharset->getValue();
- if (!value.equals_lower("utf-8"))
+ if (!value.equals_insensitive("utf-8"))
D.Diag(diag::err_drv_invalid_value) << inputCharset->getAsString(Args)
<< value;
}
// -fexec_charset=UTF-8 is default. Reject others
if (Arg *execCharset = Args.getLastArg(options::OPT_fexec_charset_EQ)) {
StringRef value = execCharset->getValue();
- if (!value.equals_lower("utf-8"))
+ if (!value.equals_insensitive("utf-8"))
D.Diag(diag::err_drv_invalid_value) << execCharset->getAsString(Args)
<< value;
}
StringRef GuardArgs = A->getValue();
// The only valid options are "cf", "cf,nochecks", "cf-", "ehcont" and
// "ehcont-".
- if (GuardArgs.equals_lower("cf")) {
+ if (GuardArgs.equals_insensitive("cf")) {
// Emit CFG instrumentation and the table of address-taken functions.
CmdArgs.push_back("-cfguard");
- } else if (GuardArgs.equals_lower("cf,nochecks")) {
+ } else if (GuardArgs.equals_insensitive("cf,nochecks")) {
// Emit only the table of address-taken functions.
CmdArgs.push_back("-cfguard-no-checks");
- } else if (GuardArgs.equals_lower("ehcont")) {
+ } else if (GuardArgs.equals_insensitive("ehcont")) {
// Emit EH continuation table.
CmdArgs.push_back("-ehcontguard");
- } else if (GuardArgs.equals_lower("cf-") ||
- GuardArgs.equals_lower("ehcont-")) {
+ } else if (GuardArgs.equals_insensitive("cf-") ||
+ GuardArgs.equals_insensitive("ehcont-")) {
// Do nothing, but we might want to emit a security warning in future.
} else {
D.Diag(diag::err_drv_invalid_value) << A->getSpelling() << GuardArgs;
CmdArgs.push_back("now");
const char *Exec = Args.MakeArgString(ToolChain.GetLinkerPath());
- if (llvm::sys::path::filename(Exec).equals_lower("ld.lld") ||
- llvm::sys::path::stem(Exec).equals_lower("ld.lld")) {
+ if (llvm::sys::path::filename(Exec).equals_insensitive("ld.lld") ||
+ llvm::sys::path::stem(Exec).equals_insensitive("ld.lld")) {
CmdArgs.push_back("-z");
CmdArgs.push_back("rodynamic");
CmdArgs.push_back("-z");
ArgStringList &CmdArgs) {
if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
StringRef CPUArg(A->getValue());
- if (CPUArg.equals_lower("krait"))
+ if (CPUArg.equals_insensitive("krait"))
CmdArgs.push_back("-mcpu=cortex-a15");
- else if(CPUArg.equals_lower("kryo"))
+ else if (CPUArg.equals_insensitive("kryo"))
CmdArgs.push_back("-mcpu=cortex-a57");
else
Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
// Handle the unsupported values passed to mhvx-length.
if (Arg *A = Args.getLastArg(options::OPT_mhexagon_hvx_length_EQ)) {
StringRef Val = A->getValue();
- if (!Val.equals_lower("64b") && !Val.equals_lower("128b"))
+ if (!Val.equals_insensitive("64b") && !Val.equals_insensitive("128b"))
D.Diag(diag::err_drv_unsupported_option_argument)
<< A->getOption().getName() << Val;
}
bool IncDefLibs = !Args.hasArg(options::OPT_nodefaultlibs);
bool UseG0 = false;
const char *Exec = Args.MakeArgString(HTC.GetLinkerPath());
- bool UseLLD = (llvm::sys::path::filename(Exec).equals_lower("ld.lld") ||
- llvm::sys::path::stem(Exec).equals_lower("ld.lld"));
+ bool UseLLD = (llvm::sys::path::filename(Exec).equals_insensitive("ld.lld") ||
+ llvm::sys::path::stem(Exec).equals_insensitive("ld.lld"));
bool UseShared = IsShared && !IsStatic;
StringRef CpuVer = toolchains::HexagonToolChain::GetTargetCPUVersion(Args);
// whatever/VC/bin --> old toolchain, VC dir is toolchain dir.
llvm::StringRef TestPath = PathEntry;
- bool IsBin = llvm::sys::path::filename(TestPath).equals_lower("bin");
+ bool IsBin =
+ llvm::sys::path::filename(TestPath).equals_insensitive("bin");
if (!IsBin) {
// Strip any architecture subdir like "amd64".
TestPath = llvm::sys::path::parent_path(TestPath);
- IsBin = llvm::sys::path::filename(TestPath).equals_lower("bin");
+ IsBin = llvm::sys::path::filename(TestPath).equals_insensitive("bin");
}
if (IsBin) {
llvm::StringRef ParentPath = llvm::sys::path::parent_path(TestPath);
llvm::StringRef ParentFilename = llvm::sys::path::filename(ParentPath);
- if (ParentFilename.equals_lower("VC")) {
+ if (ParentFilename.equals_insensitive("VC")) {
Path = std::string(ParentPath);
VSLayout = MSVCToolChain::ToolsetLayout::OlderVS;
return true;
}
- if (ParentFilename.equals_lower("x86ret") ||
- ParentFilename.equals_lower("x86chk") ||
- ParentFilename.equals_lower("amd64ret") ||
- ParentFilename.equals_lower("amd64chk")) {
+ if (ParentFilename.equals_insensitive("x86ret") ||
+ ParentFilename.equals_insensitive("x86chk") ||
+ ParentFilename.equals_insensitive("amd64ret") ||
+ ParentFilename.equals_insensitive("amd64chk")) {
Path = std::string(ParentPath);
VSLayout = MSVCToolChain::ToolsetLayout::DevDivInternal;
return true;
for (llvm::StringRef Prefix : ExpectedPrefixes) {
if (It == End)
goto NotAToolChain;
- if (!It->startswith_lower(Prefix))
+ if (!It->startswith_insensitive(Prefix))
goto NotAToolChain;
++It;
}
// Control Flow Guard checks
if (Arg *A = Args.getLastArg(options::OPT__SLASH_guard)) {
StringRef GuardArgs = A->getValue();
- if (GuardArgs.equals_lower("cf") || GuardArgs.equals_lower("cf,nochecks")) {
+ if (GuardArgs.equals_insensitive("cf") ||
+ GuardArgs.equals_insensitive("cf,nochecks")) {
// MSVC doesn't yet support the "nochecks" modifier.
CmdArgs.push_back("-guard:cf");
- } else if (GuardArgs.equals_lower("cf-")) {
+ } else if (GuardArgs.equals_insensitive("cf-")) {
CmdArgs.push_back("-guard:cf-");
- } else if (GuardArgs.equals_lower("ehcont")) {
+ } else if (GuardArgs.equals_insensitive("ehcont")) {
CmdArgs.push_back("-guard:ehcont");
- } else if (GuardArgs.equals_lower("ehcont-")) {
+ } else if (GuardArgs.equals_insensitive("ehcont-")) {
CmdArgs.push_back("-guard:ehcont-");
}
}
= Args.getLastArgValue(options::OPT_fuse_ld_EQ, CLANG_DEFAULT_LINKER);
if (Linker.empty())
Linker = "link";
- if (Linker.equals_lower("lld"))
+ if (Linker.equals_insensitive("lld"))
Linker = "lld-link";
- if (Linker.equals_lower("link")) {
+ if (Linker.equals_insensitive("link")) {
// If we're using the MSVC linker, it's not sufficient to just use link
// from the program PATH, because other environments like GnuWin32 install
// their own link.exe which may come first.
// find it.
for (const char *Cursor = EnvBlock.data(); *Cursor != '\0';) {
llvm::StringRef EnvVar(Cursor);
- if (EnvVar.startswith_lower("path=")) {
+ if (EnvVar.startswith_insensitive("path=")) {
using SubDirectoryType = toolchains::MSVCToolChain::SubDirectoryType;
constexpr size_t PrefixLen = 5; // strlen("path=")
Environment.push_back(Args.MakeArgString(
NativeLLVMSupport =
Args.getLastArgValue(options::OPT_fuse_ld_EQ, CLANG_DEFAULT_LINKER)
- .equals_lower("lld");
+ .equals_insensitive("lld");
}
bool toolchains::MinGW::IsIntegratedAssemblerDefault() const { return true; }
bool getPredefinedStyle(StringRef Name, FormatStyle::LanguageKind Language,
FormatStyle *Style) {
- if (Name.equals_lower("llvm")) {
+ if (Name.equals_insensitive("llvm")) {
*Style = getLLVMStyle(Language);
- } else if (Name.equals_lower("chromium")) {
+ } else if (Name.equals_insensitive("chromium")) {
*Style = getChromiumStyle(Language);
- } else if (Name.equals_lower("mozilla")) {
+ } else if (Name.equals_insensitive("mozilla")) {
*Style = getMozillaStyle();
- } else if (Name.equals_lower("google")) {
+ } else if (Name.equals_insensitive("google")) {
*Style = getGoogleStyle(Language);
- } else if (Name.equals_lower("webkit")) {
+ } else if (Name.equals_insensitive("webkit")) {
*Style = getWebKitStyle();
- } else if (Name.equals_lower("gnu")) {
+ } else if (Name.equals_insensitive("gnu")) {
*Style = getGNUStyle();
- } else if (Name.equals_lower("microsoft")) {
+ } else if (Name.equals_insensitive("microsoft")) {
*Style = getMicrosoftStyle(Language);
- } else if (Name.equals_lower("none")) {
+ } else if (Name.equals_insensitive("none")) {
*Style = getNoStyle();
- } else if (Name.equals_lower("inheritparentconfig")) {
+ } else if (Name.equals_insensitive("inheritparentconfig")) {
Style->InheritsParentConfig = true;
} else {
return false;
static FormatStyle::LanguageKind getLanguageByFileName(StringRef FileName) {
if (FileName.endswith(".java"))
return FormatStyle::LK_Java;
- if (FileName.endswith_lower(".js") || FileName.endswith_lower(".mjs") ||
- FileName.endswith_lower(".ts"))
+ if (FileName.endswith_insensitive(".js") ||
+ FileName.endswith_insensitive(".mjs") ||
+ FileName.endswith_insensitive(".ts"))
return FormatStyle::LK_JavaScript; // (module) JavaScript or TypeScript.
if (FileName.endswith(".m") || FileName.endswith(".mm"))
return FormatStyle::LK_ObjC;
- if (FileName.endswith_lower(".proto") ||
- FileName.endswith_lower(".protodevel"))
+ if (FileName.endswith_insensitive(".proto") ||
+ FileName.endswith_insensitive(".protodevel"))
return FormatStyle::LK_Proto;
- if (FileName.endswith_lower(".textpb") ||
- FileName.endswith_lower(".pb.txt") ||
- FileName.endswith_lower(".textproto") ||
- FileName.endswith_lower(".asciipb"))
+ if (FileName.endswith_insensitive(".textpb") ||
+ FileName.endswith_insensitive(".pb.txt") ||
+ FileName.endswith_insensitive(".textproto") ||
+ FileName.endswith_insensitive(".asciipb"))
return FormatStyle::LK_TextProto;
- if (FileName.endswith_lower(".td"))
+ if (FileName.endswith_insensitive(".td"))
return FormatStyle::LK_TableGen;
- if (FileName.endswith_lower(".cs"))
+ if (FileName.endswith_insensitive(".cs"))
return FormatStyle::LK_CSharp;
return FormatStyle::LK_Cpp;
}
// If the style inherits the parent configuration it is a command line
// configuration, which wants to inherit, so we have to skip the check of the
// StyleName.
- if (!Style.InheritsParentConfig && !StyleName.equals_lower("file")) {
+ if (!Style.InheritsParentConfig && !StyleName.equals_insensitive("file")) {
if (!getPredefinedStyle(StyleName, Style.Language, &Style))
return make_string_error("Invalid value for -style");
if (!Style.InheritsParentConfig)
// Empty URLs sort *last* (for export {...};).
if (LHS.URL.empty() != RHS.URL.empty())
return LHS.URL.empty() < RHS.URL.empty();
- if (int Res = LHS.URL.compare_lower(RHS.URL))
+ if (int Res = LHS.URL.compare_insensitive(RHS.URL))
return Res < 0;
// '*' imports (with prefix) sort before {a, b, ...} imports.
if (LHS.Prefix.empty() != RHS.Prefix.empty())
SmallVector<JsImportedSymbol, 1> Symbols = Reference.Symbols;
llvm::stable_sort(
Symbols, [&](const JsImportedSymbol &LHS, const JsImportedSymbol &RHS) {
- return LHS.Symbol.compare_lower(RHS.Symbol) < 0;
+ return LHS.Symbol.compare_insensitive(RHS.Symbol) < 0;
});
if (!Reference.SymbolsMerged && Symbols == Reference.Symbols) {
// Symbols didn't change, just emit the entire module reference.
return -1;
// Two names within a group compare case-insensitively.
- return NamesA[I].compare_lower(NamesB[I]);
+ return NamesA[I].compare_insensitive(NamesB[I]);
}
// I is the last index of NamesB and NamesB[I] is a non-namespace name.
return 1;
// Two namespaces names within a group compare case-insensitively.
- int C = NamesA[I].compare_lower(NamesB[I]);
+ int C = NamesA[I].compare_insensitive(NamesB[I]);
if (C != 0)
return C;
}
if (Arg *A = Args.getLastArg(OPT_msign_return_address_EQ)) {
StringRef SignScope = A->getValue();
- if (SignScope.equals_lower("none"))
+ if (SignScope.equals_insensitive("none"))
Opts.setSignReturnAddressScope(
LangOptions::SignReturnAddressScopeKind::None);
- else if (SignScope.equals_lower("all"))
+ else if (SignScope.equals_insensitive("all"))
Opts.setSignReturnAddressScope(
LangOptions::SignReturnAddressScopeKind::All);
- else if (SignScope.equals_lower("non-leaf"))
+ else if (SignScope.equals_insensitive("non-leaf"))
Opts.setSignReturnAddressScope(
LangOptions::SignReturnAddressScopeKind::NonLeaf);
else
if (Arg *A = Args.getLastArg(OPT_msign_return_address_key_EQ)) {
StringRef SignKey = A->getValue();
if (!SignScope.empty() && !SignKey.empty()) {
- if (SignKey.equals_lower("a_key"))
+ if (SignKey.equals_insensitive("a_key"))
Opts.setSignReturnAddressKey(
LangOptions::SignReturnAddressKeyKind::AKey);
- else if (SignKey.equals_lower("b_key"))
+ else if (SignKey.equals_insensitive("b_key"))
Opts.setSignReturnAddressKey(
LangOptions::SignReturnAddressKeyKind::BKey);
else
Optional<StringRef> Key = getString(B.Key);
if (LLVM_UNLIKELY(!Key))
continue;
- if (!Filename.equals_lower(*Key))
+ if (!Filename.equals_insensitive(*Key))
continue;
// If so, we have a match in the hash table. Construct the destination
static bool warnByDefaultOnWrongCase(StringRef Include) {
// If the first component of the path is "boost", treat this like a standard header
// for the purposes of diagnostics.
- if (::llvm::sys::path::begin(Include)->equals_lower("boost"))
+ if (::llvm::sys::path::begin(Include)->equals_insensitive("boost"))
return true;
// "condition_variable" is the longest standard header name at 18 characters.
// If these path components differ by more than just case, then we
// may be looking at symlinked paths. Bail on this diagnostic to avoid
// noisy false positives.
- SuggestReplacement = RealPathComponentIter->equals_lower(Component);
+ SuggestReplacement =
+ RealPathComponentIter->equals_insensitive(Component);
if (!SuggestReplacement)
break;
Component = *RealPathComponentIter;
StringRef VendorName = TI.getTriple().getVendorName();
if (VendorName.empty())
VendorName = "unknown";
- return VendorName.equals_lower(II->getName());
+ return VendorName.equals_insensitive(II->getName());
}
/// Implements the __is_target_os builtin macro.
std::string XSaved, YSaved;
StringRef XStr = X.getOrderedName(XSaved);
StringRef YStr = Y.getOrderedName(YSaved);
- int cmp = XStr.compare_lower(YStr);
+ int cmp = XStr.compare_insensitive(YStr);
if (cmp)
return cmp < 0;
bool ValidString = true;
if (IsARMBuiltin) {
- ValidString &= Fields[0].startswith_lower("cp") ||
- Fields[0].startswith_lower("p");
+ ValidString &= Fields[0].startswith_insensitive("cp") ||
+ Fields[0].startswith_insensitive("p");
if (ValidString)
- Fields[0] =
- Fields[0].drop_front(Fields[0].startswith_lower("cp") ? 2 : 1);
+ Fields[0] = Fields[0].drop_front(
+ Fields[0].startswith_insensitive("cp") ? 2 : 1);
- ValidString &= Fields[2].startswith_lower("c");
+ ValidString &= Fields[2].startswith_insensitive("c");
if (ValidString)
Fields[2] = Fields[2].drop_front(1);
if (FiveFields) {
- ValidString &= Fields[3].startswith_lower("c");
+ ValidString &= Fields[3].startswith_insensitive("c");
if (ValidString)
Fields[3] = Fields[3].drop_front(1);
}
// Only files that really look like headers. (Except in system dirs).
if (!IsSystem) {
// Header extensions from Types.def, which we can't depend on here.
- if (!(Filename.endswith_lower(".h") ||
- Filename.endswith_lower(".hh") ||
- Filename.endswith_lower(".hpp") ||
- Filename.endswith_lower(".inc")))
+ if (!(Filename.endswith_insensitive(".h") ||
+ Filename.endswith_insensitive(".hh") ||
+ Filename.endswith_insensitive(".hpp") ||
+ Filename.endswith_insensitive(".inc")))
break;
}
AddCompletion(Filename, /*IsDirectory=*/false);
RightStrRef = RightStrRef.substr(0, s2Term);
// Use StringRef's comparison methods to compute the actual result.
- int compareRes = IgnoreCase ? LeftStrRef.compare_lower(RightStrRef)
+ int compareRes = IgnoreCase ? LeftStrRef.compare_insensitive(RightStrRef)
: LeftStrRef.compare(RightStrRef);
// The strcmp function returns an integer greater than, equal to, or less
const auto *IdInfo = Func->getIdentifier();
if (!IdInfo)
return false;
- return IdInfo->getName().endswith_lower("begin");
+ return IdInfo->getName().endswith_insensitive("begin");
}
bool isEndCall(const FunctionDecl *Func) {
const auto *IdInfo = Func->getIdentifier();
if (!IdInfo)
return false;
- return IdInfo->getName().endswith_lower("end");
+ return IdInfo->getName().endswith_insensitive("end");
}
const CXXRecordDecl *getCXXRecordDecl(ProgramStateRef State,
if (const auto *CD = dyn_cast<ObjCContainerDecl>(OD->getParent())) {
std::string ContainerName = CD->getNameAsString();
StringRef CN(ContainerName);
- if (CN.contains_lower("test") || CN.contains_lower("mock"))
+ if (CN.contains_insensitive("test") || CN.contains_insensitive("mock"))
return true;
}
}
return false;
const auto Name = CRD->getName();
- if (!(Name.endswith_lower("iterator") || Name.endswith_lower("iter") ||
- Name.endswith_lower("it")))
+ if (!(Name.endswith_insensitive("iterator") ||
+ Name.endswith_insensitive("iter") || Name.endswith_insensitive("it")))
return false;
bool HasCopyCtor = false, HasCopyAssign = true, HasDtor = false,
static bool isReferenceCountingPointerDestructor(const CXXDestructorDecl *DD) {
if (const IdentifierInfo *II = DD->getParent()->getIdentifier()) {
StringRef N = II->getName();
- if (N.contains_lower("ptr") || N.contains_lower("pointer")) {
- if (N.contains_lower("ref") || N.contains_lower("cnt") ||
- N.contains_lower("intrusive") || N.contains_lower("shared")) {
+ if (N.contains_insensitive("ptr") || N.contains_insensitive("pointer")) {
+ if (N.contains_insensitive("ref") || N.contains_insensitive("cnt") ||
+ N.contains_insensitive("intrusive") ||
+ N.contains_insensitive("shared")) {
return true;
}
}
// 1) foo.h => bar.cc
// 2) foo.proto.h => foo.cc
StringRef Matching;
- if (MatchingFileStem.startswith_lower(HeaderStem))
+ if (MatchingFileStem.startswith_insensitive(HeaderStem))
Matching = MatchingFileStem; // example 1), 2)
- else if (FileStem.equals_lower(HeaderStem))
+ else if (FileStem.equals_insensitive(HeaderStem))
Matching = FileStem; // example 3)
if (!Matching.empty()) {
llvm::Regex MainIncludeRegex(HeaderStem.str() + Style.IncludeIsMainRegex,
// Otherwise just check the clang executable file name.
return !CmdLine.empty() &&
- llvm::sys::path::stem(CmdLine.front()).endswith_lower("cl");
+ llvm::sys::path::stem(CmdLine.front()).endswith_insensitive("cl");
}
// Map the language from the --std flag to that of the -x flag.
// Try to detect mistyped 'range:' comments to ensure tests don't miss
// anything.
auto DetectMistypedCommand = [&]() -> bool {
- if (Comment.contains_lower("range") && Comment.contains("=") &&
- !Comment.contains_lower("run") && !Comment.contains("CHECK")) {
+ if (Comment.contains_insensitive("range") && Comment.contains("=") &&
+ !Comment.contains_insensitive("run") && !Comment.contains("CHECK")) {
llvm::errs() << "error: suspicious comment '" << Comment
<< "' that "
"resembles the range command found\n";
auto FlagsEnd = llvm::find(Args, "--");
if (FlagsEnd != Args.begin()) {
ClangCLMode =
- llvm::sys::path::stem(Args[0]).contains_lower("clang-cl") ||
+ llvm::sys::path::stem(Args[0]).contains_insensitive("clang-cl") ||
llvm::is_contained(Args, "--driver-mode=cl");
// Reverse scan, starting at the end or at the element before "--".
// If the clang binary happens to be named cl.exe for compatibility reasons,
// use clang-cl.exe as the prefix to avoid confusion between clang and MSVC.
StringRef ExeBasename(llvm::sys::path::stem(Path));
- if (ExeBasename.equals_lower("cl"))
+ if (ExeBasename.equals_insensitive("cl"))
ExeBasename = "clang-cl";
DiagClient->setPrefix(std::string(ExeBasename));
}
if (XText.empty() || YText.empty())
return !XText.empty();
- int result = XText.compare_lower(YText);
+ int result = XText.compare_insensitive(YText);
if (result < 0)
return true;
if (result > 0)
struct FakeComparator : public PathComparator {
~FakeComparator() override {}
bool equivalent(StringRef FileA, StringRef FileB) const override {
- return FileA.equals_lower(FileB);
+ return FileA.equals_insensitive(FileB);
}
};