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"
18#include "clang/Basic/SourceManager.h"
19#include "clang/Lex/ModuleMap.h"
20
21namespace clang {
22class HeaderMap;
23class DirectoryEntry;
24class FileEntry;
25class HeaderSearch;
26class 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///
32class DirectoryLookup {
33public:
34  enum LookupType_t {
35    LT_NormalDir,
36    LT_Framework,
37    LT_HeaderMap
38  };
39private:
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.
43    const DirectoryEntry *Dir;
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
65public:
66  /// DirectoryLookup ctor - Note that this ctor *does not take ownership* of
67  /// 'dir'.
68  DirectoryLookup(const DirectoryEntry *dir, SrcMgr::CharacteristicKind DT,
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'.
78  DirectoryLookup(const HeaderMap *map, SrcMgr::CharacteristicKind DT,
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  ///
101  const DirectoryEntry *getFrameworkDir() const {
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.
133  SrcMgr::CharacteristicKind getDirCharacteristic() const {
134    return (SrcMgr::CharacteristicKind)DirCharacteristic;
135  }
136
137  /// \brief Whether this describes a system header directory.
138  bool isSystemHeaderDirectory() const {
139    return getDirCharacteristic() != SrcMgr::C_User;
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 SuggestedModule If non-null, and the file found is semantically
162  /// part of a known module, this will be set to the module that should
163  /// be imported instead of preprocessing/parsing the file found.
164  ///
165  /// \param [out] InUserSpecifiedSystemFramework If the file is found,
166  /// set to true if the file is located in a framework that has been
167  /// user-specified to be treated as a system framework.
168  ///
169  /// \param [out] MappedName if this is a headermap which maps the filename to
170  /// a framework include ("Foo.h" -> "Foo/Foo.h"), set the new name to this
171  /// vector and point Filename to it.
172  const FileEntry *LookupFile(StringRef &Filename, HeaderSearch &HS,
173                              SmallVectorImpl<char> *SearchPath,
174                              SmallVectorImpl<char> *RelativePath,
175                              ModuleMap::KnownHeader *SuggestedModule,
176                              bool &InUserSpecifiedSystemFramework,
177                              bool &HasBeenMapped,
178                              SmallVectorImpl<char> &MappedName) const;
179
180private:
181  const FileEntry *DoFrameworkLookup(
182      StringRef Filename, HeaderSearch &HS,
183      SmallVectorImpl<char> *SearchPath,
184      SmallVectorImpl<char> *RelativePath,
185      ModuleMap::KnownHeader *SuggestedModule,
186      bool &InUserSpecifiedSystemHeader) const;
187
188};
189
190}  // end namespace clang
191
192#endif
193