clang  10.0.0svn
DirectoryLookup.h
Go to the documentation of this file.
1 //===--- DirectoryLookup.h - Info for searching for headers -----*- C++ -*-===//
2 //
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
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file defines the DirectoryLookup interface.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #ifndef LLVM_CLANG_LEX_DIRECTORYLOOKUP_H
14 #define LLVM_CLANG_LEX_DIRECTORYLOOKUP_H
15 
16 #include "clang/Basic/LLVM.h"
18 #include "clang/Lex/ModuleMap.h"
19 
20 namespace clang {
21 class HeaderMap;
22 class DirectoryEntry;
23 class FileEntry;
24 class HeaderSearch;
25 class Module;
26 
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.
30 ///
32 public:
33  enum LookupType_t {
37  };
38 private:
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.
43 
44  /// Map - This is the HeaderMap if this is a headermap lookup.
45  ///
46  const HeaderMap *Map;
47 
48  DLU(DirectoryEntryRef Dir) : Dir(Dir) {}
49  DLU(const HeaderMap *Map) : Map(Map) {}
50  } u;
51 
52  /// DirCharacteristic - The type of directory this is: this is an instance of
53  /// SrcMgr::CharacteristicKind.
54  unsigned DirCharacteristic : 2;
55 
56  /// LookupType - This indicates whether this DirectoryLookup object is a
57  /// normal directory, a framework, or a headermap.
58  unsigned LookupType : 2;
59 
60  /// Whether this is a header map used when building a framework.
61  unsigned IsIndexHeaderMap : 1;
62 
63  /// Whether we've performed an exhaustive search for module maps
64  /// within the subdirectories of this directory.
65  unsigned SearchedAllModuleMaps : 1;
66 
67 public:
68  /// This ctor *does not take ownership* of 'Dir'.
70  bool isFramework)
71  : u(Dir), DirCharacteristic(DT),
72  LookupType(isFramework ? LT_Framework : LT_NormalDir),
73  IsIndexHeaderMap(false), SearchedAllModuleMaps(false) {}
74 
75  /// This ctor *does not take ownership* of 'Map'.
77  bool isIndexHeaderMap)
78  : u(Map), DirCharacteristic(DT), LookupType(LT_HeaderMap),
79  IsIndexHeaderMap(isIndexHeaderMap), SearchedAllModuleMaps(false) {}
80 
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; }
84 
85  /// getName - Return the directory or filename corresponding to this lookup
86  /// object.
87  StringRef getName() const;
88 
89  /// getDir - Return the directory that this entry refers to.
90  ///
91  const DirectoryEntry *getDir() const {
92  return isNormalDir() ? &u.Dir.getDirEntry() : nullptr;
93  }
94 
95  /// getFrameworkDir - Return the directory that this framework refers to.
96  ///
98  return isFramework() ? &u.Dir.getDirEntry() : nullptr;
99  }
100 
102  return isFramework() ? Optional<DirectoryEntryRef>(u.Dir) : None;
103  }
104 
105  /// getHeaderMap - Return the directory that this entry refers to.
106  ///
107  const HeaderMap *getHeaderMap() const {
108  return isHeaderMap() ? u.Map : nullptr;
109  }
110 
111  /// isNormalDir - Return true if this is a normal directory, not a header map.
112  bool isNormalDir() const { return getLookupType() == LT_NormalDir; }
113 
114  /// isFramework - True if this is a framework directory.
115  ///
116  bool isFramework() const { return getLookupType() == LT_Framework; }
117 
118  /// isHeaderMap - Return true if this is a header map, not a normal directory.
119  bool isHeaderMap() const { return getLookupType() == LT_HeaderMap; }
120 
121  /// Determine whether we have already searched this entire
122  /// directory for module maps.
123  bool haveSearchedAllModuleMaps() const { return SearchedAllModuleMaps; }
124 
125  /// Specify whether we have already searched all of the subdirectories
126  /// for module maps.
127  void setSearchedAllModuleMaps(bool SAMM) {
128  SearchedAllModuleMaps = SAMM;
129  }
130 
131  /// DirCharacteristic - The type of directory this is, one of the DirType enum
132  /// values.
134  return (SrcMgr::CharacteristicKind)DirCharacteristic;
135  }
136 
137  /// Whether this describes a system header directory.
138  bool isSystemHeaderDirectory() const {
140  }
141 
142  /// Whether this header map is building a framework or not.
143  bool isIndexHeaderMap() const {
144  return isHeaderMap() && IsIndexHeaderMap;
145  }
146 
147  /// LookupFile - Lookup the specified file in this search path, returning it
148  /// if it exists or returning null if not.
149  ///
150  /// \param Filename The file to look up relative to the search paths.
151  ///
152  /// \param HS The header search instance to search with.
153  ///
154  /// \param IncludeLoc the source location of the #include or #import
155  /// directive.
156  ///
157  /// \param SearchPath If not NULL, will be set to the search path relative
158  /// to which the file was found.
159  ///
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.
163  ///
164  /// \param RequestingModule The module in which the lookup was performed.
165  ///
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.
169  ///
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.
173  ///
174  /// \param [out] IsFrameworkFound For a framework directory set to true if
175  /// specified '.framework' directory is found.
176  ///
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.
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;
187 
188 private:
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;
194 };
195 
196 } // end namespace clang
197 
198 #endif
bool isIndexHeaderMap() const
Whether this header map is building a framework or not.
Defines the SourceManager interface.
StringRef getName() const
getName - Return the directory or filename corresponding to this lookup object.
CharacteristicKind
Indicates whether a file or directory holds normal user code, system code, or system code which is im...
Definition: SourceManager.h:77
This class represents an Apple concept known as a &#39;header map&#39;.
Definition: HeaderMap.h:65
bool isHeaderMap() const
isHeaderMap - Return true if this is a header map, not a normal directory.
Describes a module or submodule.
Definition: Module.h:64
DirectoryLookup(const HeaderMap *Map, SrcMgr::CharacteristicKind DT, bool isIndexHeaderMap)
This ctor does not take ownership of &#39;Map&#39;.
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
DirectoryLookup(DirectoryEntryRef Dir, SrcMgr::CharacteristicKind DT, bool isFramework)
This ctor does not take ownership of &#39;Dir&#39;.
Optional< DirectoryEntryRef > getFrameworkDirRef() const
Encapsulates the information needed to find the file referenced by a #include or #include_next, (sub-)framework lookup, etc.
Definition: HeaderSearch.h:158
StringRef Filename
Definition: Format.cpp:1807
bool isNormalDir() const
isNormalDir - Return true if this is a normal directory, not a header map.
bool isFramework() const
isFramework - True if this is a framework directory.
DirectoryLookup - This class represents one entry in the search list that specifies the search order ...
#define false
Definition: stdbool.h:17
Encodes a location in the source.
bool isSystemHeaderDirectory() const
Whether this describes a system header directory.
LookupType_t getLookupType() const
getLookupType - Return the kind of directory lookup that this is: either a normal directory...
SrcMgr::CharacteristicKind getDirCharacteristic() const
DirCharacteristic - The type of directory this is, one of the DirType enum values.
bool haveSearchedAllModuleMaps() const
Determine whether we have already searched this entire directory for module maps. ...
const HeaderMap * getHeaderMap() const
getHeaderMap - Return the directory that this entry refers to.
Dataflow Directional Tag Classes.
A reference to a DirectoryEntry that includes the name of the directory as it was accessed by the Fil...
Definition: FileManager.h:57
const DirectoryEntry * getDir() const
getDir - Return the directory that this entry refers to.
Cached information about one directory (either on disk or in the virtual file system).
Definition: FileManager.h:45
Optional< FileEntryRef > 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) const
LookupFile - Lookup the specified file in this search path, returning it if it exists or returning nu...
void setSearchedAllModuleMaps(bool SAMM)
Specify whether we have already searched all of the subdirectories for module maps.
A header that is known to reside within a given module, whether it was included or excluded...
Definition: ModuleMap.h:150
const DirectoryEntry * getFrameworkDir() const
getFrameworkDir - Return the directory that this framework refers to.