DirectoryLookup.h revision b5142bb7af5c70fffd09f05172a1379a35a9c29a 
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  template <typename T> class SmallVectorImpl;
22}
23namespace clang {
24class HeaderMap;
25class DirectoryEntry;
26class FileEntry;
27class HeaderSearch;
28
29/// DirectoryLookup - This class represents one entry in the search list that
30/// specifies the search order for directories in #include directives.  It
31/// represents either a directory, a framework, or a headermap.
32///
33class DirectoryLookup {
34public:
35  enum LookupType_t {
36    LT_NormalDir,
37    LT_Framework,
38    LT_HeaderMap
39  };
40private:
41  union {  // This union is discriminated by isHeaderMap.
42    /// Dir - This is the actual directory that we're referring to for a normal
43    /// directory or a framework.
44    const DirectoryEntry *Dir;
45
46    /// Map - This is the HeaderMap if this is a headermap lookup.
47    ///
48    const HeaderMap *Map;
49  } u;
50
51  /// DirCharacteristic - The type of directory this is: this is an instance of
52  /// SrcMgr::CharacteristicKind.
53  unsigned DirCharacteristic : 2;
54
55  /// UserSupplied - True if this is a user-supplied directory.
56  ///
57  bool UserSupplied : 1;
58
59  /// LookupType - This indicates whether this DirectoryLookup object is a
60  /// normal directory, a framework, or a headermap.
61  unsigned LookupType : 2;
62public:
63  /// DirectoryLookup ctor - Note that this ctor *does not take ownership* of
64  /// 'dir'.
65  DirectoryLookup(const DirectoryEntry *dir, SrcMgr::CharacteristicKind DT,
66                  bool isUser, bool isFramework)
67    : DirCharacteristic(DT), UserSupplied(isUser),
68     LookupType(isFramework ? LT_Framework : LT_NormalDir) {
69    u.Dir = dir;
70  }
71
72  /// DirectoryLookup ctor - Note that this ctor *does not take ownership* of
73  /// 'map'.
74  DirectoryLookup(const HeaderMap *map, SrcMgr::CharacteristicKind DT,
75                  bool isUser)
76    : DirCharacteristic(DT), UserSupplied(isUser), LookupType(LT_HeaderMap) {
77    u.Map = map;
78  }
79
80  /// getLookupType - Return the kind of directory lookup that this is: either a
81  /// normal directory, a framework path, or a HeaderMap.
82  LookupType_t getLookupType() const { return (LookupType_t)LookupType; }
83
84  /// getName - Return the directory or filename corresponding to this lookup
85  /// object.
86  const char *getName() const;
87
88  /// getDir - Return the directory that this entry refers to.
89  ///
90  const DirectoryEntry *getDir() const { return isNormalDir() ? u.Dir : 0; }
91
92  /// getFrameworkDir - Return the directory that this framework refers to.
93  ///
94  const DirectoryEntry *getFrameworkDir() const {
95    return isFramework() ? u.Dir : 0;
96  }
97
98  /// getHeaderMap - Return the directory that this entry refers to.
99  ///
100  const HeaderMap *getHeaderMap() const { return isHeaderMap() ? u.Map : 0; }
101
102  /// isNormalDir - Return true if this is a normal directory, not a header map.
103  bool isNormalDir() const { return getLookupType() == LT_NormalDir; }
104
105  /// isFramework - True if this is a framework directory.
106  ///
107  bool isFramework() const { return getLookupType() == LT_Framework; }
108
109  /// isHeaderMap - Return true if this is a header map, not a normal directory.
110  bool isHeaderMap() const { return getLookupType() == LT_HeaderMap; }
111
112  /// DirCharacteristic - The type of directory this is, one of the DirType enum
113  /// values.
114  SrcMgr::CharacteristicKind getDirCharacteristic() const {
115    return (SrcMgr::CharacteristicKind)DirCharacteristic;
116  }
117
118  /// isUserSupplied - True if this is a user-supplied directory.
119  ///
120  bool isUserSupplied() const { return UserSupplied; }
121
122
123  /// LookupFile - Lookup the specified file in this search path, returning it
124  /// if it exists or returning null if not.
125  /// If RawPath is not NULL and the file is found, RawPath will be set to the
126  /// raw path at which the file was found in the file system. For example,
127  /// for a search path ".." and a filename "../file.h" this would be
128  /// "../../file.h".
129  const FileEntry *LookupFile(llvm::StringRef Filename, HeaderSearch &HS,
130                              llvm::SmallVectorImpl<char> *RawPath) const;
131
132private:
133  const FileEntry *DoFrameworkLookup(
134      llvm::StringRef Filename, HeaderSearch &HS,
135      llvm::SmallVectorImpl<char> *RawPath) const;
136
137};
138
139}  // end namespace clang
140
141#endif
142