Clover coverage report - PMD - 3.7
Coverage timestamp: Wed May 31 2006 09:25:59 EDT
file stats: LOC: 190   Methods: 10
NCLOC: 133   Classes: 2
 
 Source file Conditionals Statements Methods TOTAL
SequenceChecker.java 85.7% 95.5% 100% 94.6%
coverage coverage
 1    /*
 2    * Created on 11.07.2004
 3    */
 4    package net.sourceforge.pmd.dfa;
 5   
 6    import java.util.ArrayList;
 7    import java.util.List;
 8   
 9    /**
 10    * @author raik
 11    * <p/>
 12    * Computes the first sequence in a list.
 13    * <p/>
 14    * e.g.
 15    * IF_START 0
 16    * WHILE_EXPR 1
 17    * WHILE_END 2
 18    * IF_END 3
 19    * <p/>
 20    * The first sequence is WHILE_EXPR und WHILE_END. It returns always the
 21    * first inner nested scope.
 22    */
 23    public class SequenceChecker {
 24   
 25    /*
 26    * Element of logical structure of brace nodes.
 27    * */
 28    private static class Status {
 29    public static final int ROOT = -1;
 30   
 31    private List nextSteps = new ArrayList();
 32    private int type;
 33    private boolean lastStep;
 34   
 35   
 36  48 public Status(int type) {
 37  48 this(type, false);
 38    }
 39   
 40  72 public Status(int type, boolean lastStep) {
 41  72 this.type = type;
 42  72 this.lastStep = lastStep;
 43    }
 44   
 45  136 public void addStep(Status type) {
 46  136 nextSteps.add(type);
 47    }
 48   
 49  300 public Status step(int type) {
 50  300 for (int i = 0; i < this.nextSteps.size(); i++) {
 51  500 if (type == ((Status) nextSteps.get(i)).type) {
 52  270 return (Status) nextSteps.get(i);
 53    }
 54    }
 55  30 return null;
 56    }
 57   
 58  482 public boolean isLastStep() {
 59  482 return this.lastStep;
 60    }
 61   
 62  58 public boolean hasMoreSteps() {
 63  58 return this.nextSteps.size() > 1;
 64    }
 65    }
 66   
 67    private static Status root;
 68   
 69    static {
 70  4 root = new Status(Status.ROOT);
 71  4 Status ifNode = new Status(NodeType.IF_EXPR);
 72  4 Status ifSt = new Status(NodeType.IF_LAST_STATEMENT);
 73  4 Status ifStWithoutElse = new Status(NodeType.IF_LAST_STATEMENT_WITHOUT_ELSE, true);
 74  4 Status elseSt = new Status(NodeType.ELSE_LAST_STATEMENT, true);
 75  4 Status whileNode = new Status(NodeType.WHILE_EXPR);
 76  4 Status whileSt = new Status(NodeType.WHILE_LAST_STATEMENT, true);
 77  4 Status switchNode = new Status(NodeType.SWITCH_START);
 78  4 Status caseSt = new Status(NodeType.CASE_LAST_STATEMENT);
 79  4 Status switchDefault = new Status(NodeType.SWITCH_LAST_DEFAULT_STATEMENT);
 80  4 Status switchEnd = new Status(NodeType.SWITCH_END, true);
 81   
 82  4 Status forInit = new Status(NodeType.FOR_INIT);
 83  4 Status forExpr = new Status(NodeType.FOR_EXPR);
 84  4 Status forUpdate = new Status(NodeType.FOR_UPDATE);
 85  4 Status forSt = new Status(NodeType.FOR_BEFORE_FIRST_STATEMENT);
 86  4 Status forEnd = new Status(NodeType.FOR_END, true);
 87   
 88  4 Status doSt = new Status(NodeType.DO_BEFORE_FIRST_STATEMENT);
 89  4 Status doExpr = new Status(NodeType.DO_EXPR, true);
 90   
 91  4 root.addStep(ifNode);
 92  4 root.addStep(whileNode);
 93  4 root.addStep(switchNode);
 94  4 root.addStep(forInit);
 95  4 root.addStep(forExpr);
 96  4 root.addStep(forUpdate);
 97  4 root.addStep(forSt);
 98  4 root.addStep(doSt);
 99   
 100  4 ifNode.addStep(ifSt);
 101  4 ifNode.addStep(ifStWithoutElse);
 102  4 ifSt.addStep(elseSt);
 103  4 ifStWithoutElse.addStep(root);
 104  4 elseSt.addStep(root);
 105   
 106  4 whileNode.addStep(whileSt);
 107  4 whileSt.addStep(root);
 108   
 109  4 switchNode.addStep(caseSt);
 110  4 switchNode.addStep(switchDefault);
 111  4 switchNode.addStep(switchEnd);
 112  4 caseSt.addStep(caseSt);
 113  4 caseSt.addStep(switchDefault);
 114  4 caseSt.addStep(switchEnd);
 115  4 switchDefault.addStep(switchEnd);
 116  4 switchDefault.addStep(caseSt);
 117  4 switchEnd.addStep(root);
 118   
 119  4 forInit.addStep(forExpr);
 120  4 forInit.addStep(forUpdate);
 121  4 forInit.addStep(forSt);
 122  4 forExpr.addStep(forUpdate);
 123  4 forExpr.addStep(forSt);
 124  4 forUpdate.addStep(forSt);
 125  4 forSt.addStep(forEnd);
 126  4 forEnd.addStep(root);
 127   
 128  4 doSt.addStep(doExpr);
 129  4 doExpr.addStep(root);
 130    }
 131   
 132    private Status aktStatus;
 133    private List bracesList;
 134   
 135    private int firstIndex = -1;
 136    private int lastIndex = -1;
 137   
 138    /*
 139    * Defines the logical structure.
 140    * */
 141  40 public SequenceChecker(List bracesList) {
 142  40 this.aktStatus = root;
 143  40 this.bracesList = bracesList;
 144    }
 145   
 146    /**
 147    * Finds the first most inner sequence e.g IFStart & IFEnd. If no sequence
 148    * is found or the list is empty the method returns false.
 149    */
 150  98 public boolean run() {
 151  98 this.aktStatus = root;
 152  98 this.firstIndex = 0;
 153  98 this.lastIndex = 0;
 154  98 boolean lookAhead = false;
 155   
 156  98 for (int i = 0; i < this.bracesList.size(); i++) {
 157  300 StackObject so = (StackObject) bracesList.get(i);
 158  300 aktStatus = this.aktStatus.step(so.getType());
 159   
 160  300 if (aktStatus == null) {
 161  30 if (lookAhead) {
 162  0 this.lastIndex = i - 1;
 163  0 return false;
 164    }
 165  30 this.aktStatus = root;
 166  30 this.firstIndex = i;
 167  30 i--;
 168  30 continue;
 169    } else {
 170  270 if (aktStatus.isLastStep() && !aktStatus.hasMoreSteps()) {
 171  58 this.lastIndex = i;
 172  58 return false;
 173  212 } else if (aktStatus.isLastStep() && aktStatus.hasMoreSteps()) {
 174  0 lookAhead = true;
 175  0 this.lastIndex = i;
 176    }
 177    }
 178    }
 179  40 return this.firstIndex == this.lastIndex;
 180    }
 181   
 182  464 public int getFirstIndex() {
 183  464 return this.firstIndex;
 184    }
 185   
 186  198 public int getLastIndex() {
 187  198 return this.lastIndex;
 188    }
 189   
 190    }