clang API Documentation

Classes | Namespaces | Defines | Functions
RecursiveASTVisitor.h File Reference
#include "clang/AST/Attr.h"
#include "clang/AST/Decl.h"
#include "clang/AST/DeclCXX.h"
#include "clang/AST/DeclFriend.h"
#include "clang/AST/DeclObjC.h"
#include "clang/AST/DeclOpenMP.h"
#include "clang/AST/DeclTemplate.h"
#include "clang/AST/Expr.h"
#include "clang/AST/ExprCXX.h"
#include "clang/AST/ExprObjC.h"
#include "clang/AST/NestedNameSpecifier.h"
#include "clang/AST/Stmt.h"
#include "clang/AST/StmtCXX.h"
#include "clang/AST/StmtObjC.h"
#include "clang/AST/StmtOpenMP.h"
#include "clang/AST/TemplateBase.h"
#include "clang/AST/TemplateName.h"
#include "clang/AST/Type.h"
#include "clang/AST/TypeLoc.h"
#include "clang/AST/AttrVisitor.inc"
#include "clang/AST/StmtNodes.inc"
#include "clang/AST/TypeNodes.def"
#include "clang/AST/TypeLocNodes.def"
#include "clang/AST/DeclNodes.inc"
#include "clang/Basic/OpenMPKinds.def"
Include dependency graph for RecursiveASTVisitor.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

class  clang::RecursiveASTVisitor< Derived >
 A class that does preorder depth-first traversal on the entire Clang AST and visits each node. More...
struct  clang::RecursiveASTVisitor< Derived >::EnqueueJob

Namespaces

namespace  clang

Defines

#define UNARYOP_LIST()
#define BINOP_LIST()
#define CAO_LIST()
#define TRY_TO(CALL_EXPR)
#define ATTR_VISITOR_DECLS_ONLY
#define ABSTRACT_STMT(STMT)
#define STMT(CLASS, PARENT)   bool Traverse##CLASS(CLASS *S);
#define STMT(CLASS, PARENT)
#define OPERATOR(NAME)
#define GENERAL_BINOP_FALLBACK(NAME, BINOP_TYPE)
#define OPERATOR(NAME)   GENERAL_BINOP_FALLBACK(NAME, BinaryOperator)
#define OPERATOR(NAME)   GENERAL_BINOP_FALLBACK(NAME##Assign, CompoundAssignOperator)
#define ABSTRACT_TYPE(CLASS, BASE)
#define TYPE(CLASS, BASE)   bool Traverse##CLASS##Type(CLASS##Type *T);
#define TYPE(CLASS, BASE)
#define ABSTRACT_TYPELOC(CLASS, BASE)
#define TYPELOC(CLASS, BASE)   bool Traverse##CLASS##TypeLoc(CLASS##TypeLoc TL);
#define TYPE(CLASS, BASE)
#define ABSTRACT_DECL(DECL)
#define DECL(CLASS, BASE)   bool Traverse##CLASS##Decl(CLASS##Decl *D);
#define DECL(CLASS, BASE)
#define DEF_TRAVERSE_TMPL_INST(TMPLDECLKIND)   bool TraverseTemplateInstantiations(TMPLDECLKIND##TemplateDecl *D);
#define OPENMP_CLAUSE(Name, Class)   bool Visit##Class(Class *C);
#define DISPATCH_WALK(NAME, CLASS, VAR)
#define OPERATOR(NAME)
#define OPERATOR(NAME)
#define OPERATOR(NAME)
#define ABSTRACT_STMT(STMT)
#define STMT(CLASS, PARENT)
#define DISPATCH(NAME, CLASS, VAR)   return getDerived().Traverse##NAME(static_cast<CLASS *>(VAR))
#define DISPATCH_STMT(NAME, CLASS, VAR)   DISPATCH(NAME, CLASS, VAR)
#define OPERATOR(NAME)
#define OPERATOR(NAME)
#define OPERATOR(NAME)
#define ABSTRACT_STMT(STMT)
#define STMT(CLASS, PARENT)
#define ABSTRACT_TYPE(CLASS, BASE)
#define TYPE(CLASS, BASE)
#define ABSTRACT_TYPELOC(CLASS, BASE)
#define TYPELOC(CLASS, BASE)
#define VISITORCLASS   RecursiveASTVisitor
#define ABSTRACT_DECL(DECL)
#define DECL(CLASS, BASE)
#define DEF_TRAVERSE_TYPE(TYPE, CODE)
#define DEF_TRAVERSE_TYPELOC(TYPE, CODE)
#define DEF_TRAVERSE_DECL(DECL, CODE)
#define DEF_TRAVERSE_TMPL_DECL(TMPLDECLKIND)
#define DEF_TRAVERSE_TMPL_SPEC_DECL(TMPLDECLKIND)
#define DEF_TRAVERSE_TMPL_PART_SPEC_DECL(TMPLDECLKIND, DECLKIND)
#define DEF_TRAVERSE_STMT(STMT, CODE)
#define OPENMP_CLAUSE(Name, Class)

