##### Coverage Report - org.apache.commons.configuration.plist.PropertyListParserTokenManager

Classes in this File | Line Coverage | Branch Coverage | Complexity
PropertyListParserTokenManager |
60% | 136/227
53% | 32/60
| 9.133333333333333;9,133

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