Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://clang.llvm.org/doxygen/HeaderSearch_8cpp_source.html below:

clang: lib/Lex/HeaderSearch.cpp Source File

;

NumMultiIncludeFileOptzn,

);

);

(ControllingMacro && ControllingMacro->

()) {

assert(

&&

);

->updateOutOfDateIdentifier(*ControllingMacro);

ControllingMacro;

: HSOpts(

::move(HSOpts)), Diags(Diags),

FileMgr(SourceMgr.getFileManager()), FrameworkMap(64),

ModMap(SourceMgr, Diags, LangOpts,

, *this) {}

llvm::errs() <<

<< FileInfo.size() <<

;

NumOnceOnlyFiles = 0;

(

i = 0, e = FileInfo.size(); i != e; ++i)

NumOnceOnlyFiles += (FileInfo[i].isPragmaOnce || FileInfo[i].isImport);

llvm::errs() <<

<< NumOnceOnlyFiles <<

;

llvm::errs() <<

<< NumIncluded <<

<<

<< NumMultiIncludeFileOptzn

<<

;

llvm::errs() << NumFrameworkLookups <<

<< NumSubFrameworkLookups <<

;

std::vector<DirectoryLookup> dirs,

angledDirIdx,

systemDirIdx,

llvm::DenseMap<unsigned int, unsigned int> searchDirToHSEntry) {

assert(angledDirIdx <= systemDirIdx && systemDirIdx <= dirs.size() &&

);

SearchDirs = std::move(dirs);

SearchDirsUsage.assign(SearchDirs.size(),

);

AngledDirIdx = angledDirIdx;

SystemDirIdx = systemDirIdx;

SearchDirToHSEntry = std::move(searchDirToHSEntry);

indexInitialHeaderMaps();

idx = isAngled ? SystemDirIdx : AngledDirIdx;

SearchDirs.insert(SearchDirs.begin() + idx, dir);

SearchDirsUsage.insert(SearchDirsUsage.begin() + idx,

);

std::vector<bool> UserEntryUsage(HSOpts->UserEntries.size());

(

I = 0,

= SearchDirsUsage.size(); I <

; ++I) {

(SearchDirsUsage[I]) {

UserEntryIdxIt = SearchDirToHSEntry.find(I);

(UserEntryIdxIt != SearchDirToHSEntry.end())

UserEntryUsage[UserEntryIdxIt->second] =

;

UserEntryUsage;

std::vector<bool> VFSUsage;

RootFS.visit([&](llvm::vfs::FileSystem &FS) {

(

*RFS = dyn_cast<llvm::vfs::RedirectingFileSystem>(&FS)) {

VFSUsage.push_back(RFS->hasBeenUsed());

RFS->clearHasBeenUsed();

);

std::reverse(VFSUsage.begin(), VFSUsage.end());

(!HeaderMaps.empty()) {

(

i = 0, e = HeaderMaps.size(); i != e; ++i)

(HeaderMaps[i].first == FE)

HeaderMaps[i].second.get();

HeaderMaps.emplace_back(FE, std::move(HM));

HeaderMaps.back().second.get();

(

&HM : HeaderMaps)

Names.push_back(std::string(HM.first.getName()));

i(HSOpts->PrebuiltModuleFiles.find(ModuleName));

(i != HSOpts->PrebuiltModuleFiles.end())

(FileMapOnly || HSOpts->PrebuiltModulePaths.empty())

(

std::string &Dir : HSOpts->PrebuiltModulePaths) {

llvm::sys::fs::make_absolute(

);

(ModuleName.contains(

))

llvm::sys::path::append(

, ModuleName.split(

).first +

+

ModuleName.split(

).second +

llvm::sys::path::append(

, ModuleName +

);

std::string(

);

StringRef ModuleMapPath =

->getName();

StringRef ModuleCacheHash = HSOpts->DisableModuleHash ?

:

();

(

std::string &Dir : HSOpts->PrebuiltModulePaths) {

llvm::sys::fs::make_absolute(CachePath);

llvm::sys::path::append(CachePath, ModuleCacheHash);

getCachedModuleFileNameImpl(ModuleName, ModuleMapPath, CachePath);

StringRef ModuleMapPath) {

getCachedModuleFileNameImpl(ModuleName, ModuleMapPath,

std::string HeaderSearch::getCachedModuleFileNameImpl(StringRef ModuleName,

StringRef ModuleMapPath,

StringRef CachePath) {

(CachePath.empty())

(HSOpts->DisableModuleHash) {

llvm::sys::path::append(

, ModuleName +

);

(

().canonicalizeModuleMapPath(CanonicalPath))

Hash = llvm::xxh3_64bits(CanonicalPath.str().lower());

llvm::APInt(64, Hash).toStringUnsigned(HashStr,

36);

llvm::sys::path::append(

, ModuleName +

+ HashStr +

);

.str().str();

AllowExtraModuleMapSearch) {

(

|| !AllowSearch || !HSOpts->ImplicitModuleMaps)

StringRef SearchName = ModuleName;

AllowExtraModuleMapSearch);

(!

&& SearchName.consume_back(

))

AllowExtraModuleMapSearch);

(!

&& SearchName.consume_back(

))

AllowExtraModuleMapSearch);

AllowExtraModuleMapSearch) {

(Dir.isFramework()) {

FrameworkDirName += Dir.getFrameworkDirRef()->getName();

llvm::sys::path::append(FrameworkDirName, SearchName +

);

(

FrameworkDir =

= loadFrameworkModule(ModuleName, *FrameworkDir, IsSystem);

(!Dir.isNormalDir())

IsSystem = Dir.isSystemHeaderDirectory();

) == LMM_NewlyLoaded) {

NestedModuleMapDirName = Dir.getDirRef()->getName();

llvm::sys::path::append(NestedModuleMapDirName, ModuleName);

) == LMM_NewlyLoaded){

(HSOpts->AllowModuleMapSubdirectorySearch) {

(Dir.haveSearchedAllModuleMaps())

(AllowExtraModuleMapSearch)

loadSubdirectoryModuleMaps(Dir);

HeaderSearch::indexInitialHeaderMaps() {

llvm::StringMap<unsigned, llvm::BumpPtrAllocator> Index(SearchDirs.size());

(

i = 0; i != SearchDirs.size(); ++i) {

&Dir = SearchDirs[i];

(!Dir.isHeaderMap()) {

SearchDirHeaderMapIndex = std::move(Index);

FirstNonHeaderMapSearchDirIdx = i;

Callback = [&](StringRef

) {

Index.try_emplace(

.lower(), i);

Dir.getHeaderMap()->forEachKey(Callback);

assert(

() &&

);

IsSystemHeaderDir,

*RequestingModule,

CacheFailures

) {

std::error_code EC = llvm::errorToErrorCode(

.takeError());

(EC != llvm::errc::no_such_file_or_directory &&

EC != llvm::errc::invalid_argument &&

EC != llvm::errc::is_a_directory && EC != llvm::errc::not_a_directory) {

Diags.

(IncludeLoc, diag::err_cannot_open_file)

(!findUsableModuleForHeader(

*

, Dir ? Dir :

->getFileEntry().getDir(), RequestingModule,

SuggestedModule, IsSystemHeaderDir))

&InUserSpecifiedSystemFramework,

&IsFrameworkFound,

OpenFile)

{

InUserSpecifiedSystemFramework =

;

IsInHeaderMap =

;

llvm::sys::path::append(TmpDir,

);

SearchPath->append(SearchPathRef.begin(), SearchPathRef.end());

RelativePath->clear();

HS.getFileAndSuggestModule(

RequestingModule, SuggestedModule, OpenFile);

DoFrameworkLookup(

, HS, SearchPath, RelativePath,

RequestingModule, SuggestedModule,

InUserSpecifiedSystemFramework, IsFrameworkFound);

assert(

() &&

);

IsInHeaderMap =

;

FixupSearchPathAndFindUsableModule =

StringRef SearchPathRef(

());

SearchPath->append(SearchPathRef.begin(), SearchPathRef.end());

RelativePath->clear();

(!HS.findUsableModuleForHeader(

,

.getFileEntry().getDir(),

RequestingModule, SuggestedModule,

(llvm::sys::path::is_relative(Dest)) {

MappedName.append(Dest.begin(), Dest.end());

= StringRef(MappedName.begin(), MappedName.size());

FixupSearchPathAndFindUsableModule(*Res);

HS.noteLookupUsage(HS.

(*

), IncludeLoc);

assert(llvm::sys::path::extension(DirName) ==

&&

);

DirName = llvm::sys::path::parent_path(DirName);

(llvm::sys::path::extension(DirName) ==

) {

SubmodulePath.push_back(std::string(llvm::sys::path::stem(DirName)));

TopFrameworkDir = *Dir;

TopFrameworkDir;

HasSuggestedModule) {

HasSuggestedModule ||

&InUserSpecifiedSystemFramework,

&IsFrameworkFound)

{

SlashPos =

.find(

);

(SlashPos == StringRef::npos)

(FrameworkName.empty() || FrameworkName.back() !=

)

FrameworkName.push_back(

);

StringRef ModuleName(

.begin(), SlashPos);

FrameworkName += ModuleName;

FrameworkName +=

;

++NumFrameworkLookups;

SystemFrameworkMarker +=

;

(llvm::sys::fs::exists(SystemFrameworkMarker)) {

RelativePath->clear();

OrigSize = FrameworkName.size();

FrameworkName +=

;

SearchPath->append(FrameworkName.begin(), FrameworkName.end()-1);

*

=

;

FrameworkName.insert(FrameworkName.begin()+OrigSize,

,

SearchPath->insert(SearchPath->begin()+OrigSize,

,

StringRef FrameworkPath =

->getDir().getName();

FoundFramework =

;

(llvm::sys::path::extension(FrameworkPath) ==

) {

FoundFramework =

;

FrameworkPath = llvm::sys::path::parent_path(FrameworkPath);

(FrameworkPath.empty())

(FoundFramework) {

(!HS.findUsableModuleForFrameworkHeader(*

, FrameworkPath,

SuggestedModule, IsSystem))

(!HS.findUsableModuleForHeader(*

,

(), RequestingModule,

SuggestedModule, IsSystem))

HeaderSearch::cacheLookupSuccess(LookupFileCacheInfo &CacheLookup,

CacheLookup.HitIt = HitIt;

noteLookupUsage(HitIt.Idx,

);

SearchDirsUsage[HitIdx] =

;

UserEntryIdxIt = SearchDirToHSEntry.find(HitIdx);

(UserEntryIdxIt != SearchDirToHSEntry.end())

Diags.

(

, diag::remark_pp_search_path_usage)

<< HSOpts->UserEntries[UserEntryIdxIt->second].Path;

(MSFE && FE != *MSFE) {

Diags.

(IncludeLoc, diag::ext_pp_include_search_ms) << MSFE->

();

*

(StringRef Str, llvm::BumpPtrAllocator &Alloc) {

assert(!Str.empty());

*CopyStr = Alloc.Allocate<

>(Str.size()+1);

std::copy(Str.begin(), Str.end(), CopyStr);

CopyStr[Str.size()] =

;

llvm::sys;

path::const_iterator I = path::begin(

);

path::const_iterator

= path::end(

);

IsPrivateHeader =

;

(*I ==

) {

}

(*I ==

) {

IsPrivateHeader =

;

}

(I->ends_with(

)) {

StringRef Name = I->drop_back(10);

FrameworkName.clear();

FrameworkName.append(Name.begin(), Name.end());

IncludeSpelling.clear();

IncludeSpelling.append(Name.begin(), Name.end());

}

(FoundComp >= 2) {

IncludeSpelling.push_back(

);

IncludeSpelling.append(I->begin(), I->end());

!FrameworkName.empty() && FoundComp >= 2;

StringRef Includer, StringRef IncludeFilename,

FoundByHeaderMap =

) {

IsIncluderPrivateHeader =

;

FromIncludeSpelling))

IsIncludeePrivateHeader =

;

IsIncludeeInFramework =

ToFramework, ToIncludeSpelling);

(!isAngled && !FoundByHeaderMap) {

(IsIncludeeInFramework) {

NewInclude += ToIncludeSpelling;

NewInclude += IncludeFilename;

Diags.

(IncludeLoc, diag::warn_quoted_include_in_framework_header)

(!IsIncluderPrivateHeader && IsIncludeeInFramework &&

IsIncludeePrivateHeader && FromFramework == ToFramework)

Diags.

(IncludeLoc, diag::warn_framework_include_private_from_public)

<std::pair<OptionalFileEntryRef, DirectoryEntryRef>> Includers,

*IsMapped,

*IsFrameworkFound,

SkipCache,

BuildSystemModule,

OpenFile,

CacheFailures) {

(IsFrameworkFound)

*IsFrameworkFound =

;

(llvm::sys::path::is_absolute(

)) {

RelativePath->clear();

getFileAndSuggestModule(

, IncludeLoc,

,

RequestingModule, SuggestedModule, OpenFile,

(!Includers.empty() && !isAngled) {

(

&IncluderAndDir : Includers) {

TmpDir = IncluderAndDir.second.getName();

llvm::sys::path::append(TmpDir,

);

IncluderIsSystemHeader = [&]() {

BuildSystemModule;

assert(HFI &&

);

TmpDir, IncludeLoc, IncluderAndDir.second, IncluderIsSystemHeader,

RequestingModule, SuggestedModule)) {

assert(

&&

);

assert(FromHFI &&

);

DirInfo = FromHFI->

;

StringRef SearchPathRef(IncluderAndDir.second.getName());

SearchPath->append(SearchPathRef.begin(), SearchPathRef.end());

RelativePath->clear();

IncluderAndDir.second.getName(),

,

(Diags.

(diag::ext_pp_include_search_ms, IncludeLoc)) {

(SuggestedModule) {

MSSuggestedModule = *SuggestedModule;

LookupFileCacheInfo &CacheLookup = LookupFileCache[

];

(CacheLookup.StartIt == NextIt &&

CacheLookup.RequestingModule == RequestingModule) {

(CacheLookup.HitIt)

It = CacheLookup.HitIt;

(CacheLookup.MappedName) {

CacheLookup.reset(RequestingModule,

NextIt);

= SearchDirHeaderMapIndex.find(

.lower());

(

== SearchDirHeaderMapIndex.end())

CacheLookup.reset(RequestingModule,

NextIt);

InUserSpecifiedSystemFramework =

;

IsInHeaderMap =

;

IsFrameworkFoundInDir =

;

, *

, IncludeLoc, SearchPath, RelativePath, RequestingModule,

SuggestedModule, InUserSpecifiedSystemFramework, IsFrameworkFoundInDir,

IsInHeaderMap, MappedName, OpenFile);

(!MappedName.empty()) {

assert(IsInHeaderMap &&

);

CacheLookup.MappedName =

(MappedName, LookupFileCache.getAllocator());

*IsMapped |= (!MappedName.empty() || (IsInHeaderMap &&

));

(IsFrameworkFound)

*IsFrameworkFound |= (IsFrameworkFoundInDir && !CacheLookup.MappedName);

HFI.

= CurDir->getDirCharacteristic();

(

j = SystemHeaderPrefixes.size(); j; --j) {

(

.starts_with(SystemHeaderPrefixes[j - 1].first)) {

(SuggestedModule)

*SuggestedModule = MSSuggestedModule;

FoundByHeaderMap = !IsMapped ?

: *IsMapped;

(!Includers.empty())

Includers.front().second.getName(),

,

*

, isAngled, FoundByHeaderMap);

cacheLookupSuccess(CacheLookup, It, IncludeLoc);

(SuggestedModule)

*SuggestedModule = MSSuggestedModule;

std::nullopt;

SlashPos =

.find(

);

(SlashPos == StringRef::npos)

std::nullopt;

StringRef ContextName = ContextFileEnt.

();

DotFrameworkLen = 10;

FrameworkPos = ContextName.find(

);

(FrameworkPos == StringRef::npos ||

(ContextName[FrameworkPos + DotFrameworkLen] !=

&&

ContextName[FrameworkPos + DotFrameworkLen] !=

))

std::nullopt;

DotFrameworkLen + 1);

FrameworkName +=

;

FrameworkName +=

;

*FrameworkMap.insert(std::make_pair(

.substr(0, SlashPos),

(CacheLookup.second.Directory &&

CacheLookup.first().size() == FrameworkName.size() &&

memcmp(CacheLookup.first().data(), &FrameworkName[0],

CacheLookup.first().size()) != 0)

std::nullopt;

(!CacheLookup.second.Directory) {

++NumSubFrameworkLookups;

std::nullopt;

CacheLookup.second.Directory = Dir;

RelativePath->clear();

HeadersFilename +=

;

SearchPath->clear();

SearchPath->append(HeadersFilename.begin(), HeadersFilename.end()-1);

HeadersFilename = FrameworkName;

HeadersFilename +=

;

SearchPath->clear();

SearchPath->append(HeadersFilename.begin(), HeadersFilename.end()-1);

std::nullopt;

assert(ContextHFI &&

);

DirInfo = ContextHFI->

;

FrameworkName.pop_back();

(!findUsableModuleForFrameworkHeader(*

, FrameworkName,

RequestingModule, SuggestedModule,

std::nullopt;

isModuleHeader,

isTextualModuleHeader) {

assert(OtherHFI.

&&

);

(FE.

() >= FileInfo.size())

FileInfo.resize(FE.

() + 1);

(ExternalHFI.IsValid) {

(ExternalHFI.External)

(FE.

() >= FileInfo.size())

FileInfo.resize(FE.

() + 1);

HFI = &FileInfo[FE.

()];

(ExternalHFI.IsValid) {

(ExternalHFI.External)

}

(FE.

() < FileInfo.size()) {

HFI = &FileInfo[FE.

()];

(HFI && HFI->

) ? HFI :

;

(FE.

() < FileInfo.size()) {

HFI = &FileInfo[FE.

()];

HFI->isPragmaOnce || HFI->LazyControllingMacro.isValid();

isCompilingModuleHeader) {

(!isCompilingModuleHeader) {

HFI.mergeModuleMembership(Role);

HFI.isCompilingModuleHeader |= isCompilingModuleHeader;

ModulesEnabled,

*M,

&IsFirstIncludeOfFile) {

IsFirstIncludeOfFile =

;

MaybeReenterImportedFile = [&]() ->

{

(FileInfo.

&& !MaybeReenterImportedFile()))

++NumMultiIncludeFileOptzn;

SearchDirs.capacity()

+ llvm::capacity_in_bytes(FileInfo)

+ llvm::capacity_in_bytes(HeaderMaps)

+ LookupFileCache.getAllocator().getTotalMemory()

+ FrameworkMap.getAllocator().getTotalMemory();

&DL - &*SearchDirs.begin();

FrameworkNames.insert(Framework).first->first();

It = IncludeNames.find(

);

(It == IncludeNames.end())

(!HSOpts->ImplicitModuleMaps)

DirName = llvm::sys::path::parent_path(DirName);

(DirName.empty())

llvm::sys::path::extension(Dir->getName()) ==

LMM_NewlyLoaded:

LMM_AlreadyLoaded:

(

I = 0, N = FixUpDirectories.size(); I != N; ++I)

DirectoryHasModuleMap[FixUpDirectories[I]] =

;

LMM_NoDirectory:

LMM_InvalidModuleMap:

FixUpDirectories.push_back(*Dir);

AllowExcluded)

{

*RequestingModule,

(SuggestedModule)

(SuggestedModule)

HeaderSearch::findUsableModuleForHeader(

HeaderSearch::findUsableModuleForFrameworkHeader(

assert(TopFrameworkDir &&

);

StringRef ModuleName = llvm::sys::path::stem(TopFrameworkDir->

());

loadFrameworkModule(ModuleName, *TopFrameworkDir, IsSystemFramework);

StringRef

= llvm::sys::path::filename(

.getName());

llvm::sys::path::append(PrivateFilename,

);

(

==

)

llvm::sys::path::append(PrivateFilename,

);

std::nullopt;

Diags.

(diag::warn_deprecated_module_dot_map)

<< PrivateFilename << 1

<<

.getDir().getName().ends_with(

);

ID,

*Offset,

StringRef OriginalModuleMapFile) {

(!OriginalModuleMapFile.empty()) {

llvm::sys::path::parent_path(OriginalModuleMapFile));

Dir = FakeFile.getDir();

Dir =

.getDir();

assert(Dir &&

);

StringRef DirName(Dir->

());

(llvm::sys::path::filename(DirName) ==

) {

DirName = llvm::sys::path::parent_path(DirName);

(DirName.ends_with(

))

assert(Dir &&

);

assert(Dir &&

);

(loadModuleMapFileImpl(

, IsSystem, *Dir, ID, Offset)) {

LMM_AlreadyLoaded:

LMM_NewlyLoaded:

LMM_NoDirectory:

LMM_InvalidModuleMap:

llvm_unreachable(

);

HeaderSearch::LoadModuleMapResult

AddResult = LoadedModuleMaps.insert(std::make_pair(

,

));

(!AddResult.second)

AddResult.first->second ? LMM_AlreadyLoaded : LMM_InvalidModuleMap;

LoadedModuleMaps[

] =

;

LMM_InvalidModuleMap;

LoadedModuleMaps[

] =

;

LMM_InvalidModuleMap;

LMM_NewlyLoaded;

(!HSOpts->ImplicitModuleMaps)

std::nullopt;

llvm::sys::path::append(ModuleMapFileName,

);

llvm::sys::path::append(ModuleMapFileName,

);

ModuleMapFileName = Dir.

();

llvm::sys::path::append(ModuleMapFileName,

);

Diags.

(diag::warn_deprecated_module_dot_map)

<< ModuleMapFileName << 0 << IsFramework;

ModuleMapFileName = Dir.

();

llvm::sys::path::append(ModuleMapFileName,

,

);

std::nullopt;

LMM_InvalidModuleMap:

(HSOpts->ImplicitModuleMaps)

ModMap.inferFrameworkModule(Dir, IsSystem,

);

LMM_NoDirectory:

LMM_AlreadyLoaded:

LMM_NewlyLoaded:

HeaderSearch::LoadModuleMapResult

LMM_NoDirectory;

HeaderSearch::LoadModuleMapResult

KnownDir = DirectoryHasModuleMap.find(Dir);

(KnownDir != DirectoryHasModuleMap.end())

KnownDir->second ? LMM_AlreadyLoaded : LMM_InvalidModuleMap;

LoadModuleMapResult

=

loadModuleMapFileImpl(*ModuleMapFile, IsSystem, Dir);

(

== LMM_NewlyLoaded)

DirectoryHasModuleMap[Dir] =

;

(

== LMM_InvalidModuleMap)

DirectoryHasModuleMap[Dir] =

;

LMM_InvalidModuleMap;

(HSOpts->ImplicitModuleMaps) {

IsSystem = DL.isSystemHeaderDirectory();

(DL.isFramework()) {

llvm::sys::path::native(DL.getFrameworkDirRef()->getName(), DirNative);

(llvm::vfs::directory_iterator Dir = FS.dir_begin(DirNative, EC),

Dir != DirEnd && !EC; Dir.increment(EC)) {

(llvm::sys::path::extension(Dir->path()) !=

)

loadFrameworkModule(llvm::sys::path::stem(Dir->path()), *FrameworkDir,

(DL.isHeaderMap())

loadSubdirectoryModuleMaps(DL);

llvm::transform(ModMap.

(), std::back_inserter(Modules),

[](

&NameAndMod) { return NameAndMod.second; });

(!HSOpts->ImplicitModuleMaps)

(!DL.isNormalDir())

HeaderSearch::loadSubdirectoryModuleMaps(

&SearchDir) {

assert(HSOpts->ImplicitModuleMaps &&

);

llvm::sys::path::native(Dir, DirNative);

(llvm::vfs::directory_iterator Dir = FS.dir_begin(DirNative, EC), DirEnd;

Dir != DirEnd && !EC; Dir.increment(EC)) {

(Dir->type() == llvm::sys::fs::file_type::regular_file)

IsFramework = llvm::sys::path::extension(Dir->path()) ==

;

MainFile, IsAngled);

llvm::StringRef

, llvm::StringRef WorkingDir, llvm::StringRef MainFile,

*IsAngled)

{

llvm::sys;

(!WorkingDir.empty() && !path::is_absolute(FilePath))

fs::make_absolute(WorkingDir, FilePath);

path::remove_dots(FilePath,

);

path::native(FilePath, path::Style::posix);

BestPrefixLength = 0;

(!WorkingDir.empty() && !path::is_absolute(Dir))

fs::make_absolute(WorkingDir, Dir);

path::remove_dots(Dir,

);

(

NI = path::begin(

), NE = path::end(

),

DI = path::begin(Dir), DE = path::end(Dir);

NI != NE; ++NI, ++DI) {

PrefixLength = NI - path::begin(

);

(PrefixLength > BestPrefixLength) {

BestPrefixLength = PrefixLength;

(NI->size() == 1 && DI->size() == 1 &&

path::is_separator(NI->front()) && path::is_separator(DI->front()))

(NI->ends_with(

) && DI->ends_with(

)) {

StringRef NBasename = path::stem(*NI);

StringRef DBasename = path::stem(*DI);

(DBasename.starts_with(NBasename))

BestPrefixIsFramework =

;

(DL.isNormalDir()) {

StringRef Dir = DL.getDirRef()->getName();

(CheckDir(Dir)) {

*IsAngled = BestPrefixLength && isSystem(DL.getDirCharacteristic());

BestPrefixIsFramework =

;

}

(DL.isFramework()) {

StringRef Dir = DL.getFrameworkDirRef()->getName();

(CheckDir(Dir)) {

*IsAngled = BestPrefixLength;

BestPrefixIsFramework =

;

(!BestPrefixLength && CheckDir(path::parent_path(MainFile))) {

BestPrefixIsFramework =

;

StringRef

=

.drop_front(BestPrefixLength);

(!DL.isHeaderMap())

StringRef SpelledFilename =

DL.getHeaderMap()->reverseLookupFilename(

);

(!SpelledFilename.empty()) {

BestPrefixIsFramework =

;

IsPrivateHeader;

(BestPrefixIsFramework &&

path::convert_to_slash(

);

Defines the Diagnostic-related interfaces.

Defines the clang::FileManager interface and associated types.

Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.

llvm::MachO::Target Target

Defines the clang::Module class, which describes a module in the source code.

Defines the clang::Preprocessor interface.

Defines the SourceManager interface.

constexpr bool has_value() const

Concrete class used by the front-end to report problems and issues.

DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)

Issue the message to the client.

bool isIgnored(unsigned DiagID, SourceLocation Loc) const

Determine whether the diagnostic is known to be ignored.

A reference to a DirectoryEntry that includes the name of the directory as it was accessed by the Fil...

StringRef getName() const

Cached information about one directory (either on disk or in the virtual file system).

DirectoryLookup - This class represents one entry in the search list that specifies the search order ...

SrcMgr::CharacteristicKind getDirCharacteristic() const

DirCharacteristic - The type of directory this is, one of the DirType enum values.

OptionalFileEntryRef LookupFile(StringRef &Filename, HeaderSearch &HS, SourceLocation IncludeLoc, SmallVectorImpl< char > *SearchPath, SmallVectorImpl< char > *RelativePath, Module *RequestingModule, ModuleMap::KnownHeader *SuggestedModule, bool &InUserSpecifiedSystemFramework, bool &IsFrameworkFound, bool &IsInHeaderMap, SmallVectorImpl< char > &MappedName, bool OpenFile=true) const

LookupFile - Lookup the specified file in this search path, returning it if it exists or returning nu...

bool isFramework() const

isFramework - True if this is a framework directory.

bool isSystemHeaderDirectory() const

Whether this describes a system header directory.

OptionalDirectoryEntryRef getFrameworkDirRef() const

void setSearchedAllModuleMaps(bool SAMM)

Specify whether we have already searched all of the subdirectories for module maps.

bool isHeaderMap() const

isHeaderMap - Return true if this is a header map, not a normal directory.

StringRef getName() const

getName - Return the directory or filename corresponding to this lookup object.

OptionalDirectoryEntryRef getDirRef() const

bool haveSearchedAllModuleMaps() const

Determine whether we have already searched this entire directory for module maps.

const DirectoryEntry * getDir() const

getDir - Return the directory that this entry refers to.

bool isNormalDir() const

isNormalDir - Return true if this is a normal directory, not a header map.

const HeaderMap * getHeaderMap() const

getHeaderMap - Return the directory that this entry refers to.

Abstract interface for external sources of preprocessor information.

A reference to a FileEntry that includes the name of the file as it was accessed by the FileManager's...

StringRef getName() const

The name of this FileEntry.

Cached information about one file (either on disk or in the virtual file system).

An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...

Implements support for file system lookup, file system caching, and directory search management.

llvm::vfs::FileSystem & getVirtualFileSystem() const

OptionalFileEntryRef getOptionalFileRef(StringRef Filename, bool OpenFile=false, bool CacheFailure=true)

Get a FileEntryRef if it exists, without doing anything on error.

StringRef getCanonicalName(DirectoryEntryRef Dir)

Retrieve the canonical name for a given directory.

bool makeAbsolutePath(SmallVectorImpl< char > &Path) const

Makes Path absolute taking into account FileSystemOptions and the working directory option.

FileEntryRef getVirtualFileRef(StringRef Filename, off_t Size, time_t ModificationTime)

Retrieve a file entry for a "virtual" file that acts as if there were a file with the given name on d...

OptionalDirectoryEntryRef getOptionalDirectoryRef(StringRef DirName, bool CacheFailure=true)

Get a DirectoryEntryRef if it exists, without doing anything on error.

LLVM_DEPRECATED("Functions returning DirectoryEntry are deprecated.", "getOptionalDirectoryRef()") llvm LLVM_DEPRECATED("Functions returning FileEntry are deprecated.", "getOptionalFileRef()") llvm llvm::Expected< FileEntryRef > getFileRef(StringRef Filename, bool OpenFile=false, bool CacheFailure=true, bool IsText=true)

Lookup, cache, and verify the specified directory (real or virtual).

static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)

Create a code modification hint that replaces the given source range with the given code string.

One of these records is kept for each identifier that is lexed.

bool isOutOfDate() const

Determine whether the information for this identifier is out of date with respect to the external sou...

Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...

bool isValid() const

Whether this pointer is non-NULL.

IdentifierInfo * getPtr() const

bool isID() const

Whether this pointer is currently stored as ID.

Module * findModule(StringRef Name) const

Retrieve a module with the given name.

KnownHeader findModuleForHeader(FileEntryRef File, bool AllowTextual=false, bool AllowExcluded=false)

Retrieve the module that owns the given header file, if any.

static bool isModular(ModuleHeaderRole Role)

Check if the header with the given role is a modular one.

void resolveHeaderDirectives(const FileEntry *File) const

Resolve all lazy header directives for the specified file.

ArrayRef< KnownHeader > findResolvedModulesForHeader(FileEntryRef File) const

Like findAllModulesForHeader, but do not attempt to infer module ownership from umbrella headers if w...

OptionalFileEntryRef getModuleMapFileForUniquing(const Module *M) const

bool isBuiltinHeader(FileEntryRef File)

Is this a compiler builtin header?

bool parseModuleMapFile(FileEntryRef File, bool IsSystem, DirectoryEntryRef HomeDir, FileID ID=FileID(), unsigned *Offset=nullptr, SourceLocation ExternModuleLoc=SourceLocation())

Parse the given module map file, and record any modules we encounter.

void setTarget(const TargetInfo &Target)

Set the target information.

ModuleHeaderRole

Flags describing the role of a module header.

@ ExcludedHeader

This header is explicitly excluded from the module.

@ TextualHeader

This header is part of the module (for layering purposes) but should be textually included.

ArrayRef< KnownHeader > findAllModulesForHeader(FileEntryRef File)

Retrieve all the modules that contain the given header file.

llvm::iterator_range< module_iterator > modules() const

bool resolveUses(Module *Mod, bool Complain)

Resolve all of the unresolved uses in the given module.

Describes a module or submodule.

bool directlyUses(const Module *Requested)

Determine whether this module has declared its intention to directly use another module.

std::string Name

The name of this module.

unsigned NoUndeclaredIncludes

Whether files in this module can only include non-modular headers and headers from used modules.

Engages in a tight little dance with the lexer to efficiently preprocess tokens.

bool markIncluded(FileEntryRef File)

Mark the file as included.

bool isMacroDefinedInLocalModule(const IdentifierInfo *II, Module *M)

Determine whether II is defined as a macro within the module M, if that is a module that we've alread...

bool isMacroDefined(StringRef Id)

bool alreadyIncluded(FileEntryRef File) const

Return true if this header has already been included.

Encodes a location in the source.

This class handles loading and caching of source files into memory.

Exposes information about the current target.

The JSON file list parser is used to communicate input to InstallAPI.

@ Private

'private' clause, allowed on 'parallel', 'serial', 'loop', 'parallel loop', and 'serial loop' constru...

@ External

External linkage, which indicates that the entity can be referred to from other translation units.

@ Result

The result type of a method or function.

This structure is used to record entries in our framework cache.

bool IsUserSpecifiedSystemFramework

Whether this framework has been "user-specified" to be treated as if it were a system framework (even...

OptionalDirectoryEntryRef Directory

The directory entry which should be used for the cached framework.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4