Functions

 clang::DEF_TRAVERSE_TYPE (ComplexType,{TRY_TO(TraverseType(T->getElementType()));}) DEF_TRAVERSE_TYPE(PointerType

Define Documentation

#define ABSTRACT_DECL (   DECL)

Definition at line 396 of file RecursiveASTVisitor.h.

#define ABSTRACT_DECL (   DECL)

Definition at line 396 of file RecursiveASTVisitor.h.

#define ABSTRACT_STMT (   STMT)

Definition at line 270 of file RecursiveASTVisitor.h.

#define ABSTRACT_STMT (   STMT)

Definition at line 270 of file RecursiveASTVisitor.h.

#define ABSTRACT_STMT (   STMT)

Definition at line 270 of file RecursiveASTVisitor.h.

#define ABSTRACT_TYPE (   CLASS,
  BASE 
)

Definition at line 342 of file RecursiveASTVisitor.h.

#define ABSTRACT_TYPE (   CLASS,
  BASE 
)

Definition at line 342 of file RecursiveASTVisitor.h.

#define ABSTRACT_TYPELOC (   CLASS,
  BASE 
)

Definition at line 363 of file RecursiveASTVisitor.h.

#define ABSTRACT_TYPELOC (   CLASS,
  BASE 
)

Definition at line 363 of file RecursiveASTVisitor.h.

#define ATTR_VISITOR_DECLS_ONLY

Definition at line 263 of file RecursiveASTVisitor.h.

#define BINOP_LIST ( )
Value:
OPERATOR(PtrMemD) OPERATOR(PtrMemI) OPERATOR(Mul) OPERATOR(Div)              \
      OPERATOR(Rem) OPERATOR(Add) OPERATOR(Sub) OPERATOR(Shl) OPERATOR(Shr)    \
      OPERATOR(LT) OPERATOR(GT) OPERATOR(LE) OPERATOR(GE) OPERATOR(EQ)         \
      OPERATOR(NE) OPERATOR(And) OPERATOR(Xor) OPERATOR(Or) OPERATOR(LAnd)     \
      OPERATOR(LOr) OPERATOR(Assign) OPERATOR(Comma)

Definition at line 48 of file RecursiveASTVisitor.h.

#define CAO_LIST ( )
Value:
OPERATOR(Mul) OPERATOR(Div) OPERATOR(Rem) OPERATOR(Add) OPERATOR(Sub)        \
      OPERATOR(Shl) OPERATOR(Shr) OPERATOR(And) OPERATOR(Or) OPERATOR(Xor)

Definition at line 56 of file RecursiveASTVisitor.h.

#define DECL (   CLASS,
  BASE 
)    bool Traverse##CLASS##Decl(CLASS##Decl *D);

Definition at line 404 of file RecursiveASTVisitor.h.

