1 //===--- DirectoryLookup.h - Info for searching for headers -----*- C++ -*-===//
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //===----------------------------------------------------------------------===//
9 // This file defines the DirectoryLookup interface.
11 //===----------------------------------------------------------------------===//
13 #ifndef LLVM_CLANG_LEX_DIRECTORYLOOKUP_H
14 #define LLVM_CLANG_LEX_DIRECTORYLOOKUP_H
16 #include "clang/Basic/LLVM.h"
17 #include "clang/Basic/SourceManager.h"
18 #include "clang/Lex/ModuleMap.h"
27 /// DirectoryLookup - This class represents one entry in the search list that
28 /// specifies the search order for directories in \#include directives. It
29 /// represents either a directory, a framework, or a headermap.
31 class DirectoryLookup {
39 union DLU { // This union is discriminated by isHeaderMap.
40 /// Dir - This is the actual directory that we're referring to for a normal
41 /// directory or a framework.
42 DirectoryEntryRef Dir;
44 /// Map - This is the HeaderMap if this is a headermap lookup.
48 DLU(DirectoryEntryRef Dir) : Dir(Dir) {}
49 DLU(const HeaderMap *Map) : Map(Map) {}
52 /// DirCharacteristic - The type of directory this is: this is an instance of
53 /// SrcMgr::CharacteristicKind.
54 unsigned DirCharacteristic : 2;
56 /// LookupType - This indicates whether this DirectoryLookup object is a
57 /// normal directory, a framework, or a headermap.
58 unsigned LookupType : 2;
60 /// Whether this is a header map used when building a framework.
61 unsigned IsIndexHeaderMap : 1;
63 /// Whether we've performed an exhaustive search for module maps
64 /// within the subdirectories of this directory.
65 unsigned SearchedAllModuleMaps : 1;
68 /// This ctor *does not take ownership* of 'Dir'.
69 DirectoryLookup(DirectoryEntryRef Dir, SrcMgr::CharacteristicKind DT,
71 : u(Dir), DirCharacteristic(DT),
72 LookupType(isFramework ? LT_Framework : LT_NormalDir),
73 IsIndexHeaderMap(false), SearchedAllModuleMaps(false) {}
75 /// This ctor *does not take ownership* of 'Map'.
76 DirectoryLookup(const HeaderMap *Map, SrcMgr::CharacteristicKind DT,
77 bool isIndexHeaderMap)
78 : u(Map), DirCharacteristic(DT), LookupType(LT_HeaderMap),
79 IsIndexHeaderMap(isIndexHeaderMap), SearchedAllModuleMaps(false) {}
81 /// getLookupType - Return the kind of directory lookup that this is: either a
82 /// normal directory, a framework path, or a HeaderMap.
83 LookupType_t getLookupType() const { return (LookupType_t)LookupType; }
85 /// getName - Return the directory or filename corresponding to this lookup
87 StringRef getName() const;
89 /// getDir - Return the directory that this entry refers to.
91 const DirectoryEntry *getDir() const {
92 return isNormalDir() ? &u.Dir.getDirEntry() : nullptr;
95 /// getFrameworkDir - Return the directory that this framework refers to.
97 const DirectoryEntry *getFrameworkDir() const {
98 return isFramework() ? &u.Dir.getDirEntry() : nullptr;
101 Optional<DirectoryEntryRef> getFrameworkDirRef() const {
102 return isFramework() ? Optional<DirectoryEntryRef>(u.Dir) : None;
105 /// getHeaderMap - Return the directory that this entry refers to.
107 const HeaderMap *getHeaderMap() const {
108 return isHeaderMap() ? u.Map : nullptr;
111 /// isNormalDir - Return true if this is a normal directory, not a header map.
112 bool isNormalDir() const { return getLookupType() == LT_NormalDir; }
114 /// isFramework - True if this is a framework directory.
116 bool isFramework() const { return getLookupType() == LT_Framework; }
118 /// isHeaderMap - Return true if this is a header map, not a normal directory.
119 bool isHeaderMap() const { return getLookupType() == LT_HeaderMap; }
121 /// Determine whether we have already searched this entire
122 /// directory for module maps.
123 bool haveSearchedAllModuleMaps() const { return SearchedAllModuleMaps; }
125 /// Specify whether we have already searched all of the subdirectories
127 void setSearchedAllModuleMaps(bool SAMM) {
128 SearchedAllModuleMaps = SAMM;
131 /// DirCharacteristic - The type of directory this is, one of the DirType enum
133 SrcMgr::CharacteristicKind getDirCharacteristic() const {
134 return (SrcMgr::CharacteristicKind)DirCharacteristic;
137 /// Whether this describes a system header directory.
138 bool isSystemHeaderDirectory() const {
139 return getDirCharacteristic() != SrcMgr::C_User;
142 /// Whether this header map is building a framework or not.
143 bool isIndexHeaderMap() const {
144 return isHeaderMap() && IsIndexHeaderMap;
147 /// LookupFile - Lookup the specified file in this search path, returning it
148 /// if it exists or returning null if not.
150 /// \param Filename The file to look up relative to the search paths.
152 /// \param HS The header search instance to search with.
154 /// \param IncludeLoc the source location of the #include or #import
157 /// \param SearchPath If not NULL, will be set to the search path relative
158 /// to which the file was found.
160 /// \param RelativePath If not NULL, will be set to the path relative to
161 /// SearchPath at which the file was found. This only differs from the
162 /// Filename for framework includes.
164 /// \param RequestingModule The module in which the lookup was performed.
166 /// \param SuggestedModule If non-null, and the file found is semantically
167 /// part of a known module, this will be set to the module that should
168 /// be imported instead of preprocessing/parsing the file found.
170 /// \param [out] InUserSpecifiedSystemFramework If the file is found,
171 /// set to true if the file is located in a framework that has been
172 /// user-specified to be treated as a system framework.
174 /// \param [out] IsFrameworkFound For a framework directory set to true if
175 /// specified '.framework' directory is found.
177 /// \param [out] MappedName if this is a headermap which maps the filename to
178 /// a framework include ("Foo.h" -> "Foo/Foo.h"), set the new name to this
179 /// vector and point Filename to it.
180 Optional<FileEntryRef>
181 LookupFile(StringRef &Filename, HeaderSearch &HS, SourceLocation IncludeLoc,
182 SmallVectorImpl<char> *SearchPath,
183 SmallVectorImpl<char> *RelativePath, Module *RequestingModule,
184 ModuleMap::KnownHeader *SuggestedModule,
185 bool &InUserSpecifiedSystemFramework, bool &IsFrameworkFound,
186 bool &IsInHeaderMap, SmallVectorImpl<char> &MappedName) const;
189 Optional<FileEntryRef> DoFrameworkLookup(
190 StringRef Filename, HeaderSearch &HS, SmallVectorImpl<char> *SearchPath,
191 SmallVectorImpl<char> *RelativePath, Module *RequestingModule,
192 ModuleMap::KnownHeader *SuggestedModule,
193 bool &InUserSpecifiedSystemFramework, bool &IsFrameworkFound) const;
196 } // end namespace clang