Coverage Report

Created: 2018-07-21 08:31

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/tools/clang/include/clang/Lex/DirectoryLookup.h
Line
Count
Source (jump to first uncovered line)
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
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
///
32
0
class DirectoryLookup {
33
public:
34
  enum LookupType_t {
35
    LT_NormalDir,
36
    LT_Framework,
37
    LT_HeaderMap
38
  };
39
private:
40
0
  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
  /// Whether this is a header map used when building a framework.
59
  unsigned IsIndexHeaderMap : 1;
60
61
  /// 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'.
68
  DirectoryLookup(const DirectoryEntry *dir, SrcMgr::CharacteristicKind DT,
69
                  bool isFramework)
70
    : DirCharacteristic(DT),
71
      LookupType(isFramework ? LT_Framework : LT_NormalDir),
72
108k
      IsIndexHeaderMap(false), SearchedAllModuleMaps(false) {
73
108k
    u.Dir = dir;
74
108k
  }
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
28
      IsIndexHeaderMap(isIndexHeaderMap), SearchedAllModuleMaps(false) {
82
28
    u.Map = map;
83
28
  }
84
85
  /// getLookupType - Return the kind of directory lookup that this is: either a
86
  /// normal directory, a framework path, or a HeaderMap.
87
8.68M
  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
5.69M
  const DirectoryEntry *getDir() const {
96
5.69M
    return isNormalDir() ? u.Dir : 
nullptr0
;
97
5.69M
  }
98
99
  /// getFrameworkDir - Return the directory that this framework refers to.
100
  ///
101
43.0k
  const DirectoryEntry *getFrameworkDir() const {
102
43.0k
    return isFramework() ? u.Dir : 
nullptr0
;
103
43.0k
  }
104
105
  /// getHeaderMap - Return the directory that this entry refers to.
106
  ///
107
72
  const HeaderMap *getHeaderMap() const {
108
72
    return isHeaderMap() ? u.Map : 
nullptr0
;
109
72
  }
110
111
  /// isNormalDir - Return true if this is a normal directory, not a header map.
112
7.70M
  bool isNormalDir() const { return getLookupType() == LT_NormalDir; }
113
114
  /// isFramework - True if this is a framework directory.
115
  ///
116
85.3k
  bool isFramework() const { return getLookupType() == LT_Framework; }
117
118
  /// isHeaderMap - Return true if this is a header map, not a normal directory.
119
844k
  bool isHeaderMap() const { return getLookupType() == LT_HeaderMap; }
120
121
  /// Determine whether we have already searched this entire
122
  /// directory for module maps.
123
152
  bool haveSearchedAllModuleMaps() const { return SearchedAllModuleMaps; }
124
125
  /// Specify whether we have already searched all of the subdirectories
126
  /// for module maps.
127
65
  void setSearchedAllModuleMaps(bool SAMM) {
128
65
    SearchedAllModuleMaps = SAMM;
129
65
  }
130
131
  /// DirCharacteristic - The type of directory this is, one of the DirType enum
132
  /// values.
133
2.76M
  SrcMgr::CharacteristicKind getDirCharacteristic() const {
134
2.76M
    return (SrcMgr::CharacteristicKind)DirCharacteristic;
135
2.76M
  }
136
137
  /// Whether this describes a system header directory.
138
1.86M
  bool isSystemHeaderDirectory() const {
139
1.86M
    return getDirCharacteristic() != SrcMgr::C_User;
140
1.86M
  }
141
142
  /// Whether this header map is building a framework or not.
143
844k
  bool isIndexHeaderMap() const { 
144
844k
    return isHeaderMap() && 
IsIndexHeaderMap0
;
145
844k
  }
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