#define DECL (   CLASS,
  BASE 
)
Value:
bool WalkUpFrom##CLASS##Decl(CLASS##Decl *D) {                               \
    TRY_TO(WalkUpFrom##BASE(D));                                               \
    TRY_TO(Visit##CLASS##Decl(D));                                             \
    return true;                                                               \
  }                                                                            \
  bool Visit##CLASS##Decl(CLASS##Decl *D) { return true; }

Definition at line 404 of file RecursiveASTVisitor.h.

#define DECL (   CLASS,
  BASE 
)
Value:
case Decl::CLASS:                                                            \
    if (!getDerived().Traverse##CLASS##Decl(static_cast<CLASS##Decl *>(D)))    \
      return false;                                                            \
    break;

Definition at line 404 of file RecursiveASTVisitor.h.

#define DEF_TRAVERSE_DECL (   DECL,
  CODE 
)
Value:
template <typename Derived>                                                  \
  bool RecursiveASTVisitor<Derived>::Traverse##DECL(DECL *D) {                 \
    TRY_TO(WalkUpFrom##DECL(D));                                               \
    { CODE; }                                                                  \
    TRY_TO(TraverseDeclContextHelper(dyn_cast<DeclContext>(D)));               \
    return true;                                                               \
  }
#define DEF_TRAVERSE_STMT (   STMT,
  CODE 
)
Value:
template <typename Derived>                                                  \
  bool RecursiveASTVisitor<Derived>::Traverse##STMT(STMT *S) {                 \
    TRY_TO(WalkUpFrom##STMT(S));                                               \
    { CODE; }                                                                  \
    for (Stmt::child_range range = S->children(); range; ++range) {            \
      TRY_TO(TraverseStmt(*range));                                            \
    }                                                                          \
    return true;                                                               \
  }
#define DEF_TRAVERSE_TMPL_DECL (   TMPLDECLKIND)
Value:
DEF_TRAVERSE_DECL(TMPLDECLKIND##TemplateDecl, {                              \
    TRY_TO(TraverseDecl(D->getTemplatedDecl()));                               \
    TRY_TO(TraverseTemplateParameterListHelper(D->getTemplateParameters()));   \
                                                                               \
    /* By default, we do not traverse the instantiations of                    \
       class templates since they do not appear in the user code. The          \
       following code optionally traverses them.                               \
                                                                               \
       We only traverse the class instantiations when we see the canonical     \
       declaration of the template, to ensure we only visit them once. */      \
    if (getDerived().shouldVisitTemplateInstantiations() &&                    \
        D == D->getCanonicalDecl())                                            \
      TRY_TO(TraverseTemplateInstantiations(D));                               \
                                                                               \
    /* Note that getInstantiatedFromMemberTemplate() is just a link            \
       from a template instantiation back to the template from which           \
       it was instantiated, and thus should not be traversed. */               \
  })
#define DEF_TRAVERSE_TMPL_INST (   TMPLDECLKIND)    bool TraverseTemplateInstantiations(TMPLDECLKIND##TemplateDecl *D);

Definition at line 416 of file RecursiveASTVisitor.h.

#define DEF_TRAVERSE_TMPL_PART_SPEC_DECL (   TMPLDECLKIND,
  DECLKIND 
)
Value:
DEF_TRAVERSE_DECL(TMPLDECLKIND##TemplatePartialSpecializationDecl, {         \
    /* The partial specialization. */                                          \
    if (TemplateParameterList *TPL = D->getTemplateParameters()) {             \
      for (TemplateParameterList::iterator I = TPL->begin(), E = TPL->end();   \
           I != E; ++I) {                                                      \
        TRY_TO(TraverseDecl(*I));                                              \
      }                                                                        \
    }                                                                          \
    /* The args that remains unspecialized. */                                 \
    TRY_TO(TraverseTemplateArgumentLocsHelper(                                 \
        D->getTemplateArgsAsWritten()->getTemplateArgs(),                      \
        D->getTemplateArgsAsWritten()->NumTemplateArgs));                      \
                                                                               \
    /* Don't need the *TemplatePartialSpecializationHelper, even               \
       though that's our parent class -- we already visit all the              \
       template args here. */                                                  \
    TRY_TO(Traverse##DECLKIND##Helper(D));                                     \
                                                                               \
    /* Instantiations will have been visited with the primary template. */     \
  })
