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

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

clang: lib/Lex/ModuleMap.cpp Source File

;

ModuleMapCallbacks::anchor() {}

PendingLinkAs = PendingLinkAsModule.find(Mod->

);

(PendingLinkAs != PendingLinkAsModule.end()) {

(

&Name : PendingLinkAs->second) {

M->UseExportAsModuleLinkName =

;

((

)Role) {

llvm_unreachable(

);

((

)Kind) {

llvm_unreachable(

);

ModuleMap::resolveExport(

*Mod,

Complain)

{

assert(

.Wildcard &&

);

Complain)

{

Diags.

(

[0].second, diag::err_mmap_missing_module_unqualified)

(

I = 1, N =

.size(); I != N; ++I) {

Diags.

(

[I].second, diag::err_mmap_missing_module_qualified)

<<

[I].first << Context->getFullModuleName()

(; Mod; Mod = Mod->

) {

Paths.push_back(Mod->

);

(StringRef Framework : llvm::drop_begin(llvm::reverse(Paths)))

llvm::sys::path::append(

,

, Framework +

);

FullPathLength = FullPathName.size();

RelativePathLength = RelativePathName.size();

llvm::sys::path::append(RelativePathName,

, Header.

);

llvm::sys::path::append(FullPathName, RelativePathName);

(

= GetFile(FullPathName))

RelativePathName.clear();

RelativePathName.resize(RelativePathLength);

FullPathName.resize(FullPathLength);

llvm::sys::path::append(RelativePathName,

,

llvm::sys::path::append(FullPathName, RelativePathName);

GetFile(FullPathName);

(llvm::sys::path::is_absolute(Header.

)) {

RelativePathName.clear();

RelativePathName.append(Header.

.begin(), Header.

.end());

GetFrameworkFile();

llvm::sys::path::append(RelativePathName, Header.

);

llvm::sys::path::append(FullPathName, RelativePathName);

NormalHdrFile = GetFile(FullPathName);

(!NormalHdrFile && Directory->getName().ends_with(

)) {

FullPathName.assign(Directory->getName());

RelativePathName.clear();

(GetFrameworkFile()) {

diag::warn_mmap_incomplete_framework_module_declaration)

NeedsFramework =

;

NormalHdrFile;

llvm::StringSwitch<bool>(

)

.Case(

,

)

.Case(

,

)

.Case(

,

)

.Case(

,

)

.Case(

,

)

.Case(

,

)

.Case(

,

)

.Case(

,

)

.Case(

,

)

.Case(

,

)

.Case(

,

)

llvm::StringSwitch<bool>(ModuleName)

.Case(

,

)

.Case(

,

)

.Case(

,

)

.Case(

,

)

.Case(

,

)

.Case(

,

)

.Case(

,

)

.Case(

,

)

.Case(

,

)

.Case(

,

)

.Case(

,

)

.Case(

,

)

.Case(

,

)

ModuleMap::resolveHeader(

*Mod,

&NeedsFramework) {

findHeader(Mod, Header, RelativePathName, NeedsFramework)) {

(

*UmbrellaMod = UmbrellaDirs[UmbrellaDir])

<< UmbrellaMod->getFullModuleName();

RelativePathName.str());

ModuleMap::resolveAsBuiltinHeader(

llvm::sys::path::is_absolute(Header.

) ||

!BuiltinIncludeDir || BuiltinIncludeDir == Mod->

||

: SourceMgr(SourceMgr), Diags(Diags), LangOpts(LangOpts),

(

),

HeaderInfo(HeaderInfo) {

MMapLangOpts.LineComment =

;

assert((!this->Target || this->Target == &

) &&

);

Buffer.push_back(

);

Buffer.reserve(Buffer.size() + Name.size());

(

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

Buffer.push_back(Name[I]);

Buffer.push_back(

);

Name = StringRef(Buffer.data(), Buffer.size());

(llvm::StringSwitch<bool>(Name)

#define

(Keyword,Conditions) .Case(#Keyword,

)

#define

(Keyword, AliasOf, Conditions) .Case(Keyword,

)

#include

(Name.data() != Buffer.data())

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

Buffer.push_back(

);

Name = StringRef(Buffer.data(), Buffer.size());

.getDir() == BuiltinIncludeDir && LangOpts.BuiltinHeadersInSystemModules &&

LangOpts.BuiltinHeadersInSystemModules && BuiltinIncludeDir &&

ModuleMap::HeadersMap::iterator ModuleMap::findKnownHeader(

) {

HeadersMap::iterator Known = Headers.find(

);

Headers.find(

);

(UmbrellaDirs.empty())

KnownDir = UmbrellaDirs.find(*Dir);

(KnownDir != UmbrellaDirs.end())

IntermediateDirs.push_back(*Dir);

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

IsPrivate =

;

(

Hs : HeaderList)

IsPrivate |= llvm::any_of(

assert(IsPrivate &&

);

RequestingModuleIsModuleInterface,

(RequestingModule) {

Excluded =

;

*NotUsed =

;

HeadersMap::iterator Known = findKnownHeader(

);

(Known != Headers.end()) {

(RequestingModule && LangOpts.ModulesDeclUse &&

Diags.

(FilenameLoc, diag::warn_use_of_private_header_outside_module)

Diags.

(FilenameLoc, diag::err_undeclared_use_of_module_indirect)

(Excluded || isHeaderInUmbrellaDirs(

))

(RequestingModule && LangOpts.ModulesStrictDeclUse) {

Diags.

(FilenameLoc, diag::err_undeclared_use_of_module)

}

(RequestingModule && RequestingModuleIsModuleInterface &&

diag::warn_non_modular_include_in_framework_module :

diag::warn_non_modular_include_in_module;

AllowExcluded) {

HeadersMap::iterator Known = findKnownHeader(

);

(Known != Headers.end()) {

MakeResult(H);

MakeResult(

);

MakeResult(findOrCreateModuleForHeaderInUmbrellaDir(

));

assert(!Headers.count(

) &&

);

KnownHeader H = findHeaderInUmbrellaDirs(

, SkippedDirs);

UmbrellaModule = UmbrellaModule->

;

llvm::sys::path::stem(SkippedDir.getName()), NameBuf);

UmbrellaDirs[SkippedDir] =

;

llvm::sys::path::stem(

.getName()), NameBuf);

(

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

UmbrellaDirs[SkippedDirs[I]] =

;

Headers[

].push_back(Header);

HeadersMap::iterator Known = findKnownHeader(

);

(Known != Headers.end())

Known->second;

(findOrCreateModuleForHeaderInUmbrellaDir(

))

Headers.find(

)->second;

It = Headers.find(

);

(It == Headers.end())

HeadersMap::const_iterator Known = Headers.find(Header);

(Known != Headers.end()) {

I = Known->second.begin(),

= Known->second.end();

(I->isAvailable() &&

(!RequestingModule ||

StringRef DirName = Dir->

();

IsUnavailable = [&](

*M) {

!M->

() && (!RequestingModule ||

KnownDir = UmbrellaDirs.find(*Dir);

(KnownDir != UmbrellaDirs.end()) {

(IsUnavailable(

))

UmbrellaModule = UmbrellaModule->

;

llvm::sys::path::stem(SkippedDir.getName()), NameBuf);

(IsUnavailable(

))

llvm::sys::path::stem(Header.

()),

IsUnavailable(

);

SkippedDirs.push_back(*Dir);

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

llvm::StringMap<Module *>::const_iterator Known = Modules.find(Name);

(Known != Modules.end())

Known->getValue();

(!

->InferSubmodules)

->InferExplicitSubmodules, 0);

->InferExplicitSubmodules =

->InferExplicitSubmodules;

->InferExportWildcard =

->InferExportWildcard;

(

->InferExportWildcard)

(; Context; Context = Context->Parent) {

Context->findSubmodule(Name);

std::make_pair(Sub,

);

std::make_pair(M,

);

IsFramework,

IsExplicit) {

);

IsFramework, IsExplicit, NumCreatedModules++);

ModuleScopeIDs[

] = CurrentModuleScopeID;

, NumCreatedModules++);

PendingSubmodules.emplace_back(

);

assert(

&&

);

*

=

(ModulesAlloc.Allocate())

,

, NumCreatedModules++);

, NumCreatedModules++);

*

=

(ModulesAlloc.Allocate())

, NumCreatedModules++);

(

&Submodule : PendingSubmodules)

Submodule->setParent(

);

PendingSubmodules.clear();

assert(LangOpts.

== Name &&

);

assert(!Modules[Name] &&

);

Modules[Name] = SourceModule =

;

assert(MainFile &&

);

assert(LangOpts.

== Name &&

);

);

StringRef IName =

;

assert(!Modules[IName] &&

);

Modules[IName] = SourceModule =

;

);

assert(LangOpts.

== Name &&

);

assert(!Modules[Name] &&

);

*

=

(ModulesAlloc.Allocate())

, NumCreatedModules++);

Modules[Name] = SourceModule =

;

assert(Mod->

&&

);

);

StringRef FrameworkName(Mod->

);

FrameworkName.consume_back(

);

inferFrameworkModule(FrameworkDir, Attrs,

);

StringRef FrameworkDirName =

llvm::sys::path::stem(FrameworkDirName), ModuleNameStorage);

canInfer =

;

(llvm::sys::path::has_parent_path(FrameworkDirName)) {

StringRef

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

llvm::DenseMap<const DirectoryEntry *, InferredDirectory>::const_iterator

inferred = InferredDirectories.find(*ParentDir);

(inferred == InferredDirectories.end()) {

IsFrameworkDir =

.ends_with(

);

inferred = InferredDirectories.find(*ParentDir);

(inferred == InferredDirectories.end())

inferred = InferredDirectories.insert(

std::make_pair(*ParentDir, InferredDirectory())).first;

(inferred->second.InferModules) {

StringRef Name = llvm::sys::path::stem(FrameworkDirName);

!llvm::is_contained(inferred->second.ExcludedModules, Name);

Attrs.IsSystem |= inferred->second.Attrs.IsSystem;

Attrs.IsExternC |= inferred->second.Attrs.IsExternC;

Attrs.IsExhaustive |= inferred->second.Attrs.IsExhaustive;

Attrs.NoUndeclaredIncludes |=

inferred->second.Attrs.NoUndeclaredIncludes;

ModuleMapFID = inferred->second.ModuleMapFID;

llvm::sys::path::append(UmbrellaName,

, ModuleName +

);

(!UmbrellaHeader)

,

, NumCreatedModules++);

Modules[ModuleName] =

;

ModuleScopeIDs[

] = CurrentModuleScopeID;

->IsSystem |= Attrs.IsSystem;

->IsExternC |= Attrs.IsExternC;

->ConfigMacrosExhaustive |= Attrs.IsExhaustive;

->NoUndeclaredIncludes |= Attrs.NoUndeclaredIncludes;

->Directory = FrameworkDir;

StringRef RelativePath = UmbrellaName.str().substr(

->getTopLevelModule()->Directory->getName().size());

RelativePath = llvm::sys::path::relative_path(RelativePath);

->InferSubmodules =

;

->InferExportWildcard =

;

llvm::sys::path::append(SubframeworksDirName,

);

llvm::sys::path::native(SubframeworksDirName);

(llvm::vfs::directory_iterator

Dir = FS.dir_begin(SubframeworksDirName, EC),

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

(!StringRef(Dir->path()).ends_with(

))

StringRef SubframeworkDirName =

FoundParent =

;

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

(SubframeworkDirName.empty())

(*SubDir == FrameworkDir) {

FoundParent =

;

inferFrameworkModule(*SubframeworkDir, Attrs,

);

(!

->isSubFramework())

*ShadowingModule) {

IsFramework,

, NumCreatedModules++);

->ShadowingModule = ShadowingModule;

->markUnavailable(

);

ModuleScopeIDs[

] = CurrentModuleScopeID;

ShadowModules.push_back(

);

Twine &PathRelativeToRootModuleDirectory) {

PathRelativeToRootModuleDirectory.str();

UmbrellaDirs[UmbrellaHeader.

()] = Mod;

(

&Cb : Callbacks)

Cb->moduleMapAddUmbrellaHeader(UmbrellaHeader);

Twine &PathRelativeToRootModuleDirectory) {

PathRelativeToRootModuleDirectory.str();

UmbrellaDirs[UmbrellaDir] = Mod;

ModuleMap::addUnresolvedHeader(

*Mod,

&NeedsFramework) {

(resolveAsBuiltinHeader(Mod, Header)) {

LazyHeadersByModTime[*Header.

].push_back(Mod);

LazyHeadersBySize[*Header.

].push_back(Mod);

resolveHeader(Mod, Header, NeedsFramework);

BySize = LazyHeadersBySize.find(

->getSize());

(BySize != LazyHeadersBySize.end()) {

(

*M : BySize->second)

LazyHeadersBySize.erase(BySize);

ByModTime = LazyHeadersByModTime.find(

->getModificationTime());

(ByModTime != LazyHeadersByModTime.end()) {

(

*M : ByModTime->second)

LazyHeadersByModTime.erase(ByModTime);

*Mod, std::optional<const FileEntry *>

)

{

NeedsFramework =

;

Size =

? (*File)->getSize() : 0;

ModTime =

? (*File)->getModificationTime() : 0;

(Header.

&& Header.

!= Size)))

NewHeaders.push_back(Header);

*

(

)->resolveHeader(Mod, Header, NeedsFramework);

&HeaderList = Headers[HeaderEntry];

(llvm::is_contained(HeaderList, KH))

HeaderList.push_back(KH);

isCompilingModuleHeader = Mod->

(LangOpts);

(!Imported || isCompilingModuleHeader) {

(

&Cb : Callbacks)

Cb->moduleMapAddHeader(HeaderEntry.

());

assert(InferredModuleAllowedBy.count(M) &&

);

InferredModuleAllowedBy.find(M)->second;

InferredModuleAllowedBy[M] = ModMapFID;

StringRef Dir = llvm::sys::path::parent_path({

.data(),

.size()});

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

) {

StringRef

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

(

.ends_with(

))

llvm::errorToErrorCode(DirEntry.takeError());

(CanonicalDir != Dir)

llvm::sys::path::replace_path_prefix(

, Dir, CanonicalDir);

llvm::sys::path::remove_dots(

);

std::error_code();

AdditionalModMaps[M].insert(

);

llvm::errs() <<

;

(llvm::StringMap<Module *>::iterator M = Modules.begin(),

MEnd = Modules.end();

M->getValue()->

(llvm::errs(), 2);

llvm::errs() <<

;

(HeadersMap::iterator H = Headers.begin(), HEnd = Headers.end();

llvm::errs() <<

<< H->first.getName() <<

;

= H->second.end();

(I != H->second.begin())

llvm::errs() <<

;

llvm::errs() << I->getModule()->getFullModuleName();

llvm::errs() <<

;

(Export.getPointer() || Export.getInt())

Mod->

.push_back(Export);

= std::move(Top->UnresolvedDirectUses);

Top->UnresolvedDirectUses.clear();

*DirectUse = resolveModuleId(UDU, Top, Complain);

Top->DirectUses.push_back(DirectUse);

Top->UnresolvedDirectUses.push_back(UDU);

!Top->UnresolvedDirectUses.empty();

(

*OtherMod = resolveModuleId(UC.Id, Mod, Complain)) {

Conflict.

= OtherMod;

Conflict.

= UC.Message;

HadError =

;

llvm::BumpPtrAllocator StringData;

*ActiveModule =

;

parseModuleDecl();

parseExternModuleDecl();

parseRequiresDecl();

parseExportDecl();

parseExportAsDecl();

parseUseDecl();

parseLinkDecl();

parseConfigMacros();

parseConflict();

parseInferredModuleDecl(

Framework,

);

Attributes = ModuleMap::Attributes;

parseOptionalAttributes(Attributes &Attrs);

: L(L), SourceMgr(SourceMgr),

(

), Diags(Diags), Map(Map),

ModuleMapFID(ModuleMapFID), Directory(Directory), IsSystem(IsSystem) {

tok::raw_identifier: {

Tok.

= llvm::StringSwitch<MMToken::TokenKind>(RI)

tok::string_literal: {

*Saved = StringData.Allocate<

>(Length + 1);

tok::numeric_constant: {

SpellingBuffer.resize(LToken.

() + 1);

*Start = SpellingBuffer.data();

(StringRef(Start, Length).getAsInteger(0,

)) {

NextIsIdent = [&](StringRef Str) ->

{

(NextIsIdent(

) && NextIsIdent(

) &&

NextIsIdent(

) && NextIsIdent(

)) {

braceDepth = 0;

squareDepth = 0;

(Tok.

) {

(Tok.

(K) && braceDepth == 0 && squareDepth == 0)

(Tok.

(K) && braceDepth == 0 && squareDepth == 0)

(Tok.

(K))

(squareDepth > 0)

(Tok.

(K))

(braceDepth == 0 && squareDepth == 0 && Tok.

(K))

ModuleMapParser::parseModuleId(

&

) {

AttributeKind {

AT_no_undeclared_includes

ModuleMapParser::diagnosePrivateModules(

ExplicitLoc,

GenNoteAndFixIt = [&](StringRef BadName, StringRef Canonical,

diag::note_mmap_rename_top_level_private_module);

<< BadName << M->Name;

*M =

->getValue();

(M->Directory != ActiveModule->

)

(!

.starts_with(M->Name) && !

.ends_with(

))

Canonical.append(

);

(ActiveModule->

&& ActiveModule->

==

&& !M->Parent &&

diag::warn_mmap_mismatched_private_submodule)

FixItInitBegin = FrameworkLoc;

FixItInitBegin = ExplicitLoc;

FixedPrivModDecl.append(

);

FixedPrivModDecl.append(

);

FixedPrivModDecl.append(Canonical);

GenNoteAndFixIt(

, FixedPrivModDecl, M,

ActiveModule->

!= Canonical) {

diag::warn_mmap_mismatched_private_module_name)

<< ActiveModule->

;

GenNoteAndFixIt(ActiveModule->

, Canonical, M,

ModuleMapParser::parseModuleDecl() {

parseExternModuleDecl();

Framework =

;

ExplicitLoc = consumeToken();

FrameworkLoc = consumeToken();

CurrModuleDeclLoc = consumeToken();

parseInferredModuleDecl(Framework,

);

(parseModuleId(

)) {

(

.size() > 1) {

Diags.

(

.front().second, diag::err_mmap_nested_submodule_id)

Diags.

(ExplicitLoc, diag::err_mmap_explicit_top_level);

*PreviousActiveModule = ActiveModule;

(

.size() > 1) {

ActiveModule =

;

*TopLevelModule =

;

(

I = 0, N =

.size() - 1; I != N; ++I) {

TopLevelModule = Next;

ActiveModule = Next;

Diags.

(

[I].second, diag::err_mmap_missing_parent_module)

<<

[I].first << (ActiveModule !=

)

(TopLevelModule &&

assert(ModuleMapFID !=

);

StringRef ModuleName =

.back().first;

(parseOptionalAttributes(Attrs))

*ShadowingModule =

;

Inferred = Existing->IsInferred;

PartOfFramework = Framework || Existing->isPartOfFramework();

ParsedAsMainInput =

(LoadedFromASTFile || Inferred || PartOfFramework || ParsedAsMainInput) {

ActiveModule = PreviousActiveModule;

Diags.

(LBraceLoc, diag::note_mmap_lbrace_match);

ShadowingModule = Existing;

Diags.

(ModuleNameLoc, diag::err_mmap_module_redefinition)

Diags.

(Existing->DefinitionLoc, diag::note_mmap_prev_definition);

(ShadowingModule) {

(Attrs.IsSystem || IsSystem)

(Attrs.IsExternC)

(Attrs.NoUndeclaredIncludes)

StringRef MapFileName(

(MapFileName.ends_with(

) ||

MapFileName.ends_with(

)) {

!Diags.

(diag::warn_mmap_mismatched_private_submodule,

!Diags.

(diag::warn_mmap_mismatched_private_module_name,

diagnosePrivateModules(ExplicitLoc, FrameworkLoc);

(Tok.

) {

parseConfigMacros();

parseExportAsDecl();

parseRequiresDecl();

parseUmbrellaDirDecl(UmbrellaLoc);

Diags.

(LBraceLoc, diag::note_mmap_lbrace_match);

ActiveModule->

) {

ActiveModule = PreviousActiveModule;

ModuleMapParser::parseExternModuleDecl() {

(parseModuleId(

)) {

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

ModuleMapFileName += Directory.

();

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

);

FileNameRef = ModuleMapFileName;

(),

, ExternLoc);

&IsRequiresExcludedHack) {

(Feature ==

&&

IsRequiresExcludedHack =

;

}

(Feature ==

&& M->

({

,

})) {

ModuleMapParser::parseRequiresDecl() {

RequiredState =

;

RequiredState =

;

std::string Feature = std::string(Tok.

());

IsRequiresExcludedHack =

;

ShouldAddRequirement =

(IsRequiresExcludedHack)

UsesRequiresExcludedHack.insert(ActiveModule);

(ShouldAddRequirement) {

ActiveModule->

(Feature, RequiredState, Map.LangOpts,

LeadingToken = Tok.

;

(UsesRequiresExcludedHack.count(ActiveModule)) {

!std::holds_alternative<std::monostate>(ActiveModule->

)) {

(llvm::StringSwitch<Attribute>(Str)

.Case(

, Size)

.Case(

, ModTime)

Diags.

(

, diag::err_mmap_duplicate_header_attribute) << Str;

diag::err_mmap_invalid_header_attribute_value) << Str;

Diags.

(

, diag::err_mmap_duplicate_header_attribute) << Str;

diag::err_mmap_invalid_header_attribute_value) << Str;

Diags.

(

, diag::err_mmap_expected_header_attribute);

Diags.

(LBraceLoc, diag::note_mmap_lbrace_match);

NeedsFramework =

;

(!Map.LangOpts.BuiltinHeadersInSystemModules ||

Map.addUnresolvedHeader(ActiveModule, std::move(Header), NeedsFramework);

Diags.

(CurrModuleDeclLoc, diag::note_mmap_add_framework_keyword)

ModuleMapParser::parseUmbrellaDirDecl(

UmbrellaLoc) {

std::string DirName = std::string(Tok.

());

std::string DirNameAsWritten = DirName;

(!std::holds_alternative<std::monostate>(ActiveModule->

)) {

Diags.

(DirNameLoc, diag::err_mmap_umbrella_clash)

(llvm::sys::path::is_absolute(DirName)) {

PathName = Directory.

();

llvm::sys::path::append(PathName, DirName);

Diags.

(DirNameLoc, diag::warn_mmap_umbrella_dir_not_found)

(UsesRequiresExcludedHack.count(ActiveModule)) {

llvm::vfs::FileSystem &FS =

(llvm::vfs::recursive_directory_iterator I(FS, Dir->

(), EC),

;

I !=

&& !EC; I.increment(EC)) {

Headers.push_back(std::move(Header));

(

&Header : Headers)

(

*OwningModule = Map.UmbrellaDirs[*Dir]) {

Diags.

(UmbrellaLoc, diag::err_mmap_umbrella_clash)

<< OwningModule->getFullModuleName();

ModuleMapParser::parseExportDecl() {

Wildcard =

;

ParsedModuleId.push_back(

ExportLoc, ParsedModuleId, Wildcard

ModuleMapParser::parseExportAsDecl() {

(ActiveModule->

) {

ModuleMapParser::parseUseDecl() {

KWLoc = consumeToken();

parseModuleId(ParsedModuleId);

(ActiveModule->

)

Diags.

(KWLoc, diag::err_mmap_use_decl_submodule);

ModuleMapParser::parseLinkDecl() {

IsFramework =

;

IsFramework =

;

std::string LibraryName = std::string(Tok.

());

ModuleMapParser::parseConfigMacros() {

(ActiveModule->

) {

Diags.

(ConfigMacrosLoc, diag::err_mmap_config_macro_submodule);

(parseOptionalAttributes(Attrs))

(Attrs.IsExhaustive && !ActiveModule->

) {

(!ActiveModule->

) {

(!ActiveModule->

) {

llvm::raw_string_ostream OS(result);

(

I = 0, N =

.size(); I != N; ++I) {

ModuleMapParser::parseConflict() {

(parseModuleId(Conflict.

))

ModuleMapParser::parseInferredModuleDecl(

Framework,

) {

Failed =

;

(!ActiveModule && !Framework) {

Diags.

(StarLoc, diag::err_mmap_top_level_inferred_submodule);

Diags.

(StarLoc, diag::err_mmap_inferred_no_umbrella);

Diags.

(StarLoc, diag::err_mmap_inferred_redef);

diag::note_mmap_prev_definition);

Diags.

(StarLoc, diag::err_mmap_inferred_framework_submodule);

Diags.

(StarLoc, diag::err_mmap_explicit_inferred_framework);

(parseOptionalAttributes(Attrs))

Map.InferredDirectories[Directory].InferModules =

;

Map.InferredDirectories[Directory].Attrs = Attrs;

Map.InferredDirectories[Directory].ModuleMapFID = ModuleMapFID;

(Tok.

) {

<< (ActiveModule !=

);

Map.InferredDirectories[Directory].ExcludedModules.push_back(

(!ActiveModule) {

<< (ActiveModule !=

);

diag::err_mmap_expected_export_wildcard);

<< (ActiveModule !=

);

Diags.

(LBraceLoc, diag::note_mmap_lbrace_match);

ModuleMapParser::parseOptionalAttributes(Attributes &Attrs) {

HadError =

;

AttributeKind Attribute

= llvm::StringSwitch<AttributeKind>(Tok.

())

.Case(

, AT_exhaustive)

.Case(

, AT_extern_c)

.Case(

, AT_no_undeclared_includes)

.Case(

, AT_system)

.Default(AT_unknown);

(Attribute) {

Attrs.IsSystem =

;

Attrs.IsExternC =

;

Attrs.IsExhaustive =

;

AT_no_undeclared_includes:

Attrs.NoUndeclaredIncludes =

;

Diags.

(LSquareLoc, diag::note_mmap_lsquare_match);

(Tok.

) {

assert(

&&

);

llvm::DenseMap<const FileEntry *, bool>::iterator Known

= ParsedModuleMap.find(

);

(Known != ParsedModuleMap.end())

Known->second;

(ID.isInvalid()) {

FileCharacter =

assert(

&&

);

std::optional<llvm::MemoryBufferRef> Buffer = SourceMgr.

(ID);

ParsedModuleMap[

] =

;

assert((!Offset || *Offset <= Buffer->getBufferSize()) &&

);

Buffer->getBufferStart(),

Buffer->getBufferStart() + (Offset ? *Offset : 0),

Buffer->getBufferEnd());

assert(

.first == ID &&

);

*Offset =

.second;

(

&Cb : Callbacks)

Cb->moduleMapFileRead(Start,

, IsSystem);

Defines the Diagnostic-related interfaces.

Defines the clang::FileManager interface and associated types.

#define ALIAS(NAME, TOK, FLAGS)

#define KEYWORD(NAME, FLAGS)

Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.

Defines the clang::LangOptions interface.

llvm::MachO::Target Target

static bool isBuiltinHeaderName(StringRef FileName)

Determine whether the given file name is the name of a builtin header, supplied by Clang to replace,...

static bool isBuiltInModuleName(StringRef ModuleName)

Determine whether the given module name is the name of a builtin module that is cyclic with a system ...

static Module * getTopLevelOrNull(Module *M)

static bool violatesPrivateInclude(Module *RequestingModule, const FileEntry *IncFileEnt, ModuleMap::KnownHeader Header)

static void inferFrameworkLink(Module *Mod)

For a framework module, infer the framework against which we should link.

static StringRef sanitizeFilenameAsIdentifier(StringRef Name, SmallVectorImpl< char > &Buffer)

"Sanitize" a filename so that it can be used as an identifier.

static void appendSubframeworkPaths(Module *Mod, SmallVectorImpl< char > &Path)

Append to Paths the set of paths needed to get to the subframework in which the given module lives.

static bool shouldAddRequirement(Module *M, StringRef Feature, bool &IsRequiresExcludedHack)

Whether to add the requirement Feature to the module M.

static std::string formatModuleId(const ModuleId &Id)

Format a module-id into a string.

static bool isBetterKnownHeader(const ModuleMap::KnownHeader &New, const ModuleMap::KnownHeader &Old)

static bool compareModuleHeaders(const Module::Header &A, const Module::Header &B)

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

Defines the clang::SourceLocation class and associated facilities.

Defines the SourceManager interface.

__DEVICE__ void * memcpy(void *__a, const void *__b, size_t __c)

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).

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.

DirectoryEntryRef getDir() const

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.

llvm::Expected< DirectoryEntryRef > getDirectoryRef(StringRef DirName, bool CacheFailure=true)

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

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.

@ CMK_ModuleMap

Compiling a module from a module map.

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

bool isCompilingModule() const

Are we compiling a module?

std::string CurrentModule

The name of the current module, of which the main source file is a part.

Lexer - This provides a simple interface that turns a text buffer into a stream of tokens.

bool LexFromRawLexer(Token &Result)

LexFromRawLexer - Lex a token from a designated raw lexer (one with no associated preprocessor object...

SourceLocation getSourceLocation(const char *Loc, unsigned TokLen=1) const

getSourceLocation - Return a source location identifier for the specified offset in the current file.

static unsigned getSpelling(const Token &Tok, const char *&Buffer, const SourceManager &SourceMgr, const LangOptions &LangOpts, bool *Invalid=nullptr)

getSpelling - This method is used to get the spelling of a token into a preallocated buffer,...

Required to construct a Module.

SourceLocation getLocation()

bool terminatedByDirective()

bool parseModuleMapFile()

Parse a module map file.

ModuleMapParser(Lexer &L, SourceManager &SourceMgr, const TargetInfo *Target, DiagnosticsEngine &Diags, ModuleMap &Map, FileID ModuleMapFID, DirectoryEntryRef Directory, bool IsSystem)

Module * createShadowedModule(StringRef Name, bool IsFramework, Module *ShadowingModule)

Create a new top-level module that is shadowed by ShadowingModule.

bool resolveExports(Module *Mod, bool Complain)

Resolve all of the unresolved exports in the given module.

void addLinkAsDependency(Module *Mod)

Make module to use export_as as the link dependency name if enough information is available or add it...

void dump()

Dump the contents of the module map, for debugging purposes.

std::pair< Module *, bool > findOrCreateModule(StringRef Name, Module *Parent, bool IsFramework, bool IsExplicit)

Find a new module or submodule, or create it if it does not already exist.

void setUmbrellaDirAsWritten(Module *Mod, DirectoryEntryRef UmbrellaDir, const Twine &NameAsWritten, const Twine &PathRelativeToRootModuleDirectory)

Sets the umbrella directory of the given module to the given directory.

void diagnoseHeaderInclusion(Module *RequestingModule, bool RequestingModuleIsModuleInterface, SourceLocation FilenameLoc, StringRef Filename, FileEntryRef File)

Reports errors if a module must not include a specific file.

void addAdditionalModuleMapFile(const Module *M, FileEntryRef ModuleMap)

OptionalFileEntryRef getContainingModuleMapFile(const Module *Module) const

static Module::HeaderKind headerRoleToKind(ModuleHeaderRole Role)

Convert a header role to a kind.

Module * findModule(StringRef Name) const

Retrieve a module with the given name.

bool mayShadowNewModule(Module *ExistingModule)

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

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

Module * createHeaderUnit(SourceLocation Loc, StringRef Name, Module::Header H)

Create a C++20 header unit.

static bool isModular(ModuleHeaderRole Role)

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

bool resolveConflicts(Module *Mod, bool Complain)

Resolve all of the unresolved conflicts in the given module.

bool isHeaderUnavailableInModule(FileEntryRef Header, const Module *RequestingModule) const

Determine whether the given header is unavailable as part of the specified module.

void resolveHeaderDirectives(const FileEntry *File) const

Resolve all lazy header directives for the specified file.

module_iterator module_begin() const

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 shouldImportRelativeToBuiltinIncludeDir(StringRef FileName, Module *Module) const

Module * createModuleForImplementationUnit(SourceLocation Loc, StringRef Name)

Create a new module for a C++ module implementation unit.

ModuleMap(SourceManager &SourceMgr, DiagnosticsEngine &Diags, const LangOptions &LangOpts, const TargetInfo *Target, HeaderSearch &HeaderInfo)

Construct a new module map.

std::error_code canonicalizeModuleMapPath(SmallVectorImpl< char > &Path)

Canonicalize Path in a manner suitable for a module map file.

FileID getModuleMapFileIDForUniquing(const Module *M) const

Get the module map file that (along with the module name) uniquely identifies this module.

void setInferredModuleAllowedBy(Module *M, FileID ModMapFID)

void setUmbrellaHeaderAsWritten(Module *Mod, FileEntryRef UmbrellaHeader, const Twine &NameAsWritten, const Twine &PathRelativeToRootModuleDirectory)

Sets the umbrella header of the given module to the given header.

Module * findOrCreateModuleFirst(StringRef Name, Module *Parent, bool IsFramework, bool IsExplicit)

Call ModuleMap::findOrCreateModule and throw away the information whether the module was found or cre...

Module * lookupModuleUnqualified(StringRef Name, Module *Context) const

Retrieve a module with the given name using lexical name lookup, starting at the given context.

bool isBuiltinHeader(FileEntryRef File)

Is this a compiler builtin header?

Module * createModule(StringRef Name, Module *Parent, bool IsFramework, bool IsExplicit)

Create new submodule, assuming it does not exist.

module_iterator module_end() const

bool isHeaderInUnavailableModule(FileEntryRef Header) const

Determine whether the given header is part of a module marked 'unavailable'.

FileID getContainingModuleMapFileID(const Module *Module) const

Retrieve the module map file containing the definition of the given module.

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.

~ModuleMap()

Destroy the module map.

Module * createGlobalModuleFragmentForModuleUnit(SourceLocation Loc, Module *Parent=nullptr)

Create a global module fragment for a C++ module unit.

void setTarget(const TargetInfo &Target)

Set the target information.

Module * lookupModuleQualified(StringRef Name, Module *Context) const

Retrieve a module with the given name within the given context, using direct (qualified) name lookup.

void resolveLinkAsDependencies(Module *Mod)

Use PendingLinkAsModule information to mark top level link names that are going to be replaced by exp...

ModuleHeaderRole

Flags describing the role of a module header.

@ PrivateHeader

This header is included but private.

@ ExcludedHeader

This header is explicitly excluded from the module.

@ NormalHeader

This header is normally included in the module.

@ TextualHeader

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

Module * createModuleForInterfaceUnit(SourceLocation Loc, StringRef Name)

Create a new module for a C++ module interface unit.

void addHeader(Module *Mod, Module::Header Header, ModuleHeaderRole Role, bool Imported=false)

Adds this header to the given module.

Module * createPrivateModuleFragmentForInterfaceUnit(Module *Parent, SourceLocation Loc)

Create a global module fragment for a C++ module interface unit.

Module * findOrInferSubmodule(Module *Parent, StringRef Name)

ArrayRef< KnownHeader > findAllModulesForHeader(FileEntryRef File)

Retrieve all the modules that contain the given header file.

Module * createImplicitGlobalModuleFragmentForModuleUnit(SourceLocation Loc, Module *Parent)

Module * createModuleUnitWithKind(SourceLocation Loc, StringRef Name, Module::ModuleKind Kind)

Create a new C++ module with the specified kind, and reparent any pending global module fragment(s) t...

static ModuleHeaderRole headerKindToRole(Module::HeaderKind Kind)

Convert a header kind to a role. Requires Kind to not be HK_Excluded.

bool resolveUses(Module *Mod, bool Complain)

Resolve all of the unresolved uses in the given module.

Describes a module or submodule.

StringRef getTopLevelModuleName() const

Retrieve the name of the top-level module.

void addRequirement(StringRef Feature, bool RequiredState, const LangOptions &LangOpts, const TargetInfo &Target)

Add the given feature requirement to the list of features required by this module.

SmallVector< ExportDecl, 2 > Exports

The set of export declarations.

bool isForBuilding(const LangOptions &LangOpts) const

Determine whether this module can be built in this compilation.

std::variant< std::monostate, FileEntryRef, DirectoryEntryRef > Umbrella

The umbrella header or directory.

unsigned InferSubmodules

Whether we should infer submodules for this module based on the headers.

bool directlyUses(const Module *Requested)

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

std::vector< std::string > ConfigMacros

The set of "configuration macros", which are macros that (intentionally) change how this module is bu...

SourceLocation InferredSubmoduleLoc

The location of the inferred submodule.

unsigned IsUnimportable

Whether this module has declared itself unimportable, either because it's missing a requirement from ...

void print(raw_ostream &OS, unsigned Indent=0, bool Dump=false) const

Print the module map for this module to the given stream.

SourceLocation DefinitionLoc

The location of the module definition.

SmallVector< UnresolvedHeaderDirective, 1 > MissingHeaders

Headers that are mentioned in the module map file but could not be found on the file system.

Module * Parent

The parent of this module.

void markUnavailable(bool Unimportable)

Mark this module and all of its submodules as unavailable.

SmallVector< UnresolvedHeaderDirective, 1 > UnresolvedHeaders

Headers that are mentioned in the module map file but that we have not yet attempted to resolve to a ...

bool fullModuleNameIs(ArrayRef< StringRef > nameParts) const

Whether the full name of this module is equal to joining nameParts with "."s.

unsigned IsInferred

Whether this is an inferred submodule (module * { ... }).

unsigned IsSystem

Whether this is a "system" module (which assumes that all headers in it are system headers).

std::string Name

The name of this module.

bool isSubFramework() const

Determine whether this module is a subframework of another framework.

unsigned IsExternC

Whether this is an 'extern "C"' module (which implicitly puts all headers in it within an 'extern "C"...

unsigned ModuleMapIsPrivate

Whether this module came from a "private" module map, found next to a regular (public) module map.

llvm::SmallVector< LinkLibrary, 2 > LinkLibraries

The set of libraries or frameworks to link against when an entity from this module is used.

SmallVector< UnresolvedExportDecl, 2 > UnresolvedExports

The set of export declarations that have yet to be resolved.

void addHeader(HeaderKind HK, Header H)

std::string UmbrellaRelativeToRootModuleDirectory

OptionalDirectoryEntryRef Directory

The build directory of this module.

SmallVector< ModuleId, 2 > UnresolvedDirectUses

The set of use declarations that have yet to be resolved.

unsigned NoUndeclaredIncludes

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

unsigned ConfigMacrosExhaustive

Whether the set of configuration macros is exhaustive.

ArrayRef< Header > getHeaders(HeaderKind HK) const

unsigned InferExportWildcard

Whether, when inferring submodules, the inferr submodules should export all modules they import (e....

std::vector< UnresolvedConflict > UnresolvedConflicts

The list of conflicts for which the module-id has not yet been resolved.

unsigned IsFromModuleFile

Whether this module was loaded from a module file.

bool isSubModuleOf(const Module *Other) const

Check if this module is a (possibly transitive) submodule of Other.

bool isPartOfFramework() const

Determine whether this module is a part of a framework, either because it is a framework module or be...

bool isAvailable() const

Determine whether this module is available for use within the current translation unit.

llvm::PointerIntPair< Module *, 1, bool > ExportDecl

Describes an exported module.

@ ModuleImplementationUnit

This is a C++20 module implementation unit.

@ ImplicitGlobalModuleFragment

This is an implicit fragment of the global module which contains only language linkage declarations (...

@ ModuleInterfaceUnit

This is a C++20 module interface unit.

@ ModuleHeaderUnit

This is a C++20 header unit.

@ PrivateModuleFragment

This is the private module fragment within some C++ module.

@ ExplicitGlobalModuleFragment

This is the explicit Global Module Fragment of a modular TU.

unsigned IsFramework

Whether this is a framework module.

std::string ExportAsModule

The module through which entities defined in this module will eventually be exposed,...

std::string getFullModuleName(bool AllowStringLiterals=false) const

Retrieve the full name of this module, including the path from its top-level module.

std::string UmbrellaAsWritten

The name of the umbrella entry, as written in the module map.

unsigned IsAvailable

Whether this module is available in the current translation unit.

unsigned InferExplicitSubmodules

Whether, when inferring submodules, the inferred submodules should be explicit.

Module * getTopLevelModule()

Retrieve the top-level module for this (sub)module, which may be this module.

OptionalDirectoryEntryRef getEffectiveUmbrellaDir() const

Get the effective umbrella directory for this module: either the one explicitly written in the module...

bool UseExportAsModuleLinkName

Autolinking uses the framework name for linking purposes when this is false and the export_as name ot...

std::vector< Conflict > Conflicts

The list of conflicts.

Parser - This implements a parser for the C family of languages.

Encodes a location in the source.

static SourceLocation getFromRawEncoding(UIntTy Encoding)

Turn a raw encoding of a SourceLocation object into a real SourceLocation.

bool isValid() const

Return true if this is a valid SourceLocation object.

UIntTy getRawEncoding() const

When a SourceLocation itself cannot be used, this returns an (opaque) 32-bit integer encoding for it.

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

FileID getFileID(SourceLocation SpellingLoc) const

Return the FileID for a SourceLocation.

OptionalFileEntryRef getFileEntryRefForID(FileID FID) const

Returns the FileEntryRef for the provided FileID.

FileID createFileID(FileEntryRef SourceFile, SourceLocation IncludePos, SrcMgr::CharacteristicKind FileCharacter, int LoadedID=0, SourceLocation::UIntTy LoadedOffset=0)

Create a new FileID that represents the specified file being #included from the specified IncludePosi...

FileManager & getFileManager() const

FileID getMainFileID() const

Returns the FileID of the main source file.

std::pair< FileID, unsigned > getDecomposedLoc(SourceLocation Loc) const

Decompose the specified location into a raw FileID + Offset pair.

const FileEntry * getFileEntryForID(FileID FID) const

Returns the FileEntry record for the provided FileID.

SourceLocation getLocForStartOfFile(FileID FID) const

Return the source location corresponding to the first byte of the specified file.

std::optional< llvm::MemoryBufferRef > getBufferOrNone(FileID FID, SourceLocation Loc=SourceLocation()) const

Return the buffer for the specified FileID.

A trivial tuple used to represent a source range.

StringLiteralParser - This decodes string escape characters and performs wide string analysis and Tra...

StringLiteral - This represents a string literal expression, e.g.

Exposes information about the current target.

Token - This structure provides full information about a lexed token.

SourceLocation getLocation() const

Return a source location identifier for the specified offset in the current file.

unsigned getLength() const

bool is(tok::TokenKind K) const

is/isNot - Predicates to check if this token is a specific kind, as in "if (Tok.is(tok::l_brace)) {....

tok::TokenKind getKind() const

bool isAtStartOfLine() const

isAtStartOfLine - Return true if this token is at the start of a line.

bool hasUDSuffix() const

Return true if this token is a string or character literal which has a ud-suffix.

StringRef getRawIdentifier() const

getRawIdentifier - For a raw identifier token (i.e., an identifier lexed in raw mode),...

Defines the clang::TargetInfo interface.

bool Sub(InterpState &S, CodePtr OpPC)

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

if(T->getSizeExpr()) TRY_TO(TraverseStmt(const_cast< Expr * >(T -> getSizeExpr())))

LLVM_READONLY bool isAsciiIdentifierContinue(unsigned char c)

@ Private

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

LLVM_READONLY bool isValidAsciiIdentifier(StringRef S, bool AllowDollar=false)

Return true if this is a valid ASCII identifier.

@ Result

The result type of a method or function.

LLVM_READONLY bool isDigit(unsigned char c)

Return true if this character is an ASCII digit: [0-9].

A token in a module map file.

SourceLocation getLocation() const

bool is(TokenKind K) const

SourceLocation::UIntTy Location

StringRef getString() const

enum clang::MMToken::TokenKind Kind

uint64_t getInteger() const

A conflict between two modules.

Module * Other

The module that this module conflicts with.

std::string Message

The message provided to the user when there is a conflict.

A library or framework to link against when an entity from this module is used.

An unresolved conflict with another module.

std::string Message

The message provided to the user when there is a conflict.

ModuleId Id

The (unresolved) module id.

Describes an exported module that has not yet been resolved (perhaps because the module it refers to ...

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