1 //===--- MultiplexExternalSemaSource.cpp  ---------------------------------===//
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 implements the event dispatching to the subscribed clients.
11 //
12 //===----------------------------------------------------------------------===//
13 #include "clang/Sema/MultiplexExternalSemaSource.h"
14 
15 #include "clang/AST/DeclContextInternals.h"
16 #include "clang/Sema/Lookup.h"
17 
18 using namespace clang;
19 
20 ///\brief Constructs a new multiplexing external sema source and appends the
21 /// given element to it.
22 ///
23 ///\param[in] source - An ExternalSemaSource.
24 ///
25 MultiplexExternalSemaSource::MultiplexExternalSemaSource(ExternalSemaSource &s1,
26                                                         ExternalSemaSource &s2){
27   Sources.push_back(&s1);
28   Sources.push_back(&s2);
29 }
30 
31 // pin the vtable here.
32 MultiplexExternalSemaSource::~MultiplexExternalSemaSource() {}
33 
34 ///\brief Appends new source to the source list.
35 ///
36 ///\param[in] source - An ExternalSemaSource.
37 ///
38 void MultiplexExternalSemaSource::addSource(ExternalSemaSource &source) {
39   Sources.push_back(&source);
40 }
41 
42 //===----------------------------------------------------------------------===//
43 // ExternalASTSource.
44 //===----------------------------------------------------------------------===//
45 
46 Decl *MultiplexExternalSemaSource::GetExternalDecl(uint32_t ID) {
47   for(size_t i = 0; i < Sources.size(); ++i)
48     if (Decl *Result = Sources[i]->GetExternalDecl(ID))
49       return Result;
50   return 0;
51 }
52 
53 Selector MultiplexExternalSemaSource::GetExternalSelector(uint32_t ID) {
54   Selector Sel;
55   for(size_t i = 0; i < Sources.size(); ++i) {
56     Sel = Sources[i]->GetExternalSelector(ID);
57     if (!Sel.isNull())
58       return Sel;
59   }
60   return Sel;
61 }
62 
63 uint32_t MultiplexExternalSemaSource::GetNumExternalSelectors() {
64   uint32_t total = 0;
65   for(size_t i = 0; i < Sources.size(); ++i)
66     total += Sources[i]->GetNumExternalSelectors();
67   return total;
68 }
69 
70 Stmt *MultiplexExternalSemaSource::GetExternalDeclStmt(uint64_t Offset) {
71   for(size_t i = 0; i < Sources.size(); ++i)
72     if (Stmt *Result = Sources[i]->GetExternalDeclStmt(Offset))
73       return Result;
74   return 0;
75 }
76 
77 CXXBaseSpecifier *MultiplexExternalSemaSource::GetExternalCXXBaseSpecifiers(
78                                                                uint64_t Offset){
79   for(size_t i = 0; i < Sources.size(); ++i)
80     if (CXXBaseSpecifier *R = Sources[i]->GetExternalCXXBaseSpecifiers(Offset))
81       return R;
82   return 0;
83 }
84 
85 DeclContextLookupResult MultiplexExternalSemaSource::
86 FindExternalVisibleDeclsByName(const DeclContext *DC, DeclarationName Name) {
87   StoredDeclsList DeclsFound;
88   DeclContextLookupResult lookup;
89   for(size_t i = 0; i < Sources.size(); ++i) {
90     lookup = Sources[i]->FindExternalVisibleDeclsByName(DC, Name);
91     while(lookup.first != lookup.second) {
92       if (!DeclsFound.HandleRedeclaration(*lookup.first))
93         DeclsFound.AddSubsequentDecl(*lookup.first);
94       lookup.first++;
95     }
96   }
97   return DeclsFound.getLookupResult();
98 }
99 
100 void MultiplexExternalSemaSource::completeVisibleDeclsMap(const DeclContext *DC){
101   for(size_t i = 0; i < Sources.size(); ++i)
102     Sources[i]->completeVisibleDeclsMap(DC);
103 }
104 
105 ExternalLoadResult MultiplexExternalSemaSource::
106 FindExternalLexicalDecls(const DeclContext *DC,
107                          bool (*isKindWeWant)(Decl::Kind),
108                          SmallVectorImpl<Decl*> &Result) {
109   for(size_t i = 0; i < Sources.size(); ++i)
110     // FIXME: The semantics of the return result is unclear to me...
111     Sources[i]->FindExternalLexicalDecls(DC, isKindWeWant, Result);
112 
113   return ELR_Success;
114 }
115 
116 void MultiplexExternalSemaSource::FindFileRegionDecls(FileID File,
117                                                       unsigned Offset,
118                                                       unsigned Length,
119                                                 SmallVectorImpl<Decl *> &Decls){
120   for(size_t i = 0; i < Sources.size(); ++i)
121     Sources[i]->FindFileRegionDecls(File, Offset, Length, Decls);
122 }
123 
124 void MultiplexExternalSemaSource::CompleteType(TagDecl *Tag) {
125   for(size_t i = 0; i < Sources.size(); ++i)
126     Sources[i]->CompleteType(Tag);
127 }
128 
129 void MultiplexExternalSemaSource::CompleteType(ObjCInterfaceDecl *Class) {
130   for(size_t i = 0; i < Sources.size(); ++i)
131     Sources[i]->CompleteType(Class);
132 }
133 
134 void MultiplexExternalSemaSource::ReadComments() {
135   for(size_t i = 0; i < Sources.size(); ++i)
136     Sources[i]->ReadComments();
137 }
138 
139 void MultiplexExternalSemaSource::StartedDeserializing() {
140   for(size_t i = 0; i < Sources.size(); ++i)
141     Sources[i]->StartedDeserializing();
142 }
143 
144 void MultiplexExternalSemaSource::FinishedDeserializing() {
145   for(size_t i = 0; i < Sources.size(); ++i)
146     Sources[i]->FinishedDeserializing();
147 }
148 
149 void MultiplexExternalSemaSource::StartTranslationUnit(ASTConsumer *Consumer) {
150   for(size_t i = 0; i < Sources.size(); ++i)
151     Sources[i]->StartTranslationUnit(Consumer);
152 }
153 
154 void MultiplexExternalSemaSource::PrintStats() {
155   for(size_t i = 0; i < Sources.size(); ++i)
156     Sources[i]->PrintStats();
157 }
158 
159 bool MultiplexExternalSemaSource::layoutRecordType(const RecordDecl *Record,
160                                                    uint64_t &Size,
161                                                    uint64_t &Alignment,
162                       llvm::DenseMap<const FieldDecl *, uint64_t> &FieldOffsets,
163                   llvm::DenseMap<const CXXRecordDecl *, CharUnits> &BaseOffsets,
164           llvm::DenseMap<const CXXRecordDecl *, CharUnits> &VirtualBaseOffsets){
165   for(size_t i = 0; i < Sources.size(); ++i)
166     if (Sources[i]->layoutRecordType(Record, Size, Alignment, FieldOffsets,
167                                      BaseOffsets, VirtualBaseOffsets))
168       return true;
169   return false;
170 }
171 
172 void MultiplexExternalSemaSource::
173 getMemoryBufferSizes(MemoryBufferSizes &sizes) const {
174   for(size_t i = 0; i < Sources.size(); ++i)
175     Sources[i]->getMemoryBufferSizes(sizes);
176 
177 }
178 
179 //===----------------------------------------------------------------------===//
180 // ExternalSemaSource.
181 //===----------------------------------------------------------------------===//
182 
183 
184 void MultiplexExternalSemaSource::InitializeSema(Sema &S) {
185   for(size_t i = 0; i < Sources.size(); ++i)
186     Sources[i]->InitializeSema(S);
187 }
188 
189 void MultiplexExternalSemaSource::ForgetSema() {
190   for(size_t i = 0; i < Sources.size(); ++i)
191     Sources[i]->ForgetSema();
192 }
193 
194 void MultiplexExternalSemaSource::ReadMethodPool(Selector Sel) {
195   for(size_t i = 0; i < Sources.size(); ++i)
196     Sources[i]->ReadMethodPool(Sel);
197 }
198 
199 void MultiplexExternalSemaSource::ReadKnownNamespaces(
200                                    SmallVectorImpl<NamespaceDecl*> &Namespaces){
201   for(size_t i = 0; i < Sources.size(); ++i)
202     Sources[i]->ReadKnownNamespaces(Namespaces);
203 }
204 
205 bool MultiplexExternalSemaSource::LookupUnqualified(LookupResult &R, Scope *S){
206   for(size_t i = 0; i < Sources.size(); ++i)
207     Sources[i]->LookupUnqualified(R, S);
208 
209   return !R.empty();
210 }
211 
212 void MultiplexExternalSemaSource::ReadTentativeDefinitions(
213                                      SmallVectorImpl<VarDecl*> &TentativeDefs) {
214   for(size_t i = 0; i < Sources.size(); ++i)
215     Sources[i]->ReadTentativeDefinitions(TentativeDefs);
216 }
217 
218 void MultiplexExternalSemaSource::ReadUnusedFileScopedDecls(
219                                 SmallVectorImpl<const DeclaratorDecl*> &Decls) {
220   for(size_t i = 0; i < Sources.size(); ++i)
221     Sources[i]->ReadUnusedFileScopedDecls(Decls);
222 }
223 
224 void MultiplexExternalSemaSource::ReadDelegatingConstructors(
225                                   SmallVectorImpl<CXXConstructorDecl*> &Decls) {
226   for(size_t i = 0; i < Sources.size(); ++i)
227     Sources[i]->ReadDelegatingConstructors(Decls);
228 }
229 
230 void MultiplexExternalSemaSource::ReadExtVectorDecls(
231                                      SmallVectorImpl<TypedefNameDecl*> &Decls) {
232   for(size_t i = 0; i < Sources.size(); ++i)
233     Sources[i]->ReadExtVectorDecls(Decls);
234 }
235 
236 void MultiplexExternalSemaSource::ReadDynamicClasses(
237                                        SmallVectorImpl<CXXRecordDecl*> &Decls) {
238   for(size_t i = 0; i < Sources.size(); ++i)
239     Sources[i]->ReadDynamicClasses(Decls);
240 }
241 
242 void MultiplexExternalSemaSource::ReadLocallyScopedExternalDecls(
243                                            SmallVectorImpl<NamedDecl*> &Decls) {
244   for(size_t i = 0; i < Sources.size(); ++i)
245     Sources[i]->ReadLocallyScopedExternalDecls(Decls);
246 }
247 
248 void MultiplexExternalSemaSource::ReadReferencedSelectors(
249                   SmallVectorImpl<std::pair<Selector, SourceLocation> > &Sels) {
250   for(size_t i = 0; i < Sources.size(); ++i)
251     Sources[i]->ReadReferencedSelectors(Sels);
252 }
253 
254 void MultiplexExternalSemaSource::ReadWeakUndeclaredIdentifiers(
255                    SmallVectorImpl<std::pair<IdentifierInfo*, WeakInfo> > &WI) {
256   for(size_t i = 0; i < Sources.size(); ++i)
257     Sources[i]->ReadWeakUndeclaredIdentifiers(WI);
258 }
259 
260 void MultiplexExternalSemaSource::ReadUsedVTables(
261                                   SmallVectorImpl<ExternalVTableUse> &VTables) {
262   for(size_t i = 0; i < Sources.size(); ++i)
263     Sources[i]->ReadUsedVTables(VTables);
264 }
265 
266 void MultiplexExternalSemaSource::ReadPendingInstantiations(
267                                            SmallVectorImpl<std::pair<ValueDecl*,
268                                                    SourceLocation> > &Pending) {
269   for(size_t i = 0; i < Sources.size(); ++i)
270     Sources[i]->ReadPendingInstantiations(Pending);
271 }
272