#define DEF_TRAVERSE_TMPL_SPEC_DECL (   TMPLDECLKIND)
Value:
DEF_TRAVERSE_DECL(TMPLDECLKIND##TemplateSpecializationDecl, {                \
    /* For implicit instantiations ("set<int> x;"), we don't want to           \
       recurse at all, since the instatiated template isn't written in         \
       the source code anywhere.  (Note the instatiated *type* --              \
       set<int> -- is written, and will still get a callback of                \
       TemplateSpecializationType).  For explicit instantiations               \
       ("template set<int>;"), we do need a callback, since this               \
       is the only callback that's made for this instantiation.                \
       We use getTypeAsWritten() to distinguish. */                            \
    if (TypeSourceInfo *TSI = D->getTypeAsWritten())                           \
      TRY_TO(TraverseTypeLoc(TSI->getTypeLoc()));                              \
                                                                               \
    if (!getDerived().shouldVisitTemplateInstantiations() &&                   \
        D->getTemplateSpecializationKind() != TSK_ExplicitSpecialization)      \
      /* Returning from here skips traversing the                              \
         declaration context of the *TemplateSpecializationDecl                \
         (embedded in the DEF_TRAVERSE_DECL() macro)                           \
         which contains the instantiated members of the template. */           \
      return true;                                                             \
  })
#define DEF_TRAVERSE_TYPE (   TYPE,
  CODE 
)
Value:
template <typename Derived>                                                  \
  bool RecursiveASTVisitor<Derived>::Traverse##TYPE(TYPE *T) {                 \
    TRY_TO(WalkUpFrom##TYPE(T));                                               \
    { CODE; }                                                                  \
    return true;                                                               \
  }

Definition at line 874 of file RecursiveASTVisitor.h.

#define DEF_TRAVERSE_TYPELOC (   TYPE,
  CODE 
)
Value:
template <typename Derived>                                                  \
  bool RecursiveASTVisitor<Derived>::Traverse##TYPE##Loc(TYPE##Loc TL) {       \
    if (getDerived().shouldWalkTypesOfTypeLocs())                              \
      TRY_TO(WalkUpFrom##TYPE(const_cast<TYPE *>(TL.getTypePtr())));           \
    TRY_TO(WalkUpFrom##TYPE##Loc(TL));                                         \
    { CODE; }                                                                  \
    return true;                                                               \
  }
#define DISPATCH (   NAME,
  CLASS,
  VAR 
)    return getDerived().Traverse##NAME(static_cast<CLASS *>(VAR))

Definition at line 550 of file RecursiveASTVisitor.h.

#define DISPATCH_STMT (   NAME,
  CLASS,
  VAR 
)    DISPATCH(NAME, CLASS, VAR)
#define DISPATCH_WALK (   NAME,
  CLASS,
  VAR 
)
Value:
{                                                                            \
    bool (Derived::*DerivedFn)(CLASS *) = &Derived::Traverse##NAME;            \
    bool (Derived::*BaseFn)(CLASS *) = &RecursiveASTVisitor::Traverse##NAME;   \
    if (DerivedFn == BaseFn)                                                   \
      return getDerived().WalkUpFrom##NAME(static_cast<CLASS *>(VAR));         \
  }                                                                            \
  EnqueueChildren = false;                                                     \
  return getDerived().Traverse##NAME(static_cast<CLASS *>(VAR));
