contrib/llvm/tools/clang/lib/Frontend/ASTConsumers.cpp

   1 //===--- ASTConsumers.cpp - ASTConsumer implementations -------------------===//
   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 // AST Consumer Implementations.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "clang/Frontend/ASTConsumers.h"
  15 #include "clang/Basic/Diagnostic.h"
  16 #include "clang/Basic/SourceManager.h"
  17 #include "clang/Basic/FileManager.h"
  18 #include "clang/AST/AST.h"
  19 #include "clang/AST/ASTConsumer.h"
  20 #include "clang/AST/ASTContext.h"
  21 #include "clang/AST/RecordLayout.h"
  22 #include "clang/AST/PrettyPrinter.h"
  23 #include "llvm/Module.h"
  24 #include "llvm/Support/Timer.h"
  25 #include "llvm/Support/raw_ostream.h"
  26 #include "llvm/Support/Path.h"
  27 using namespace clang;
  28
  29 //===----------------------------------------------------------------------===//
  30 /// ASTPrinter - Pretty-printer and dumper of ASTs
  31
  32 namespace {
  33   class ASTPrinter : public ASTConsumer {
  34     raw_ostream &Out;
  35     bool Dump;
  36
  37   public:
  38     ASTPrinter(raw_ostream* o = NULL, bool Dump = false)
  39       : Out(o? *o : llvm::outs()), Dump(Dump) { }
  40
  41     virtual void HandleTranslationUnit(ASTContext &Context) {
  42       PrintingPolicy Policy = Context.getPrintingPolicy();
  43       Policy.Dump = Dump;
  44       Context.getTranslationUnitDecl()->print(Out, Policy, /*Indentation=*/0,
  45                                               /*PrintInstantiation=*/true);
  46     }
  47   };
  48 } // end anonymous namespace
  49
  50 ASTConsumer *clang::CreateASTPrinter(raw_ostream* out) {
  51   return new ASTPrinter(out);
  52 }
  53
  54 ASTConsumer *clang::CreateASTDumper() {
  55   return new ASTPrinter(0, true);
  56 }
  57
  58 //===----------------------------------------------------------------------===//
  59 /// ASTViewer - AST Visualization
  60
  61 namespace {
  62   class ASTViewer : public ASTConsumer {
  63     ASTContext *Context;
  64   public:
  65     void Initialize(ASTContext &Context) {
  66       this->Context = &Context;
  67     }
  68
  69     virtual void HandleTopLevelDecl(DeclGroupRef D) {
  70       for (DeclGroupRef::iterator I = D.begin(), E = D.end(); I != E; ++I)
  71         HandleTopLevelSingleDecl(*I);
  72     }
  73
  74     void HandleTopLevelSingleDecl(Decl *D);
  75   };
  76 }
  77
  78 void ASTViewer::HandleTopLevelSingleDecl(Decl *D) {
  79   if (isa<FunctionDecl>(D) || isa<ObjCMethodDecl>(D)) {
  80     D->print(llvm::errs());
  81
  82     if (Stmt *Body = D->getBody()) {
  83       llvm::errs() << '\n';
  84       Body->viewAST();
  85       llvm::errs() << '\n';
  86     }
  87   }
  88 }
  89
  90
  91 ASTConsumer *clang::CreateASTViewer() { return new ASTViewer(); }
  92
  93 //===----------------------------------------------------------------------===//
  94 /// DeclContextPrinter - Decl and DeclContext Visualization
  95
  96 namespace {
  97
  98 class DeclContextPrinter : public ASTConsumer {
  99   raw_ostream& Out;
 100 public:
 101   DeclContextPrinter() : Out(llvm::errs()) {}
 102
 103   void HandleTranslationUnit(ASTContext &C) {
 104     PrintDeclContext(C.getTranslationUnitDecl(), 4);
 105   }
 106
 107   void PrintDeclContext(const DeclContext* DC, unsigned Indentation);
 108 };
 109 }  // end anonymous namespace
 110
 111 void DeclContextPrinter::PrintDeclContext(const DeclContext* DC,
 112                                           unsigned Indentation) {
 113   // Print DeclContext name.
 114   switch (DC->getDeclKind()) {
 115   case Decl::TranslationUnit:
 116     Out << "[translation unit] " << DC;
 117     break;
 118   case Decl::Namespace: {
 119     Out << "[namespace] ";
 120     const NamespaceDecl* ND = cast<NamespaceDecl>(DC);
 121     Out << *ND;
 122     break;
 123   }
 124   case Decl::Enum: {
 125     const EnumDecl* ED = cast<EnumDecl>(DC);
 126     if (ED->isCompleteDefinition())
 127       Out << "[enum] ";
 128     else
 129       Out << "<enum> ";
 130     Out << *ED;
 131     break;
 132   }
 133   case Decl::Record: {
 134     const RecordDecl* RD = cast<RecordDecl>(DC);
 135     if (RD->isCompleteDefinition())
 136       Out << "[struct] ";
 137     else
 138       Out << "<struct> ";
 139     Out << *RD;
 140     break;
 141   }
 142   case Decl::CXXRecord: {
 143     const CXXRecordDecl* RD = cast<CXXRecordDecl>(DC);
 144     if (RD->isCompleteDefinition())
 145       Out << "[class] ";
 146     else
 147       Out << "<class> ";
 148     Out << *RD << ' ' << DC;
 149     break;
 150   }
 151   case Decl::ObjCMethod:
 152     Out << "[objc method]";
 153     break;
 154   case Decl::ObjCInterface:
 155     Out << "[objc interface]";
 156     break;
 157   case Decl::ObjCCategory:
 158     Out << "[objc category]";
 159     break;
 160   case Decl::ObjCProtocol:
 161     Out << "[objc protocol]";
 162     break;
 163   case Decl::ObjCImplementation:
 164     Out << "[objc implementation]";
 165     break;
 166   case Decl::ObjCCategoryImpl:
 167     Out << "[objc categoryimpl]";
 168     break;
 169   case Decl::LinkageSpec:
 170     Out << "[linkage spec]";
 171     break;
 172   case Decl::Block:
 173     Out << "[block]";
 174     break;
 175   case Decl::Function: {
 176     const FunctionDecl* FD = cast<FunctionDecl>(DC);
 177     if (FD->doesThisDeclarationHaveABody())
 178       Out << "[function] ";
 179     else
 180       Out << "<function> ";
 181     Out << *FD;
 182     // Print the parameters.
 183     Out << "(";
 184     bool PrintComma = false;
 185     for (FunctionDecl::param_const_iterator I = FD->param_begin(),
 186            E = FD->param_end(); I != E; ++I) {
 187       if (PrintComma)
 188         Out << ", ";
 189       else
 190         PrintComma = true;
 191       Out << **I;
 192     }
 193     Out << ")";
 194     break;
 195   }
 196   case Decl::CXXMethod: {
 197     const CXXMethodDecl* D = cast<CXXMethodDecl>(DC);
 198     if (D->isOutOfLine())
 199       Out << "[c++ method] ";
 200     else if (D->isImplicit())
 201       Out << "(c++ method) ";
 202     else
 203       Out << "<c++ method> ";
 204     Out << *D;
 205     // Print the parameters.
 206     Out << "(";
 207     bool PrintComma = false;
 208     for (FunctionDecl::param_const_iterator I = D->param_begin(),
 209            E = D->param_end(); I != E; ++I) {
 210       if (PrintComma)
 211         Out << ", ";
 212       else
 213         PrintComma = true;
 214       Out << **I;
 215     }
 216     Out << ")";
 217
 218     // Check the semantic DeclContext.
 219     const DeclContext* SemaDC = D->getDeclContext();
 220     const DeclContext* LexicalDC = D->getLexicalDeclContext();
 221     if (SemaDC != LexicalDC)
 222       Out << " [[" << SemaDC << "]]";
 223
 224     break;
 225   }
 226   case Decl::CXXConstructor: {
 227     const CXXConstructorDecl* D = cast<CXXConstructorDecl>(DC);
 228     if (D->isOutOfLine())
 229       Out << "[c++ ctor] ";
 230     else if (D->isImplicit())
 231       Out << "(c++ ctor) ";
 232     else
 233       Out << "<c++ ctor> ";
 234     Out << *D;
 235     // Print the parameters.
 236     Out << "(";
 237     bool PrintComma = false;
 238     for (FunctionDecl::param_const_iterator I = D->param_begin(),
 239            E = D->param_end(); I != E; ++I) {
 240       if (PrintComma)
 241         Out << ", ";
 242       else
 243         PrintComma = true;
 244       Out << **I;
 245     }
 246     Out << ")";
 247
 248     // Check the semantic DC.
 249     const DeclContext* SemaDC = D->getDeclContext();
 250     const DeclContext* LexicalDC = D->getLexicalDeclContext();
 251     if (SemaDC != LexicalDC)
 252       Out << " [[" << SemaDC << "]]";
 253     break;
 254   }
 255   case Decl::CXXDestructor: {
 256     const CXXDestructorDecl* D = cast<CXXDestructorDecl>(DC);
 257     if (D->isOutOfLine())
 258       Out << "[c++ dtor] ";
 259     else if (D->isImplicit())
 260       Out << "(c++ dtor) ";
 261     else
 262       Out << "<c++ dtor> ";
 263     Out << *D;
 264     // Check the semantic DC.
 265     const DeclContext* SemaDC = D->getDeclContext();
 266     const DeclContext* LexicalDC = D->getLexicalDeclContext();
 267     if (SemaDC != LexicalDC)
 268       Out << " [[" << SemaDC << "]]";
 269     break;
 270   }
 271   case Decl::CXXConversion: {
 272     const CXXConversionDecl* D = cast<CXXConversionDecl>(DC);
 273     if (D->isOutOfLine())
 274       Out << "[c++ conversion] ";
 275     else if (D->isImplicit())
 276       Out << "(c++ conversion) ";
 277     else
 278       Out << "<c++ conversion> ";
 279     Out << *D;
 280     // Check the semantic DC.
 281     const DeclContext* SemaDC = D->getDeclContext();
 282     const DeclContext* LexicalDC = D->getLexicalDeclContext();
 283     if (SemaDC != LexicalDC)
 284       Out << " [[" << SemaDC << "]]";
 285     break;
 286   }
 287
 288   default:
 289     llvm_unreachable("a decl that inherits DeclContext isn't handled");
 290   }
 291
 292   Out << "\n";
 293
 294   // Print decls in the DeclContext.
 295   for (DeclContext::decl_iterator I = DC->decls_begin(), E = DC->decls_end();
 296        I != E; ++I) {
 297     for (unsigned i = 0; i < Indentation; ++i)
 298       Out << "  ";
 299
 300     Decl::Kind DK = I->getKind();
 301     switch (DK) {
 302     case Decl::Namespace:
 303     case Decl::Enum:
 304     case Decl::Record:
 305     case Decl::CXXRecord:
 306     case Decl::ObjCMethod:
 307     case Decl::ObjCInterface:
 308     case Decl::ObjCCategory:
 309     case Decl::ObjCProtocol:
 310     case Decl::ObjCImplementation:
 311     case Decl::ObjCCategoryImpl:
 312     case Decl::LinkageSpec:
 313     case Decl::Block:
 314     case Decl::Function:
 315     case Decl::CXXMethod:
 316     case Decl::CXXConstructor:
 317     case Decl::CXXDestructor:
 318     case Decl::CXXConversion:
 319     {
 320       DeclContext* DC = cast<DeclContext>(*I);
 321       PrintDeclContext(DC, Indentation+2);
 322       break;
 323     }
 324     case Decl::IndirectField: {
 325       IndirectFieldDecl* IFD = cast<IndirectFieldDecl>(*I);
 326       Out << "<IndirectField> " << *IFD << '\n';
 327       break;
 328     }
 329     case Decl::Label: {
 330       LabelDecl *LD = cast<LabelDecl>(*I);
 331       Out << "<Label> " << *LD << '\n';
 332       break;
 333     }
 334     case Decl::Field: {
 335       FieldDecl *FD = cast<FieldDecl>(*I);
 336       Out << "<field> " << *FD << '\n';
 337       break;
 338     }
 339     case Decl::Typedef:
 340     case Decl::TypeAlias: {
 341       TypedefNameDecl* TD = cast<TypedefNameDecl>(*I);
 342       Out << "<typedef> " << *TD << '\n';
 343       break;
 344     }
 345     case Decl::EnumConstant: {
 346       EnumConstantDecl* ECD = cast<EnumConstantDecl>(*I);
 347       Out << "<enum constant> " << *ECD << '\n';
 348       break;
 349     }
 350     case Decl::Var: {
 351       VarDecl* VD = cast<VarDecl>(*I);
 352       Out << "<var> " << *VD << '\n';
 353       break;
 354     }
 355     case Decl::ImplicitParam: {
 356       ImplicitParamDecl* IPD = cast<ImplicitParamDecl>(*I);
 357       Out << "<implicit parameter> " << *IPD << '\n';
 358       break;
 359     }
 360     case Decl::ParmVar: {
 361       ParmVarDecl* PVD = cast<ParmVarDecl>(*I);
 362       Out << "<parameter> " << *PVD << '\n';
 363       break;
 364     }
 365     case Decl::ObjCProperty: {
 366       ObjCPropertyDecl* OPD = cast<ObjCPropertyDecl>(*I);
 367       Out << "<objc property> " << *OPD << '\n';
 368       break;
 369     }
 370     case Decl::FunctionTemplate: {
 371       FunctionTemplateDecl* FTD = cast<FunctionTemplateDecl>(*I);
 372       Out << "<function template> " << *FTD << '\n';
 373       break;
 374     }
 375     case Decl::FileScopeAsm: {
 376       Out << "<file-scope asm>\n";
 377       break;
 378     }
 379     case Decl::UsingDirective: {
 380       Out << "<using directive>\n";
 381       break;
 382     }
 383     case Decl::NamespaceAlias: {
 384       NamespaceAliasDecl* NAD = cast<NamespaceAliasDecl>(*I);
 385       Out << "<namespace alias> " << *NAD << '\n';
 386       break;
 387     }
 388     case Decl::ClassTemplate: {
 389       ClassTemplateDecl *CTD = cast<ClassTemplateDecl>(*I);
 390       Out << "<class template> " << *CTD << '\n';
 391       break;
 392     }
 393     default:
 394       Out << "DeclKind: " << DK << '"' << *I << "\"\n";
 395       llvm_unreachable("decl unhandled");
 396     }
 397   }
 398 }
 399 ASTConsumer *clang::CreateDeclContextPrinter() {
 400   return new DeclContextPrinter();
 401 }
 402
 403 //===----------------------------------------------------------------------===//
 404 /// ASTDumperXML - In-depth XML dumping.
 405
 406 namespace {
 407 class ASTDumpXML : public ASTConsumer {
 408   raw_ostream &OS;
 409
 410 public:
 411   ASTDumpXML(raw_ostream &OS) : OS(OS) {}
 412
 413   void HandleTranslationUnit(ASTContext &C) {
 414     C.getTranslationUnitDecl()->dumpXML(OS);
 415   }
 416 };
 417 }
 418
 419 ASTConsumer *clang::CreateASTDumperXML(raw_ostream &OS) {
 420   return new ASTDumpXML(OS);
 421 }