1 | |
|
2 | |
package org.apache.commons.configuration.plist; |
3 | |
|
4 | |
class PropertyListParserTokenManager implements PropertyListParserConstants |
5 | |
{ |
6 | 40 | public java.io.PrintStream debugStream = System.out; |
7 | |
|
8 | |
public void setDebugStream(java.io.PrintStream ds) |
9 | |
{ |
10 | 0 | debugStream = ds; |
11 | 0 | } |
12 | |
|
13 | |
private final int jjStopStringLiteralDfa_0(int pos, long active0) |
14 | |
{ |
15 | 68 | switch (pos) |
16 | |
{ |
17 | |
case 0: |
18 | 68 | if ((active0 & 0x2000L) != 0L) |
19 | |
{ |
20 | 0 | return 8; |
21 | |
} |
22 | 68 | if ((active0 & 0x8000L) != 0L) |
23 | |
{ |
24 | 0 | return 14; |
25 | |
} |
26 | 68 | if ((active0 & 0x800000L) != 0L) |
27 | |
{ |
28 | 0 | jjmatchedKind = 21; |
29 | 0 | return 8; |
30 | |
} |
31 | 68 | if ((active0 & 0x5000L) != 0L) |
32 | |
{ |
33 | 68 | return 6; |
34 | |
} |
35 | 0 | return -1; |
36 | |
case 1: |
37 | 0 | if ((active0 & 0x4000L) != 0L) |
38 | |
{ |
39 | 0 | jjmatchedKind = 21; |
40 | 0 | jjmatchedPos = 1; |
41 | 0 | return 3; |
42 | |
} |
43 | 0 | return -1; |
44 | |
default : |
45 | 0 | return -1; |
46 | |
} |
47 | |
} |
48 | |
|
49 | |
private final int jjStartNfa_0(int pos, long active0) |
50 | |
{ |
51 | 68 | return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1); |
52 | |
} |
53 | |
|
54 | |
private final int jjStopAtPos(int pos, int kind) |
55 | |
{ |
56 | 2284 | jjmatchedKind = kind; |
57 | 2284 | jjmatchedPos = pos; |
58 | 2284 | return pos + 1; |
59 | |
} |
60 | |
|
61 | |
private final int jjStartNfaWithStates_0(int pos, int kind, int state) |
62 | |
{ |
63 | 323 | jjmatchedKind = kind; |
64 | 323 | jjmatchedPos = pos; |
65 | |
try |
66 | |
{ |
67 | 323 | curChar = input_stream.readChar(); |
68 | |
} |
69 | 0 | catch (java.io.IOException e) |
70 | |
{ |
71 | 0 | return pos + 1; |
72 | 323 | } |
73 | 323 | return jjMoveNfa_0(state, pos + 1); |
74 | |
} |
75 | |
|
76 | |
private final int jjMoveStringLiteralDfa0_0() |
77 | |
{ |
78 | 3607 | switch (curChar) |
79 | |
{ |
80 | |
case 34: |
81 | 290 | return jjStartNfaWithStates_0(0, 15, 14); |
82 | |
case 40: |
83 | 198 | return jjStopAtPos(0, 5); |
84 | |
case 41: |
85 | 198 | return jjStopAtPos(0, 6); |
86 | |
case 44: |
87 | 198 | return jjStopAtPos(0, 7); |
88 | |
case 59: |
89 | 466 | return jjStopAtPos(0, 10); |
90 | |
case 60: |
91 | 101 | jjmatchedKind = 12; |
92 | 101 | return jjMoveStringLiteralDfa1_0(0x4000L); |
93 | |
case 61: |
94 | 694 | return jjStopAtPos(0, 11); |
95 | |
case 62: |
96 | 0 | return jjStartNfaWithStates_0(0, 13, 8); |
97 | |
case 92: |
98 | 0 | return jjMoveStringLiteralDfa1_0(0x800000L); |
99 | |
case 123: |
100 | 265 | return jjStopAtPos(0, 8); |
101 | |
case 125: |
102 | 265 | return jjStopAtPos(0, 9); |
103 | |
default : |
104 | 932 | return jjMoveNfa_0(0, 0); |
105 | |
} |
106 | |
} |
107 | |
|
108 | |
private final int jjMoveStringLiteralDfa1_0(long active0) |
109 | |
{ |
110 | |
try |
111 | |
{ |
112 | 101 | curChar = input_stream.readChar(); |
113 | |
} |
114 | 0 | catch (java.io.IOException e) |
115 | |
{ |
116 | 0 | jjStopStringLiteralDfa_0(0, active0); |
117 | 0 | return 1; |
118 | 101 | } |
119 | 101 | switch (curChar) |
120 | |
{ |
121 | |
case 34: |
122 | 0 | if ((active0 & 0x800000L) != 0L) |
123 | |
{ |
124 | 0 | return jjStopAtPos(1, 23); |
125 | |
} |
126 | |
break; |
127 | |
case 42: |
128 | 33 | return jjMoveStringLiteralDfa2_0(active0, 0x4000L); |
129 | |
default : |
130 | |
break; |
131 | |
} |
132 | 68 | return jjStartNfa_0(0, active0); |
133 | |
} |
134 | |
|
135 | |
private final int jjMoveStringLiteralDfa2_0(long old0, long active0) |
136 | |
{ |
137 | 33 | if (((active0 &= old0)) == 0L) |
138 | |
{ |
139 | 0 | return jjStartNfa_0(0, old0); |
140 | |
} |
141 | |
try |
142 | |
{ |
143 | 33 | curChar = input_stream.readChar(); |
144 | |
} |
145 | 0 | catch (java.io.IOException e) |
146 | |
{ |
147 | 0 | jjStopStringLiteralDfa_0(1, active0); |
148 | 0 | return 2; |
149 | 33 | } |
150 | 33 | switch (curChar) |
151 | |
{ |
152 | |
case 68: |
153 | 33 | if ((active0 & 0x4000L) != 0L) |
154 | |
{ |
155 | 33 | return jjStartNfaWithStates_0(2, 14, 15); |
156 | |
} |
157 | |
break; |
158 | |
default : |
159 | |
break; |
160 | |
} |
161 | 0 | return jjStartNfa_0(1, active0); |
162 | |
} |
163 | |
|
164 | |
private final void jjCheckNAdd(int state) |
165 | |
{ |
166 | 19486 | if (jjrounds[state] != jjround) |
167 | |
{ |
168 | 19486 | jjstateSet[jjnewStateCnt++] = state; |
169 | 19486 | jjrounds[state] = jjround; |
170 | |
} |
171 | 19486 | } |
172 | |
|
173 | |
private final void jjAddStates(int start, int end) |
174 | |
{ |
175 | |
do |
176 | |
{ |
177 | 0 | jjstateSet[jjnewStateCnt++] = jjnextStates[start]; |
178 | |
} |
179 | 0 | while (start++ != end); |
180 | 0 | } |
181 | |
|
182 | |
private final void jjCheckNAddTwoStates(int state1, int state2) |
183 | |
{ |
184 | 1399 | jjCheckNAdd(state1); |
185 | 1399 | jjCheckNAdd(state2); |
186 | 1399 | } |
187 | |
|
188 | |
private final void jjCheckNAddStates(int start, int end) |
189 | |
{ |
190 | |
do |
191 | |
{ |
192 | 9660 | jjCheckNAdd(jjnextStates[start]); |
193 | |
} |
194 | 9660 | while (start++ != end); |
195 | 3220 | } |
196 | |
|
197 | |
private final void jjCheckNAddStates(int start) |
198 | |
{ |
199 | 0 | jjCheckNAdd(jjnextStates[start]); |
200 | 0 | jjCheckNAdd(jjnextStates[start + 1]); |
201 | 0 | } |
202 | |
|
203 | 3 | static final long[] jjbitVec0 = { |
204 | |
0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL |
205 | |
}; |
206 | |
|
207 | |
private final int jjMoveNfa_0(int startState, int curPos) |
208 | |
{ |
209 | |
int[] nextStates; |
210 | 1323 | int startsAt = 0; |
211 | 1323 | jjnewStateCnt = 14; |
212 | 1323 | int i = 1; |
213 | 1323 | jjstateSet[0] = startState; |
214 | 1323 | int j, kind = 0x7fffffff; |
215 | |
for (; ;) |
216 | |
{ |
217 | 12418 | if (++jjround == 0x7fffffff) |
218 | |
{ |
219 | 0 | ReInitRounds(); |
220 | |
} |
221 | 12418 | if (curChar < 64) |
222 | |
{ |
223 | 3814 | long l = 1L << curChar; |
224 | |
MatchLoop: |
225 | |
do |
226 | |
{ |
227 | 7589 | switch (jjstateSet[--i]) |
228 | |
{ |
229 | |
case 15: |
230 | 33 | if ((0xd7ffecfaffffd9ffL & l) != 0L) |
231 | |
{ |
232 | 33 | if (kind > 21) |
233 | |
{ |
234 | 33 | kind = 21; |
235 | |
} |
236 | 33 | jjCheckNAdd(8); |
237 | |
} |
238 | 33 | if ((0x7ff280100000000L & l) != 0L) |
239 | |
{ |
240 | 33 | jjCheckNAddTwoStates(4, 5); |
241 | |
} |
242 | 0 | else if (curChar == 62) |
243 | |
{ |
244 | 0 | if (kind > 20) |
245 | |
{ |
246 | 0 | kind = 20; |
247 | |
} |
248 | |
} |
249 | |
break; |
250 | |
case 6: |
251 | 68 | if ((0xd7ffecfaffffd9ffL & l) != 0L) |
252 | |
{ |
253 | 36 | if (kind > 21) |
254 | |
{ |
255 | 36 | kind = 21; |
256 | |
} |
257 | 36 | jjCheckNAdd(8); |
258 | |
} |
259 | 68 | if ((0x3ff000100002600L & l) != 0L) |
260 | |
{ |
261 | 67 | jjCheckNAddTwoStates(1, 2); |
262 | |
} |
263 | 1 | else if (curChar == 42) |
264 | |
{ |
265 | 0 | jjstateSet[jjnewStateCnt++] = 3; |
266 | |
} |
267 | 1 | else if (curChar == 62) |
268 | |
{ |
269 | 1 | if (kind > 19) |
270 | |
{ |
271 | 1 | kind = 19; |
272 | |
} |
273 | |
} |
274 | |
break; |
275 | |
case 14: |
276 | 0 | if ((0xfffffffbffffffffL & l) != 0L) |
277 | |
{ |
278 | 0 | jjCheckNAddStates(0, 2); |
279 | |
} |
280 | 0 | else if (curChar == 34) |
281 | |
{ |
282 | 0 | if (kind > 22) |
283 | |
{ |
284 | 0 | kind = 22; |
285 | |
} |
286 | |
} |
287 | |
break; |
288 | |
case 3: |
289 | |
case 8: |
290 | 1921 | if ((0xd7ffecfaffffd9ffL & l) == 0L) |
291 | |
{ |
292 | 1001 | break; |
293 | |
} |
294 | 920 | if (kind > 21) |
295 | |
{ |
296 | 920 | kind = 21; |
297 | |
} |
298 | 920 | jjCheckNAdd(8); |
299 | 920 | break; |
300 | |
case 0: |
301 | 0 | if ((0xd7ffecfaffffd9ffL & l) != 0L) |
302 | |
{ |
303 | 0 | if (kind > 21) |
304 | |
{ |
305 | 0 | kind = 21; |
306 | |
} |
307 | 0 | jjCheckNAdd(8); |
308 | |
} |
309 | 0 | else if (curChar == 34) |
310 | |
{ |
311 | 0 | jjCheckNAddStates(0, 2); |
312 | |
} |
313 | 0 | if (curChar == 60) |
314 | |
{ |
315 | 0 | jjstateSet[jjnewStateCnt++] = 6; |
316 | |
} |
317 | 0 | if (curChar == 60) |
318 | |
{ |
319 | 0 | jjCheckNAddTwoStates(1, 2); |
320 | |
} |
321 | |
break; |
322 | |
case 1: |
323 | 508 | if ((0x3ff000100002600L & l) != 0L) |
324 | |
{ |
325 | 441 | jjCheckNAddTwoStates(1, 2); |
326 | |
} |
327 | |
break; |
328 | |
case 2: |
329 | 508 | if (curChar == 62 && kind > 19) |
330 | |
{ |
331 | 67 | kind = 19; |
332 | |
} |
333 | |
break; |
334 | |
case 4: |
335 | 825 | if ((0x7ff280100000000L & l) != 0L) |
336 | |
{ |
337 | 792 | jjCheckNAddTwoStates(4, 5); |
338 | |
} |
339 | |
break; |
340 | |
case 5: |
341 | 825 | if (curChar == 62 && kind > 20) |
342 | |
{ |
343 | 33 | kind = 20; |
344 | |
} |
345 | |
break; |
346 | |
case 7: |
347 | 0 | if (curChar == 60) |
348 | |
{ |
349 | 0 | jjstateSet[jjnewStateCnt++] = 6; |
350 | |
} |
351 | |
break; |
352 | |
case 9: |
353 | |
case 11: |
354 | 66 | if (curChar == 34) |
355 | |
{ |
356 | 66 | jjCheckNAddStates(0, 2); |
357 | |
} |
358 | |
break; |
359 | |
case 10: |
360 | 945 | if ((0xfffffffbffffffffL & l) != 0L) |
361 | |
{ |
362 | 589 | jjCheckNAddStates(0, 2); |
363 | |
} |
364 | |
break; |
365 | |
case 13: |
366 | 945 | if (curChar == 34 && kind > 22) |
367 | |
{ |
368 | 356 | kind = 22; |
369 | |
} |
370 | |
break; |
371 | |
default : |
372 | |
break; |
373 | |
} |
374 | |
} |
375 | 7589 | while (i != startsAt); |
376 | |
} |
377 | 8604 | else if (curChar < 128) |
378 | |
{ |
379 | 8604 | long l = 1L << (curChar & 077); |
380 | |
MatchLoop: |
381 | |
do |
382 | |
{ |
383 | 13286 | switch (jjstateSet[--i]) |
384 | |
{ |
385 | |
case 15: |
386 | 0 | if ((0xd7ffffffffffffffL & l) != 0L) |
387 | |
{ |
388 | 0 | if (kind > 21) |
389 | |
{ |
390 | 0 | kind = 21; |
391 | |
} |
392 | 0 | jjCheckNAdd(8); |
393 | |
} |
394 | 0 | if (curChar == 90) |
395 | |
{ |
396 | 0 | jjCheckNAddTwoStates(4, 5); |
397 | |
} |
398 | |
break; |
399 | |
case 6: |
400 | 0 | if ((0xd7ffffffffffffffL & l) != 0L) |
401 | |
{ |
402 | 0 | if (kind > 21) |
403 | |
{ |
404 | 0 | kind = 21; |
405 | |
} |
406 | 0 | jjCheckNAdd(8); |
407 | |
} |
408 | 0 | if ((0x7e0000007eL & l) != 0L) |
409 | |
{ |
410 | 0 | jjCheckNAddTwoStates(1, 2); |
411 | |
} |
412 | |
break; |
413 | |
case 14: |
414 | 290 | jjCheckNAddStates(0, 2); |
415 | 290 | if (curChar == 92) |
416 | |
{ |
417 | 0 | jjstateSet[jjnewStateCnt++] = 11; |
418 | |
} |
419 | |
break; |
420 | |
case 3: |
421 | 0 | if ((0xd7ffffffffffffffL & l) != 0L) |
422 | |
{ |
423 | 0 | if (kind > 21) |
424 | |
{ |
425 | 0 | kind = 21; |
426 | |
} |
427 | 0 | jjCheckNAdd(8); |
428 | |
} |
429 | 0 | if (curChar == 68) |
430 | |
{ |
431 | 0 | jjCheckNAddTwoStates(4, 5); |
432 | |
} |
433 | |
break; |
434 | |
case 0: |
435 | |
case 8: |
436 | 6039 | if ((0xd7ffffffffffffffL & l) == 0L) |
437 | |
{ |
438 | 0 | break; |
439 | |
} |
440 | 6039 | if (kind > 21) |
441 | |
{ |
442 | 6039 | kind = 21; |
443 | |
} |
444 | 6039 | jjCheckNAdd(8); |
445 | 6039 | break; |
446 | |
case 1: |
447 | 66 | if ((0x7e0000007eL & l) != 0L) |
448 | |
{ |
449 | 66 | jjCheckNAddTwoStates(1, 2); |
450 | |
} |
451 | |
break; |
452 | |
case 4: |
453 | 0 | if (curChar == 90) |
454 | |
{ |
455 | 0 | jjCheckNAddTwoStates(4, 5); |
456 | |
} |
457 | |
break; |
458 | |
case 10: |
459 | 2275 | jjCheckNAddStates(0, 2); |
460 | 2275 | break; |
461 | |
case 12: |
462 | 2275 | if (curChar == 92) |
463 | |
{ |
464 | 66 | jjstateSet[jjnewStateCnt++] = 11; |
465 | |
} |
466 | |
break; |
467 | |
default : |
468 | |
break; |
469 | |
} |
470 | |
} |
471 | 13286 | while (i != startsAt); |
472 | |
} |
473 | |
else |
474 | |
{ |
475 | 0 | int i2 = (curChar & 0xff) >> 6; |
476 | 0 | long l2 = 1L << (curChar & 077); |
477 | |
MatchLoop: |
478 | |
do |
479 | |
{ |
480 | 0 | switch (jjstateSet[--i]) |
481 | |
{ |
482 | |
case 15: |
483 | |
case 8: |
484 | 0 | if ((jjbitVec0[i2] & l2) == 0L) |
485 | |
{ |
486 | 0 | break; |
487 | |
} |
488 | 0 | if (kind > 21) |
489 | |
{ |
490 | 0 | kind = 21; |
491 | |
} |
492 | 0 | jjCheckNAdd(8); |
493 | 0 | break; |
494 | |
case 6: |
495 | 0 | if ((jjbitVec0[i2] & l2) == 0L) |
496 | |
{ |
497 | 0 | break; |
498 | |
} |
499 | 0 | if (kind > 21) |
500 | |
{ |
501 | 0 | kind = 21; |
502 | |
} |
503 | 0 | jjCheckNAdd(8); |
504 | 0 | break; |
505 | |
case 14: |
506 | |
case 10: |
507 | 0 | if ((jjbitVec0[i2] & l2) != 0L) |
508 | |
{ |
509 | 0 | jjCheckNAddStates(0, 2); |
510 | |
} |
511 | |
break; |
512 | |
case 3: |
513 | 0 | if ((jjbitVec0[i2] & l2) == 0L) |
514 | |
{ |
515 | 0 | break; |
516 | |
} |
517 | 0 | if (kind > 21) |
518 | |
{ |
519 | 0 | kind = 21; |
520 | |
} |
521 | 0 | jjCheckNAdd(8); |
522 | 0 | break; |
523 | |
case 0: |
524 | 0 | if ((jjbitVec0[i2] & l2) == 0L) |
525 | |
{ |
526 | 0 | break; |
527 | |
} |
528 | 0 | if (kind > 21) |
529 | |
{ |
530 | 0 | kind = 21; |
531 | |
} |
532 | 0 | jjCheckNAdd(8); |
533 | 0 | break; |
534 | |
default : |
535 | |
break; |
536 | |
} |
537 | |
} |
538 | 0 | while (i != startsAt); |
539 | |
} |
540 | 12418 | if (kind != 0x7fffffff) |
541 | |
{ |
542 | 7481 | jjmatchedKind = kind; |
543 | 7481 | jjmatchedPos = curPos; |
544 | 7481 | kind = 0x7fffffff; |
545 | |
} |
546 | 12418 | ++curPos; |
547 | 12418 | if ((i = jjnewStateCnt) == (startsAt = 14 - (jjnewStateCnt = startsAt))) |
548 | |
{ |
549 | 1323 | return curPos; |
550 | |
} |
551 | |
try |
552 | |
{ |
553 | 11095 | curChar = input_stream.readChar(); |
554 | |
} |
555 | 0 | catch (java.io.IOException e) |
556 | |
{ |
557 | 0 | return curPos; |
558 | 11095 | } |
559 | |
} |
560 | |
} |
561 | |
|
562 | 3 | static final int[] jjnextStates = { |
563 | |
10, 12, 13, |
564 | |
}; |
565 | 3 | public static final String[] jjstrLiteralImages = { |
566 | |
"", null, null, null, null, "\50", "\51", "\54", "\173", "\175", "\73", "\75", |
567 | |
"\74", "\76", "\74\52\104", "\42", null, null, null, null, null, null, null, |
568 | |
"\134\42",}; |
569 | 3 | public static final String[] lexStateNames = { |
570 | |
"DEFAULT", |
571 | |
}; |
572 | 3 | static final long[] jjtoToken = { |
573 | |
0xf8ffe1L, |
574 | |
}; |
575 | 3 | static final long[] jjtoSkip = { |
576 | |
0x1eL, |
577 | |
}; |
578 | |
protected SimpleCharStream input_stream; |
579 | 40 | private final int[] jjrounds = new int[14]; |
580 | 40 | private final int[] jjstateSet = new int[28]; |
581 | |
protected char curChar; |
582 | |
|
583 | |
public PropertyListParserTokenManager(SimpleCharStream stream) |
584 | 40 | { |
585 | |
if (SimpleCharStream.staticFlag) |
586 | |
{ |
587 | |
throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer."); |
588 | |
} |
589 | 40 | input_stream = stream; |
590 | 40 | } |
591 | |
|
592 | |
public PropertyListParserTokenManager(SimpleCharStream stream, int lexState) |
593 | |
{ |
594 | 0 | this(stream); |
595 | 0 | SwitchTo(lexState); |
596 | 0 | } |
597 | |
|
598 | |
public void ReInit(SimpleCharStream stream) |
599 | |
{ |
600 | 0 | jjmatchedPos = jjnewStateCnt = 0; |
601 | 0 | curLexState = defaultLexState; |
602 | 0 | input_stream = stream; |
603 | 0 | ReInitRounds(); |
604 | 0 | } |
605 | |
|
606 | |
private final void ReInitRounds() |
607 | |
{ |
608 | |
int i; |
609 | 0 | jjround = 0x80000001; |
610 | 0 | for (i = 14; i-- > 0;) |
611 | |
{ |
612 | 0 | jjrounds[i] = 0x80000000; |
613 | |
} |
614 | 0 | } |
615 | |
|
616 | |
public void ReInit(SimpleCharStream stream, int lexState) |
617 | |
{ |
618 | 0 | ReInit(stream); |
619 | 0 | SwitchTo(lexState); |
620 | 0 | } |
621 | |
|
622 | |
public void SwitchTo(int lexState) |
623 | |
{ |
624 | 0 | if (lexState >= 1 || lexState < 0) |
625 | |
{ |
626 | 0 | throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE); |
627 | |
} |
628 | |
else |
629 | |
{ |
630 | 0 | curLexState = lexState; |
631 | |
} |
632 | 0 | } |
633 | |
|
634 | |
protected Token jjFillToken() |
635 | |
{ |
636 | 3643 | Token t = Token.newToken(jjmatchedKind); |
637 | 3643 | t.kind = jjmatchedKind; |
638 | 3643 | String im = jjstrLiteralImages[jjmatchedKind]; |
639 | 3643 | t.image = (im == null) ? input_stream.GetImage() : im; |
640 | 3643 | t.beginLine = input_stream.getBeginLine(); |
641 | 3643 | t.beginColumn = input_stream.getBeginColumn(); |
642 | 3643 | t.endLine = input_stream.getEndLine(); |
643 | 3643 | t.endColumn = input_stream.getEndColumn(); |
644 | 3643 | return t; |
645 | |
} |
646 | |
|
647 | 40 | int curLexState = 0; |
648 | 40 | int defaultLexState = 0; |
649 | |
int jjnewStateCnt; |
650 | |
int jjround; |
651 | |
int jjmatchedPos; |
652 | |
int jjmatchedKind; |
653 | |
|
654 | |
public Token getNextToken() |
655 | |
{ |
656 | |
int kind; |
657 | 3643 | Token specialToken = null; |
658 | |
Token matchedToken; |
659 | 3643 | int curPos = 0; |
660 | |
|
661 | |
EOFLoop : |
662 | |
for (; ;) |
663 | |
{ |
664 | |
try |
665 | |
{ |
666 | 3675 | curChar = input_stream.BeginToken(); |
667 | |
} |
668 | 36 | catch (java.io.IOException e) |
669 | |
{ |
670 | 36 | jjmatchedKind = 0; |
671 | 36 | matchedToken = jjFillToken(); |
672 | 36 | return matchedToken; |
673 | 3639 | } |
674 | |
|
675 | |
try |
676 | |
{ |
677 | 3639 | input_stream.backup(0); |
678 | 14443 | while (curChar <= 32 && (0x100002600L & (1L << curChar)) != 0L) |
679 | |
{ |
680 | 10836 | curChar = input_stream.BeginToken(); |
681 | |
} |
682 | |
} |
683 | 32 | catch (java.io.IOException e1) |
684 | |
{ |
685 | 32 | continue EOFLoop; |
686 | 3607 | } |
687 | 3607 | jjmatchedKind = 0x7fffffff; |
688 | 3607 | jjmatchedPos = 0; |
689 | 3607 | curPos = jjMoveStringLiteralDfa0_0(); |
690 | 3607 | if (jjmatchedKind != 0x7fffffff) |
691 | |
{ |
692 | 3607 | if (jjmatchedPos + 1 < curPos) |
693 | |
{ |
694 | 936 | input_stream.backup(curPos - jjmatchedPos - 1); |
695 | |
} |
696 | 3607 | if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) |
697 | |
{ |
698 | 3607 | matchedToken = jjFillToken(); |
699 | 3607 | return matchedToken; |
700 | |
} |
701 | |
else |
702 | |
{ |
703 | |
continue EOFLoop; |
704 | |
} |
705 | |
} |
706 | 0 | int error_line = input_stream.getEndLine(); |
707 | 0 | int error_column = input_stream.getEndColumn(); |
708 | 0 | String error_after = null; |
709 | 0 | boolean EOFSeen = false; |
710 | |
try |
711 | |
{ |
712 | 0 | input_stream.readChar(); |
713 | 0 | input_stream.backup(1); |
714 | |
} |
715 | 0 | catch (java.io.IOException e1) |
716 | |
{ |
717 | 0 | EOFSeen = true; |
718 | 0 | error_after = curPos <= 1 ? "" : input_stream.GetImage(); |
719 | 0 | if (curChar == '\n' || curChar == '\r') |
720 | |
{ |
721 | 0 | error_line++; |
722 | 0 | error_column = 0; |
723 | |
} |
724 | |
else |
725 | |
{ |
726 | 0 | error_column++; |
727 | |
} |
728 | 0 | } |
729 | 0 | if (!EOFSeen) |
730 | |
{ |
731 | 0 | input_stream.backup(1); |
732 | 0 | error_after = curPos <= 1 ? "" : input_stream.GetImage(); |
733 | |
} |
734 | 0 | throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR); |
735 | |
} |
736 | |
} |
737 | |
|
738 | |
} |