PMD - 3.7

Clover coverage report - PMD - 3.7

Coverage timestamp: Wed May 31 2006 09:25:59 EDT

FRAMES NO FRAMES

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%

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		}