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