clang  6.0.0svn
DirectoryLookup.h
Go to the documentation of this file.
1 //===--- DirectoryLookup.h - Info for searching for headers -----*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file defines the DirectoryLookup interface.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_CLANG_LEX_DIRECTORYLOOKUP_H
15 #define LLVM_CLANG_LEX_DIRECTORYLOOKUP_H
16 
17 #include "clang/Basic/LLVM.h"
19 #include "clang/Lex/ModuleMap.h"
20 
21 namespace clang {
22 class HeaderMap;
23 class DirectoryEntry;
24 class FileEntry;
25 class HeaderSearch;
26 class Module;
27 
28 /// DirectoryLookup - This class represents one entry in the search list that
29 /// specifies the search order for directories in \#include directives. It
30 /// represents either a directory, a framework, or a headermap.
31 ///
33 public:
34  enum LookupType_t {
38  };
39 private:
40  union { // This union is discriminated by isHeaderMap.
41  /// Dir - This is the actual directory that we're referring to for a normal
42  /// directory or a framework.
44 
45  /// Map - This is the HeaderMap if this is a headermap lookup.
46  ///
47  const HeaderMap *Map;
48  } u;
49 
50  /// DirCharacteristic - The type of directory this is: this is an instance of
51  /// SrcMgr::CharacteristicKind.
52  unsigned DirCharacteristic : 2;
53 
54  /// LookupType - This indicates whether this DirectoryLookup object is a
55  /// normal directory, a framework, or a headermap.
56  unsigned LookupType : 2;
57 
58  /// \brief Whether this is a header map used when building a framework.
59  unsigned IsIndexHeaderMap : 1;
60 
61  /// \brief Whether we've performed an exhaustive search for module maps
62  /// within the subdirectories of this directory.
63  unsigned SearchedAllModuleMaps : 1;
64 
65 public:
66  /// DirectoryLookup ctor - Note that this ctor *does not take ownership* of
67  /// 'dir'.
69  bool isFramework)
70  : DirCharacteristic(DT),
71  LookupType(isFramework ? LT_Framework : LT_NormalDir),
72  IsIndexHeaderMap(false), SearchedAllModuleMaps(false) {
73  u.Dir = dir;
74  }
75 
76  /// DirectoryLookup ctor - Note that this ctor *does not take ownership* of
77  /// 'map'.
79  bool isIndexHeaderMap)
80  : DirCharacteristic(DT), LookupType(LT_HeaderMap),
81  IsIndexHeaderMap(isIndexHeaderMap), SearchedAllModuleMaps(false) {
82  u.Map = map;
83  }
84 
85  /// getLookupType - Return the kind of directory lookup that this is: either a
86  /// normal directory, a framework path, or a HeaderMap.
87  LookupType_t getLookupType() const { return (LookupType_t)LookupType; }
88 
89  /// getName - Return the directory or filename corresponding to this lookup
90  /// object.
91  StringRef getName() const;
92 
93  /// getDir - Return the directory that this entry refers to.
94  ///
95  const DirectoryEntry *getDir() const {
96  return isNormalDir() ? u.Dir : nullptr;
97  }
98 
99  /// getFrameworkDir - Return the directory that this framework refers to.
100  ///
102  return isFramework() ? u.Dir : nullptr;
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  /// \brief Determine whether we have already searched this entire
122  /// directory for module maps.
123  bool haveSearchedAllModuleMaps() const { return SearchedAllModuleMaps; }
124 
125  /// \brief 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  /// \brief Whether this describes a system header directory.
138  bool isSystemHeaderDirectory() const {
140  }
141 
142  /// \brief 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] MappedName if this is a headermap which maps the filename to
175  /// a framework include ("Foo.h" -> "Foo/Foo.h"), set the new name to this
176  /// vector and point Filename to it.
177  const FileEntry *LookupFile(StringRef &Filename, HeaderSearch &HS,
178  SourceLocation IncludeLoc,
179  SmallVectorImpl<char> *SearchPath,
180  SmallVectorImpl<char> *RelativePath,
181  Module *RequestingModule,
182  ModuleMap::KnownHeader *SuggestedModule,
183  bool &InUserSpecifiedSystemFramework,
184  bool &HasBeenMapped,
185  SmallVectorImpl<char> &MappedName) const;
186 
187 private:
188  const FileEntry *DoFrameworkLookup(
189  StringRef Filename, HeaderSearch &HS,
190  SmallVectorImpl<char> *SearchPath,
191  SmallVectorImpl<char> *RelativePath,
192  Module *RequestingModule,
193  ModuleMap::KnownHeader *SuggestedModule,
194  bool &InUserSpecifiedSystemHeader) const;
195 
196 };
197 
198 } // end namespace clang
199 
200 #endif
bool isIndexHeaderMap() const
Whether this header map is building a framework or not.
Defines the SourceManager interface.
const HeaderMap * Map
Map - This is the HeaderMap if this is a headermap lookup.
StringRef getName() const
getName - Return the directory or filename corresponding to this lookup object.
const DirectoryEntry * Dir
Dir - This is the actual directory that we&#39;re referring to for a normal directory or a framework...
CharacteristicKind
Indicates whether a file or directory holds normal user code, system code, or system code which is im...
Definition: SourceManager.h:82
This class represents an Apple concept known as a &#39;header map&#39;.
Definition: HeaderMap.h:67
bool isHeaderMap() const
isHeaderMap - Return true if this is a header map, not a normal directory.
DirectoryLookup(const DirectoryEntry *dir, SrcMgr::CharacteristicKind DT, bool isFramework)
DirectoryLookup ctor - Note that this ctor does not take ownership of &#39;dir&#39;.
Describes a module or submodule.
Definition: Module.h:57
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
Encapsulates the information needed to find the file referenced by a #include or #include_next, (sub-)framework lookup, etc.
Definition: HeaderSearch.h:137
StringRef Filename
Definition: Format.cpp:1316
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.
const FileEntry * LookupFile(StringRef &Filename, HeaderSearch &HS, SourceLocation IncludeLoc, SmallVectorImpl< char > *SearchPath, SmallVectorImpl< char > *RelativePath, Module *RequestingModule, ModuleMap::KnownHeader *SuggestedModule, bool &InUserSpecifiedSystemFramework, bool &HasBeenMapped, SmallVectorImpl< char > &MappedName) const
LookupFile - Lookup the specified file in this search path, returning it if it exists or returning nu...
DirectoryLookup - This class represents one entry in the search list that specifies the search order ...
#define false
Definition: stdbool.h:33
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...
Cached information about one file (either on disk or in the virtual file system). ...
Definition: FileManager.h:59
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.
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
DirectoryLookup(const HeaderMap *map, SrcMgr::CharacteristicKind DT, bool isIndexHeaderMap)
DirectoryLookup ctor - Note that this ctor does not take ownership of &#39;map&#39;.
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:131
const DirectoryEntry * getFrameworkDir() const
getFrameworkDir - Return the directory that this framework refers to.