contrib/llvm/tools/clang/lib/Sema/MultiplexExternalSemaSource.cpp

   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 }