1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
|
//===--- ModuleMap.h - Describe the layout of modules -----------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines the ModuleMap interface, which describes the layout of a
// module as it relates to headers.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_CLANG_LEX_MODULEMAP_H
#define LLVM_CLANG_LEX_MODULEMAP_H
#include "clang/Basic/LangOptions.h"
#include "clang/Basic/SourceManager.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/IntrusiveRefCntPtr.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/StringMap.h"
#include <string>
namespace clang {
class DirectoryEntry;
class FileEntry;
class FileManager;
class DiagnosticConsumer;
class DiagnosticsEngine;
class ModuleMapParser;
class ModuleMap {
public:
/// \brief Describes a module or submodule.
struct Module {
/// \brief The name of this module.
std::string Name;
/// \brief The location of the module definition.
SourceLocation DefinitionLoc;
/// \brief The parent of this module. This will be NULL for the top-level
/// module.
Module *Parent;
/// \brief The umbrella header, if any.
///
/// Only the top-level module can have an umbrella header.
const FileEntry *UmbrellaHeader;
/// \brief The submodules of this module, indexed by name.
llvm::StringMap<Module *> SubModules;
/// \brief The headers that are part of this module.
llvm::SmallVector<const FileEntry *, 2> Headers;
/// \brief Whether this is an explicit submodule.
bool IsExplicit;
/// \brief Construct a top-level module.
explicit Module(StringRef Name, SourceLocation DefinitionLoc)
: Name(Name), DefinitionLoc(DefinitionLoc), Parent(0), UmbrellaHeader(0),
IsExplicit(false) { }
/// \brief Construct a new module or submodule.
Module(StringRef Name, SourceLocation DefinitionLoc, Module *Parent,
bool IsExplicit)
: Name(Name), DefinitionLoc(DefinitionLoc), Parent(Parent),
UmbrellaHeader(0), IsExplicit(IsExplicit) {
}
/// \brief Determine whether this module is a submodule.
bool isSubModule() const { return Parent != 0; }
/// \brief Retrieve the full name of this module, including the path from
/// its top-level module.
std::string getFullModuleName() const;
/// \brief Retrieve the name of the top-level module.
StringRef getTopLevelModuleName() const;
};
private:
SourceManager *SourceMgr;
llvm::IntrusiveRefCntPtr<DiagnosticsEngine> Diags;
LangOptions LangOpts;
/// \brief The top-level modules that are known.
llvm::StringMap<Module *> Modules;
/// \brief Mapping from each header to the module that owns the contents of the
/// that header.
llvm::DenseMap<const FileEntry *, Module *> Headers;
/// \brief Mapping from directories with umbrella headers to the module
/// that is generated from the umbrella header.
///
/// This mapping is used to map headers that haven't explicitly been named
/// in the module map over to the module that includes them via its umbrella
/// header.
llvm::DenseMap<const DirectoryEntry *, Module *> UmbrellaDirs;
friend class ModuleMapParser;
public:
/// \brief Construct a new module map.
///
/// \param FileMgr The file manager used to find module files and headers.
/// This file manager should be shared with the header-search mechanism, since
/// they will refer to the same headers.
///
/// \param DC A diagnostic consumer that will be cloned for use in generating
/// diagnostics.
ModuleMap(FileManager &FileMgr, const DiagnosticConsumer &DC);
/// \brief Destroy the module map.
///
~ModuleMap();
/// \brief Retrieve the module that owns the given header file, if any.
///
/// \param File The header file that is likely to be included.
///
/// \returns The module that owns the given header file, or null to indicate
/// that no module owns this header file.
Module *findModuleForHeader(const FileEntry *File);
/// \brief Retrieve a module with the given name.
///
/// \param The name of the module to look up.
///
/// \returns The named module, if known; otherwise, returns null.
Module *findModule(StringRef Name);
/// \brief Parse the given module map file, and record any modules we
/// encounter.
///
/// \param File The file to be parsed.
///
/// \returns true if an error occurred, false otherwise.
bool parseModuleMapFile(const FileEntry *File);
/// \brief Dump the contents of the module map, for debugging purposes.
void dump();
};
}
#endif
|
