← Back to branch summary

~ubuntu-branches/ubuntu/trusty/llvm-toolchain-snapshot/trusty-201310232150

« back to all changes in this revision

Viewing changes to clang/include/clang/Analysis/Visitors/CFGStmtVisitor.h

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2013-05-27 15:01:57 UTC
  • mfrom: (0.10.1) (0.9.1) (0.8.1) (0.7.1) (0.6.1) (0.5.2)
  • Revision ID: package-import@ubuntu.com-20130527150157-tdkrsjpuvht7v0qx
Tags: 1:3.4~svn182733-1~exp1
http://bugs.debian.org/708677
* New snapshot release (3.4 release)
* Add a symlink of libLLVM-3.4.so.1 to usr/lib/llvm-3.4/lib/libLLVM-3.4.so
    to fix make the llvm-config-3.4 --libdir work (Closes: #708677)
  * Various packages rename to allow co installations:
    * libclang1 => libclang1-3.4
    * libclang1-dbg => libclang1-3.4-dbg
    * libclang-dev => libclang-3.4-dev
    * libclang-common-dev => libclang-common-3.4-dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
clang/include/clang/Analysis/Visitors/CFGStmtVisitor.h
1
 
//===--- CFGStmtVisitor.h - Visitor for Stmts in a CFG ----------*- C++ -*-===//
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 defines the CFGStmtVisitor interface, which extends
11
 
//  StmtVisitor.  This interface is useful for visiting statements in a CFG
12
 
//  where some statements have implicit control-flow and thus should
13
 
//  be treated specially.
14
 
//
15
 
//===----------------------------------------------------------------------===//
16
 
 
17
 
#ifndef LLVM_CLANG_ANALYSIS_CFGSTMTVISITOR_H
18
 
#define LLVM_CLANG_ANALYSIS_CFGSTMTVISITOR_H
19
 
 
20
 
#include "clang/AST/StmtVisitor.h"
21
 
#include "clang/Analysis/CFG.h"
22
 
 
23
 
namespace clang {
24
 
 
25
 
#define DISPATCH_CASE(CLASS) \
26
 
case Stmt::CLASS ## Class: return \
27
 
static_cast<ImplClass*>(this)->BlockStmt_Visit ## CLASS(static_cast<CLASS*>(S));
28
 
 
29
 
#define DEFAULT_BLOCKSTMT_VISIT(CLASS) RetTy BlockStmt_Visit ## CLASS(CLASS *S)\
30
 
{ return\
31
 
  static_cast<ImplClass*>(this)->BlockStmt_VisitImplicitControlFlowExpr(\
32
 
  cast<Expr>(S)); }
33
 
 
34
 
template <typename ImplClass, typename RetTy=void>
35
 
class CFGStmtVisitor : public StmtVisitor<ImplClass,RetTy> {
36
 
  Stmt *CurrentBlkStmt;
37
 
 
38
 
  struct NullifyStmt {
39
 
    Stmt*& S;
40
 
 
41
 
    NullifyStmt(Stmt*& s) : S(s) {}
42
 
    ~NullifyStmt() { S = NULL; }
43
 
  };
44
 
 
45
 
public:
46
 
  CFGStmtVisitor() : CurrentBlkStmt(NULL) {}
47
 
 
48
 
  Stmt *getCurrentBlkStmt() const { return CurrentBlkStmt; }
49
 
 
50
 
  RetTy Visit(Stmt *S) {
51
 
    if (S == CurrentBlkStmt ||
52
 
        !static_cast<ImplClass*>(this)->getCFG().isBlkExpr(S))
53
 
      return StmtVisitor<ImplClass,RetTy>::Visit(S);
54
 
    else
55
 
      return RetTy();
56
 
  }
57
 
  
58
 
  /// VisitConditionVariableInit - Handle the initialization of condition
59
 
  ///  variables at branches.  Valid statements include IfStmt, ForStmt,
60
 
  ///  WhileStmt, and SwitchStmt.
61
 
  RetTy VisitConditionVariableInit(Stmt *S) {
62
 
    return RetTy();
63
 
  }
64
 
 
65
 
  /// BlockVisit_XXX - Visitor methods for visiting the "root" statements in
66
 
  /// CFGBlocks.  Root statements are the statements that appear explicitly in
67
 
  /// the list of statements in a CFGBlock.  For substatements, or when there
68
 
  /// is no implementation provided for a BlockStmt_XXX method, we default
69
 
  /// to using StmtVisitor's Visit method.
70
 
  RetTy BlockStmt_Visit(Stmt *S) {
71
 
    CurrentBlkStmt = S;
72
 
    NullifyStmt cleanup(CurrentBlkStmt);
73
 
 
74
 
    switch (S->getStmtClass()) {
75
 
      case Stmt::IfStmtClass:
76
 
      case Stmt::ForStmtClass:
77
 
      case Stmt::WhileStmtClass:
78
 
      case Stmt::SwitchStmtClass:
79
 
        return static_cast<ImplClass*>(this)->VisitConditionVariableInit(S);
80
 
 
81
 
      DISPATCH_CASE(StmtExpr)
82
 
      DISPATCH_CASE(ConditionalOperator)
83
 
      DISPATCH_CASE(BinaryConditionalOperator)
84
 
      DISPATCH_CASE(ObjCForCollectionStmt)
85
 
      DISPATCH_CASE(CXXForRangeStmt)
86
 
 
87
 
      case Stmt::BinaryOperatorClass: {
88
 
        BinaryOperator* B = cast<BinaryOperator>(S);
89
 
        if (B->isLogicalOp())
90
 
          return static_cast<ImplClass*>(this)->BlockStmt_VisitLogicalOp(B);
91
 
        else if (B->getOpcode() == BO_Comma)
92
 
          return static_cast<ImplClass*>(this)->BlockStmt_VisitComma(B);
93
 
        // Fall through.
94
 
      }
95
 
 
96
 
      default:
97
 
        if (isa<Expr>(S))
98
 
          return
99
 
            static_cast<ImplClass*>(this)->BlockStmt_VisitExpr(cast<Expr>(S));
100
 
        else
101
 
          return static_cast<ImplClass*>(this)->BlockStmt_VisitStmt(S);
102
 
    }
103
 
  }
104
 
 
105
 
  DEFAULT_BLOCKSTMT_VISIT(StmtExpr)
106
 
  DEFAULT_BLOCKSTMT_VISIT(ConditionalOperator)
107
 
  DEFAULT_BLOCKSTMT_VISIT(BinaryConditionalOperator)
108
 
 
109
 
  RetTy BlockStmt_VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
110
 
    return static_cast<ImplClass*>(this)->BlockStmt_VisitStmt(S);
111
 
  }
112
 
 
113
 
  RetTy BlockStmt_VisitCXXForRangeStmt(CXXForRangeStmt *S) {
114
 
    return static_cast<ImplClass*>(this)->BlockStmt_VisitStmt(S);
115
 
  }
116
 
 
117
 
  RetTy BlockStmt_VisitImplicitControlFlowExpr(Expr *E) {
118
 
    return static_cast<ImplClass*>(this)->BlockStmt_VisitExpr(E);
119
 
  }
120
 
 
121
 
  RetTy BlockStmt_VisitExpr(Expr *E) {
122
 
    return static_cast<ImplClass*>(this)->BlockStmt_VisitStmt(E);
123
 
  }
124
 
 
125
 
  RetTy BlockStmt_VisitStmt(Stmt *S) {
126
 
    return static_cast<ImplClass*>(this)->Visit(S);
127
 
  }
128
 
 
129
 
  RetTy BlockStmt_VisitLogicalOp(BinaryOperator* B) {
130
 
    return
131
 
     static_cast<ImplClass*>(this)->BlockStmt_VisitImplicitControlFlowExpr(B);
132
 
  }
133
 
 
134
 
  RetTy BlockStmt_VisitComma(BinaryOperator* B) {
135
 
    return
136
 
     static_cast<ImplClass*>(this)->BlockStmt_VisitImplicitControlFlowExpr(B);
137
 
  }
138
 
 
139
 
  //===--------------------------------------------------------------------===//
140
 
  // Utility methods.  Not called by default (but subclasses may use them).
141
 
  //===--------------------------------------------------------------------===//
142
 
 
143
 
  /// VisitChildren: Call "Visit" on each child of S.
144
 
  void VisitChildren(Stmt *S) {
145
 
 
146
 
    switch (S->getStmtClass()) {
147
 
      default:
148
 
        break;
149
 
 
150
 
      case Stmt::StmtExprClass: {
151
 
        CompoundStmt *CS = cast<StmtExpr>(S)->getSubStmt();
152
 
        if (CS->body_empty()) return;
153
 
        static_cast<ImplClass*>(this)->Visit(CS->body_back());
154
 
        return;
155
 
      }
156
 
 
157
 
      case Stmt::BinaryOperatorClass: {
158
 
        BinaryOperator* B = cast<BinaryOperator>(S);
159
 
        if (B->getOpcode() != BO_Comma) break;
160
 
        static_cast<ImplClass*>(this)->Visit(B->getRHS());
161
 
        return;
162
 
      }
163
 
    }
164
 
 
165
 
    for (Stmt::child_range I = S->children(); I; ++I)
166
 
      if (*I) static_cast<ImplClass*>(this)->Visit(*I);
167
 
  }
168
 
};
169
 
 
170
 
#undef DEFAULT_BLOCKSTMT_VISIT
171
 
#undef DISPATCH_CASE
172
 
 
173
 
}  // end namespace clang
174
 
 
175
 
#endif