clang  3.9.0
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  const char *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
Defines the SourceManager interface.
const HeaderMap * Map
Map - This is the HeaderMap if this is a headermap lookup.
SrcMgr::CharacteristicKind getDirCharacteristic() const
DirCharacteristic - The type of directory this is, one of the DirType enum values.
const DirectoryEntry * Dir
Dir - This is the actual directory that we'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:78
This class represents an Apple concept known as a 'header map'.
Definition: HeaderMap.h:67
bool isFramework() const
isFramework - True if this is a framework directory.
DirectoryLookup(const DirectoryEntry *dir, SrcMgr::CharacteristicKind DT, bool isFramework)
DirectoryLookup ctor - Note that this ctor does not take ownership of 'dir'.
Describes a module or submodule.
Definition: Basic/Module.h:47
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
const HeaderMap * getHeaderMap() const
getHeaderMap - Return the directory that this entry refers to.
StringRef Filename
Definition: Format.cpp:1194
LookupType_t getLookupType() const
getLookupType - Return the kind of directory lookup that this is: either a normal directory...
bool isSystemHeaderDirectory() const
Whether this describes a system header directory.
bool isNormalDir() const
isNormalDir - Return true if this is a normal directory, not a header map.
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 ...
bool haveSearchedAllModuleMaps() const
Determine whether we have already searched this entire directory for module maps. ...
#define false
Definition: stdbool.h:33
const DirectoryEntry * getFrameworkDir() const
getFrameworkDir - Return the directory that this framework refers to.
Encodes a location in the source.
Cached information about one file (either on disk or in the virtual file system). ...
Definition: FileManager.h:53
const char * getName() const
getName - Return the directory or filename corresponding to this lookup object.
Cached information about one directory (either on disk or in the virtual file system).
Definition: FileManager.h:40
bool isHeaderMap() const
isHeaderMap - Return true if this is a header map, not a normal directory.
DirectoryLookup(const HeaderMap *map, SrcMgr::CharacteristicKind DT, bool isIndexHeaderMap)
DirectoryLookup ctor - Note that this ctor does not take ownership of 'map'.
bool isIndexHeaderMap() const
Whether this header map is building a framework or not.
const DirectoryEntry * getDir() const
getDir - Return the directory that this entry refers to.
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:115