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

Classes in this File | Line Coverage | Branch Coverage | Complexity
PropertyListParserTokenManager |
53% | 181/342
54% | 47/87
| 8.681818181818182;8,682

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