DirectoryLookup.h revision a139481e62fdb209d9d87a54a5733f989d2e8d51 
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/SourceManager.h"
18
19namespace llvm {
20  class StringRef;
21}
22namespace clang {
23class HeaderMap;
24class DirectoryEntry;
25class FileEntry;
26class HeaderSearch;
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  /// UserSupplied - True if this is a user-supplied directory.
55  ///
56  bool UserSupplied : 1;
57
58  /// LookupType - This indicates whether this DirectoryLookup object is a
59  /// normal directory, a framework, or a headermap.
60  unsigned LookupType : 2;
61public:
62  /// DirectoryLookup ctor - Note that this ctor *does not take ownership* of
63  /// 'dir'.
64  DirectoryLookup(const DirectoryEntry *dir, SrcMgr::CharacteristicKind DT,
65                  bool isUser, bool isFramework)
66    : DirCharacteristic(DT), UserSupplied(isUser),
67     LookupType(isFramework ? LT_Framework : LT_NormalDir) {
68    u.Dir = dir;
69  }
70
71  /// DirectoryLookup ctor - Note that this ctor *does not take ownership* of
72  /// 'map'.
73  DirectoryLookup(const HeaderMap *map, SrcMgr::CharacteristicKind DT,
74                  bool isUser)
75    : DirCharacteristic(DT), UserSupplied(isUser), LookupType(LT_HeaderMap) {
76    u.Map = map;
77  }
78
79  /// getLookupType - Return the kind of directory lookup that this is: either a
80  /// normal directory, a framework path, or a HeaderMap.
81  LookupType_t getLookupType() const { return (LookupType_t)LookupType; }
82
83  /// getName - Return the directory or filename corresponding to this lookup
84  /// object.
85  const char *getName() const;
86
87  /// getDir - Return the directory that this entry refers to.
88  ///
89  const DirectoryEntry *getDir() const { return isNormalDir() ? u.Dir : 0; }
90
91  /// getFrameworkDir - Return the directory that this framework refers to.
92  ///
93  const DirectoryEntry *getFrameworkDir() const {
94    return isFramework() ? u.Dir : 0;
95  }
96
97  /// getHeaderMap - Return the directory that this entry refers to.
98  ///
99  const HeaderMap *getHeaderMap() const { return isHeaderMap() ? u.Map : 0; }
100
101  /// isNormalDir - Return true if this is a normal directory, not a header map.
102  bool isNormalDir() const { return getLookupType() == LT_NormalDir; }
103
104  /// isFramework - True if this is a framework directory.
105  ///
106  bool isFramework() const { return getLookupType() == LT_Framework; }
107
108  /// isHeaderMap - Return true if this is a header map, not a normal directory.
109  bool isHeaderMap() const { return getLookupType() == LT_HeaderMap; }
110
111  /// DirCharacteristic - The type of directory this is, one of the DirType enum
112  /// values.
113  SrcMgr::CharacteristicKind getDirCharacteristic() const {
114    return (SrcMgr::CharacteristicKind)DirCharacteristic;
115  }
116
117  /// isUserSupplied - True if this is a user-supplied directory.
118  ///
119  bool isUserSupplied() const { return UserSupplied; }
120
121
122  /// LookupFile - Lookup the specified file in this search path, returning it
123  /// if it exists or returning null if not.
124  const FileEntry *LookupFile(llvm::StringRef Filename, HeaderSearch &HS) const;
125
126private:
127  const FileEntry *DoFrameworkLookup(llvm::StringRef Filename,
128                                     HeaderSearch &HS) const;
129
130};
131
132}  // end namespace clang
133
134#endif
135