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