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

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

clang: include/clang/Lex/ModuleMap.h Source File

DiagnosticsEngine;

anchor();

*SourceModule =

;

llvm::SpecificBumpPtrAllocator<Module> ModulesAlloc;

llvm::StringMap<Module *> Modules;

llvm::DenseMap<const IdentifierInfo *, Module *> CachedModuleLoads;

NumCreatedModules = 0;

llvm::StringMap<llvm::StringSet<>> PendingLinkAsModule;

llvm::PointerIntPair<Module *, 3, ModuleHeaderRole> Storage;

A.Storage == B.Storage;

A.Storage != B.Storage;

()

{

Storage.getPointer() !=

;

HeadersMap = llvm::DenseMap<FileEntryRef, SmallVector<KnownHeader, 1>>;

llvm::DenseMap<off_t, llvm::TinyPtrVector<Module*>> LazyHeadersBySize;

llvm::DenseMap<time_t, llvm::TinyPtrVector<Module*>>

LazyHeadersByModTime;

llvm::DenseMap<const DirectoryEntry *, Module *> UmbrellaDirs;

CurrentModuleScopeID = 0;

llvm::DenseMap<Module *, unsigned> ModuleScopeIDs;

LLVM_PREFERRED_TYPE(

)

IsSystem : 1;

LLVM_PREFERRED_TYPE(

)

IsExternC : 1;

LLVM_PREFERRED_TYPE(

)

IsExhaustive : 1;

LLVM_PREFERRED_TYPE(

)

NoUndeclaredIncludes : 1;

NoUndeclaredIncludes(

) {}

InferredDirectory {

LLVM_PREFERRED_TYPE(

)

InferModules : 1;

SmallVector<std::string, 2> ExcludedModules;

InferredDirectory() : InferModules(

) {}

llvm::DenseMap<const DirectoryEntry *, InferredDirectory> InferredDirectories;

llvm::DenseMap<const Module *, FileID> InferredModuleAllowedBy;

llvm::DenseMap<const Module *, AdditionalModMapsSet> AdditionalModMaps;

llvm::DenseMap<const FileEntry *, bool> ParsedModuleMap;

resolveExport(Module *Mod,

Module::UnresolvedExportDecl &

,

Complain)

;

*resolveModuleId(

&

, Module *Mod,

Complain)

;

addUnresolvedHeader(Module *Mod,

Module::UnresolvedHeaderDirective Header,

&NeedsFramework);

findHeader(Module *M,

Module::UnresolvedHeaderDirective &Header,

SmallVectorImpl<char> &RelativePathName,

&NeedsFramework);

resolveHeader(Module *M,

Module::UnresolvedHeaderDirective &Header,

&NeedsFramework);

resolveAsBuiltinHeader(Module *M,

Module::UnresolvedHeaderDirective &Header);

HeadersMap::iterator findKnownHeader(FileEntryRef

);

KnownHeader findHeaderInUmbrellaDirs(

FileEntryRef

, SmallVectorImpl<DirectoryEntryRef> &IntermediateDirs);

KnownHeader findOrCreateModuleForHeaderInUmbrellaDir(FileEntryRef

);

isHeaderInUmbrellaDirs(FileEntryRef

) {

SmallVector<DirectoryEntryRef, 2> IntermediateDirs;

(findHeaderInUmbrellaDirs(

, IntermediateDirs));

*inferFrameworkModule(DirectoryEntryRef FrameworkDir, Attributes Attrs,

(SourceManager &SourceMgr, DiagnosticsEngine &Diags,

LangOptions &LangOpts,

TargetInfo *

,

HeaderSearch &HeaderInfo);

Callbacks.push_back(std::move(Callback));

AllowExcluded =

);

std::optional<const FileEntry *>

)

;

RequestingModuleIsModuleInterface,

*RequestingModule)

;

IsFramework,

IsExplicit) {

assert(!ExistingModule->

&&

);

assert(ModuleScopeIDs.count(ExistingModule) &&

);

ModuleScopeIDs[ExistingModule] < CurrentModuleScopeID;

It = InferredDirectories.find(Dir);

It != InferredDirectories.end() && It->getSecond().InferModules;

I = AdditionalModMaps.find(M);

(I == AdditionalModMaps.end())

Twine &NameAsWritten,

Twine &PathRelativeToRootModuleDirectory);

Twine &NameAsWritten,

Twine &PathRelativeToRootModuleDirectory);

*Offset =

,

llvm::iterator_range<module_iterator>

()

{

CachedModuleLoads[&II] = M;

I = CachedModuleLoads.find(&II);

(I == CachedModuleLoads.end())

enum clang::sema::@1704::IndirectLocalPathEntry::EntryKind Kind

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

Defines the clang::LangOptions interface.

llvm::MachO::Target Target

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

Defines the clang::SourceLocation class and associated facilities.

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

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

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

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

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

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

A mechanism to observe the actions of the module map parser as it reads module map files.

virtual void moduleMapFileRead(SourceLocation FileStart, FileEntryRef File, bool IsSystem)

Called when a module map file has been read.

virtual ~ModuleMapCallbacks()=default

virtual void moduleMapAddHeader(StringRef Filename)

Called when a header is added during module map parsing.

virtual void moduleMapAddUmbrellaHeader(FileEntryRef Header)

Called when an umbrella header is added during module map parsing.

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.

llvm::StringMap< Module * >::const_iterator module_iterator

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.

void finishModuleDeclarationScope()

Creates a new declaration scope for module names, allowing previously defined modules to shadow defin...

bool canInferFrameworkModule(const DirectoryEntry *Dir) const

Check whether a framework module can be inferred in the given directory.

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.

void addModuleMapCallbacks(std::unique_ptr< ModuleMapCallbacks > Callback)

Add a module map callback.

void setBuiltinIncludeDir(DirectoryEntryRef Dir)

Set the directory that contains Clang-supplied include files, such as our stdarg.h or tgmath....

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::optional< Module * > getCachedModuleLoad(const IdentifierInfo &II)

Return a cached module load.

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.

llvm::DenseSet< FileEntryRef > AdditionalModMapsSet

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

AdditionalModMapsSet * getAdditionalModuleMapFiles(const Module *M)

Get any module map files other than getModuleMapFileForUniquing(M) that define submodules of a top-le...

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.

OptionalDirectoryEntryRef getBuiltinDir() const

Get the directory that contains Clang-supplied include files.

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

void cacheModuleLoad(const IdentifierInfo &II, Module *M)

Cache a module load. M might be nullptr.

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.

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.

Module * Parent

The parent of this module.

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.

Module * getTopLevelModule()

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

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.

@ Module

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

CustomizableOptional< FileEntryRef > OptionalFileEntryRef

SmallVector< std::pair< std::string, SourceLocation >, 2 > ModuleId

Describes the name of a module.

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