Debian Codegraph @

util/org/j_paine/formatter/NumberParserTokenManager.java

raw
1 /* Generated By:JavaCC: Do not edit this line. NumberParserTokenManager.java */
2 package org.j_paine.formatter;
3
4 public class NumberParserTokenManager implements NumberParserConstants
5 {
6 public java.io.PrintStream debugStream = System.out;
7 public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
8 private final int jjStopStringLiteralDfa_0(int pos, long active0)
9 {
10 switch (pos)
11 {
12 default :
13 return -1;
14 }
15 }
16 private final int jjStartNfa_0(int pos, long active0)
17 {
18 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
19 }
20 private final int jjStopAtPos(int pos, int kind)
21 {
22 jjmatchedKind = kind;
23 jjmatchedPos = pos;
24 return pos + 1;
25 }
26 private final int jjStartNfaWithStates_0(int pos, int kind, int state)
27 {
28 jjmatchedKind = kind;
29 jjmatchedPos = pos;
30 try { curChar = input_stream.readChar(); }
31 catch(java.io.IOException e) { return pos + 1; }
32 return jjMoveNfa_0(state, pos + 1);
33 }
34 private final int jjMoveStringLiteralDfa0_0()
35 {
36 switch(curChar)
37 {
38 case 32:
39 return jjStopAtPos(0, 6);
40 case 43:
41 return jjStopAtPos(0, 8);
42 case 45:
43 return jjStopAtPos(0, 7);
44 default :
45 return jjMoveNfa_0(0, 0);
46 }
47 }
48 private final void jjCheckNAdd(int state)
49 {
50 if (jjrounds[state] != jjround)
51 {
52 jjstateSet[jjnewStateCnt++] = state;
53 jjrounds[state] = jjround;
54 }
55 }
56 private final void jjAddStates(int start, int end)
57 {
58 do {
59 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
60 } while (start++ != end);
61 }
62 private final void jjCheckNAddTwoStates(int state1, int state2)
63 {
64 jjCheckNAdd(state1);
65 jjCheckNAdd(state2);
66 }
67 private final void jjCheckNAddStates(int start, int end)
68 {
69 do {
70 jjCheckNAdd(jjnextStates[start]);
71 } while (start++ != end);
72 }
73 private final void jjCheckNAddStates(int start)
74 {
75 jjCheckNAdd(jjnextStates[start]);
76 jjCheckNAdd(jjnextStates[start + 1]);
77 }
78 private final int jjMoveNfa_0(int startState, int curPos)
79 {
80 int[] nextStates;
81 int startsAt = 0;
82 jjnewStateCnt = 24;
83 int i = 1;
84 jjstateSet[0] = startState;
85 int j, kind = 0x7fffffff;
86 for (;;)
87 {
88 if (++jjround == 0x7fffffff)
89 ReInitRounds();
90 if (curChar < 64)
91 {
92 long l = 1L << curChar;
93 MatchLoop: do
94 {
95 switch(jjstateSet[--i])
96 {
97 case 0:
98 if ((0x3ff000000000000L & l) != 0L)
99 {
100 if (kind > 4)
101 kind = 4;
102 jjCheckNAddStates(0, 5);
103 }
104 else if (curChar == 46)
105 jjCheckNAdd(5);
106 if ((0x3fe000000000000L & l) != 0L)
107 {
108 if (kind > 1)
109 kind = 1;
110 jjCheckNAdd(2);
111 }
112 else if (curChar == 48)
113 {
114 if (kind > 1)
115 kind = 1;
116 }
117 break;
118 case 1:
119 if ((0x3fe000000000000L & l) == 0L)
120 break;
121 if (kind > 1)
122 kind = 1;
123 jjCheckNAdd(2);
124 break;
125 case 2:
126 if ((0x3ff000000000000L & l) == 0L)
127 break;
128 if (kind > 1)
129 kind = 1;
130 jjCheckNAdd(2);
131 break;
132 case 4:
133 if (curChar == 46)
134 jjCheckNAdd(5);
135 break;
136 case 5:
137 if ((0x3ff000000000000L & l) == 0L)
138 break;
139 if (kind > 4)
140 kind = 4;
141 jjCheckNAddTwoStates(5, 6);
142 break;
143 case 7:
144 if ((0x280000000000L & l) != 0L)
145 jjCheckNAdd(8);
146 break;
147 case 8:
148 if ((0x3ff000000000000L & l) == 0L)
149 break;
150 if (kind > 4)
151 kind = 4;
152 jjCheckNAdd(8);
153 break;
154 case 9:
155 if ((0x3ff000000000000L & l) == 0L)
156 break;
157 if (kind > 4)
158 kind = 4;
159 jjCheckNAddStates(0, 5);
160 break;
161 case 10:
162 if ((0x3ff000000000000L & l) != 0L)
163 jjCheckNAddTwoStates(10, 11);
164 break;
165 case 11:
166 if (curChar != 46)
167 break;
168 if (kind > 4)
169 kind = 4;
170 jjCheckNAddTwoStates(12, 13);
171 break;
172 case 12:
173 if ((0x3ff000000000000L & l) == 0L)
174 break;
175 if (kind > 4)
176 kind = 4;
177 jjCheckNAddTwoStates(12, 13);
178 break;
179 case 14:
180 if ((0x280000000000L & l) != 0L)
181 jjCheckNAdd(15);
182 break;
183 case 15:
184 if ((0x3ff000000000000L & l) == 0L)
185 break;
186 if (kind > 4)
187 kind = 4;
188 jjCheckNAdd(15);
189 break;
190 case 16:
191 if ((0x3ff000000000000L & l) != 0L)
192 jjCheckNAddTwoStates(16, 17);
193 break;
194 case 18:
195 if ((0x280000000000L & l) != 0L)
196 jjCheckNAdd(19);
197 break;
198 case 19:
199 if ((0x3ff000000000000L & l) == 0L)
200 break;
201 if (kind > 4)
202 kind = 4;
203 jjCheckNAdd(19);
204 break;
205 case 20:
206 if ((0x3ff000000000000L & l) == 0L)
207 break;
208 if (kind > 4)
209 kind = 4;
210 jjCheckNAddTwoStates(20, 21);
211 break;
212 case 22:
213 if ((0x280000000000L & l) != 0L)
214 jjCheckNAdd(23);
215 break;
216 case 23:
217 if ((0x3ff000000000000L & l) == 0L)
218 break;
219 if (kind > 4)
220 kind = 4;
221 jjCheckNAdd(23);
222 break;
223 default : break;
224 }
225 } while(i != startsAt);
226 }
227 else if (curChar < 128)
228 {
229 long l = 1L << (curChar & 077);
230 MatchLoop: do
231 {
232 switch(jjstateSet[--i])
233 {
234 case 0:
235 if ((0x100040L & l) != 0L)
236 kind = 3;
237 break;
238 case 6:
239 if ((0x2000000020L & l) != 0L)
240 jjAddStates(6, 7);
241 break;
242 case 13:
243 if ((0x2000000020L & l) != 0L)
244 jjAddStates(8, 9);
245 break;
246 case 17:
247 if ((0x2000000020L & l) != 0L)
248 jjAddStates(10, 11);
249 break;
250 case 21:
251 if ((0x2000000020L & l) != 0L)
252 jjAddStates(12, 13);
253 break;
254 default : break;
255 }
256 } while(i != startsAt);
257 }
258 else
259 {
260 int i2 = (curChar & 0xff) >> 6;
261 long l2 = 1L << (curChar & 077);
262 MatchLoop: do
263 {
264 switch(jjstateSet[--i])
265 {
266 default : break;
267 }
268 } while(i != startsAt);
269 }
270 if (kind != 0x7fffffff)
271 {
272 jjmatchedKind = kind;
273 jjmatchedPos = curPos;
274 kind = 0x7fffffff;
275 }
276 ++curPos;
277 if ((i = jjnewStateCnt) == (startsAt = 24 - (jjnewStateCnt = startsAt)))
278 return curPos;
279 try { curChar = input_stream.readChar(); }
280 catch(java.io.IOException e) { return curPos; }
281 }
282 }
283 static final int[] jjnextStates = {
284 10, 11, 16, 17, 20, 21, 7, 8, 14, 15, 18, 19, 22, 23,
285 };
286 public static final String[] jjstrLiteralImages = {
287 "", null, null, null, null, null, "\40", "\55", "\53", };
288 public static final String[] lexStateNames = {
289 "DEFAULT",
290 };
291 protected SimpleCharStream input_stream;
292 private final int[] jjrounds = new int[24];
293 private final int[] jjstateSet = new int[48];
294 protected char curChar;
295 public NumberParserTokenManager(SimpleCharStream stream){
296 if (SimpleCharStream.staticFlag)
297 throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
298 input_stream = stream;
299 }
300 public NumberParserTokenManager(SimpleCharStream stream, int lexState){
301 this(stream);
302 SwitchTo(lexState);
303 }
304 public void ReInit(SimpleCharStream stream)
305 {
306 jjmatchedPos = jjnewStateCnt = 0;
307 curLexState = defaultLexState;
308 input_stream = stream;
309 ReInitRounds();
310 }
311 private final void ReInitRounds()
312 {
313 int i;
314 jjround = 0x80000001;
315 for (i = 24; i-- > 0;)
316 jjrounds[i] = 0x80000000;
317 }
318 public void ReInit(SimpleCharStream stream, int lexState)
319 {
320 ReInit(stream);
321 SwitchTo(lexState);
322 }
323 public void SwitchTo(int lexState)
324 {
325 if (lexState >= 1 || lexState < 0)
326 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
327 else
328 curLexState = lexState;
329 }
330
331 protected Token jjFillToken()
332 {
333 Token t = Token.newToken(jjmatchedKind);
334 t.kind = jjmatchedKind;
335 String im = jjstrLiteralImages[jjmatchedKind];
336 t.image = (im == null) ? input_stream.GetImage() : im;
337 t.beginLine = input_stream.getBeginLine();
338 t.beginColumn = input_stream.getBeginColumn();
339 t.endLine = input_stream.getEndLine();
340 t.endColumn = input_stream.getEndColumn();
341 return t;
342 }
343
344 int curLexState = 0;
345 int defaultLexState = 0;
346 int jjnewStateCnt;
347 int jjround;
348 int jjmatchedPos;
349 int jjmatchedKind;
350
351 public Token getNextToken()
352 {
353 int kind;
354 Token specialToken = null;
355 Token matchedToken;
356 int curPos = 0;
357
358 EOFLoop :
359 for (;;)
360 {
361 try
362 {
363 curChar = input_stream.BeginToken();
364 }
365 catch(java.io.IOException e)
366 {
367 jjmatchedKind = 0;
368 matchedToken = jjFillToken();
369 return matchedToken;
370 }
371
372 jjmatchedKind = 0x7fffffff;
373 jjmatchedPos = 0;
374 curPos = jjMoveStringLiteralDfa0_0();
375 if (jjmatchedKind != 0x7fffffff)
376 {
377 if (jjmatchedPos + 1 < curPos)
378 input_stream.backup(curPos - jjmatchedPos - 1);
379 matchedToken = jjFillToken();
380 return matchedToken;
381 }
382 int error_line = input_stream.getEndLine();
383 int error_column = input_stream.getEndColumn();
384 String error_after = null;
385 boolean EOFSeen = false;
386 try { input_stream.readChar(); input_stream.backup(1); }
387 catch (java.io.IOException e1) {
388 EOFSeen = true;
389 error_after = curPos <= 1 ? "" : input_stream.GetImage();
390 if (curChar == '\n' || curChar == '\r') {
391 error_line++;
392 error_column = 0;
393 }
394 else
395 error_column++;
396 }
397 if (!EOFSeen) {
398 input_stream.backup(1);
399 error_after = curPos <= 1 ? "" : input_stream.GetImage();
400 }
401 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
402 }
403 }
404
405 }