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