#define GENERAL_BINOP_FALLBACK (   NAME,
  BINOP_TYPE 
)
Value:
bool TraverseBin##NAME(BINOP_TYPE *S) {                                      \
    TRY_TO(WalkUpFromBin##NAME(S));                                            \
    TRY_TO(TraverseStmt(S->getLHS()));                                         \
    TRY_TO(TraverseStmt(S->getRHS()));                                         \
    return true;                                                               \
  }                                                                            \
  bool WalkUpFromBin##NAME(BINOP_TYPE *S) {                                    \
    TRY_TO(WalkUpFrom##BINOP_TYPE(S));                                         \
    TRY_TO(VisitBin##NAME(S));                                                 \
    return true;                                                               \
  }                                                                            \
  bool VisitBin##NAME(BINOP_TYPE *S) { return true; }

Definition at line 309 of file RecursiveASTVisitor.h.

#define OPENMP_CLAUSE (   Name,
  Class 
)    bool Visit##Class(Class *C);

Definition at line 434 of file RecursiveASTVisitor.h.

#define OPENMP_CLAUSE (   Name,
  Class 
)
Value:
case OMPC_##Name:                                                            \
    TRY_TO(Visit##Class(static_cast<Class *>(C)));                             \
    break;

Definition at line 434 of file RecursiveASTVisitor.h.

#define OPERATOR (   NAME)
Value:
bool TraverseUnary##NAME(UnaryOperator *S) {                                 \
    TRY_TO(WalkUpFromUnary##NAME(S));                                          \
    TRY_TO(TraverseStmt(S->getSubExpr()));                                     \
    return true;                                                               \
  }                                                                            \
  bool WalkUpFromUnary##NAME(UnaryOperator *S) {                               \
    TRY_TO(WalkUpFromUnaryOperator(S));                                        \
    TRY_TO(VisitUnary##NAME(S));                                               \
    return true;                                                               \
  }                                                                            \
  bool VisitUnary##NAME(UnaryOperator *S) { return true; }

Definition at line 331 of file RecursiveASTVisitor.h.

#define OPERATOR (   NAME)    GENERAL_BINOP_FALLBACK(NAME, BinaryOperator)

Definition at line 331 of file RecursiveASTVisitor.h.

#define OPERATOR (   NAME)    GENERAL_BINOP_FALLBACK(NAME##Assign, CompoundAssignOperator)

Definition at line 331 of file RecursiveASTVisitor.h.

#define OPERATOR (   NAME)
Value:
case BO_##NAME:                                                              \
    DISPATCH_WALK(Bin##NAME, BinaryOperator, S);

Definition at line 331 of file RecursiveASTVisitor.h.

#define OPERATOR (   NAME)
Value:
case BO_##NAME##Assign:                                                      \
    DISPATCH_WALK(Bin##NAME##Assign, CompoundAssignOperator, S);

Definition at line 331 of file RecursiveASTVisitor.h.

#define OPERATOR (   NAME)
Value:
case UO_##NAME:                                                              \
    DISPATCH_WALK(Unary##NAME, UnaryOperator, S);

Definition at line 331 of file RecursiveASTVisitor.h.

#define OPERATOR (   NAME)
Value:
case BO_##NAME:                                                              \
    DISPATCH_STMT(Bin##NAME, BinaryOperator, S);

Definition at line 331 of file RecursiveASTVisitor.h.

#define OPERATOR (   NAME)
Value:
case BO_##NAME##Assign:                                                      \
    DISPATCH_STMT(Bin##NAME##Assign, CompoundAssignOperator, S);

Definition at line 331 of file RecursiveASTVisitor.h.

#define OPERATOR (   NAME)
Value:
case UO_##NAME:                                                              \
    DISPATCH_STMT(Unary##NAME, UnaryOperator, S);

Definition at line 331 of file RecursiveASTVisitor.h.

#define STMT (   CLASS,
  PARENT 
)    bool Traverse##CLASS(CLASS *S);

Definition at line 278 of file RecursiveASTVisitor.h.

#define STMT (   CLASS,
  PARENT 
)
Value:
bool WalkUpFrom##CLASS(CLASS *S) {                                           \
    TRY_TO(WalkUpFrom##PARENT(S));                                             \
    TRY_TO(Visit##CLASS(S));                                                   \
    return true;                                                               \
  }                                                                            \
  bool Visit##CLASS(CLASS *S) { return true; }

Definition at line 278 of file RecursiveASTVisitor.h.

#define STMT (   CLASS,
  PARENT 
)
Value:
case Stmt::CLASS##Class:                                                     \
    DISPATCH_WALK(CLASS, CLASS, S);

Definition at line 278 of file RecursiveASTVisitor.h.

#define STMT (   CLASS,
  PARENT 
)
Value:
case Stmt::CLASS##Class:                                                     \
    DISPATCH_STMT(CLASS, CLASS, S);

Definition at line 278 of file RecursiveASTVisitor.h.

#define TRY_TO (   CALL_EXPR)
Value:
do {                                                                         \
    if (!getDerived().CALL_EXPR)                                               \
      return false;                                                            \
  } while (0)

Definition at line 66 of file RecursiveASTVisitor.h.

#define TYPE (   CLASS,
  BASE 
)    bool Traverse##CLASS##Type(CLASS##Type *T);

Definition at line 384 of file RecursiveASTVisitor.h.

#define TYPE (   CLASS,
  BASE 
)
Value:
bool WalkUpFrom##CLASS##Type(CLASS##Type *T) {                               \
    TRY_TO(WalkUpFrom##BASE(T));                                               \
    TRY_TO(Visit##CLASS##Type(T));                                             \
    return true;                                                               \
  }                                                                            \
  bool Visit##CLASS##Type(CLASS##Type *T) { return true; }

Definition at line 384 of file RecursiveASTVisitor.h.

#define TYPE (   CLASS,
  BASE 
)
Value:
bool WalkUpFrom##CLASS##TypeLoc(CLASS##TypeLoc TL) {                         \
    TRY_TO(WalkUpFrom##BASE##Loc(TL));                                         \
    TRY_TO(Visit##CLASS##TypeLoc(TL));                                         \
    return true;                                                               \
  }                                                                            \
  bool Visit##CLASS##TypeLoc(CLASS##TypeLoc TL) { return true; }

Definition at line 384 of file RecursiveASTVisitor.h.

#define TYPE (   CLASS,
  BASE 
)
Value:
case Type::CLASS:                                                            \
    DISPATCH(CLASS##Type, CLASS##Type, const_cast<Type *>(T.getTypePtr()));

Definition at line 384 of file RecursiveASTVisitor.h.

#define TYPELOC (   CLASS,
  BASE 
)    bool Traverse##CLASS##TypeLoc(CLASS##TypeLoc TL);

Definition at line 364 of file RecursiveASTVisitor.h.

#define TYPELOC (   CLASS,
  BASE 
)
Value:
case TypeLoc::CLASS:                                                         \
    return getDerived().Traverse##CLASS##TypeLoc(TL.castAs<CLASS##TypeLoc>());

Definition at line 364 of file RecursiveASTVisitor.h.

#define UNARYOP_LIST ( )
Value:
OPERATOR(PostInc) OPERATOR(PostDec) OPERATOR(PreInc) OPERATOR(PreDec)        \
      OPERATOR(AddrOf) OPERATOR(Deref) OPERATOR(Plus) OPERATOR(Minus)          \
      OPERATOR(Not) OPERATOR(LNot) OPERATOR(Real) OPERATOR(Imag)               \
      OPERATOR(Extension)

Definition at line 41 of file RecursiveASTVisitor.h.

#define VISITORCLASS   RecursiveASTVisitor

Definition at line 645 of file RecursiveASTVisitor.h.

Generated on Tue Nov 18 2014 04:29:53 for r222231 by Doxygen 1.7.6.1.

See the Main Clang Web Page for more information.