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