View Javadoc
1   package de.fhdw.wtf.parser;
2   
3   import de.fhdw.wtf.common.exception.parser.NoArrowException;
4   import de.fhdw.wtf.common.exception.parser.NoBracketCloseException;
5   import de.fhdw.wtf.common.exception.parser.NoBracketOpenException;
6   import de.fhdw.wtf.common.exception.parser.NoColonException;
7   import de.fhdw.wtf.common.exception.parser.NoCurlyBracketCloseException;
8   import de.fhdw.wtf.common.exception.parser.NoCurlyBracketOpenException;
9   import de.fhdw.wtf.common.exception.parser.NoDoubleSquareBracketCloseException;
10  import de.fhdw.wtf.common.exception.parser.NoEqualException;
11  import de.fhdw.wtf.common.exception.parser.NoGroupElementException;
12  import de.fhdw.wtf.common.exception.parser.NoGroupException;
13  import de.fhdw.wtf.common.exception.parser.NoIdentifierException;
14  import de.fhdw.wtf.common.exception.parser.NoPlusSymbolException;
15  import de.fhdw.wtf.common.exception.parser.NoSemicolonException;
16  import de.fhdw.wtf.common.exception.parser.NoSquareBracketCloseException;
17  import de.fhdw.wtf.common.exception.parser.NoSquareBracketOpenException;
18  import de.fhdw.wtf.common.stream.TokenStream;
19  import de.fhdw.wtf.common.token.IdentifierToken;
20  import de.fhdw.wtf.common.token.Token;
21  import de.fhdw.wtf.common.token.symbols.PlusSymbolToken;
22  
23  /**
24   * Contains util methods for Parser.
25   */
26  final class ParserUtils {
27  	
28  	/**
29  	 * Constructor of {@link ParserUtils}.
30  	 */
31  	private ParserUtils() {
32  	}
33  	
34  	/**
35  	 * Takes the next Token from this.stream and checks if the Token is an IdentifierToken. If it is, it will be removed
36  	 * from this.stream and returned, otherwise a NoIdentifierException will be returned.
37  	 * 
38  	 * @param stream
39  	 *            stream
40  	 * @return {@link IdentifierToken}
41  	 * @throws NoIdentifierException
42  	 *             possible Exception
43  	 */
44  	static IdentifierToken requireAndRemoveIdentifier(final TokenStream stream) throws NoIdentifierException {
45  		final Token token = stream.peek();
46  		if (token.isIdentifierToken()) {
47  			final IdentifierToken iToken = (IdentifierToken) token;
48  			stream.removeFirst();
49  			return iToken;
50  		} else {
51  			throw NoIdentifierException.create(token);
52  		}
53  	}
54  	
55  	/**
56  	 * Throws a {@link NoArrowException} if the next Token of <code>this.stream</code> is not an ArrowToken.
57  	 * 
58  	 * @param stream
59  	 *            stream
60  	 * @throws NoArrowException
61  	 *             possible Exception
62  	 */
63  	static void requireAndRemoveArrowToken(final TokenStream stream) throws NoArrowException {
64  		if (!stream.peek().isArrowToken()) {
65  			throw NoArrowException.create(stream.peek());
66  		}
67  		stream.next();
68  	}
69  	
70  	/**
71  	 * Throws a NoColonException if the next Token of this.stream is a not a ColonToken.
72  	 * 
73  	 * @param stream
74  	 *            stream
75  	 * @throws NoColonException
76  	 *             possible Exception
77  	 */
78  	static void requireAndRemoveColonToken(final TokenStream stream) throws NoColonException {
79  		final Token nextToken = stream.peek();
80  		if (!(nextToken.isColonToken())) {
81  			throw NoColonException.create(nextToken);
82  		}
83  		stream.removeFirst();
84  	}
85  	
86  	/**
87  	 * Throws a {@link NoBracketOpenException} if the next Token of <code>this.getStream()</code> is not a
88  	 * BracketOpenToken.
89  	 * 
90  	 * @param stream
91  	 *            stream
92  	 * @throws NoBracketOpenException
93  	 *             possible Exception
94  	 */
95  	static void requireAndRemoveBracketOpenToken(final TokenStream stream) throws NoBracketOpenException {
96  		final Token token = stream.peek();
97  		if (!token.isBracketOpenToken()) {
98  			throw NoBracketOpenException.create(token);
99  		}
100 		stream.removeFirst();
101 	}
102 	
103 	/**
104 	 * Throws a {@link NoBracketCloseException} if the next Token of <code>this.stream</code> is not a
105 	 * BracketCloseToken.
106 	 * 
107 	 * @param stream
108 	 *            stream
109 	 * @return {@link Token}
110 	 * @throws NoBracketCloseException
111 	 *             possible Exception
112 	 */
113 	static Token requireAndRemoveBracketCloseToken(final TokenStream stream) throws NoBracketCloseException {
114 		final Token token = stream.peek();
115 		if (!token.isBracketCloseToken()) {
116 			throw NoBracketCloseException.create(token);
117 		}
118 		return stream.next();
119 	}
120 	
121 	/**
122 	 * Throws a {@link NoSemicolonException} if the next Token of this.stream is a not a SemicolonToken.
123 	 * 
124 	 * @param stream
125 	 *            stream
126 	 * @throws NoSemicolonException
127 	 *             possible Exception
128 	 */
129 	static void requireSemicolonToken(final TokenStream stream) throws NoSemicolonException {
130 		final Token nextToken = stream.peek();
131 		if (!(nextToken.isSemicolonToken())) {
132 			throw NoSemicolonException.create(nextToken);
133 		}
134 	}
135 	
136 	/**
137 	 * If the next element of this.stream is not a ColonToken, the element will be removed and skipToSemicolonToken will
138 	 * be called again. Otherwise only the SemicolonToken will be removed.
139 	 * 
140 	 * @param stream
141 	 *            stream
142 	 */
143 	static void skipToSemicolonToken(final TokenStream stream) {
144 		// First semicolon is the reason for exception.
145 		// if (stream.hasNext() && stream.peek().isSemicolonToken()) {
146 		// stream.removeFirst();
147 		// }
148 		if (stream.hasNext() && !(stream.peek().isSemicolonToken()) && !(stream.peek().isEndToken())) {
149 			stream.removeFirst();
150 			ParserUtils.skipToSemicolonToken(stream);
151 		}
152 		if (stream.hasNext() && stream.peek().isSemicolonToken()) {
153 			stream.removeFirst();
154 		}
155 	}
156 	
157 	/**
158 	 * Throws a NoSquareBracketCloseException if the next Token of this.stream is a not a SquareBracketCloseToken.
159 	 * 
160 	 * @param stream
161 	 *            stream
162 	 * @throws NoSquareBracketCloseException
163 	 *             possible Exception
164 	 */
165 	static void requireAndRemoveSquareBracketCloseToken(final TokenStream stream) throws NoSquareBracketCloseException {
166 		final Token nextToken = stream.peek();
167 		if (!nextToken.isSquareBracketCloseToken()) {
168 			throw NoSquareBracketCloseException.create(nextToken);
169 		}
170 		stream.removeFirst();
171 	}
172 	
173 	/**
174 	 * Throws a {@link NoDoubleSquareBracketCloseException} if the next Token of this.stream is a not a
175 	 * DoubleSquareBracketCloseToken.
176 	 * 
177 	 * @param stream
178 	 *            stream
179 	 * @throws NoDoubleSquareBracketCloseException
180 	 *             possible Exception
181 	 */
182 	static void requireAndRemoveDoubleSquareBracketCloseToken(final TokenStream stream)
183 			throws NoDoubleSquareBracketCloseException {
184 		final Token nextToken = stream.peek();
185 		if (!nextToken.isDoubleSquareBracketCloseToken()) {
186 			throw NoDoubleSquareBracketCloseException.create(nextToken);
187 		}
188 		stream.removeFirst();
189 	}
190 	
191 	/**
192 	 * Throws a NoEqualException if the next Token of this.stream is not an EqualToken.
193 	 * 
194 	 * @param stream
195 	 *            stream
196 	 * @throws NoEqualException
197 	 *             possible Exception
198 	 */
199 	static void requireAndRemoveEqualToken(final TokenStream stream) throws NoEqualException {
200 		final Token nextToken = stream.peek();
201 		if (!(nextToken.isEqualToken())) {
202 			throw NoEqualException.create(nextToken);
203 		}
204 		stream.removeFirst();
205 	}
206 	
207 	/**
208 	 * Throws a {@link NoPlusSymbolException} if the next Token of this.stream is a not a {@link PlusSymbolToken}.
209 	 * 
210 	 * @param stream
211 	 *            stream
212 	 * @return {@link PlusSymbolToken}
213 	 * @throws NoPlusSymbolException
214 	 *             possible Exception
215 	 */
216 	static PlusSymbolToken requireAndRemovePlusSymbol(final TokenStream stream) throws NoPlusSymbolException {
217 		final Token nextToken = stream.peek();
218 		if (nextToken.isPlusSymbolToken()) {
219 			stream.removeFirst();
220 			return (PlusSymbolToken) nextToken;
221 		} else {
222 			throw NoPlusSymbolException.create(nextToken);
223 		}
224 	}
225 	
226 	/**
227 	 * Throws a NoCurlyBracketOpenException if the next Token of this.stream is not a CurlyBracketOpenToken.
228 	 * 
229 	 * @param stream
230 	 *            stream
231 	 * @throws NoCurlyBracketOpenException
232 	 *             possible Exception
233 	 */
234 	static void requireAndRemoveCurlyBracketOpenToken(final TokenStream stream) throws NoCurlyBracketOpenException {
235 		final Token nextToken = stream.peek();
236 		if (!(nextToken.isCurlyBracketOpenToken())) {
237 			throw NoCurlyBracketOpenException.create(nextToken);
238 		}
239 		stream.removeFirst();
240 	}
241 	
242 	/**
243 	 * Throws a NoCurlyBracketCloseException if the next Token of this.stream is not a CurlyBracketCloseToken.
244 	 * 
245 	 * @param stream
246 	 *            stream
247 	 * @throws NoCurlyBracketCloseException
248 	 *             possible Exception
249 	 */
250 	static void requireAndRemoveCurlyBracketCloseToken(final TokenStream stream) throws NoCurlyBracketCloseException {
251 		final Token nextToken = stream.peek();
252 		if (!(nextToken.isCurlyBracketCloseToken())) {
253 			throw NoCurlyBracketCloseException.create(nextToken);
254 		}
255 		stream.removeFirst();
256 	}
257 	
258 	/**
259 	 * Throws a NoSquareBracketOpenException if the next Token of this.stream is not a SquareBracketOpenToken.
260 	 * 
261 	 * @param stream
262 	 *            stream
263 	 * @throws NoSquareBracketOpenException
264 	 *             possible Exception
265 	 */
266 	static void requireAndRemoveSquareBracketOpenToken(final TokenStream stream) throws NoSquareBracketOpenException {
267 		final Token nextToken = stream.peek();
268 		if (!(nextToken.isSquareBracketOpenToken())) {
269 			throw NoSquareBracketOpenException.create(nextToken);
270 		}
271 		stream.removeFirst();
272 	}
273 	
274 	/**
275 	 * Throws a NoGroupElementException if the next Token of this.stream is not a GroupToken or a ClassToken.
276 	 * 
277 	 * @param stream
278 	 *            stream
279 	 * @throws NoGroupElementException
280 	 *             possible Exception
281 	 */
282 	static void requireGroupElement(final TokenStream stream) throws NoGroupElementException {
283 		final Token nextToken = stream.peek();
284 		if (!(nextToken.isGroupToken() || nextToken.isClassToken() || nextToken.isExceptionToken())) {
285 			throw NoGroupElementException.create(nextToken);
286 		}
287 	}
288 	
289 	/**
290 	 * Throws a NoGroupException if the next Token of this.stream is not a GroupToken.
291 	 * 
292 	 * @param stream
293 	 *            stream
294 	 * @throws NoGroupException
295 	 *             possible Exception
296 	 */
297 	static void requireAndRemoveGroupToken(final TokenStream stream) throws NoGroupException {
298 		final Token token = stream.next();
299 		if (!(token.isGroupToken())) {
300 			throw NoGroupException.create(token);
301 		}
302 	}
303 }