View Javadoc

1   /* Generated By:JavaCC: Do not edit this line. PropertyListParserTokenManager.java */
2   package org.apache.commons.configuration.plist;
3   
4   import java.io.IOException;
5   import java.io.PrintStream;
6   
7   class PropertyListParserTokenManager implements PropertyListParserConstants
8   {
9       public PrintStream debugStream = System.out;
10  
11      private final int jjStopStringLiteralDfa_0(int pos, long active0)
12      {
13          switch (pos)
14          {
15              case 0:
16                  if ((active0 & 0x4000L) != 0L)
17                      return 9;
18                  if ((active0 & 0x1000L) != 0L)
19                      return 10;
20                  if ((active0 & 0x2000L) != 0L)
21                      return 3;
22                  if ((active0 & 0x200000L) != 0L)
23                  {
24                      jjmatchedKind = 19;
25                      return 3;
26                  }
27                  return -1;
28              default :
29                  return -1;
30          }
31      }
32  
33      private final int jjStartNfa_0(int pos, long active0)
34      {
35          return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
36      }
37  
38      private final int jjStopAtPos(int pos, int kind)
39      {
40          jjmatchedKind = kind;
41          jjmatchedPos = pos;
42          return pos + 1;
43      }
44  
45      private final int jjStartNfaWithStates_0(int pos, int kind, int state)
46      {
47          jjmatchedKind = kind;
48          jjmatchedPos = pos;
49          try
50          {
51              curChar = input_stream.readChar();
52          }
53          catch (IOException e)
54          {
55              return pos + 1;
56          }
57          return jjMoveNfa_0(state, pos + 1);
58      }
59  
60      private final int jjMoveStringLiteralDfa0_0()
61      {
62          switch (curChar)
63          {
64              case 34:
65                  return jjStartNfaWithStates_0(0, 14, 9);
66              case 40:
67                  return jjStopAtPos(0, 5);
68              case 41:
69                  return jjStopAtPos(0, 6);
70              case 44:
71                  return jjStopAtPos(0, 7);
72              case 59:
73                  return jjStopAtPos(0, 10);
74              case 60:
75                  return jjStartNfaWithStates_0(0, 12, 10);
76              case 61:
77                  return jjStopAtPos(0, 11);
78              case 62:
79                  return jjStartNfaWithStates_0(0, 13, 3);
80              case 92:
81                  return jjMoveStringLiteralDfa1_0(0x200000L);
82              case 123:
83                  return jjStopAtPos(0, 8);
84              case 125:
85                  return jjStopAtPos(0, 9);
86              default :
87                  return jjMoveNfa_0(0, 0);
88          }
89      }
90  
91      private final int jjMoveStringLiteralDfa1_0(long active0)
92      {
93          try
94          {
95              curChar = input_stream.readChar();
96          }
97          catch (IOException e)
98          {
99              jjStopStringLiteralDfa_0(0, active0);
100             return 1;
101         }
102         switch (curChar)
103         {
104             case 34:
105                 if ((active0 & 0x200000L) != 0L)
106                     return jjStopAtPos(1, 21);
107                 break;
108             default :
109                 break;
110         }
111         return jjStartNfa_0(0, active0);
112     }
113 
114     private final void jjCheckNAdd(int state)
115     {
116         if (jjrounds[state] != jjround)
117         {
118             jjstateSet[jjnewStateCnt++] = state;
119             jjrounds[state] = jjround;
120         }
121     }
122 
123     private final void jjCheckNAddTwoStates(int state1, int state2)
124     {
125         jjCheckNAdd(state1);
126         jjCheckNAdd(state2);
127     }
128 
129     private final void jjCheckNAddStates(int start, int end)
130     {
131         do
132         {
133             jjCheckNAdd(jjnextStates[start]);
134         }
135         while (start++ != end);
136     }
137 
138     static final long[] jjbitVec0 = {
139         0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
140     };
141 
142     private final int jjMoveNfa_0(int startState, int curPos)
143     {
144         int startsAt = 0;
145         jjnewStateCnt = 9;
146         int i = 1;
147         jjstateSet[0] = startState;
148         int kind = 0x7fffffff;
149         for (; ;)
150         {
151             if (++jjround == 0x7fffffff)
152                 ReInitRounds();
153             if (curChar < 64)
154             {
155                 long l = 1L << curChar;
156                 MatchLoop: do
157                 {
158                     switch (jjstateSet[--i])
159                     {
160                         case 9:
161                             if ((0xfffffffbffffffffL & l) != 0L)
162                                 jjCheckNAddStates(0, 2);
163                             else if (curChar == 34)
164                             {
165                                 if (kind > 20)
166                                     kind = 20;
167                             }
168                             break;
169                         case 10:
170                             if ((0xd7ffecfaffffd9ffL & l) != 0L)
171                             {
172                                 if (kind > 19)
173                                     kind = 19;
174                                 jjCheckNAdd(3);
175                             }
176                             if ((0x3ff000100002600L & l) != 0L)
177                                 jjCheckNAddTwoStates(1, 2);
178                             else if (curChar == 62)
179                             {
180                                 if (kind > 18)
181                                     kind = 18;
182                             }
183                             break;
184                         case 0:
185                             if ((0xd7ffecfaffffd9ffL & l) != 0L)
186                             {
187                                 if (kind > 19)
188                                     kind = 19;
189                                 jjCheckNAdd(3);
190                             }
191                             else if (curChar == 34)
192                                 jjCheckNAddStates(0, 2);
193                             if (curChar == 60)
194                                 jjCheckNAddTwoStates(1, 2);
195                             break;
196                         case 1:
197                             if ((0x3ff000100002600L & l) != 0L)
198                                 jjCheckNAddTwoStates(1, 2);
199                             break;
200                         case 2:
201                             if (curChar == 62 && kind > 18)
202                                 kind = 18;
203                             break;
204                         case 3:
205                             if ((0xd7ffecfaffffd9ffL & l) == 0L)
206                                 break;
207                             if (kind > 19)
208                                 kind = 19;
209                             jjCheckNAdd(3);
210                             break;
211                         case 4:
212                         case 6:
213                             if (curChar == 34)
214                                 jjCheckNAddStates(0, 2);
215                             break;
216                         case 5:
217                             if ((0xfffffffbffffffffL & l) != 0L)
218                                 jjCheckNAddStates(0, 2);
219                             break;
220                         case 8:
221                             if (curChar == 34 && kind > 20)
222                                 kind = 20;
223                             break;
224                         default :
225                             break;
226                     }
227                 }
228                 while (i != startsAt);
229             }
230             else if (curChar < 128)
231             {
232                 long l = 1L << (curChar & 077);
233                 MatchLoop: do
234                 {
235                     switch (jjstateSet[--i])
236                     {
237                         case 9:
238                             jjCheckNAddStates(0, 2);
239                             if (curChar == 92)
240                                 jjstateSet[jjnewStateCnt++] = 6;
241                             break;
242                         case 10:
243                             if ((0xd7ffffffffffffffL & l) != 0L)
244                             {
245                                 if (kind > 19)
246                                     kind = 19;
247                                 jjCheckNAdd(3);
248                             }
249                             if ((0x7e0000007eL & l) != 0L)
250                                 jjCheckNAddTwoStates(1, 2);
251                             break;
252                         case 0:
253                         case 3:
254                             if ((0xd7ffffffffffffffL & l) == 0L)
255                                 break;
256                             if (kind > 19)
257                                 kind = 19;
258                             jjCheckNAdd(3);
259                             break;
260                         case 1:
261                             if ((0x7e0000007eL & l) != 0L)
262                                 jjCheckNAddTwoStates(1, 2);
263                             break;
264                         case 5:
265                             jjCheckNAddStates(0, 2);
266                             break;
267                         case 7:
268                             if (curChar == 92)
269                                 jjstateSet[jjnewStateCnt++] = 6;
270                             break;
271                         default :
272                             break;
273                     }
274                 }
275                 while (i != startsAt);
276             }
277             else
278             {
279                 int i2 = (curChar & 0xff) >> 6;
280                 long l2 = 1L << (curChar & 077);
281                 MatchLoop: do
282                 {
283                     switch (jjstateSet[--i])
284                     {
285                         case 9:
286                         case 5:
287                             if ((jjbitVec0[i2] & l2) != 0L)
288                                 jjCheckNAddStates(0, 2);
289                             break;
290                         case 10:
291                         case 3:
292                             if ((jjbitVec0[i2] & l2) == 0L)
293                                 break;
294                             if (kind > 19)
295                                 kind = 19;
296                             jjCheckNAdd(3);
297                             break;
298                         case 0:
299                             if ((jjbitVec0[i2] & l2) == 0L)
300                                 break;
301                             if (kind > 19)
302                                 kind = 19;
303                             jjCheckNAdd(3);
304                             break;
305                         default :
306                             break;
307                     }
308                 }
309                 while (i != startsAt);
310             }
311             if (kind != 0x7fffffff)
312             {
313                 jjmatchedKind = kind;
314                 jjmatchedPos = curPos;
315                 kind = 0x7fffffff;
316             }
317             ++curPos;
318             if ((i = jjnewStateCnt) == (startsAt = 9 - (jjnewStateCnt = startsAt)))
319                 return curPos;
320             try
321             {
322                 curChar = input_stream.readChar();
323             }
324             catch (IOException e)
325             {
326                 return curPos;
327             }
328         }
329     }
330 
331     static final int[] jjnextStates = {
332         5, 7, 8,
333     };
334     public static final String[] jjstrLiteralImages = {
335         "", null, null, null, null, "\50", "\51", "\54", "\173", "\175", "\73", "\75",
336         "\74", "\76", "\42", null, null, null, null, null, null, "\134\42", };
337     public static final String[] lexStateNames = {
338         "DEFAULT",
339     };
340     static final long[] jjtoToken = {
341         0x3c7fe1L,
342     };
343     static final long[] jjtoSkip = {
344         0x1eL,
345     };
346     protected SimpleCharStream input_stream;
347     private final int[] jjrounds = new int[9];
348     private final int[] jjstateSet = new int[18];
349     protected char curChar;
350 
351     public PropertyListParserTokenManager(SimpleCharStream stream)
352     {
353         if (SimpleCharStream.staticFlag)
354             throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
355         input_stream = stream;
356     }
357 
358     public void ReInit(SimpleCharStream stream)
359     {
360         jjmatchedPos = jjnewStateCnt = 0;
361         curLexState = defaultLexState;
362         input_stream = stream;
363         ReInitRounds();
364     }
365 
366     private final void ReInitRounds()
367     {
368         int i;
369         jjround = 0x80000001;
370         for (i = 9; i-- > 0;)
371             jjrounds[i] = 0x80000000;
372     }
373 
374     protected Token jjFillToken()
375     {
376         Token t = Token.newToken(jjmatchedKind);
377         t.kind = jjmatchedKind;
378         String im = jjstrLiteralImages[jjmatchedKind];
379         t.image = (im == null) ? input_stream.GetImage() : im;
380         t.beginLine = input_stream.getBeginLine();
381         t.beginColumn = input_stream.getBeginColumn();
382         t.endLine = input_stream.getEndLine();
383         t.endColumn = input_stream.getEndColumn();
384         return t;
385     }
386 
387     int curLexState = 0;
388     int defaultLexState = 0;
389     int jjnewStateCnt;
390     int jjround;
391     int jjmatchedPos;
392     int jjmatchedKind;
393 
394     public Token getNextToken()
395     {
396         Token matchedToken;
397         int curPos = 0;
398 
399         EOFLoop :
400         for (; ;)
401         {
402             try
403             {
404                 curChar = input_stream.BeginToken();
405             }
406             catch (IOException e)
407             {
408                 jjmatchedKind = 0;
409                 matchedToken = jjFillToken();
410                 return matchedToken;
411             }
412 
413             try
414             {
415                 input_stream.backup(0);
416                 while (curChar <= 32 && (0x100002600L & (1L << curChar)) != 0L)
417                     curChar = input_stream.BeginToken();
418             }
419             catch (IOException e1)
420             {
421                 continue EOFLoop;
422             }
423             jjmatchedKind = 0x7fffffff;
424             jjmatchedPos = 0;
425             curPos = jjMoveStringLiteralDfa0_0();
426             if (jjmatchedKind != 0x7fffffff)
427             {
428                 if (jjmatchedPos + 1 < curPos)
429                     input_stream.backup(curPos - jjmatchedPos - 1);
430                 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
431                 {
432                     matchedToken = jjFillToken();
433                     return matchedToken;
434                 }
435                 else
436                 {
437                     continue EOFLoop;
438                 }
439             }
440             int error_line = input_stream.getEndLine();
441             int error_column = input_stream.getEndColumn();
442             String error_after = null;
443             boolean EOFSeen = false;
444             try
445             {
446                 input_stream.readChar();
447                 input_stream.backup(1);
448             }
449             catch (IOException e1)
450             {
451                 EOFSeen = true;
452                 error_after = curPos <= 1 ? "" : input_stream.GetImage();
453                 if (curChar == '\n' || curChar == '\r')
454                 {
455                     error_line++;
456                     error_column = 0;
457                 }
458                 else
459                     error_column++;
460             }
461             if (!EOFSeen)
462             {
463                 input_stream.backup(1);
464                 error_after = curPos <= 1 ? "" : input_stream.GetImage();
465             }
466             throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
467         }
468     }
469 
470 }