clang  3.8.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 SearchPath If not NULL, will be set to the search path relative
155  /// to which the file was found.
156  ///
157  /// \param RelativePath If not NULL, will be set to the path relative to
158  /// SearchPath at which the file was found. This only differs from the
159  /// Filename for framework includes.
160  ///
161  /// \param RequestingModule The module in which the lookup was performed.
162  ///
163  /// \param SuggestedModule If non-null, and the file found is semantically
164  /// part of a known module, this will be set to the module that should
165  /// be imported instead of preprocessing/parsing the file found.
166  ///
167  /// \param [out] InUserSpecifiedSystemFramework If the file is found,
168  /// set to true if the file is located in a framework that has been
169  /// user-specified to be treated as a system framework.
170  ///
171  /// \param [out] MappedName if this is a headermap which maps the filename to
172  /// a framework include ("Foo.h" -> "Foo/Foo.h"), set the new name to this
173  /// vector and point Filename to it.
174  const FileEntry *LookupFile(StringRef &Filename, HeaderSearch &HS,
175  SmallVectorImpl<char> *SearchPath,
176  SmallVectorImpl<char> *RelativePath,
177  Module *RequestingModule,
178  ModuleMap::KnownHeader *SuggestedModule,
179  bool &InUserSpecifiedSystemFramework,
180  bool &HasBeenMapped,
181  SmallVectorImpl<char> &MappedName) const;
182 
183 private:
184  const FileEntry *DoFrameworkLookup(
185  StringRef Filename, HeaderSearch &HS,
186  SmallVectorImpl<char> *SearchPath,
187  SmallVectorImpl<char> *RelativePath,
188  Module *RequestingModule,
189  ModuleMap::KnownHeader *SuggestedModule,
190  bool &InUserSpecifiedSystemHeader) const;
191 
192 };
193 
194 } // end namespace clang
195 
196 #endif
const FileEntry * LookupFile(StringRef &Filename, HeaderSearch &HS, 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...
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:79
This class represents an Apple concept known as a 'header map'.
Definition: HeaderMap.h:34
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:1723
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.
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.
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:108