Clover coverage report - PMD - 3.7
Coverage timestamp: Wed May 31 2006 09:25:59 EDT
Overview   Package   File
    FRAMES   NO FRAMES  
file stats: LOC: 235   Methods: 13
NCLOC: 189   Classes: 1
 
 Source file Conditionals Statements Methods TOTAL
StatementAndBraceFinder.java 81.4% 86.3% 92.3% 85%
coverage coverage
 1    /*
 2    * Created on 11.07.2004
 3    */
 4    package net.sourceforge.pmd.dfa;
 5   
 6    import net.sourceforge.pmd.ast.*;
 7   
 8    /**
 9    * @author raik
 10    * <p/>
 11    * Sublayer of DataFlowFacade. Finds all data flow nodes and stores the
 12    * type information (@see StackObject). At last it uses this information to
 13    * link the nodes.
 14    */
 15    public class StatementAndBraceFinder extends JavaParserVisitorAdapter {
 16   
 17    private Structure dataFlow;
 18   
 19  41 public void buildDataFlowFor(SimpleJavaNode node) {
 20  41 if (!(node instanceof ASTMethodDeclaration) && !(node instanceof ASTConstructorDeclaration)) {
 21  1 throw new RuntimeException("Can't build a data flow for anything other than a method or a constructor");
 22    }
 23   
 24  40 this.dataFlow = new Structure();
 25  40 this.dataFlow.createStartNode(node.getBeginLine());
 26  40 this.dataFlow.createNewNode(node);
 27   
 28  40 node.jjtAccept(this, dataFlow);
 29   
 30  40 this.dataFlow.createEndNode(node.getEndLine());
 31   
 32  40 Linker linker = new Linker(dataFlow.getBraceStack(), dataFlow.getContinueBreakReturnStack());
 33  40 try {
 34  40 linker.computePaths();
 35    } catch (LinkerException e) {
 36  0 e.printStackTrace();
 37    } catch (SequenceException e) {
 38  0 e.printStackTrace();
 39    }
 40    }
 41   
 42  67 public Object visit(ASTStatementExpression node, Object data) {
 43  67 if (!(data instanceof Structure)) {
 44  0 return data;
 45    }
 46  67 Structure dataFlow = (Structure) data;
 47  67 dataFlow.createNewNode(node);
 48  67 return super.visit(node, data);
 49    }
 50   
 51  36 public Object visit(ASTVariableDeclarator node, Object data) {
 52  36 if (!(data instanceof Structure)) {
 53  0 return data;
 54    }
 55  36 Structure dataFlow = (Structure) data;
 56  36 dataFlow.createNewNode(node);
 57  36 return super.visit(node, data);
 58    }
 59   
 60  121 public Object visit(ASTExpression node, Object data) {
 61  121 if (!(data instanceof Structure)) {
 62  0 return data;
 63    }
 64  121 Structure dataFlow = (Structure) data;
 65   
 66    // TODO what about throw stmts?
 67  121 if (node.jjtGetParent() instanceof ASTIfStatement) {
 68  24 dataFlow.createNewNode(node); // START IF
 69  24 dataFlow.pushOnStack(NodeType.IF_EXPR, dataFlow.getLast());
 70  97 } else if (node.jjtGetParent() instanceof ASTWhileStatement) {
 71  3 dataFlow.createNewNode(node); // START WHILE
 72  3 dataFlow.pushOnStack(NodeType.WHILE_EXPR, dataFlow.getLast());
 73  94 } else if (node.jjtGetParent() instanceof ASTSwitchStatement) {
 74  3 dataFlow.createNewNode(node); // START SWITCH
 75  3 dataFlow.pushOnStack(NodeType.SWITCH_START, dataFlow.getLast());
 76  91 } else if (node.jjtGetParent() instanceof ASTForStatement) {
 77  20 dataFlow.createNewNode(node); // FOR EXPR
 78  20 dataFlow.pushOnStack(NodeType.FOR_EXPR, dataFlow.getLast());
 79  71 } else if (node.jjtGetParent() instanceof ASTDoStatement) {
 80  3 dataFlow.createNewNode(node); // DO EXPR
 81  3 dataFlow.pushOnStack(NodeType.DO_EXPR, dataFlow.getLast());
 82    }
 83   
 84  121 return super.visit(node, data);
 85    }
 86   
 87  20 public Object visit(ASTForInit node, Object data) {
 88  20 if (!(data instanceof Structure)) {
 89  0 return data;
 90    }
 91  20 Structure dataFlow = (Structure) data;
 92  20 super.visit(node, data);
 93  20 dataFlow.pushOnStack(NodeType.FOR_INIT, dataFlow.getLast());
 94  20 this.addForExpressionNode(node, dataFlow);
 95  20 return data;
 96    }
 97   
 98  20 public Object visit(ASTForUpdate node, Object data) {
 99  20 if (!(data instanceof Structure)) {
 100  0 return data;
 101    }
 102  20 Structure dataFlow = (Structure) data;
 103  20 this.addForExpressionNode(node, dataFlow);
 104  20 super.visit(node, data);
 105  20 dataFlow.pushOnStack(NodeType.FOR_UPDATE, dataFlow.getLast());
 106  20 return data;
 107    }
 108   
 109    // ----------------------------------------------------------------------------
 110    // BRANCH OUT
 111   
 112  168 public Object visit(ASTStatement node, Object data) {
 113  168 if (!(data instanceof Structure)) {
 114  0 return data;
 115    }
 116  168 Structure dataFlow = (Structure) data;
 117   
 118  168 if (node.jjtGetParent() instanceof ASTForStatement) {
 119  25 this.addForExpressionNode(node, dataFlow);
 120  25 dataFlow.pushOnStack(NodeType.FOR_BEFORE_FIRST_STATEMENT, dataFlow.getLast());
 121  143 } else if (node.jjtGetParent() instanceof ASTDoStatement) {
 122  3 dataFlow.pushOnStack(NodeType.DO_BEFORE_FIRST_STATEMENT, dataFlow.getLast());
 123  3 dataFlow.createNewNode((SimpleNode) node.jjtGetParent());
 124    }
 125   
 126  168 super.visit(node, data);
 127   
 128  168 if (node.jjtGetParent() instanceof ASTIfStatement) {
 129  35 ASTIfStatement st = (ASTIfStatement) node.jjtGetParent();
 130  35 if (!st.hasElse()) {
 131  13 dataFlow.pushOnStack(NodeType.IF_LAST_STATEMENT_WITHOUT_ELSE, dataFlow.getLast());
 132  22 } else if (st.hasElse() && !st.jjtGetChild(1).equals(node)) {
 133  11 dataFlow.pushOnStack(NodeType.ELSE_LAST_STATEMENT, dataFlow.getLast());
 134    } else {
 135  11 dataFlow.pushOnStack(NodeType.IF_LAST_STATEMENT, dataFlow.getLast());
 136    }
 137  133 } else if (node.jjtGetParent() instanceof ASTWhileStatement) {
 138  3 dataFlow.pushOnStack(NodeType.WHILE_LAST_STATEMENT, dataFlow.getLast());
 139  130 } else if (node.jjtGetParent() instanceof ASTForStatement) {
 140  25 dataFlow.pushOnStack(NodeType.FOR_END, dataFlow.getLast());
 141    }
 142  168 return data;
 143    }
 144   
 145  3 public Object visit(ASTSwitchStatement node, Object data) {
 146  3 if (!(data instanceof Structure)) {
 147  0 return data;
 148    }
 149  3 Structure dataFlow = (Structure) data;
 150  3 super.visit(node, data);
 151  3 dataFlow.pushOnStack(NodeType.SWITCH_END, dataFlow.getLast());
 152  3 return data;
 153    }
 154   
 155  5 public Object visit(ASTSwitchLabel node, Object data) {
 156  5 if (!(data instanceof Structure)) {
 157  0 return data;
 158    }
 159  5 Structure dataFlow = (Structure) data;
 160    //super.visit(node, data);
 161  5 if (node.jjtGetNumChildren() == 0) {
 162  2 dataFlow.pushOnStack(NodeType.SWITCH_LAST_DEFAULT_STATEMENT, dataFlow.getLast());
 163    } else {
 164  3 dataFlow.pushOnStack(NodeType.CASE_LAST_STATEMENT, dataFlow.getLast());
 165    }
 166  5 return data;
 167    }
 168   
 169  5 public Object visit(ASTBreakStatement node, Object data) {
 170  5 if (!(data instanceof Structure)) {
 171  0 return data;
 172    }
 173  5 Structure dataFlow = (Structure) data;
 174  5 dataFlow.createNewNode(node);
 175  5 dataFlow.pushOnStack(NodeType.BREAK_STATEMENT, dataFlow.getLast());
 176  5 return super.visit(node, data);
 177    }
 178   
 179   
 180  1 public Object visit(ASTContinueStatement node, Object data) {
 181  1 if (!(data instanceof Structure)) {
 182  0 return data;
 183    }
 184  1 Structure dataFlow = (Structure) data;
 185  1 dataFlow.createNewNode(node);
 186  1 dataFlow.pushOnStack(NodeType.CONTINUE_STATEMENT, dataFlow.getLast());
 187  1 return super.visit(node, data);
 188    }
 189   
 190  0 public Object visit(ASTReturnStatement node, Object data) {
 191  0 if (!(data instanceof Structure)) {
 192  0 return data;
 193    }
 194  0 Structure dataFlow = (Structure) data;
 195  0 dataFlow.createNewNode(node);
 196  0 dataFlow.pushOnStack(NodeType.RETURN_STATEMENT, dataFlow.getLast());
 197  0 return super.visit(node, data);
 198    }
 199   
 200    /*
 201    * The method handles the special "for" loop. It creates always an
 202    * expression node even if the loop looks like for(;;).
 203    * */
 204  65 private void addForExpressionNode(SimpleNode node, Structure dataFlow) {
 205  65 ASTForStatement parent = (ASTForStatement) node.jjtGetParent();
 206  65 boolean hasExpressionChild = false;
 207  65 boolean hasForInitNode = false;
 208  65 boolean hasForUpdateNode = false;
 209   
 210  65 for (int i = 0; i < parent.jjtGetNumChildren(); i++) {
 211  237 if (parent.jjtGetChild(i) instanceof ASTExpression)
 212  56 hasExpressionChild = true;
 213  181 else if (parent.jjtGetChild(i) instanceof ASTForUpdate)
 214  58 hasForUpdateNode = true;
 215  123 else if (parent.jjtGetChild(i) instanceof ASTForInit)
 216  58 hasForInitNode = true;
 217    }
 218  65 if (!hasExpressionChild) {
 219  9 if (node instanceof ASTForInit) {
 220  2 dataFlow.createNewNode(node);
 221  2 dataFlow.pushOnStack(NodeType.FOR_EXPR, dataFlow.getLast());
 222  7 } else if (node instanceof ASTForUpdate) {
 223  2 if (!hasForInitNode) {
 224  1 dataFlow.createNewNode(node);
 225  1 dataFlow.pushOnStack(NodeType.FOR_EXPR, dataFlow.getLast());
 226    }
 227  5 } else if (node instanceof ASTStatement) {
 228  5 if (!hasForInitNode && !hasForUpdateNode) {
 229  2 dataFlow.createNewNode(node);
 230  2 dataFlow.pushOnStack(NodeType.FOR_EXPR, dataFlow.getLast());
 231    }
 232    }
 233    }
 234    }
 235    }
 
CloverReport generated by Clover Code Coverage v1.3.6
Wed May 31 2006 09:26:49 EDT.		   Open Source License registered to the PMD Project. This license of Clover is provided to support the development of PMD only.