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