001    /* Generated By:JavaCC: Do not edit this line. PropertyListParserTokenManager.java */
002    package org.apache.commons.configuration.plist;
003    import java.util.Date;
004    import java.util.List;
005    import java.util.ArrayList;
006    import org.apache.commons.configuration.HierarchicalConfiguration;
007    import org.apache.commons.configuration.HierarchicalConfiguration.Node;
008    import org.apache.commons.codec.binary.Hex;
009    
010    /** Token Manager. */
011    public class PropertyListParserTokenManager implements PropertyListParserConstants
012    {
013    
014      /** Debug output. */
015      public  java.io.PrintStream debugStream = System.out;
016      /** Set debug output. */
017      public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
018    private final int jjStopStringLiteralDfa_0(int pos, long active0)
019    {
020       switch (pos)
021       {
022          case 0:
023             if ((active0 & 0x2000L) != 0L)
024                return 8;
025             if ((active0 & 0x8000L) != 0L)
026                return 14;
027             if ((active0 & 0x800000L) != 0L)
028             {
029                jjmatchedKind = 21;
030                return 8;
031             }
032             if ((active0 & 0x5000L) != 0L)
033                return 6;
034             return -1;
035          case 1:
036             if ((active0 & 0x4000L) != 0L)
037             {
038                jjmatchedKind = 21;
039                jjmatchedPos = 1;
040                return 3;
041             }
042             return -1;
043          default :
044             return -1;
045       }
046    }
047    private final int jjStartNfa_0(int pos, long active0)
048    {
049       return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
050    }
051    private int jjStopAtPos(int pos, int kind)
052    {
053       jjmatchedKind = kind;
054       jjmatchedPos = pos;
055       return pos + 1;
056    }
057    private int jjMoveStringLiteralDfa0_0()
058    {
059       switch(curChar)
060       {
061          case 34:
062             return jjStartNfaWithStates_0(0, 15, 14);
063          case 40:
064             return jjStopAtPos(0, 5);
065          case 41:
066             return jjStopAtPos(0, 6);
067          case 44:
068             return jjStopAtPos(0, 7);
069          case 59:
070             return jjStopAtPos(0, 10);
071          case 60:
072             jjmatchedKind = 12;
073             return jjMoveStringLiteralDfa1_0(0x4000L);
074          case 61:
075             return jjStopAtPos(0, 11);
076          case 62:
077             return jjStartNfaWithStates_0(0, 13, 8);
078          case 92:
079             return jjMoveStringLiteralDfa1_0(0x800000L);
080          case 123:
081             return jjStopAtPos(0, 8);
082          case 125:
083             return jjStopAtPos(0, 9);
084          default :
085             return jjMoveNfa_0(0, 0);
086       }
087    }
088    private int jjMoveStringLiteralDfa1_0(long active0)
089    {
090       try { curChar = input_stream.readChar(); }
091       catch(java.io.IOException e) {
092          jjStopStringLiteralDfa_0(0, active0);
093          return 1;
094       }
095       switch(curChar)
096       {
097          case 34:
098             if ((active0 & 0x800000L) != 0L)
099                return jjStopAtPos(1, 23);
100             break;
101          case 42:
102             return jjMoveStringLiteralDfa2_0(active0, 0x4000L);
103          default :
104             break;
105       }
106       return jjStartNfa_0(0, active0);
107    }
108    private int jjMoveStringLiteralDfa2_0(long old0, long active0)
109    {
110       if (((active0 &= old0)) == 0L)
111          return jjStartNfa_0(0, old0);
112       try { curChar = input_stream.readChar(); }
113       catch(java.io.IOException e) {
114          jjStopStringLiteralDfa_0(1, active0);
115          return 2;
116       }
117       switch(curChar)
118       {
119          case 68:
120             if ((active0 & 0x4000L) != 0L)
121                return jjStartNfaWithStates_0(2, 14, 15);
122             break;
123          default :
124             break;
125       }
126       return jjStartNfa_0(1, active0);
127    }
128    private int jjStartNfaWithStates_0(int pos, int kind, int state)
129    {
130       jjmatchedKind = kind;
131       jjmatchedPos = pos;
132       try { curChar = input_stream.readChar(); }
133       catch(java.io.IOException e) { return pos + 1; }
134       return jjMoveNfa_0(state, pos + 1);
135    }
136    static final long[] jjbitVec0 = {
137       0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
138    };
139    private int jjMoveNfa_0(int startState, int curPos)
140    {
141       int startsAt = 0;
142       jjnewStateCnt = 14;
143       int i = 1;
144       jjstateSet[0] = startState;
145       int kind = 0x7fffffff;
146       for (;;)
147       {
148          if (++jjround == 0x7fffffff)
149             ReInitRounds();
150          if (curChar < 64)
151          {
152             long l = 1L << curChar;
153             do
154             {
155                switch(jjstateSet[--i])
156                {
157                   case 15:
158                      if ((0xd7ffecfaffffd9ffL & l) != 0L)
159                      {
160                         if (kind > 21)
161                            kind = 21;
162                         jjCheckNAdd(8);
163                      }
164                      if ((0x7ff280100000000L & l) != 0L)
165                         jjCheckNAddTwoStates(4, 5);
166                      else if (curChar == 62)
167                      {
168                         if (kind > 20)
169                            kind = 20;
170                      }
171                      break;
172                   case 6:
173                      if ((0xd7ffecfaffffd9ffL & l) != 0L)
174                      {
175                         if (kind > 21)
176                            kind = 21;
177                         jjCheckNAdd(8);
178                      }
179                      if ((0x3ff000100002600L & l) != 0L)
180                         jjCheckNAddTwoStates(1, 2);
181                      else if (curChar == 42)
182                         jjstateSet[jjnewStateCnt++] = 3;
183                      else if (curChar == 62)
184                      {
185                         if (kind > 19)
186                            kind = 19;
187                      }
188                      break;
189                   case 14:
190                      if ((0xfffffffbffffffffL & l) != 0L)
191                         jjCheckNAddStates(0, 2);
192                      else if (curChar == 34)
193                      {
194                         if (kind > 22)
195                            kind = 22;
196                      }
197                      break;
198                   case 3:
199                   case 8:
200                      if ((0xd7ffecfaffffd9ffL & l) == 0L)
201                         break;
202                      if (kind > 21)
203                         kind = 21;
204                      jjCheckNAdd(8);
205                      break;
206                   case 0:
207                      if ((0xd7ffecfaffffd9ffL & l) != 0L)
208                      {
209                         if (kind > 21)
210                            kind = 21;
211                         jjCheckNAdd(8);
212                      }
213                      else if (curChar == 34)
214                         jjCheckNAddStates(0, 2);
215                      if (curChar == 60)
216                         jjstateSet[jjnewStateCnt++] = 6;
217                      if (curChar == 60)
218                         jjCheckNAddTwoStates(1, 2);
219                      break;
220                   case 1:
221                      if ((0x3ff000100002600L & l) != 0L)
222                         jjCheckNAddTwoStates(1, 2);
223                      break;
224                   case 2:
225                      if (curChar == 62 && kind > 19)
226                         kind = 19;
227                      break;
228                   case 4:
229                      if ((0x7ff280100000000L & l) != 0L)
230                         jjCheckNAddTwoStates(4, 5);
231                      break;
232                   case 5:
233                      if (curChar == 62 && kind > 20)
234                         kind = 20;
235                      break;
236                   case 7:
237                      if (curChar == 60)
238                         jjstateSet[jjnewStateCnt++] = 6;
239                      break;
240                   case 9:
241                   case 11:
242                      if (curChar == 34)
243                         jjCheckNAddStates(0, 2);
244                      break;
245                   case 10:
246                      if ((0xfffffffbffffffffL & l) != 0L)
247                         jjCheckNAddStates(0, 2);
248                      break;
249                   case 13:
250                      if (curChar == 34 && kind > 22)
251                         kind = 22;
252                      break;
253                   default : break;
254                }
255             } while(i != startsAt);
256          }
257          else if (curChar < 128)
258          {
259             long l = 1L << (curChar & 077);
260             do
261             {
262                switch(jjstateSet[--i])
263                {
264                   case 15:
265                      if ((0xd7ffffffffffffffL & l) != 0L)
266                      {
267                         if (kind > 21)
268                            kind = 21;
269                         jjCheckNAdd(8);
270                      }
271                      if (curChar == 90)
272                         jjCheckNAddTwoStates(4, 5);
273                      break;
274                   case 6:
275                      if ((0xd7ffffffffffffffL & l) != 0L)
276                      {
277                         if (kind > 21)
278                            kind = 21;
279                         jjCheckNAdd(8);
280                      }
281                      if ((0x7e0000007eL & l) != 0L)
282                         jjCheckNAddTwoStates(1, 2);
283                      break;
284                   case 14:
285                      jjCheckNAddStates(0, 2);
286                      if (curChar == 92)
287                         jjstateSet[jjnewStateCnt++] = 11;
288                      break;
289                   case 3:
290                      if ((0xd7ffffffffffffffL & l) != 0L)
291                      {
292                         if (kind > 21)
293                            kind = 21;
294                         jjCheckNAdd(8);
295                      }
296                      if (curChar == 68)
297                         jjCheckNAddTwoStates(4, 5);
298                      break;
299                   case 0:
300                   case 8:
301                      if ((0xd7ffffffffffffffL & l) == 0L)
302                         break;
303                      if (kind > 21)
304                         kind = 21;
305                      jjCheckNAdd(8);
306                      break;
307                   case 1:
308                      if ((0x7e0000007eL & l) != 0L)
309                         jjCheckNAddTwoStates(1, 2);
310                      break;
311                   case 4:
312                      if (curChar == 90)
313                         jjCheckNAddTwoStates(4, 5);
314                      break;
315                   case 10:
316                      jjCheckNAddStates(0, 2);
317                      break;
318                   case 12:
319                      if (curChar == 92)
320                         jjstateSet[jjnewStateCnt++] = 11;
321                      break;
322                   default : break;
323                }
324             } while(i != startsAt);
325          }
326          else
327          {
328             int i2 = (curChar & 0xff) >> 6;
329             long l2 = 1L << (curChar & 077);
330             do
331             {
332                switch(jjstateSet[--i])
333                {
334                   case 15:
335                   case 8:
336                      if ((jjbitVec0[i2] & l2) == 0L)
337                         break;
338                      if (kind > 21)
339                         kind = 21;
340                      jjCheckNAdd(8);
341                      break;
342                   case 6:
343                      if ((jjbitVec0[i2] & l2) == 0L)
344                         break;
345                      if (kind > 21)
346                         kind = 21;
347                      jjCheckNAdd(8);
348                      break;
349                   case 14:
350                   case 10:
351                      if ((jjbitVec0[i2] & l2) != 0L)
352                         jjCheckNAddStates(0, 2);
353                      break;
354                   case 3:
355                      if ((jjbitVec0[i2] & l2) == 0L)
356                         break;
357                      if (kind > 21)
358                         kind = 21;
359                      jjCheckNAdd(8);
360                      break;
361                   case 0:
362                      if ((jjbitVec0[i2] & l2) == 0L)
363                         break;
364                      if (kind > 21)
365                         kind = 21;
366                      jjCheckNAdd(8);
367                      break;
368                   default : break;
369                }
370             } while(i != startsAt);
371          }
372          if (kind != 0x7fffffff)
373          {
374             jjmatchedKind = kind;
375             jjmatchedPos = curPos;
376             kind = 0x7fffffff;
377          }
378          ++curPos;
379          if ((i = jjnewStateCnt) == (startsAt = 14 - (jjnewStateCnt = startsAt)))
380             return curPos;
381          try { curChar = input_stream.readChar(); }
382          catch(java.io.IOException e) { return curPos; }
383       }
384    }
385    static final int[] jjnextStates = {
386       10, 12, 13, 
387    };
388    
389    /** Token literal values. */
390    public static final String[] jjstrLiteralImages = {
391    "", null, null, null, null, "\50", "\51", "\54", "\173", "\175", "\73", "\75", 
392    "\74", "\76", "\74\52\104", "\42", null, null, null, null, null, null, null, 
393    "\134\42", };
394    
395    /** Lexer state names. */
396    public static final String[] lexStateNames = {
397       "DEFAULT",
398    };
399    static final long[] jjtoToken = {
400       0xf8ffe1L, 
401    };
402    static final long[] jjtoSkip = {
403       0x1eL, 
404    };
405    protected SimpleCharStream input_stream;
406    private final int[] jjrounds = new int[14];
407    private final int[] jjstateSet = new int[28];
408    protected char curChar;
409    /** Constructor. */
410    public PropertyListParserTokenManager(SimpleCharStream stream){
411       if (SimpleCharStream.staticFlag)
412          throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
413       input_stream = stream;
414    }
415    
416    /** Constructor. */
417    public PropertyListParserTokenManager(SimpleCharStream stream, int lexState){
418       this(stream);
419       SwitchTo(lexState);
420    }
421    
422    /** Reinitialise parser. */
423    public void ReInit(SimpleCharStream stream)
424    {
425       jjmatchedPos = jjnewStateCnt = 0;
426       curLexState = defaultLexState;
427       input_stream = stream;
428       ReInitRounds();
429    }
430    private void ReInitRounds()
431    {
432       int i;
433       jjround = 0x80000001;
434       for (i = 14; i-- > 0;)
435          jjrounds[i] = 0x80000000;
436    }
437    
438    /** Reinitialise parser. */
439    public void ReInit(SimpleCharStream stream, int lexState)
440    {
441       ReInit(stream);
442       SwitchTo(lexState);
443    }
444    
445    /** Switch to specified lex state. */
446    public void SwitchTo(int lexState)
447    {
448       if (lexState >= 1 || lexState < 0)
449          throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
450       else
451          curLexState = lexState;
452    }
453    
454    protected Token jjFillToken()
455    {
456       final Token t;
457       final String curTokenImage;
458       final int beginLine;
459       final int endLine;
460       final int beginColumn;
461       final int endColumn;
462       String im = jjstrLiteralImages[jjmatchedKind];
463       curTokenImage = (im == null) ? input_stream.GetImage() : im;
464       beginLine = input_stream.getBeginLine();
465       beginColumn = input_stream.getBeginColumn();
466       endLine = input_stream.getEndLine();
467       endColumn = input_stream.getEndColumn();
468       t = Token.newToken(jjmatchedKind, curTokenImage);
469    
470       t.beginLine = beginLine;
471       t.endLine = endLine;
472       t.beginColumn = beginColumn;
473       t.endColumn = endColumn;
474    
475       return t;
476    }
477    
478    int curLexState = 0;
479    int defaultLexState = 0;
480    int jjnewStateCnt;
481    int jjround;
482    int jjmatchedPos;
483    int jjmatchedKind;
484    
485    /** Get the next Token. */
486    public Token getNextToken() 
487    {
488      Token matchedToken;
489      int curPos = 0;
490    
491      EOFLoop :
492      for (;;)
493      {
494       try
495       {
496          curChar = input_stream.BeginToken();
497       }
498       catch(java.io.IOException e)
499       {
500          jjmatchedKind = 0;
501          matchedToken = jjFillToken();
502          return matchedToken;
503       }
504    
505       try { input_stream.backup(0);
506          while (curChar <= 32 && (0x100002600L & (1L << curChar)) != 0L)
507             curChar = input_stream.BeginToken();
508       }
509       catch (java.io.IOException e1) { continue EOFLoop; }
510       jjmatchedKind = 0x7fffffff;
511       jjmatchedPos = 0;
512       curPos = jjMoveStringLiteralDfa0_0();
513       if (jjmatchedKind != 0x7fffffff)
514       {
515          if (jjmatchedPos + 1 < curPos)
516             input_stream.backup(curPos - jjmatchedPos - 1);
517          if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
518          {
519             matchedToken = jjFillToken();
520             return matchedToken;
521          }
522          else
523          {
524             continue EOFLoop;
525          }
526       }
527       int error_line = input_stream.getEndLine();
528       int error_column = input_stream.getEndColumn();
529       String error_after = null;
530       boolean EOFSeen = false;
531       try { input_stream.readChar(); input_stream.backup(1); }
532       catch (java.io.IOException e1) {
533          EOFSeen = true;
534          error_after = curPos <= 1 ? "" : input_stream.GetImage();
535          if (curChar == '\n' || curChar == '\r') {
536             error_line++;
537             error_column = 0;
538          }
539          else
540             error_column++;
541       }
542       if (!EOFSeen) {
543          input_stream.backup(1);
544          error_after = curPos <= 1 ? "" : input_stream.GetImage();
545       }
546       throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
547      }
548    }
549    
550    private void jjCheckNAdd(int state)
551    {
552       if (jjrounds[state] != jjround)
553       {
554          jjstateSet[jjnewStateCnt++] = state;
555          jjrounds[state] = jjround;
556       }
557    }
558    private void jjAddStates(int start, int end)
559    {
560       do {
561          jjstateSet[jjnewStateCnt++] = jjnextStates[start];
562       } while (start++ != end);
563    }
564    private void jjCheckNAddTwoStates(int state1, int state2)
565    {
566       jjCheckNAdd(state1);
567       jjCheckNAdd(state2);
568    }
569    
570    private void jjCheckNAddStates(int start, int end)
571    {
572       do {
573          jjCheckNAdd(jjnextStates[start]);
574       } while (start++ != end);
575    }
576    
577    }