![[Jenkins]](/jenkins/static/5c0124f8/images/svgs/logo.svg){kind=logo}
Method: create(int)
1: package de.fhdw.wtf.dsl.scanner.modelScanner;
2:
3: import java.util.ArrayList;
4: import java.util.List;
5:
6: import de.fhdw.wtf.common.token.Position;
7: import de.fhdw.wtf.dsl.scanner.common.CreatingDelta;
8: import de.fhdw.wtf.dsl.scanner.common.Delta;
9: import de.fhdw.wtf.dsl.scanner.common.InputMatcher;
10: import de.fhdw.wtf.dsl.scanner.common.LoopDelta;
11: import de.fhdw.wtf.dsl.scanner.common.Scanner;
12: import de.fhdw.wtf.dsl.scanner.common.ScannerState;
13: import de.fhdw.wtf.dsl.scanner.common.StateCreater;
14: import de.fhdw.wtf.dsl.scanner.common.StateMatcher;
15: import de.fhdw.wtf.dsl.scanner.modelScanner.state.CommentState;
16: import de.fhdw.wtf.dsl.scanner.modelScanner.state.InvalidState;
17: import de.fhdw.wtf.dsl.scanner.modelScanner.state.KeywordIdentifierState;
18: import de.fhdw.wtf.dsl.scanner.modelScanner.state.ScannerStateVisitor;
19: import de.fhdw.wtf.dsl.scanner.modelScanner.state.SymbolState;
20: import de.fhdw.wtf.dsl.scanner.modelScanner.state.WhitespaceState;
21:
22: /**
23: * {@link Scanner} implementation for the model language of WTF.
24: */
25: public final class ModelDslScanner extends Scanner {
26:
27: /**
28: * Default number of whitespaces, who representing a tabulator.
29: */
30: private static final int DEFAULT_TAB_WIDTH = 2;
31:
32: /**
33: * List of allowed Transitions between ScannerStates.
34: */
35: private final List<Delta> deltas;
36:
37: /**
38: * Creates a new ModelDslScanner-Object with the given tabulator width.
39: *
40: * @param tabulatorWidth
41: * the number of whitespaces representing a tabulator
42: *
43: * @return a new instance of ModelDslScanner
44: */
45: public static ModelDslScanner create(final int tabulatorWidth) {
46: return new ModelDslScanner(tabulatorWidth);
47: }
48:
49: /**
50: * Creates a new ModelDslScanner-Object, where the tabulator width is default.
51: *
52: * @return a new instance of ModelDslScanner
53: */
54: public static ModelDslScanner create() {
55: return new ModelDslScanner(DEFAULT_TAB_WIDTH);
56: }
57:
58: /**
59: * Creates a new ModelDslScanner-Object with the given tabulator width.
60: *
61: * @param tabulatorWidth
62: * the number of whitespaces representing a tabulator
63: */
64: private ModelDslScanner(final int tabulatorWidth) {
65: super(tabulatorWidth);
66: this.deltas = new ArrayList<>();
67: this.initDelta();
68: }
69:
70: @Override
71: protected List<Delta> getDeltas() {
72: return this.deltas;
73: }
74:
75: @Override
76: protected ScannerState getStartState() {
77: return SymbolState.create(Position.create("", 1, 1, 0));
78: }
79:
80: @Override
81: protected ScannerState getDefaultState(final Position position) {
82: return InvalidState.create(position);
83: }
84:
85: /**
86: * Builds the delta-function for the 'Automata' the scanner uses.
87: */
88: private void initDelta() {
89: final StateCreater commentCreater = new StateCreater() {
90: @Override
91: public ScannerState create(final Position position) {
92: return CommentState.create(position);
93: }
94: };
95: final StateCreater whitespaceCreater = new StateCreater() {
96: @Override
97: public ScannerState create(final Position position) {
98: return WhitespaceState.create(position);
99: }
100: };
101: final StateCreater keyIdentCreater = new StateCreater() {
102: @Override
103: public ScannerState create(final Position position) {
104: return KeywordIdentifierState.create(position);
105: }
106: };
107: final StateCreater symbolCreater = new StateCreater() {
108: @Override
109: public ScannerState create(final Position position) {
110: return SymbolState.create(position);
111: }
112: };
113: final InputMatcher keyIdentPrefixMatcher = new InputMatcher() {
114: @Override
115: public boolean match(final Character c) {
116: return Character.isLetter(c) || c == '_';
117: }
118: };
119: final InputMatcher keyIdentMatcher = new InputMatcher() {
120: @Override
121: public boolean match(final Character c) {
122: return Character.isLetterOrDigit(c) || c == '_';
123: }
124: };
125: final InputMatcher whitespaceMatcher = new InputMatcher() {
126: @Override
127: public boolean match(final Character c) {
128: return Character.isWhitespace(c);
129: }
130: };
131:
132: final InputMatcher invalidMatcher = new InputMatcher() {
133: @Override
134: public boolean match(final Character c) {
135: return InvalidState.isInValid(c);
136: }
137: };
138: final InputMatcher symbolMatcher = new InputMatcher() {
139: @Override
140: public boolean match(final Character c) {
141: return SymbolState.isSymbol(c);
142: }
143: };
144:
145: final InputMatcher commentBeginMatcher = new InputMatcher() {
146: @Override
147: public boolean match(final Character c) {
148: return c == CommentState.COMMENT_OPEN;
149: }
150: };
151: final InputMatcher commentMatcher = new InputMatcher() {
152: @Override
153: public boolean match(final Character c) {
154: return c != CommentState.COMMENT_CLOSE;
155: }
156: };
157: final InputMatcher commentEndMatcher = new InputMatcher() {
158: @Override
159: public boolean match(final Character c) {
160: return c == CommentState.COMMENT_CLOSE;
161: }
162: };
163: final StateMatcher exceptCommentState = new StateMatcher() {
164: @Override
165: public boolean match(final ScannerState state) {
166: return state.accept(new ScannerStateVisitor() {
167: @Override
168: public boolean handleWhitespaceState() {
169: return true;
170: }
171:
172: @Override
173: public boolean handleSymbolState() {
174: return true;
175: }
176:
177: @Override
178: public boolean handleKeywordIdentifierState() {
179: return true;
180: }
181:
182: @Override
183: public boolean handleInvalidState() {
184: return true;
185: }
186:
187: @Override
188: public boolean handleCommentState() {
189: return false;
190: }
191: });
192: }
193: };
194: final StateMatcher exceptCommentAndSymbolState = new StateMatcher() {
195: @Override
196: public boolean match(final ScannerState state) {
197: return state.accept(new ScannerStateVisitor() {
198: @Override
199: public boolean handleWhitespaceState() {
200: return true;
201: }
202:
203: @Override
204: public boolean handleSymbolState() {
205: return false;
206: }
207:
208: @Override
209: public boolean handleKeywordIdentifierState() {
210: return true;
211: }
212:
213: @Override
214: public boolean handleInvalidState() {
215: return true;
216: }
217:
218: @Override
219: public boolean handleCommentState() {
220: return false;
221: }
222: });
223: }
224: };
225: final StateMatcher exceptCommentAndKeyIdentState = new StateMatcher() {
226: @Override
227: public boolean match(final ScannerState state) {
228: return state.accept(new ScannerStateVisitor() {
229: @Override
230: public boolean handleWhitespaceState() {
231: return true;
232: }
233:
234: @Override
235: public boolean handleSymbolState() {
236: return true;
237: }
238:
239: @Override
240: public boolean handleKeywordIdentifierState() {
241: return false;
242: }
243:
244: @Override
245: public boolean handleInvalidState() {
246: return true;
247: }
248:
249: @Override
250: public boolean handleCommentState() {
251: return false;
252: }
253: });
254: }
255: };
256: final StateMatcher exceptCommentAndWhitespaceState = new StateMatcher() {
257: @Override
258: public boolean match(final ScannerState state) {
259: return state.accept(new ScannerStateVisitor() {
260: @Override
261: public boolean handleWhitespaceState() {
262: return false;
263: }
264:
265: @Override
266: public boolean handleSymbolState() {
267: return true;
268: }
269:
270: @Override
271: public boolean handleKeywordIdentifierState() {
272: return true;
273: }
274:
275: @Override
276: public boolean handleInvalidState() {
277: return true;
278: }
279:
280: @Override
281: public boolean handleCommentState() {
282: return false;
283: }
284: });
285: }
286: };
287: final StateMatcher whitespaceState = new StateMatcher() {
288: @Override
289: public boolean match(final ScannerState state) {
290: return state.accept(new ScannerStateVisitor() {
291: @Override
292: public boolean handleWhitespaceState() {
293: return true;
294: }
295:
296: @Override
297: public boolean handleSymbolState() {
298: return false;
299: }
300:
301: @Override
302: public boolean handleKeywordIdentifierState() {
303: return false;
304: }
305:
306: @Override
307: public boolean handleInvalidState() {
308: return false;
309: }
310:
311: @Override
312: public boolean handleCommentState() {
313: return false;
314: }
315: });
316: }
317: };
318: final StateMatcher invalidState = new StateMatcher() {
319: @Override
320: public boolean match(final ScannerState state) {
321: return state.accept(new ScannerStateVisitor() {
322: @Override
323: public boolean handleWhitespaceState() {
324: return false;
325: }
326:
327: @Override
328: public boolean handleSymbolState() {
329: return false;
330: }
331:
332: @Override
333: public boolean handleKeywordIdentifierState() {
334: return false;
335: }
336:
337: @Override
338: public boolean handleInvalidState() {
339: return true;
340: }
341:
342: @Override
343: public boolean handleCommentState() {
344: return false;
345: }
346: });
347: }
348: };
349: final StateMatcher keyIdentState = new StateMatcher() {
350: @Override
351: public boolean match(final ScannerState state) {
352: return state.accept(new ScannerStateVisitor() {
353: @Override
354: public boolean handleWhitespaceState() {
355: return false;
356: }
357:
358: @Override
359: public boolean handleSymbolState() {
360: return false;
361: }
362:
363: @Override
364: public boolean handleKeywordIdentifierState() {
365: return true;
366: }
367:
368: @Override
369: public boolean handleInvalidState() {
370: return false;
371: }
372:
373: @Override
374: public boolean handleCommentState() {
375: return false;
376: }
377: });
378: }
379: };
380: final StateMatcher commentState = new StateMatcher() {
381: @Override
382: public boolean match(final ScannerState state) {
383: return state.accept(new ScannerStateVisitor() {
384: @Override
385: public boolean handleWhitespaceState() {
386: return false;
387: }
388:
389: @Override
390: public boolean handleSymbolState() {
391: return false;
392: }
393:
394: @Override
395: public boolean handleKeywordIdentifierState() {
396: return false;
397: }
398:
399: @Override
400: public boolean handleInvalidState() {
401: return false;
402: }
403:
404: @Override
405: public boolean handleCommentState() {
406: return true;
407: }
408: });
409: }
410: };
411: final StateMatcher symbolState = new StateMatcher() {
412: @Override
413: public boolean match(final ScannerState state) {
414: return state.accept(new ScannerStateVisitor() {
415: @Override
416: public boolean handleWhitespaceState() {
417: return false;
418: }
419:
420: @Override
421: public boolean handleSymbolState() {
422: return true;
423: }
424:
425: @Override
426: public boolean handleKeywordIdentifierState() {
427: return false;
428: }
429:
430: @Override
431: public boolean handleInvalidState() {
432: return false;
433: }
434:
435: @Override
436: public boolean handleCommentState() {
437: return false;
438: }
439: });
440: }
441: };
442: this.getDeltas().add(CreatingDelta.create(exceptCommentAndSymbolState, symbolMatcher, symbolCreater));
443: this.getDeltas().add(
444: CreatingDelta.create(exceptCommentAndKeyIdentState, keyIdentPrefixMatcher, keyIdentCreater));
445: this.getDeltas().add(
446: CreatingDelta.create(exceptCommentAndWhitespaceState, whitespaceMatcher, whitespaceCreater));
447: this.getDeltas().add(LoopDelta.create(invalidState, invalidMatcher));
448: this.getDeltas().add(LoopDelta.create(whitespaceState, whitespaceMatcher));
449: this.getDeltas().add(LoopDelta.create(keyIdentState, keyIdentMatcher));
450: this.getDeltas().add(LoopDelta.create(symbolState, symbolMatcher));
451: this.getDeltas().add(CreatingDelta.create(exceptCommentState, commentBeginMatcher, commentCreater));
452: this.getDeltas().add(CreatingDelta.create(commentState, commentEndMatcher, symbolCreater));
453: this.getDeltas().add(LoopDelta.create(commentState, commentMatcher));
454: }
455:
456: }