1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21 package com.allanbank.mongodb.bson.json;
22 import java.io.Reader;
23 import java.io.StringReader;
24 import java.text.SimpleDateFormat;
25 import java.util.Arrays;
26 import java.util.Date;
27 import java.util.List;
28 import java.util.TimeZone;
29 import java.util.concurrent.TimeUnit;
30 import com.allanbank.mongodb.bson.Document;
31 import com.allanbank.mongodb.bson.Element;
32 import com.allanbank.mongodb.bson.builder.ArrayBuilder;
33 import com.allanbank.mongodb.bson.builder.BuilderFactory;
34 import com.allanbank.mongodb.bson.builder.DocumentBuilder;
35 import com.allanbank.mongodb.bson.element.ObjectId;
36 import com.allanbank.mongodb.error.JsonParseException;
37 import com.allanbank.mongodb.bson.io.EndianUtils;
38 import com.allanbank.mongodb.util.IOUtils;
39
40
41 class JsonParserTokenManager implements JsonParserConstants
42 {
43
44
45 public java.io.PrintStream debugStream = System.out;
46
47 public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
48 private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1)
49 {
50 switch (pos)
51 {
52 case 0:
53 if ((active0 & 0x808000000200L) != 0L)
54 {
55 jjmatchedKind = 38;
56 return 277;
57 }
58 if ((active0 & 0x7f0000000500L) != 0L)
59 {
60 jjmatchedKind = 57;
61 return 277;
62 }
63 if ((active0 & 0x80000L) != 0L)
64 return 56;
65 return -1;
66 case 1:
67 if ((active0 & 0x40000000400L) != 0L)
68 {
69 jjmatchedKind = 57;
70 jjmatchedPos = 1;
71 return 31;
72 }
73 if ((active0 & 0xfb8000000300L) != 0L)
74 {
75 jjmatchedKind = 57;
76 jjmatchedPos = 1;
77 return 277;
78 }
79 return -1;
80 case 2:
81 if ((active0 & 0x100L) != 0L)
82 {
83 jjmatchedKind = 57;
84 jjmatchedPos = 2;
85 return 31;
86 }
87 if ((active0 & 0xff8000000600L) != 0L)
88 {
89 jjmatchedKind = 57;
90 jjmatchedPos = 2;
91 return 277;
92 }
93 return -1;
94 case 3:
95 if ((active0 & 0xff8000000200L) != 0L)
96 {
97 jjmatchedKind = 57;
98 jjmatchedPos = 3;
99 return 277;
100 }
101 if ((active0 & 0x400L) != 0L)
102 return 277;
103 if ((active0 & 0x100L) != 0L)
104 return 32;
105 return -1;
106 case 4:
107 if ((active0 & 0x200L) != 0L)
108 return 277;
109 if ((active0 & 0xff8000000000L) != 0L)
110 {
111 jjmatchedKind = 57;
112 jjmatchedPos = 4;
113 return 277;
114 }
115 return -1;
116 case 5:
117 if ((active0 & 0x600000000000L) != 0L)
118 return 277;
119 if ((active0 & 0x9f8000000000L) != 0L)
120 {
121 jjmatchedKind = 57;
122 jjmatchedPos = 5;
123 return 277;
124 }
125 return -1;
126 case 6:
127 if ((active0 & 0x9c0000000000L) != 0L)
128 {
129 jjmatchedKind = 57;
130 jjmatchedPos = 6;
131 return 277;
132 }
133 if ((active0 & 0x38000000000L) != 0L)
134 return 277;
135 return -1;
136 case 7:
137 if ((active0 & 0x80000000000L) != 0L)
138 return 277;
139 if ((active0 & 0x940000000000L) != 0L)
140 {
141 jjmatchedKind = 57;
142 jjmatchedPos = 7;
143 return 277;
144 }
145 return -1;
146 case 8:
147 if ((active0 & 0x900000000000L) != 0L)
148 return 277;
149 if ((active0 & 0x40000000000L) != 0L)
150 {
151 jjmatchedKind = 57;
152 jjmatchedPos = 8;
153 return 277;
154 }
155 return -1;
156 default :
157 return -1;
158 }
159 }
160 private final int jjStartNfa_0(int pos, long active0, long active1)
161 {
162 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1);
163 }
164 private int jjStopAtPos(int pos, int kind)
165 {
166 jjmatchedKind = kind;
167 jjmatchedPos = pos;
168 return pos + 1;
169 }
170 private int jjMoveStringLiteralDfa0_0()
171 {
172 switch(curChar)
173 {
174 case 40:
175 return jjStopAtPos(0, 69);
176 case 41:
177 return jjStopAtPos(0, 70);
178 case 43:
179 return jjStopAtPos(0, 18);
180 case 44:
181 return jjStopAtPos(0, 15);
182 case 45:
183 return jjStartNfaWithStates_0(0, 19, 56);
184 case 46:
185 return jjStopAtPos(0, 17);
186 case 58:
187 return jjStopAtPos(0, 16);
188 case 66:
189 return jjMoveStringLiteralDfa1_0(0x8000000000L);
190 case 68:
191 return jjMoveStringLiteralDfa1_0(0x800000000000L);
192 case 72:
193 return jjMoveStringLiteralDfa1_0(0x10000000000L);
194 case 73:
195 return jjMoveStringLiteralDfa1_0(0x20000000000L);
196 case 77:
197 return jjMoveStringLiteralDfa1_0(0x600000000000L);
198 case 78:
199 return jjMoveStringLiteralDfa1_0(0x40000000000L);
200 case 79:
201 return jjMoveStringLiteralDfa1_0(0x80000000000L);
202 case 84:
203 return jjMoveStringLiteralDfa1_0(0x100000000000L);
204 case 91:
205 return jjStopAtPos(0, 13);
206 case 93:
207 return jjStopAtPos(0, 14);
208 case 102:
209 return jjMoveStringLiteralDfa1_0(0x200L);
210 case 110:
211 return jjMoveStringLiteralDfa1_0(0x400L);
212 case 116:
213 return jjMoveStringLiteralDfa1_0(0x100L);
214 case 123:
215 return jjStopAtPos(0, 11);
216 case 125:
217 return jjStopAtPos(0, 12);
218 default :
219 return jjMoveNfa_0(0, 0);
220 }
221 }
222 private int jjMoveStringLiteralDfa1_0(long active0)
223 {
224 try { curChar = input_stream.readChar(); }
225 catch(java.io.IOException e) {
226 jjStopStringLiteralDfa_0(0, active0, 0L);
227 return 1;
228 }
229 switch(curChar)
230 {
231 case 66:
232 return jjMoveStringLiteralDfa2_0(active0, 0x800000000000L);
233 case 83:
234 return jjMoveStringLiteralDfa2_0(active0, 0x20000000000L);
235 case 97:
236 return jjMoveStringLiteralDfa2_0(active0, 0x200000000200L);
237 case 98:
238 return jjMoveStringLiteralDfa2_0(active0, 0x80000000000L);
239 case 101:
240 return jjMoveStringLiteralDfa2_0(active0, 0x10000000000L);
241 case 105:
242 return jjMoveStringLiteralDfa2_0(active0, 0x508000000000L);
243 case 114:
244 return jjMoveStringLiteralDfa2_0(active0, 0x100L);
245 case 117:
246 return jjMoveStringLiteralDfa2_0(active0, 0x40000000400L);
247 default :
248 break;
249 }
250 return jjStartNfa_0(0, active0, 0L);
251 }
252 private int jjMoveStringLiteralDfa2_0(long old0, long active0)
253 {
254 if (((active0 &= old0)) == 0L)
255 return jjStartNfa_0(0, old0, 0L);
256 try { curChar = input_stream.readChar(); }
257 catch(java.io.IOException e) {
258 jjStopStringLiteralDfa_0(1, active0, 0L);
259 return 2;
260 }
261 switch(curChar)
262 {
263 case 79:
264 return jjMoveStringLiteralDfa3_0(active0, 0x20000000000L);
265 case 80:
266 return jjMoveStringLiteralDfa3_0(active0, 0x800000000000L);
267 case 106:
268 return jjMoveStringLiteralDfa3_0(active0, 0x80000000000L);
269 case 108:
270 return jjMoveStringLiteralDfa3_0(active0, 0x600L);
271 case 109:
272 return jjMoveStringLiteralDfa3_0(active0, 0x140000000000L);
273 case 110:
274 return jjMoveStringLiteralDfa3_0(active0, 0x408000000000L);
275 case 117:
276 return jjMoveStringLiteralDfa3_0(active0, 0x100L);
277 case 120:
278 return jjMoveStringLiteralDfa3_0(active0, 0x210000000000L);
279 default :
280 break;
281 }
282 return jjStartNfa_0(1, active0, 0L);
283 }
284 private int jjMoveStringLiteralDfa3_0(long old0, long active0)
285 {
286 if (((active0 &= old0)) == 0L)
287 return jjStartNfa_0(1, old0, 0L);
288 try { curChar = input_stream.readChar(); }
289 catch(java.io.IOException e) {
290 jjStopStringLiteralDfa_0(2, active0, 0L);
291 return 3;
292 }
293 switch(curChar)
294 {
295 case 68:
296 return jjMoveStringLiteralDfa4_0(active0, 0x38000000000L);
297 case 75:
298 return jjMoveStringLiteralDfa4_0(active0, 0x600000000000L);
299 case 98:
300 return jjMoveStringLiteralDfa4_0(active0, 0x40000000000L);
301 case 101:
302 if ((active0 & 0x100L) != 0L)
303 return jjStartNfaWithStates_0(3, 8, 32);
304 return jjMoveStringLiteralDfa4_0(active0, 0x180000000000L);
305 case 108:
306 if ((active0 & 0x400L) != 0L)
307 return jjStartNfaWithStates_0(3, 10, 277);
308 break;
309 case 111:
310 return jjMoveStringLiteralDfa4_0(active0, 0x800000000000L);
311 case 115:
312 return jjMoveStringLiteralDfa4_0(active0, 0x200L);
313 default :
314 break;
315 }
316 return jjStartNfa_0(2, active0, 0L);
317 }
318 private int jjMoveStringLiteralDfa4_0(long old0, long active0)
319 {
320 if (((active0 &= old0)) == 0L)
321 return jjStartNfa_0(2, old0, 0L);
322 try { curChar = input_stream.readChar(); }
323 catch(java.io.IOException e) {
324 jjStopStringLiteralDfa_0(3, active0, 0L);
325 return 4;
326 }
327 switch(curChar)
328 {
329 case 97:
330 return jjMoveStringLiteralDfa5_0(active0, 0x38000000000L);
331 case 99:
332 return jjMoveStringLiteralDfa5_0(active0, 0x80000000000L);
333 case 101:
334 if ((active0 & 0x200L) != 0L)
335 return jjStartNfaWithStates_0(4, 9, 277);
336 return jjMoveStringLiteralDfa5_0(active0, 0x640000000000L);
337 case 105:
338 return jjMoveStringLiteralDfa5_0(active0, 0x800000000000L);
339 case 115:
340 return jjMoveStringLiteralDfa5_0(active0, 0x100000000000L);
341 default :
342 break;
343 }
344 return jjStartNfa_0(3, active0, 0L);
345 }
346 private int jjMoveStringLiteralDfa5_0(long old0, long active0)
347 {
348 if (((active0 &= old0)) == 0L)
349 return jjStartNfa_0(3, old0, 0L);
350 try { curChar = input_stream.readChar(); }
351 catch(java.io.IOException e) {
352 jjStopStringLiteralDfa_0(4, active0, 0L);
353 return 5;
354 }
355 switch(curChar)
356 {
357 case 110:
358 return jjMoveStringLiteralDfa6_0(active0, 0x800000000000L);
359 case 114:
360 return jjMoveStringLiteralDfa6_0(active0, 0x40000000000L);
361 case 116:
362 return jjMoveStringLiteralDfa6_0(active0, 0x1b8000000000L);
363 case 121:
364 if ((active0 & 0x200000000000L) != 0L)
365 return jjStartNfaWithStates_0(5, 45, 277);
366 else if ((active0 & 0x400000000000L) != 0L)
367 return jjStartNfaWithStates_0(5, 46, 277);
368 break;
369 default :
370 break;
371 }
372 return jjStartNfa_0(4, active0, 0L);
373 }
374 private int jjMoveStringLiteralDfa6_0(long old0, long active0)
375 {
376 if (((active0 &= old0)) == 0L)
377 return jjStartNfa_0(4, old0, 0L);
378 try { curChar = input_stream.readChar(); }
379 catch(java.io.IOException e) {
380 jjStopStringLiteralDfa_0(5, active0, 0L);
381 return 6;
382 }
383 switch(curChar)
384 {
385 case 73:
386 return jjMoveStringLiteralDfa7_0(active0, 0x80000000000L);
387 case 76:
388 return jjMoveStringLiteralDfa7_0(active0, 0x40000000000L);
389 case 97:
390 if ((active0 & 0x8000000000L) != 0L)
391 return jjStartNfaWithStates_0(6, 39, 277);
392 else if ((active0 & 0x10000000000L) != 0L)
393 return jjStartNfaWithStates_0(6, 40, 277);
394 return jjMoveStringLiteralDfa7_0(active0, 0x100000000000L);
395 case 101:
396 if ((active0 & 0x20000000000L) != 0L)
397 return jjStartNfaWithStates_0(6, 41, 277);
398 break;
399 case 116:
400 return jjMoveStringLiteralDfa7_0(active0, 0x800000000000L);
401 default :
402 break;
403 }
404 return jjStartNfa_0(5, active0, 0L);
405 }
406 private int jjMoveStringLiteralDfa7_0(long old0, long active0)
407 {
408 if (((active0 &= old0)) == 0L)
409 return jjStartNfa_0(5, old0, 0L);
410 try { curChar = input_stream.readChar(); }
411 catch(java.io.IOException e) {
412 jjStopStringLiteralDfa_0(6, active0, 0L);
413 return 7;
414 }
415 switch(curChar)
416 {
417 case 100:
418 if ((active0 & 0x80000000000L) != 0L)
419 return jjStartNfaWithStates_0(7, 43, 277);
420 break;
421 case 101:
422 return jjMoveStringLiteralDfa8_0(active0, 0x800000000000L);
423 case 109:
424 return jjMoveStringLiteralDfa8_0(active0, 0x100000000000L);
425 case 111:
426 return jjMoveStringLiteralDfa8_0(active0, 0x40000000000L);
427 default :
428 break;
429 }
430 return jjStartNfa_0(6, active0, 0L);
431 }
432 private int jjMoveStringLiteralDfa8_0(long old0, long active0)
433 {
434 if (((active0 &= old0)) == 0L)
435 return jjStartNfa_0(6, old0, 0L);
436 try { curChar = input_stream.readChar(); }
437 catch(java.io.IOException e) {
438 jjStopStringLiteralDfa_0(7, active0, 0L);
439 return 8;
440 }
441 switch(curChar)
442 {
443 case 110:
444 return jjMoveStringLiteralDfa9_0(active0, 0x40000000000L);
445 case 112:
446 if ((active0 & 0x100000000000L) != 0L)
447 return jjStartNfaWithStates_0(8, 44, 277);
448 break;
449 case 114:
450 if ((active0 & 0x800000000000L) != 0L)
451 return jjStartNfaWithStates_0(8, 47, 277);
452 break;
453 default :
454 break;
455 }
456 return jjStartNfa_0(7, active0, 0L);
457 }
458 private int jjMoveStringLiteralDfa9_0(long old0, long active0)
459 {
460 if (((active0 &= old0)) == 0L)
461 return jjStartNfa_0(7, old0, 0L);
462 try { curChar = input_stream.readChar(); }
463 catch(java.io.IOException e) {
464 jjStopStringLiteralDfa_0(8, active0, 0L);
465 return 9;
466 }
467 switch(curChar)
468 {
469 case 103:
470 if ((active0 & 0x40000000000L) != 0L)
471 return jjStartNfaWithStates_0(9, 42, 277);
472 break;
473 default :
474 break;
475 }
476 return jjStartNfa_0(8, active0, 0L);
477 }
478 private int jjStartNfaWithStates_0(int pos, int kind, int state)
479 {
480 jjmatchedKind = kind;
481 jjmatchedPos = pos;
482 try { curChar = input_stream.readChar(); }
483 catch(java.io.IOException e) { return pos + 1; }
484 return jjMoveNfa_0(state, pos + 1);
485 }
486 static final long[] jjbitVec0 = {
487 0xfffffffefffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
488 };
489 static final long[] jjbitVec2 = {
490 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
491 };
492 static final long[] jjbitVec3 = {
493 0xfffffcffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
494 };
495 static final long[] jjbitVec4 = {
496 0x200002L, 0x0L, 0xf00000000L, 0x1200000000000000L
497 };
498 static final long[] jjbitVec5 = {
499 0x10000000000000L, 0x4000L, 0x100000000000L, 0x0L
500 };
501 static final long[] jjbitVec6 = {
502 0x1L, 0x0L, 0x0L, 0x0L
503 };
504 static final long[] jjbitVec7 = {
505 0x0L, 0x0L, 0x420040000000000L, 0xff7fffffff7fffffL
506 };
507 static final long[] jjbitVec8 = {
508 0xffffcffffffffL, 0xffffffffffff0000L, 0xf9ff3fffffffffffL, 0x401f00030003L
509 };
510 static final long[] jjbitVec9 = {
511 0x0L, 0x400000000000000L, 0xfffffffbffffd740L, 0xffffffcff7fffL
512 };
513 static final long[] jjbitVec10 = {
514 0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffffff003L, 0x33fffffffff199fL
515 };
516 static final long[] jjbitVec11 = {
517 0xfffe000000000000L, 0xfffffffe027fffffL, 0xffL, 0x707ffffff0000L
518 };
519 static final long[] jjbitVec12 = {
520 0x7fffffe00000000L, 0xfffe0000000007ffL, 0xffffffffffffffffL, 0x1c000060002fffffL
521 };
522 static final long[] jjbitVec13 = {
523 0x1ffffffd0000L, 0x0L, 0x3fffffffffL, 0x0L
524 };
525 static final long[] jjbitVec14 = {
526 0x23ffffffffffffe0L, 0x3ff010000L, 0x3c5fdfffff99fe0L, 0x30003b0000000L
527 };
528 static final long[] jjbitVec15 = {
529 0x36dfdfffff987e0L, 0x1c00005e000000L, 0x23edfdfffffbafe0L, 0x100010000L
530 };
531 static final long[] jjbitVec16 = {
532 0x23cdfdfffff99fe0L, 0x3b0000000L, 0x3bfc718d63dc7e0L, 0x0L
533 };
534 static final long[] jjbitVec17 = {
535 0x3effdfffffddfe0L, 0x300000000L, 0x3effdfffffddfe0L, 0x340000000L
536 };
537 static final long[] jjbitVec18 = {
538 0x3fffdfffffddfe0L, 0x300000000L, 0x2ffbfffffc7fffe0L, 0x7fL
539 };
540 static final long[] jjbitVec19 = {
541 0xdfffffffffffeL, 0x7fL, 0xe00decaefef02596L, 0x3000005fL
542 };
543 static final long[] jjbitVec20 = {
544 0x1L, 0x7ffffffffffL, 0xf00L, 0x0L
545 };
546 static final long[] jjbitVec21 = {
547 0x6fbffffffffL, 0x3f0000L, 0xffffffff00000000L, 0x7fffffffff003fL
548 };
549 static final long[] jjbitVec22 = {
550 0xffffffffffffffffL, 0xffffffff83ffffffL, 0xffffff07ffffffffL, 0x3ffffffffffffffL
551 };
552 static final long[] jjbitVec23 = {
553 0xffffffffffffff7fL, 0xffffffff3d7f3d7fL, 0x7f3d7fffffff3d7fL, 0xffff7fffff7f7f3dL
554 };
555 static final long[] jjbitVec24 = {
556 0xffffffff7f3d7fffL, 0x7ffff7fL, 0xffffffff00000000L, 0x1fffffffffffffL
557 };
558 static final long[] jjbitVec25 = {
559 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
560 };
561 static final long[] jjbitVec26 = {
562 0xffffffffffffffffL, 0x7fffffffffffffL, 0xffffffff07fffffeL, 0x7ffffffffffL
563 };
564 static final long[] jjbitVec27 = {
565 0x0L, 0x0L, 0xfffffffffffffL, 0x0L
566 };
567 static final long[] jjbitVec28 = {
568 0xffffffff00000000L, 0xffffffffffffffL, 0x1ffffffffffL, 0x0L
569 };
570 static final long[] jjbitVec29 = {
571 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffff0fffffffL, 0x3ffffffffffffffL
572 };
573 static final long[] jjbitVec30 = {
574 0xffffffff3f3fffffL, 0x3fffffffaaff3f3fL, 0x5fdfffffffffffffL, 0x1fdc1fff0fcf1fdcL
575 };
576 static final long[] jjbitVec31 = {
577 0x0L, 0x8000000000000000L, 0x0L, 0x0L
578 };
579 static final long[] jjbitVec32 = {
580 0x3fbbd503e2ffc84L, 0xffffffff00000000L, 0xfL, 0x0L
581 };
582 static final long[] jjbitVec33 = {
583 0x73e03fe000000e0L, 0xfffffffffffffffeL, 0xfffffffe601fffffL, 0x77ffffffffffffffL
584 };
585 static final long[] jjbitVec34 = {
586 0xfffe1fffffffffe0L, 0xffffffffffffffffL, 0xffffff00007fffL, 0x0L
587 };
588 static final long[] jjbitVec35 = {
589 0x0L, 0x0L, 0x20000000000000L, 0x0L
590 };
591 static final long[] jjbitVec36 = {
592 0x0L, 0x0L, 0x2000000000L, 0x0L
593 };
594 static final long[] jjbitVec37 = {
595 0xffffffffffffffffL, 0xffffffffffffffffL, 0x1fffL, 0x0L
596 };
597 static final long[] jjbitVec38 = {
598 0x0L, 0x0L, 0x800000000L, 0x0L
599 };
600 static final long[] jjbitVec39 = {
601 0x3fffffffffffL, 0x0L, 0x0L, 0x0L
602 };
603 static final long[] jjbitVec40 = {
604 0x5f7ffdffa0f8007fL, 0xffffffffffffffdbL, 0x3ffffffffffffL, 0xfffffffffff80000L
605 };
606 static final long[] jjbitVec41 = {
607 0x3fffffffffffffffL, 0xffffffffffff0000L, 0xfffffffffffcffffL, 0xfff0000000000ffL
608 };
609 static final long[] jjbitVec42 = {
610 0x0L, 0xffd7000000000000L, 0xffffffffffffffffL, 0x1fffffffffffffffL
611 };
612 static final long[] jjbitVec43 = {
613 0x7fffffe00000000L, 0xffffffc007fffffeL, 0x7fffffffffffffffL, 0x1cfcfcfcL
614 };
615 static final long[] jjbitVec44 = {
616 0xffffffffffffffffL, 0x400000700007fffL, 0xfffffffbffffd740L, 0xffffffcff7fffL
617 };
618 static final long[] jjbitVec45 = {
619 0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffffff07bL, 0x33fffffffff199fL
620 };
621 static final long[] jjbitVec46 = {
622 0xfffe000000000000L, 0xfffffffe027fffffL, 0xbbfffffbfffe00ffL, 0x707ffffff0016L
623 };
624 static final long[] jjbitVec47 = {
625 0x7fffffe00000000L, 0xffff03ff003fffffL, 0xffffffffffffffffL, 0x1fff3dff9fefffffL
626 };
627 static final long[] jjbitVec48 = {
628 0xffff1fffffff0000L, 0x7ffL, 0x1ffffffffffffL, 0x0L
629 };
630 static final long[] jjbitVec49 = {
631 0xf3ffffffffffffeeL, 0xffcfff1f3fffL, 0xf3c5fdfffff99feeL, 0x3ffcfb080399fL
632 };
633 static final long[] jjbitVec50 = {
634 0xd36dfdfffff987ecL, 0x1fffc05e003987L, 0xf3edfdfffffbafeeL, 0xffc100013bbfL
635 };
636 static final long[] jjbitVec51 = {
637 0xf3cdfdfffff99feeL, 0xffc3b0c0398fL, 0xc3bfc718d63dc7ecL, 0xff8000803dc7L
638 };
639 static final long[] jjbitVec52 = {
640 0xc3effdfffffddfeeL, 0xffc300603ddfL, 0xc3effdfffffddfecL, 0xffc340603ddfL
641 };
642 static final long[] jjbitVec53 = {
643 0xc3fffdfffffddfecL, 0xffc300803dcfL, 0x2ffbfffffc7fffecL, 0xc0000ff5f847fL
644 };
645 static final long[] jjbitVec54 = {
646 0x7fffffffffffffeL, 0x3ff7fffL, 0xfbffecaefef02596L, 0x33ff3f5fL
647 };
648 static final long[] jjbitVec55 = {
649 0xc2a003ff03000001L, 0xfffe07ffffffffffL, 0x1ffffffffeff0fdfL, 0x40L
650 };
651 static final long[] jjbitVec56 = {
652 0x3c7f6fbffffffffL, 0x3ff03ffL, 0xffffffff00000000L, 0x7fffffffff003fL
653 };
654 static final long[] jjbitVec57 = {
655 0xffffffff7f3d7fffL, 0x3fe0007ffff7fL, 0xffffffff00000000L, 0x1fffffffffffffL
656 };
657 static final long[] jjbitVec58 = {
658 0x0L, 0x0L, 0xffffffffffffffffL, 0x3ff000fffffL
659 };
660 static final long[] jjbitVec59 = {
661 0xffffffff03ff0000L, 0xffffffffffffffL, 0x3ffffffffffL, 0x0L
662 };
663 static final long[] jjbitVec60 = {
664 0x1fb0e7800000000L, 0x0L, 0xffff000000000000L, 0x301L
665 };
666 static final long[] jjbitVec61 = {
667 0xe000000L, 0x0L, 0x0L, 0x0L
668 };
669 static final long[] jjbitVec62 = {
670 0xc00000L, 0x0L, 0x0L, 0x0L
671 };
672 static final long[] jjbitVec63 = {
673 0x8000000000000000L, 0x8000000000000001L, 0x0L, 0x21fff0000L
674 };
675 static final long[] jjbitVec64 = {
676 0x73efffe000000e0L, 0xfffffffffffffffeL, 0xfffffffe661fffffL, 0x7fffffffffffffffL
677 };
678 static final long[] jjbitVec65 = {
679 0x9800000004L, 0x0L, 0x0L, 0x0L
680 };
681 static final long[] jjbitVec66 = {
682 0x5f7ffdffe0f8007fL, 0xffffffffffffffdbL, 0x3ffffffffffffL, 0xfffffffffff80000L
683 };
684 static final long[] jjbitVec67 = {
685 0x18000f00000000L, 0xffd700000000e000L, 0xffffffffffffffffL, 0x1fffffffffffffffL
686 };
687 static final long[] jjbitVec68 = {
688 0x87fffffe03ff0000L, 0xffffffe007fffffeL, 0x7fffffffffffffffL, 0x1cfcfcfcL
689 };
690 static final long[] jjbitVec69 = {
691 0xffffffffffffffffL, 0x700007fffL, 0x0L, 0x0L
692 };
693 static final long[] jjbitVec70 = {
694 0x0L, 0x0L, 0x78L, 0x0L
695 };
696 static final long[] jjbitVec71 = {
697 0x0L, 0x0L, 0xbbfffffbfffe0000L, 0x16L
698 };
699 static final long[] jjbitVec72 = {
700 0x0L, 0x10000003ff800L, 0x0L, 0x3d9f9fc00000L
701 };
702 static final long[] jjbitVec73 = {
703 0xffff000000020000L, 0x7ffL, 0x1ffc000000000L, 0x0L
704 };
705 static final long[] jjbitVec74 = {
706 0xd00000000000000eL, 0xc001e3fffL, 0xf00000000000000eL, 0xc0080399fL
707 };
708 static final long[] jjbitVec75 = {
709 0xd00000000000000cL, 0x3000000003987L, 0xd00000000000000eL, 0x3bbfL
710 };
711 static final long[] jjbitVec76 = {
712 0xd00000000000000eL, 0xc0398fL, 0xc00000000000000cL, 0x803dc7L
713 };
714 static final long[] jjbitVec77 = {
715 0xc00000000000000eL, 0x603ddfL, 0xc00000000000000cL, 0x603ddfL
716 };
717 static final long[] jjbitVec78 = {
718 0xc00000000000000cL, 0x803dcfL, 0xcL, 0xc0000ff5f8400L
719 };
720 static final long[] jjbitVec79 = {
721 0x7f2000000000000L, 0x7f80L, 0x1bf2000000000000L, 0x3f00L
722 };
723 static final long[] jjbitVec80 = {
724 0xc2a0000003000000L, 0xfffe000000000000L, 0x1ffffffffeff00dfL, 0x40L
725 };
726 static final long[] jjbitVec81 = {
727 0x3c7f00000000000L, 0x3c00000L, 0x0L, 0x0L
728 };
729 static final long[] jjbitVec82 = {
730 0x0L, 0x0L, 0xfff0000000000000L, 0xfffffL
731 };
732 static final long[] jjbitVec83 = {
733 0x0L, 0x0L, 0x20000000000L, 0x0L
734 };
735 static final long[] jjbitVec84 = {
736 0x0L, 0x0L, 0x0L, 0x21fff0000L
737 };
738 static final long[] jjbitVec85 = {
739 0xfc0000000000L, 0x0L, 0x6000000L, 0x0L
740 };
741 static final long[] jjbitVec86 = {
742 0x40000000L, 0x0L, 0x0L, 0x0L
743 };
744 static final long[] jjbitVec87 = {
745 0xf00000000L, 0x0L, 0x0L, 0x0L
746 };
747 static final long[] jjbitVec88 = {
748 0xc000000000000008L, 0x1e01L, 0xc00000000000000cL, 0x801981L
749 };
750 static final long[] jjbitVec89 = {
751 0xc000000000000008L, 0x1L, 0xc000000000000008L, 0x1a01L
752 };
753 static final long[] jjbitVec90 = {
754 0x400000000000000cL, 0x801981L, 0xc000000000000000L, 0x801dc6L
755 };
756 static final long[] jjbitVec91 = {
757 0xeL, 0x1eL, 0x400000000000000cL, 0x600d9fL
758 };
759 static final long[] jjbitVec92 = {
760 0xc00000000000000cL, 0x801dc1L, 0xcL, 0xc0000ff038000L
761 };
762 static final long[] jjbitVec93 = {
763 0xc000000000000000L, 0x8000000000000000L, 0x0L, 0x0L
764 };
765 static final long[] jjbitVec94 = {
766 0x102100000000000L, 0xc00000L, 0x0L, 0x0L
767 };
768 static final long[] jjbitVec95 = {
769 0x0L, 0x0L, 0xc040000000000000L, 0x1bfL
770 };
771 static final long[] jjbitVec96 = {
772 0xd000000000000004L, 0x3000000003987L, 0xd00000000000000eL, 0x3bbfL
773 };
774 static final long[] jjbitVec97 = {
775 0x1600L, 0x0L, 0x0L, 0x0L
776 };
777 static final long[] jjbitVec98 = {
778 0x0L, 0xffc000000000L, 0x0L, 0xffc000000000L
779 };
780 static final long[] jjbitVec99 = {
781 0x1000000L, 0x0L, 0x0L, 0x8000000000000000L
782 };
783 static final long[] jjbitVec100 = {
784 0x3ff0000L, 0x0L, 0x0L, 0x0L
785 };
786 static final long[] jjbitVec101 = {
787 0x0L, 0x3ff00000000L, 0x0L, 0x3ff000000000000L
788 };
789 static final long[] jjbitVec102 = {
790 0x0L, 0xffc000000000L, 0x0L, 0xff8000000000L
791 };
792 static final long[] jjbitVec103 = {
793 0x0L, 0xffc000000000L, 0x0L, 0x0L
794 };
795 static final long[] jjbitVec104 = {
796 0x0L, 0x3ff0000L, 0x0L, 0x3ff0000L
797 };
798 static final long[] jjbitVec105 = {
799 0x3ff00000000L, 0x0L, 0x0L, 0x0L
800 };
801 static final long[] jjbitVec106 = {
802 0x0L, 0x3ffL, 0x0L, 0x0L
803 };
804 static final long[] jjbitVec107 = {
805 0x0L, 0x3fe0000000000L, 0x0L, 0x0L
806 };
807 static final long[] jjbitVec108 = {
808 0x0L, 0x0L, 0x0L, 0x3ff00000000L
809 };
810 static final long[] jjbitVec109 = {
811 0x8000000000000000L, 0x1L, 0x0L, 0x0L
812 };
813 static final long[] jjbitVec110 = {
814 0x0L, 0x0L, 0x0L, 0x800000000000000L
815 };
816 static final long[] jjbitVec111 = {
817 0x18000000000000L, 0xe000L, 0x0L, 0x0L
818 };
819 static final long[] jjbitVec112 = {
820 0x8000000000000000L, 0x2000000000L, 0x0L, 0x0L
821 };
822 private int jjMoveNfa_0(int startState, int curPos)
823 {
824 int startsAt = 0;
825 jjnewStateCnt = 277;
826 int i = 1;
827 jjstateSet[0] = startState;
828 int kind = 0x7fffffff;
829 for (;;)
830 {
831 if (++jjround == 0x7fffffff)
832 ReInitRounds();
833 if (curChar < 64)
834 {
835 long l = 1L << curChar;
836 do
837 {
838 switch(jjstateSet[--i])
839 {
840 case 0:
841 if ((0x3ff000000000000L & l) != 0L)
842 {
843 if (kind > 21)
844 kind = 21;
845 jjCheckNAddStates(0, 2);
846 }
847 else if (curChar == 36)
848 jjAddStates(3, 11);
849 else if (curChar == 39)
850 jjAddStates(12, 20);
851 else if (curChar == 34)
852 jjAddStates(21, 29);
853 else if (curChar == 45)
854 jjAddStates(30, 37);
855 else if (curChar == 47)
856 jjAddStates(38, 39);
857 if ((0x3ff000000000000L & l) != 0L)
858 {
859 if (kind > 66)
860 kind = 66;
861 }
862 else if (curChar == 36)
863 {
864 if (kind > 57)
865 kind = 57;
866 jjCheckNAddTwoStates(29, 30);
867 }
868 else if (curChar == 39)
869 jjCheckNAddStates(40, 42);
870 else if (curChar == 34)
871 jjCheckNAddStates(43, 45);
872 if ((0x3ff000000000000L & l) != 0L)
873 {
874 if (kind > 38)
875 kind = 38;
876 }
877 if ((0x3fe000000000000L & l) != 0L)
878 jjCheckNAddStates(46, 49);
879 break;
880 case 32:
881 if ((0x3ff001000000000L & l) != 0L)
882 {
883 if (kind > 57)
884 kind = 57;
885 jjCheckNAddTwoStates(29, 30);
886 }
887 if ((0x3ff000000000000L & l) != 0L)
888 jjstateSet[jjnewStateCnt++] = 37;
889 if ((0x3ff000000000000L & l) != 0L)
890 jjstateSet[jjnewStateCnt++] = 33;
891 break;
892 case 277:
893 case 29:
894 if ((0x3ff001000000000L & l) == 0L)
895 break;
896 if (kind > 57)
897 kind = 57;
898 jjCheckNAddTwoStates(29, 30);
899 break;
900 case 31:
901 if ((0x3ff001000000000L & l) != 0L)
902 {
903 if (kind > 57)
904 kind = 57;
905 jjCheckNAddTwoStates(29, 30);
906 }
907 if ((0x3ff000000000000L & l) != 0L)
908 jjstateSet[jjnewStateCnt++] = 36;
909 if ((0x3ff000000000000L & l) != 0L)
910 jjstateSet[jjnewStateCnt++] = 32;
911 break;
912 case 56:
913 if ((0x3ff000000000000L & l) != 0L)
914 {
915 if (kind > 21)
916 kind = 21;
917 }
918 if ((0x3ff000000000000L & l) != 0L)
919 jjCheckNAdd(68);
920 if ((0x3ff000000000000L & l) != 0L)
921 jjCheckNAdd(62);
922 if ((0x3ff000000000000L & l) != 0L)
923 jjCheckNAdd(57);
924 if ((0x3fe000000000000L & l) != 0L)
925 jjCheckNAdd(77);
926 if ((0x3fe000000000000L & l) != 0L)
927 jjCheckNAdd(74);
928 if ((0x3fe000000000000L & l) != 0L)
929 jjCheckNAdd(66);
930 if ((0x3fe000000000000L & l) != 0L)
931 jjCheckNAdd(60);
932 break;
933 case 1:
934 if ((0xfffffffbffffdbffL & l) != 0L)
935 jjCheckNAddStates(43, 45);
936 break;
937 case 3:
938 jjCheckNAddStates(43, 45);
939 break;
940 case 4:
941 if (curChar == 34 && kind > 28)
942 kind = 28;
943 break;
944 case 6:
945 case 11:
946 if ((0x3ff000000000000L & l) != 0L)
947 jjCheckNAdd(7);
948 break;
949 case 7:
950 if ((0x3ff000000000000L & l) != 0L)
951 jjCheckNAddStates(43, 45);
952 break;
953 case 9:
954 if ((0x3ff000000000000L & l) != 0L)
955 jjstateSet[jjnewStateCnt++] = 10;
956 break;
957 case 10:
958 if ((0x3ff000000000000L & l) != 0L)
959 jjstateSet[jjnewStateCnt++] = 11;
960 break;
961 case 12:
962 if (curChar == 39)
963 jjCheckNAddStates(40, 42);
964 break;
965 case 13:
966 if ((0xffffff7fffffdbffL & l) != 0L)
967 jjCheckNAddStates(40, 42);
968 break;
969 case 15:
970 jjCheckNAddStates(40, 42);
971 break;
972 case 16:
973 if (curChar == 39 && kind > 28)
974 kind = 28;
975 break;
976 case 18:
977 case 23:
978 if ((0x3ff000000000000L & l) != 0L)
979 jjCheckNAdd(19);
980 break;
981 case 19:
982 if ((0x3ff000000000000L & l) != 0L)
983 jjCheckNAddStates(40, 42);
984 break;
985 case 21:
986 if ((0x3ff000000000000L & l) != 0L)
987 jjstateSet[jjnewStateCnt++] = 22;
988 break;
989 case 22:
990 if ((0x3ff000000000000L & l) != 0L)
991 jjstateSet[jjnewStateCnt++] = 23;
992 break;
993 case 25:
994 if ((0x3ff000000000000L & l) != 0L)
995 jjstateSet[jjnewStateCnt++] = 26;
996 break;
997 case 26:
998 if ((0x3ff000000000000L & l) != 0L && kind > 37)
999 kind = 37;
1000 break;
1001 case 27:
1002 if ((0x3ff000000000000L & l) != 0L && kind > 38)
1003 kind = 38;
1004 break;
1005 case 28:
1006 if (curChar != 36)
1007 break;
1008 if (kind > 57)
1009 kind = 57;
1010 jjCheckNAddTwoStates(29, 30);
1011 break;
1012 case 33:
1013 case 37:
1014 case 272:
1015 if ((0x3ff000000000000L & l) != 0L)
1016 jjCheckNAdd(34);
1017 break;
1018 case 34:
1019 if ((0x3ff000000000000L & l) == 0L)
1020 break;
1021 if (kind > 57)
1022 kind = 57;
1023 jjCheckNAddTwoStates(29, 30);
1024 break;
1025 case 35:
1026 if ((0x3ff000000000000L & l) != 0L)
1027 jjstateSet[jjnewStateCnt++] = 36;
1028 break;
1029 case 36:
1030 if ((0x3ff000000000000L & l) != 0L)
1031 jjstateSet[jjnewStateCnt++] = 37;
1032 break;
1033 case 41:
1034 if ((0x3ff000000000000L & l) != 0L && kind > 66)
1035 kind = 66;
1036 break;
1037 case 43:
1038 if (curChar == 47)
1039 jjAddStates(38, 39);
1040 break;
1041 case 44:
1042 if (curChar == 47)
1043 jjCheckNAddStates(50, 52);
1044 break;
1045 case 45:
1046 if ((0xffffffffffffdbffL & l) != 0L)
1047 jjCheckNAddStates(50, 52);
1048 break;
1049 case 46:
1050 if ((0x2400L & l) != 0L && kind > 6)
1051 kind = 6;
1052 break;
1053 case 47:
1054 if (curChar == 10 && kind > 6)
1055 kind = 6;
1056 break;
1057 case 48:
1058 if (curChar == 13)
1059 jjstateSet[jjnewStateCnt++] = 47;
1060 break;
1061 case 49:
1062 if (curChar == 42)
1063 jjCheckNAddTwoStates(50, 51);
1064 break;
1065 case 50:
1066 if ((0xfffffbffffffffffL & l) != 0L)
1067 jjCheckNAddTwoStates(50, 51);
1068 break;
1069 case 51:
1070 if (curChar == 42)
1071 jjCheckNAddStates(53, 55);
1072 break;
1073 case 52:
1074 if ((0xffff7bffffffffffL & l) != 0L)
1075 jjCheckNAddTwoStates(53, 51);
1076 break;
1077 case 53:
1078 if ((0xfffffbffffffffffL & l) != 0L)
1079 jjCheckNAddTwoStates(53, 51);
1080 break;
1081 case 54:
1082 if (curChar == 47 && kind > 7)
1083 kind = 7;
1084 break;
1085 case 55:
1086 if (curChar == 45)
1087 jjAddStates(30, 37);
1088 break;
1089 case 57:
1090 if (curChar == 46)
1091 jjCheckNAdd(58);
1092 break;
1093 case 58:
1094 if ((0x3ff000000000000L & l) == 0L)
1095 break;
1096 if (kind > 20)
1097 kind = 20;
1098 jjCheckNAdd(58);
1099 break;
1100 case 59:
1101 if ((0x3fe000000000000L & l) != 0L)
1102 jjCheckNAdd(60);
1103 break;
1104 case 60:
1105 if ((0x3ff000000000000L & l) != 0L)
1106 jjCheckNAddTwoStates(60, 57);
1107 break;
1108 case 61:
1109 if ((0x3ff000000000000L & l) != 0L)
1110 jjCheckNAdd(62);
1111 break;
1112 case 63:
1113 if ((0x280000000000L & l) != 0L)
1114 jjCheckNAdd(64);
1115 break;
1116 case 64:
1117 if ((0x3ff000000000000L & l) == 0L)
1118 break;
1119 if (kind > 20)
1120 kind = 20;
1121 jjCheckNAdd(64);
1122 break;
1123 case 65:
1124 if ((0x3fe000000000000L & l) != 0L)
1125 jjCheckNAdd(66);
1126 break;
1127 case 66:
1128 if ((0x3ff000000000000L & l) != 0L)
1129 jjCheckNAddTwoStates(66, 62);
1130 break;
1131 case 67:
1132 if ((0x3ff000000000000L & l) != 0L)
1133 jjCheckNAdd(68);
1134 break;
1135 case 68:
1136 if (curChar == 46)
1137 jjCheckNAdd(69);
1138 break;
1139 case 69:
1140 if ((0x3ff000000000000L & l) != 0L)
1141 jjCheckNAddTwoStates(69, 70);
1142 break;
1143 case 71:
1144 if ((0x280000000000L & l) != 0L)
1145 jjCheckNAdd(72);
1146 break;
1147 case 72:
1148 if ((0x3ff000000000000L & l) == 0L)
1149 break;
1150 if (kind > 20)
1151 kind = 20;
1152 jjCheckNAdd(72);
1153 break;
1154 case 73:
1155 if ((0x3fe000000000000L & l) != 0L)
1156 jjCheckNAdd(74);
1157 break;
1158 case 74:
1159 if ((0x3ff000000000000L & l) != 0L)
1160 jjCheckNAddTwoStates(74, 68);
1161 break;
1162 case 75:
1163 if ((0x3ff000000000000L & l) != 0L && kind > 21)
1164 kind = 21;
1165 break;
1166 case 76:
1167 if ((0x3fe000000000000L & l) != 0L)
1168 jjCheckNAdd(77);
1169 break;
1170 case 77:
1171 if ((0x3ff000000000000L & l) == 0L)
1172 break;
1173 if (kind > 21)
1174 kind = 21;
1175 jjCheckNAdd(77);
1176 break;
1177 case 78:
1178 if ((0x3ff000000000000L & l) == 0L)
1179 break;
1180 if (kind > 21)
1181 kind = 21;
1182 jjCheckNAddStates(0, 2);
1183 break;
1184 case 79:
1185 if ((0x3fe000000000000L & l) != 0L)
1186 jjCheckNAddStates(46, 49);
1187 break;
1188 case 80:
1189 if (curChar == 34)
1190 jjAddStates(21, 29);
1191 break;
1192 case 81:
1193 if (curChar == 34 && kind > 48)
1194 kind = 48;
1195 break;
1196 case 88:
1197 if (curChar == 36)
1198 jjstateSet[jjnewStateCnt++] = 87;
1199 break;
1200 case 89:
1201 if (curChar == 34 && kind > 49)
1202 kind = 49;
1203 break;
1204 case 94:
1205 if (curChar == 36)
1206 jjstateSet[jjnewStateCnt++] = 93;
1207 break;
1208 case 95:
1209 if (curChar == 34 && kind > 50)
1210 kind = 50;
1211 break;
1212 case 100:
1213 if (curChar == 36)
1214 jjstateSet[jjnewStateCnt++] = 99;
1215 break;
1216 case 101:
1217 if (curChar == 34 && kind > 51)
1218 kind = 51;
1219 break;
1220 case 111:
1221 if (curChar == 36)
1222 jjstateSet[jjnewStateCnt++] = 110;
1223 break;
1224 case 112:
1225 if (curChar == 34 && kind > 52)
1226 kind = 52;
1227 break;
1228 case 118:
1229 if (curChar == 36)
1230 jjstateSet[jjnewStateCnt++] = 117;
1231 break;
1232 case 119:
1233 if (curChar == 34 && kind > 53)
1234 kind = 53;
1235 break;
1236 case 127:
1237 if (curChar == 36)
1238 jjstateSet[jjnewStateCnt++] = 126;
1239 break;
1240 case 128:
1241 if (curChar == 34 && kind > 54)
1242 kind = 54;
1243 break;
1244 case 132:
1245 if (curChar == 36)
1246 jjstateSet[jjnewStateCnt++] = 131;
1247 break;
1248 case 133:
1249 if (curChar == 34 && kind > 55)
1250 kind = 55;
1251 break;
1252 case 140:
1253 if (curChar == 36)
1254 jjstateSet[jjnewStateCnt++] = 139;
1255 break;
1256 case 141:
1257 if (curChar == 34 && kind > 56)
1258 kind = 56;
1259 break;
1260 case 148:
1261 if (curChar == 36)
1262 jjstateSet[jjnewStateCnt++] = 147;
1263 break;
1264 case 149:
1265 if (curChar == 39)
1266 jjAddStates(12, 20);
1267 break;
1268 case 150:
1269 if (curChar == 39 && kind > 48)
1270 kind = 48;
1271 break;
1272 case 157:
1273 if (curChar == 36)
1274 jjstateSet[jjnewStateCnt++] = 156;
1275 break;
1276 case 158:
1277 if (curChar == 39 && kind > 49)
1278 kind = 49;
1279 break;
1280 case 163:
1281 if (curChar == 36)
1282 jjstateSet[jjnewStateCnt++] = 162;
1283 break;
1284 case 164:
1285 if (curChar == 39 && kind > 50)
1286 kind = 50;
1287 break;
1288 case 169:
1289 if (curChar == 36)
1290 jjstateSet[jjnewStateCnt++] = 168;
1291 break;
1292 case 170:
1293 if (curChar == 39 && kind > 51)
1294 kind = 51;
1295 break;
1296 case 180:
1297 if (curChar == 36)
1298 jjstateSet[jjnewStateCnt++] = 179;
1299 break;
1300 case 181:
1301 if (curChar == 39 && kind > 52)
1302 kind = 52;
1303 break;
1304 case 187:
1305 if (curChar == 36)
1306 jjstateSet[jjnewStateCnt++] = 186;
1307 break;
1308 case 188:
1309 if (curChar == 39 && kind > 53)
1310 kind = 53;
1311 break;
1312 case 196:
1313 if (curChar == 36)
1314 jjstateSet[jjnewStateCnt++] = 195;
1315 break;
1316 case 197:
1317 if (curChar == 39 && kind > 54)
1318 kind = 54;
1319 break;
1320 case 201:
1321 if (curChar == 36)
1322 jjstateSet[jjnewStateCnt++] = 200;
1323 break;
1324 case 202:
1325 if (curChar == 39 && kind > 55)
1326 kind = 55;
1327 break;
1328 case 209:
1329 if (curChar == 36)
1330 jjstateSet[jjnewStateCnt++] = 208;
1331 break;
1332 case 210:
1333 if (curChar == 39 && kind > 56)
1334 kind = 56;
1335 break;
1336 case 217:
1337 if (curChar == 36)
1338 jjstateSet[jjnewStateCnt++] = 216;
1339 break;
1340 case 218:
1341 if (curChar == 36)
1342 jjAddStates(3, 11);
1343 break;
1344 case 270:
1345 if ((0x3ff000000000000L & l) != 0L)
1346 jjstateSet[jjnewStateCnt++] = 271;
1347 break;
1348 case 271:
1349 if ((0x3ff000000000000L & l) != 0L)
1350 jjstateSet[jjnewStateCnt++] = 272;
1351 break;
1352 case 273:
1353 if ((0x3ff000000000000L & l) != 0L)
1354 jjstateSet[jjnewStateCnt++] = 274;
1355 break;
1356 case 274:
1357 if ((0x3ff000000000000L & l) != 0L)
1358 jjstateSet[jjnewStateCnt++] = 275;
1359 break;
1360 case 275:
1361 if ((0x3ff000000000000L & l) != 0L)
1362 jjstateSet[jjnewStateCnt++] = 276;
1363 break;
1364 case 276:
1365 if ((0x3ff000000000000L & l) != 0L && kind > 68)
1366 kind = 68;
1367 break;
1368 default : break;
1369 }
1370 } while(i != startsAt);
1371 }
1372 else if (curChar < 128)
1373 {
1374 long l = 1L << (curChar & 077);
1375 do
1376 {
1377 switch(jjstateSet[--i])
1378 {
1379 case 0:
1380 if ((0x7fffffe87fffffeL & l) != 0L)
1381 {
1382 if (kind > 57)
1383 kind = 57;
1384 jjCheckNAddTwoStates(29, 30);
1385 }
1386 if ((0x7e0000007eL & l) != 0L)
1387 {
1388 if (kind > 38)
1389 kind = 38;
1390 }
1391 else if (curChar == 117)
1392 jjAddStates(56, 57);
1393 else if (curChar == 95)
1394 {
1395 if (kind > 67)
1396 kind = 67;
1397 }
1398 else if (curChar == 120)
1399 jjstateSet[jjnewStateCnt++] = 25;
1400 break;
1401 case 32:
1402 if ((0x7fffffe87fffffeL & l) != 0L)
1403 {
1404 if (kind > 57)
1405 kind = 57;
1406 jjCheckNAddTwoStates(29, 30);
1407 }
1408 if ((0x7e0000007eL & l) != 0L)
1409 jjstateSet[jjnewStateCnt++] = 37;
1410 else if (curChar == 117)
1411 jjAddStates(58, 59);
1412 if ((0x7e0000007eL & l) != 0L)
1413 jjstateSet[jjnewStateCnt++] = 33;
1414 break;
1415 case 277:
1416 if ((0x7fffffe87fffffeL & l) != 0L)
1417 {
1418 if (kind > 57)
1419 kind = 57;
1420 jjCheckNAddTwoStates(29, 30);
1421 }
1422 if (curChar == 117)
1423 jjAddStates(58, 59);
1424 break;
1425 case 31:
1426 if ((0x7fffffe87fffffeL & l) != 0L)
1427 {
1428 if (kind > 57)
1429 kind = 57;
1430 jjCheckNAddTwoStates(29, 30);
1431 }
1432 if ((0x7e0000007eL & l) != 0L)
1433 jjstateSet[jjnewStateCnt++] = 36;
1434 else if (curChar == 117)
1435 jjAddStates(58, 59);
1436 if ((0x7e0000007eL & l) != 0L)
1437 jjstateSet[jjnewStateCnt++] = 32;
1438 break;
1439 case 1:
1440 if ((0xffffffffefffffffL & l) != 0L)
1441 jjCheckNAddStates(43, 45);
1442 break;
1443 case 2:
1444 if (curChar == 92)
1445 jjAddStates(60, 62);
1446 break;
1447 case 3:
1448 jjCheckNAddStates(43, 45);
1449 break;
1450 case 5:
1451 if (curChar == 120)
1452 jjstateSet[jjnewStateCnt++] = 6;
1453 break;
1454 case 6:
1455 case 11:
1456 if ((0x7e0000007eL & l) != 0L)
1457 jjCheckNAdd(7);
1458 break;
1459 case 7:
1460 if ((0x7e0000007eL & l) != 0L)
1461 jjCheckNAddStates(43, 45);
1462 break;
1463 case 8:
1464 if (curChar == 117)
1465 jjstateSet[jjnewStateCnt++] = 9;
1466 break;
1467 case 9:
1468 if ((0x7e0000007eL & l) != 0L)
1469 jjstateSet[jjnewStateCnt++] = 10;
1470 break;
1471 case 10:
1472 if ((0x7e0000007eL & l) != 0L)
1473 jjstateSet[jjnewStateCnt++] = 11;
1474 break;
1475 case 13:
1476 if ((0xffffffffefffffffL & l) != 0L)
1477 jjCheckNAddStates(40, 42);
1478 break;
1479 case 14:
1480 if (curChar == 92)
1481 jjAddStates(63, 65);
1482 break;
1483 case 15:
1484 jjCheckNAddStates(40, 42);
1485 break;
1486 case 17:
1487 if (curChar == 120)
1488 jjstateSet[jjnewStateCnt++] = 18;
1489 break;
1490 case 18:
1491 case 23:
1492 if ((0x7e0000007eL & l) != 0L)
1493 jjCheckNAdd(19);
1494 break;
1495 case 19:
1496 if ((0x7e0000007eL & l) != 0L)
1497 jjCheckNAddStates(40, 42);
1498 break;
1499 case 20:
1500 if (curChar == 117)
1501 jjstateSet[jjnewStateCnt++] = 21;
1502 break;
1503 case 21:
1504 if ((0x7e0000007eL & l) != 0L)
1505 jjstateSet[jjnewStateCnt++] = 22;
1506 break;
1507 case 22:
1508 if ((0x7e0000007eL & l) != 0L)
1509 jjstateSet[jjnewStateCnt++] = 23;
1510 break;
1511 case 24:
1512 if (curChar == 120)
1513 jjstateSet[jjnewStateCnt++] = 25;
1514 break;
1515 case 25:
1516 if ((0x7e0000007eL & l) != 0L)
1517 jjstateSet[jjnewStateCnt++] = 26;
1518 break;
1519 case 26:
1520 if ((0x7e0000007eL & l) != 0L && kind > 37)
1521 kind = 37;
1522 break;
1523 case 27:
1524 if ((0x7e0000007eL & l) != 0L && kind > 38)
1525 kind = 38;
1526 break;
1527 case 28:
1528 if ((0x7fffffe87fffffeL & l) == 0L)
1529 break;
1530 if (kind > 57)
1531 kind = 57;
1532 jjCheckNAddTwoStates(29, 30);
1533 break;
1534 case 29:
1535 if ((0x7fffffe87fffffeL & l) == 0L)
1536 break;
1537 if (kind > 57)
1538 kind = 57;
1539 jjCheckNAddTwoStates(29, 30);
1540 break;
1541 case 30:
1542 if (curChar == 117)
1543 jjAddStates(58, 59);
1544 break;
1545 case 33:
1546 case 37:
1547 case 272:
1548 if ((0x7e0000007eL & l) != 0L)
1549 jjCheckNAdd(34);
1550 break;
1551 case 34:
1552 if ((0x7e0000007eL & l) == 0L)
1553 break;
1554 if (kind > 57)
1555 kind = 57;
1556 jjCheckNAddTwoStates(29, 30);
1557 break;
1558 case 35:
1559 if ((0x7e0000007eL & l) != 0L)
1560 jjstateSet[jjnewStateCnt++] = 36;
1561 break;
1562 case 36:
1563 if ((0x7e0000007eL & l) != 0L)
1564 jjstateSet[jjnewStateCnt++] = 37;
1565 break;
1566 case 42:
1567 if (curChar == 95 && kind > 67)
1568 kind = 67;
1569 break;
1570 case 45:
1571 jjAddStates(50, 52);
1572 break;
1573 case 50:
1574 jjCheckNAddTwoStates(50, 51);
1575 break;
1576 case 52:
1577 case 53:
1578 jjCheckNAddTwoStates(53, 51);
1579 break;
1580 case 62:
1581 if ((0x2000000020L & l) != 0L)
1582 jjAddStates(66, 67);
1583 break;
1584 case 70:
1585 if ((0x2000000020L & l) != 0L)
1586 jjAddStates(68, 69);
1587 break;
1588 case 82:
1589 if (curChar == 121)
1590 jjstateSet[jjnewStateCnt++] = 81;
1591 break;
1592 case 83:
1593 if (curChar == 114)
1594 jjstateSet[jjnewStateCnt++] = 82;
1595 break;
1596 case 84:
1597 if (curChar == 97)
1598 jjstateSet[jjnewStateCnt++] = 83;
1599 break;
1600 case 85:
1601 if (curChar == 110)
1602 jjstateSet[jjnewStateCnt++] = 84;
1603 break;
1604 case 86:
1605 if (curChar == 105)
1606 jjstateSet[jjnewStateCnt++] = 85;
1607 break;
1608 case 87:
1609 if (curChar == 98)
1610 jjstateSet[jjnewStateCnt++] = 86;
1611 break;
1612 case 90:
1613 if (curChar == 101)
1614 jjstateSet[jjnewStateCnt++] = 89;
1615 break;
1616 case 91:
1617 if (curChar == 112)
1618 jjstateSet[jjnewStateCnt++] = 90;
1619 break;
1620 case 92:
1621 if (curChar == 121)
1622 jjstateSet[jjnewStateCnt++] = 91;
1623 break;
1624 case 93:
1625 if (curChar == 116)
1626 jjstateSet[jjnewStateCnt++] = 92;
1627 break;
1628 case 96:
1629 if (curChar == 101)
1630 jjstateSet[jjnewStateCnt++] = 95;
1631 break;
1632 case 97:
1633 if (curChar == 116)
1634 jjstateSet[jjnewStateCnt++] = 96;
1635 break;
1636 case 98:
1637 if (curChar == 97)
1638 jjstateSet[jjnewStateCnt++] = 97;
1639 break;
1640 case 99:
1641 if (curChar == 100)
1642 jjstateSet[jjnewStateCnt++] = 98;
1643 break;
1644 case 102:
1645 if (curChar == 112)
1646 jjstateSet[jjnewStateCnt++] = 101;
1647 break;
1648 case 103:
1649 if (curChar == 109)
1650 jjstateSet[jjnewStateCnt++] = 102;
1651 break;
1652 case 104:
1653 if (curChar == 97)
1654 jjstateSet[jjnewStateCnt++] = 103;
1655 break;
1656 case 105:
1657 if (curChar == 116)
1658 jjstateSet[jjnewStateCnt++] = 104;
1659 break;
1660 case 106:
1661 if (curChar == 115)
1662 jjstateSet[jjnewStateCnt++] = 105;
1663 break;
1664 case 107:
1665 if (curChar == 101)
1666 jjstateSet[jjnewStateCnt++] = 106;
1667 break;
1668 case 108:
1669 if (curChar == 109)
1670 jjstateSet[jjnewStateCnt++] = 107;
1671 break;
1672 case 109:
1673 if (curChar == 105)
1674 jjstateSet[jjnewStateCnt++] = 108;
1675 break;
1676 case 110:
1677 if (curChar == 116)
1678 jjstateSet[jjnewStateCnt++] = 109;
1679 break;
1680 case 113:
1681 if (curChar == 120)
1682 jjstateSet[jjnewStateCnt++] = 112;
1683 break;
1684 case 114:
1685 if (curChar == 101)
1686 jjstateSet[jjnewStateCnt++] = 113;
1687 break;
1688 case 115:
1689 if (curChar == 103)
1690 jjstateSet[jjnewStateCnt++] = 114;
1691 break;
1692 case 116:
1693 if (curChar == 101)
1694 jjstateSet[jjnewStateCnt++] = 115;
1695 break;
1696 case 117:
1697 if (curChar == 114)
1698 jjstateSet[jjnewStateCnt++] = 116;
1699 break;
1700 case 120:
1701 if (curChar == 115)
1702 jjstateSet[jjnewStateCnt++] = 119;
1703 break;
1704 case 121:
1705 if (curChar == 110)
1706 jjstateSet[jjnewStateCnt++] = 120;
1707 break;
1708 case 122:
1709 if (curChar == 111)
1710 jjstateSet[jjnewStateCnt++] = 121;
1711 break;
1712 case 123:
1713 if (curChar == 105)
1714 jjstateSet[jjnewStateCnt++] = 122;
1715 break;
1716 case 124:
1717 if (curChar == 116)
1718 jjstateSet[jjnewStateCnt++] = 123;
1719 break;
1720 case 125:
1721 if (curChar == 112)
1722 jjstateSet[jjnewStateCnt++] = 124;
1723 break;
1724 case 126:
1725 if (curChar == 111)
1726 jjstateSet[jjnewStateCnt++] = 125;
1727 break;
1728 case 129:
1729 if (curChar == 100)
1730 jjstateSet[jjnewStateCnt++] = 128;
1731 break;
1732 case 130:
1733 if (curChar == 105)
1734 jjstateSet[jjnewStateCnt++] = 129;
1735 break;
1736 case 131:
1737 if (curChar == 111)
1738 jjstateSet[jjnewStateCnt++] = 130;
1739 break;
1740 case 134:
1741 if (curChar == 121)
1742 jjstateSet[jjnewStateCnt++] = 133;
1743 break;
1744 case 135:
1745 if (curChar == 101)
1746 jjstateSet[jjnewStateCnt++] = 134;
1747 break;
1748 case 136:
1749 if (curChar == 75)
1750 jjstateSet[jjnewStateCnt++] = 135;
1751 break;
1752 case 137:
1753 if (curChar == 120)
1754 jjstateSet[jjnewStateCnt++] = 136;
1755 break;
1756 case 138:
1757 if (curChar == 97)
1758 jjstateSet[jjnewStateCnt++] = 137;
1759 break;
1760 case 139:
1761 if (curChar == 109)
1762 jjstateSet[jjnewStateCnt++] = 138;
1763 break;
1764 case 142:
1765 if (curChar == 121)
1766 jjstateSet[jjnewStateCnt++] = 141;
1767 break;
1768 case 143:
1769 if (curChar == 101)
1770 jjstateSet[jjnewStateCnt++] = 142;
1771 break;
1772 case 144:
1773 if (curChar == 75)
1774 jjstateSet[jjnewStateCnt++] = 143;
1775 break;
1776 case 145:
1777 if (curChar == 110)
1778 jjstateSet[jjnewStateCnt++] = 144;
1779 break;
1780 case 146:
1781 if (curChar == 105)
1782 jjstateSet[jjnewStateCnt++] = 145;
1783 break;
1784 case 147:
1785 if (curChar == 109)
1786 jjstateSet[jjnewStateCnt++] = 146;
1787 break;
1788 case 151:
1789 if (curChar == 121)
1790 jjstateSet[jjnewStateCnt++] = 150;
1791 break;
1792 case 152:
1793 if (curChar == 114)
1794 jjstateSet[jjnewStateCnt++] = 151;
1795 break;
1796 case 153:
1797 if (curChar == 97)
1798 jjstateSet[jjnewStateCnt++] = 152;
1799 break;
1800 case 154:
1801 if (curChar == 110)
1802 jjstateSet[jjnewStateCnt++] = 153;
1803 break;
1804 case 155:
1805 if (curChar == 105)
1806 jjstateSet[jjnewStateCnt++] = 154;
1807 break;
1808 case 156:
1809 if (curChar == 98)
1810 jjstateSet[jjnewStateCnt++] = 155;
1811 break;
1812 case 159:
1813 if (curChar == 101)
1814 jjstateSet[jjnewStateCnt++] = 158;
1815 break;
1816 case 160:
1817 if (curChar == 112)
1818 jjstateSet[jjnewStateCnt++] = 159;
1819 break;
1820 case 161:
1821 if (curChar == 121)
1822 jjstateSet[jjnewStateCnt++] = 160;
1823 break;
1824 case 162:
1825 if (curChar == 116)
1826 jjstateSet[jjnewStateCnt++] = 161;
1827 break;
1828 case 165:
1829 if (curChar == 101)
1830 jjstateSet[jjnewStateCnt++] = 164;
1831 break;
1832 case 166:
1833 if (curChar == 116)
1834 jjstateSet[jjnewStateCnt++] = 165;
1835 break;
1836 case 167:
1837 if (curChar == 97)
1838 jjstateSet[jjnewStateCnt++] = 166;
1839 break;
1840 case 168:
1841 if (curChar == 100)
1842 jjstateSet[jjnewStateCnt++] = 167;
1843 break;
1844 case 171:
1845 if (curChar == 112)
1846 jjstateSet[jjnewStateCnt++] = 170;
1847 break;
1848 case 172:
1849 if (curChar == 109)
1850 jjstateSet[jjnewStateCnt++] = 171;
1851 break;
1852 case 173:
1853 if (curChar == 97)
1854 jjstateSet[jjnewStateCnt++] = 172;
1855 break;
1856 case 174:
1857 if (curChar == 116)
1858 jjstateSet[jjnewStateCnt++] = 173;
1859 break;
1860 case 175:
1861 if (curChar == 115)
1862 jjstateSet[jjnewStateCnt++] = 174;
1863 break;
1864 case 176:
1865 if (curChar == 101)
1866 jjstateSet[jjnewStateCnt++] = 175;
1867 break;
1868 case 177:
1869 if (curChar == 109)
1870 jjstateSet[jjnewStateCnt++] = 176;
1871 break;
1872 case 178:
1873 if (curChar == 105)
1874 jjstateSet[jjnewStateCnt++] = 177;
1875 break;
1876 case 179:
1877 if (curChar == 116)
1878 jjstateSet[jjnewStateCnt++] = 178;
1879 break;
1880 case 182:
1881 if (curChar == 120)
1882 jjstateSet[jjnewStateCnt++] = 181;
1883 break;
1884 case 183:
1885 if (curChar == 101)
1886 jjstateSet[jjnewStateCnt++] = 182;
1887 break;
1888 case 184:
1889 if (curChar == 103)
1890 jjstateSet[jjnewStateCnt++] = 183;
1891 break;
1892 case 185:
1893 if (curChar == 101)
1894 jjstateSet[jjnewStateCnt++] = 184;
1895 break;
1896 case 186:
1897 if (curChar == 114)
1898 jjstateSet[jjnewStateCnt++] = 185;
1899 break;
1900 case 189:
1901 if (curChar == 115)
1902 jjstateSet[jjnewStateCnt++] = 188;
1903 break;
1904 case 190:
1905 if (curChar == 110)
1906 jjstateSet[jjnewStateCnt++] = 189;
1907 break;
1908 case 191:
1909 if (curChar == 111)
1910 jjstateSet[jjnewStateCnt++] = 190;
1911 break;
1912 case 192:
1913 if (curChar == 105)
1914 jjstateSet[jjnewStateCnt++] = 191;
1915 break;
1916 case 193:
1917 if (curChar == 116)
1918 jjstateSet[jjnewStateCnt++] = 192;
1919 break;
1920 case 194:
1921 if (curChar == 112)
1922 jjstateSet[jjnewStateCnt++] = 193;
1923 break;
1924 case 195:
1925 if (curChar == 111)
1926 jjstateSet[jjnewStateCnt++] = 194;
1927 break;
1928 case 198:
1929 if (curChar == 100)
1930 jjstateSet[jjnewStateCnt++] = 197;
1931 break;
1932 case 199:
1933 if (curChar == 105)
1934 jjstateSet[jjnewStateCnt++] = 198;
1935 break;
1936 case 200:
1937 if (curChar == 111)
1938 jjstateSet[jjnewStateCnt++] = 199;
1939 break;
1940 case 203:
1941 if (curChar == 121)
1942 jjstateSet[jjnewStateCnt++] = 202;
1943 break;
1944 case 204:
1945 if (curChar == 101)
1946 jjstateSet[jjnewStateCnt++] = 203;
1947 break;
1948 case 205:
1949 if (curChar == 75)
1950 jjstateSet[jjnewStateCnt++] = 204;
1951 break;
1952 case 206:
1953 if (curChar == 120)
1954 jjstateSet[jjnewStateCnt++] = 205;
1955 break;
1956 case 207:
1957 if (curChar == 97)
1958 jjstateSet[jjnewStateCnt++] = 206;
1959 break;
1960 case 208:
1961 if (curChar == 109)
1962 jjstateSet[jjnewStateCnt++] = 207;
1963 break;
1964 case 211:
1965 if (curChar == 121)
1966 jjstateSet[jjnewStateCnt++] = 210;
1967 break;
1968 case 212:
1969 if (curChar == 101)
1970 jjstateSet[jjnewStateCnt++] = 211;
1971 break;
1972 case 213:
1973 if (curChar == 75)
1974 jjstateSet[jjnewStateCnt++] = 212;
1975 break;
1976 case 214:
1977 if (curChar == 110)
1978 jjstateSet[jjnewStateCnt++] = 213;
1979 break;
1980 case 215:
1981 if (curChar == 105)
1982 jjstateSet[jjnewStateCnt++] = 214;
1983 break;
1984 case 216:
1985 if (curChar == 109)
1986 jjstateSet[jjnewStateCnt++] = 215;
1987 break;
1988 case 219:
1989 if (curChar == 121 && kind > 48)
1990 kind = 48;
1991 break;
1992 case 220:
1993 if (curChar == 114)
1994 jjstateSet[jjnewStateCnt++] = 219;
1995 break;
1996 case 221:
1997 if (curChar == 97)
1998 jjstateSet[jjnewStateCnt++] = 220;
1999 break;
2000 case 222:
2001 if (curChar == 110)
2002 jjstateSet[jjnewStateCnt++] = 221;
2003 break;
2004 case 223:
2005 if (curChar == 105)
2006 jjstateSet[jjnewStateCnt++] = 222;
2007 break;
2008 case 224:
2009 if (curChar == 98)
2010 jjstateSet[jjnewStateCnt++] = 223;
2011 break;
2012 case 225:
2013 if (curChar == 101 && kind > 49)
2014 kind = 49;
2015 break;
2016 case 226:
2017 if (curChar == 112)
2018 jjstateSet[jjnewStateCnt++] = 225;
2019 break;
2020 case 227:
2021 if (curChar == 121)
2022 jjstateSet[jjnewStateCnt++] = 226;
2023 break;
2024 case 228:
2025 if (curChar == 116)
2026 jjstateSet[jjnewStateCnt++] = 227;
2027 break;
2028 case 229:
2029 if (curChar == 101 && kind > 50)
2030 kind = 50;
2031 break;
2032 case 230:
2033 if (curChar == 116)
2034 jjstateSet[jjnewStateCnt++] = 229;
2035 break;
2036 case 231:
2037 if (curChar == 97)
2038 jjstateSet[jjnewStateCnt++] = 230;
2039 break;
2040 case 232:
2041 if (curChar == 100)
2042 jjstateSet[jjnewStateCnt++] = 231;
2043 break;
2044 case 233:
2045 if (curChar == 112 && kind > 51)
2046 kind = 51;
2047 break;
2048 case 234:
2049 if (curChar == 109)
2050 jjstateSet[jjnewStateCnt++] = 233;
2051 break;
2052 case 235:
2053 if (curChar == 97)
2054 jjstateSet[jjnewStateCnt++] = 234;
2055 break;
2056 case 236:
2057 if (curChar == 116)
2058 jjstateSet[jjnewStateCnt++] = 235;
2059 break;
2060 case 237:
2061 if (curChar == 115)
2062 jjstateSet[jjnewStateCnt++] = 236;
2063 break;
2064 case 238:
2065 if (curChar == 101)
2066 jjstateSet[jjnewStateCnt++] = 237;
2067 break;
2068 case 239:
2069 if (curChar == 109)
2070 jjstateSet[jjnewStateCnt++] = 238;
2071 break;
2072 case 240:
2073 if (curChar == 105)
2074 jjstateSet[jjnewStateCnt++] = 239;
2075 break;
2076 case 241:
2077 if (curChar == 116)
2078 jjstateSet[jjnewStateCnt++] = 240;
2079 break;
2080 case 242:
2081 if (curChar == 120 && kind > 52)
2082 kind = 52;
2083 break;
2084 case 243:
2085 if (curChar == 101)
2086 jjstateSet[jjnewStateCnt++] = 242;
2087 break;
2088 case 244:
2089 if (curChar == 103)
2090 jjstateSet[jjnewStateCnt++] = 243;
2091 break;
2092 case 245:
2093 if (curChar == 101)
2094 jjstateSet[jjnewStateCnt++] = 244;
2095 break;
2096 case 246:
2097 if (curChar == 114)
2098 jjstateSet[jjnewStateCnt++] = 245;
2099 break;
2100 case 247:
2101 if (curChar == 115 && kind > 53)
2102 kind = 53;
2103 break;
2104 case 248:
2105 if (curChar == 110)
2106 jjstateSet[jjnewStateCnt++] = 247;
2107 break;
2108 case 249:
2109 if (curChar == 111)
2110 jjstateSet[jjnewStateCnt++] = 248;
2111 break;
2112 case 250:
2113 if (curChar == 105)
2114 jjstateSet[jjnewStateCnt++] = 249;
2115 break;
2116 case 251:
2117 if (curChar == 116)
2118 jjstateSet[jjnewStateCnt++] = 250;
2119 break;
2120 case 252:
2121 if (curChar == 112)
2122 jjstateSet[jjnewStateCnt++] = 251;
2123 break;
2124 case 253:
2125 if (curChar == 111)
2126 jjstateSet[jjnewStateCnt++] = 252;
2127 break;
2128 case 254:
2129 if (curChar == 100 && kind > 54)
2130 kind = 54;
2131 break;
2132 case 255:
2133 if (curChar == 105)
2134 jjstateSet[jjnewStateCnt++] = 254;
2135 break;
2136 case 256:
2137 if (curChar == 111)
2138 jjstateSet[jjnewStateCnt++] = 255;
2139 break;
2140 case 257:
2141 if (curChar == 121 && kind > 55)
2142 kind = 55;
2143 break;
2144 case 258:
2145 if (curChar == 101)
2146 jjstateSet[jjnewStateCnt++] = 257;
2147 break;
2148 case 259:
2149 if (curChar == 75)
2150 jjstateSet[jjnewStateCnt++] = 258;
2151 break;
2152 case 260:
2153 if (curChar == 120)
2154 jjstateSet[jjnewStateCnt++] = 259;
2155 break;
2156 case 261:
2157 if (curChar == 97)
2158 jjstateSet[jjnewStateCnt++] = 260;
2159 break;
2160 case 262:
2161 if (curChar == 109)
2162 jjstateSet[jjnewStateCnt++] = 261;
2163 break;
2164 case 263:
2165 if (curChar == 121 && kind > 56)
2166 kind = 56;
2167 break;
2168 case 264:
2169 if (curChar == 101)
2170 jjstateSet[jjnewStateCnt++] = 263;
2171 break;
2172 case 265:
2173 if (curChar == 75)
2174 jjstateSet[jjnewStateCnt++] = 264;
2175 break;
2176 case 266:
2177 if (curChar == 110)
2178 jjstateSet[jjnewStateCnt++] = 265;
2179 break;
2180 case 267:
2181 if (curChar == 105)
2182 jjstateSet[jjnewStateCnt++] = 266;
2183 break;
2184 case 268:
2185 if (curChar == 109)
2186 jjstateSet[jjnewStateCnt++] = 267;
2187 break;
2188 case 269:
2189 if (curChar == 117)
2190 jjAddStates(56, 57);
2191 break;
2192 case 270:
2193 if ((0x7e0000007eL & l) != 0L)
2194 jjstateSet[jjnewStateCnt++] = 271;
2195 break;
2196 case 271:
2197 if ((0x7e0000007eL & l) != 0L)
2198 jjstateSet[jjnewStateCnt++] = 272;
2199 break;
2200 case 273:
2201 if ((0x7e0000007eL & l) != 0L)
2202 jjstateSet[jjnewStateCnt++] = 274;
2203 break;
2204 case 274:
2205 if ((0x7e0000007eL & l) != 0L)
2206 jjstateSet[jjnewStateCnt++] = 275;
2207 break;
2208 case 275:
2209 if ((0x7e0000007eL & l) != 0L)
2210 jjstateSet[jjnewStateCnt++] = 276;
2211 break;
2212 case 276:
2213 if ((0x7e0000007eL & l) != 0L && kind > 68)
2214 kind = 68;
2215 break;
2216 default : break;
2217 }
2218 } while(i != startsAt);
2219 }
2220 else
2221 {
2222 int hiByte = (int)(curChar >> 8);
2223 int i1 = hiByte >> 6;
2224 long l1 = 1L << (hiByte & 077);
2225 int i2 = (curChar & 0xff) >> 6;
2226 long l2 = 1L << (curChar & 077);
2227 do
2228 {
2229 switch(jjstateSet[--i])
2230 {
2231 case 0:
2232 if (jjCanMove_1(hiByte, i1, i2, l1, l2))
2233 {
2234 if (kind > 57)
2235 kind = 57;
2236 jjCheckNAddTwoStates(29, 30);
2237 }
2238 if (jjCanMove_3(hiByte, i1, i2, l1, l2))
2239 {
2240 if (kind > 63)
2241 kind = 63;
2242 }
2243 if (jjCanMove_4(hiByte, i1, i2, l1, l2))
2244 {
2245 if (kind > 64)
2246 kind = 64;
2247 }
2248 if (jjCanMove_5(hiByte, i1, i2, l1, l2))
2249 {
2250 if (kind > 65)
2251 kind = 65;
2252 }
2253 if (jjCanMove_6(hiByte, i1, i2, l1, l2))
2254 {
2255 if (kind > 66)
2256 kind = 66;
2257 }
2258 if (jjCanMove_7(hiByte, i1, i2, l1, l2))
2259 {
2260 if (kind > 67)
2261 kind = 67;
2262 }
2263 break;
2264 case 32:
2265 case 29:
2266 if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
2267 break;
2268 if (kind > 57)
2269 kind = 57;
2270 jjCheckNAddTwoStates(29, 30);
2271 break;
2272 case 277:
2273 if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
2274 break;
2275 if (kind > 57)
2276 kind = 57;
2277 jjCheckNAddTwoStates(29, 30);
2278 break;
2279 case 31:
2280 if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
2281 break;
2282 if (kind > 57)
2283 kind = 57;
2284 jjCheckNAddTwoStates(29, 30);
2285 break;
2286 case 1:
2287 case 3:
2288 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
2289 jjCheckNAddStates(43, 45);
2290 break;
2291 case 13:
2292 case 15:
2293 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
2294 jjCheckNAddStates(40, 42);
2295 break;
2296 case 28:
2297 if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
2298 break;
2299 if (kind > 57)
2300 kind = 57;
2301 jjCheckNAddTwoStates(29, 30);
2302 break;
2303 case 38:
2304 if (jjCanMove_3(hiByte, i1, i2, l1, l2) && kind > 63)
2305 kind = 63;
2306 break;
2307 case 39:
2308 if (jjCanMove_4(hiByte, i1, i2, l1, l2) && kind > 64)
2309 kind = 64;
2310 break;
2311 case 40:
2312 if (jjCanMove_5(hiByte, i1, i2, l1, l2) && kind > 65)
2313 kind = 65;
2314 break;
2315 case 41:
2316 if (jjCanMove_6(hiByte, i1, i2, l1, l2) && kind > 66)
2317 kind = 66;
2318 break;
2319 case 42:
2320 if (jjCanMove_7(hiByte, i1, i2, l1, l2) && kind > 67)
2321 kind = 67;
2322 break;
2323 case 45:
2324 if (jjCanMove_8(hiByte, i1, i2, l1, l2))
2325 jjAddStates(50, 52);
2326 break;
2327 case 50:
2328 if (jjCanMove_8(hiByte, i1, i2, l1, l2))
2329 jjCheckNAddTwoStates(50, 51);
2330 break;
2331 case 52:
2332 case 53:
2333 if (jjCanMove_8(hiByte, i1, i2, l1, l2))
2334 jjCheckNAddTwoStates(53, 51);
2335 break;
2336 default : break;
2337 }
2338 } while(i != startsAt);
2339 }
2340 if (kind != 0x7fffffff)
2341 {
2342 jjmatchedKind = kind;
2343 jjmatchedPos = curPos;
2344 kind = 0x7fffffff;
2345 }
2346 ++curPos;
2347 if ((i = jjnewStateCnt) == (startsAt = 277 - (jjnewStateCnt = startsAt)))
2348 return curPos;
2349 try { curChar = input_stream.readChar(); }
2350 catch(java.io.IOException e) { return curPos; }
2351 }
2352 }
2353 static final int[] jjnextStates = {
2354 57, 62, 68, 224, 228, 232, 241, 246, 253, 256, 262, 268, 157, 163, 169, 180,
2355 187, 196, 201, 209, 217, 88, 94, 100, 111, 118, 127, 132, 140, 148, 56, 59,
2356 61, 65, 67, 73, 75, 76, 44, 49, 13, 14, 16, 1, 2, 4, 60, 66,
2357 74, 77, 45, 46, 48, 51, 52, 54, 270, 273, 31, 35, 3, 5, 8, 15,
2358 17, 20, 63, 64, 71, 72,
2359 };
2360 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
2361 {
2362 switch(hiByte)
2363 {
2364 case 0:
2365 return ((jjbitVec2[i2] & l2) != 0L);
2366 case 32:
2367 return ((jjbitVec3[i2] & l2) != 0L);
2368 default :
2369 if ((jjbitVec0[i1] & l1) != 0L)
2370 return true;
2371 return false;
2372 }
2373 }
2374 private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2)
2375 {
2376 switch(hiByte)
2377 {
2378 case 0:
2379 return ((jjbitVec7[i2] & l2) != 0L);
2380 case 2:
2381 return ((jjbitVec8[i2] & l2) != 0L);
2382 case 3:
2383 return ((jjbitVec9[i2] & l2) != 0L);
2384 case 4:
2385 return ((jjbitVec10[i2] & l2) != 0L);
2386 case 5:
2387 return ((jjbitVec11[i2] & l2) != 0L);
2388 case 6:
2389 return ((jjbitVec12[i2] & l2) != 0L);
2390 case 7:
2391 return ((jjbitVec13[i2] & l2) != 0L);
2392 case 9:
2393 return ((jjbitVec14[i2] & l2) != 0L);
2394 case 10:
2395 return ((jjbitVec15[i2] & l2) != 0L);
2396 case 11:
2397 return ((jjbitVec16[i2] & l2) != 0L);
2398 case 12:
2399 return ((jjbitVec17[i2] & l2) != 0L);
2400 case 13:
2401 return ((jjbitVec18[i2] & l2) != 0L);
2402 case 14:
2403 return ((jjbitVec19[i2] & l2) != 0L);
2404 case 15:
2405 return ((jjbitVec20[i2] & l2) != 0L);
2406 case 16:
2407 return ((jjbitVec21[i2] & l2) != 0L);
2408 case 17:
2409 return ((jjbitVec22[i2] & l2) != 0L);
2410 case 18:
2411 return ((jjbitVec23[i2] & l2) != 0L);
2412 case 19:
2413 return ((jjbitVec24[i2] & l2) != 0L);
2414 case 20:
2415 return ((jjbitVec25[i2] & l2) != 0L);
2416 case 22:
2417 return ((jjbitVec26[i2] & l2) != 0L);
2418 case 23:
2419 return ((jjbitVec27[i2] & l2) != 0L);
2420 case 24:
2421 return ((jjbitVec28[i2] & l2) != 0L);
2422 case 30:
2423 return ((jjbitVec29[i2] & l2) != 0L);
2424 case 31:
2425 return ((jjbitVec30[i2] & l2) != 0L);
2426 case 32:
2427 return ((jjbitVec31[i2] & l2) != 0L);
2428 case 33:
2429 return ((jjbitVec32[i2] & l2) != 0L);
2430 case 48:
2431 return ((jjbitVec33[i2] & l2) != 0L);
2432 case 49:
2433 return ((jjbitVec34[i2] & l2) != 0L);
2434 case 77:
2435 return ((jjbitVec35[i2] & l2) != 0L);
2436 case 159:
2437 return ((jjbitVec36[i2] & l2) != 0L);
2438 case 164:
2439 return ((jjbitVec37[i2] & l2) != 0L);
2440 case 215:
2441 return ((jjbitVec38[i2] & l2) != 0L);
2442 case 250:
2443 return ((jjbitVec39[i2] & l2) != 0L);
2444 case 251:
2445 return ((jjbitVec40[i2] & l2) != 0L);
2446 case 253:
2447 return ((jjbitVec41[i2] & l2) != 0L);
2448 case 254:
2449 return ((jjbitVec42[i2] & l2) != 0L);
2450 case 255:
2451 return ((jjbitVec43[i2] & l2) != 0L);
2452 default :
2453 if ((jjbitVec5[i1] & l1) != 0L)
2454 if ((jjbitVec6[i2] & l2) == 0L)
2455 return false;
2456 else
2457 return true;
2458 if ((jjbitVec4[i1] & l1) != 0L)
2459 return true;
2460 return false;
2461 }
2462 }
2463 private static final boolean jjCanMove_2(int hiByte, int i1, int i2, long l1, long l2)
2464 {
2465 switch(hiByte)
2466 {
2467 case 0:
2468 return ((jjbitVec7[i2] & l2) != 0L);
2469 case 2:
2470 return ((jjbitVec8[i2] & l2) != 0L);
2471 case 3:
2472 return ((jjbitVec44[i2] & l2) != 0L);
2473 case 4:
2474 return ((jjbitVec45[i2] & l2) != 0L);
2475 case 5:
2476 return ((jjbitVec46[i2] & l2) != 0L);
2477 case 6:
2478 return ((jjbitVec47[i2] & l2) != 0L);
2479 case 7:
2480 return ((jjbitVec48[i2] & l2) != 0L);
2481 case 9:
2482 return ((jjbitVec49[i2] & l2) != 0L);
2483 case 10:
2484 return ((jjbitVec50[i2] & l2) != 0L);
2485 case 11:
2486 return ((jjbitVec51[i2] & l2) != 0L);
2487 case 12:
2488 return ((jjbitVec52[i2] & l2) != 0L);
2489 case 13:
2490 return ((jjbitVec53[i2] & l2) != 0L);
2491 case 14:
2492 return ((jjbitVec54[i2] & l2) != 0L);
2493 case 15:
2494 return ((jjbitVec55[i2] & l2) != 0L);
2495 case 16:
2496 return ((jjbitVec56[i2] & l2) != 0L);
2497 case 17:
2498 return ((jjbitVec22[i2] & l2) != 0L);
2499 case 18:
2500 return ((jjbitVec23[i2] & l2) != 0L);
2501 case 19:
2502 return ((jjbitVec57[i2] & l2) != 0L);
2503 case 20:
2504 return ((jjbitVec25[i2] & l2) != 0L);
2505 case 22:
2506 return ((jjbitVec26[i2] & l2) != 0L);
2507 case 23:
2508 return ((jjbitVec58[i2] & l2) != 0L);
2509 case 24:
2510 return ((jjbitVec59[i2] & l2) != 0L);
2511 case 25:
2512 return ((jjbitVec60[i2] & l2) != 0L);
2513 case 26:
2514 return ((jjbitVec61[i2] & l2) != 0L);
2515 case 29:
2516 return ((jjbitVec62[i2] & l2) != 0L);
2517 case 30:
2518 return ((jjbitVec29[i2] & l2) != 0L);
2519 case 31:
2520 return ((jjbitVec30[i2] & l2) != 0L);
2521 case 32:
2522 return ((jjbitVec63[i2] & l2) != 0L);
2523 case 33:
2524 return ((jjbitVec32[i2] & l2) != 0L);
2525 case 48:
2526 return ((jjbitVec64[i2] & l2) != 0L);
2527 case 49:
2528 return ((jjbitVec34[i2] & l2) != 0L);
2529 case 77:
2530 return ((jjbitVec35[i2] & l2) != 0L);
2531 case 159:
2532 return ((jjbitVec36[i2] & l2) != 0L);
2533 case 164:
2534 return ((jjbitVec37[i2] & l2) != 0L);
2535 case 168:
2536 return ((jjbitVec65[i2] & l2) != 0L);
2537 case 215:
2538 return ((jjbitVec38[i2] & l2) != 0L);
2539 case 250:
2540 return ((jjbitVec39[i2] & l2) != 0L);
2541 case 251:
2542 return ((jjbitVec66[i2] & l2) != 0L);
2543 case 253:
2544 return ((jjbitVec41[i2] & l2) != 0L);
2545 case 254:
2546 return ((jjbitVec67[i2] & l2) != 0L);
2547 case 255:
2548 return ((jjbitVec68[i2] & l2) != 0L);
2549 default :
2550 if ((jjbitVec5[i1] & l1) != 0L)
2551 if ((jjbitVec6[i2] & l2) == 0L)
2552 return false;
2553 else
2554 return true;
2555 if ((jjbitVec4[i1] & l1) != 0L)
2556 return true;
2557 return false;
2558 }
2559 }
2560 private static final boolean jjCanMove_3(int hiByte, int i1, int i2, long l1, long l2)
2561 {
2562 switch(hiByte)
2563 {
2564 case 3:
2565 return ((jjbitVec69[i2] & l2) != 0L);
2566 case 4:
2567 return ((jjbitVec70[i2] & l2) != 0L);
2568 case 5:
2569 return ((jjbitVec71[i2] & l2) != 0L);
2570 case 6:
2571 return ((jjbitVec72[i2] & l2) != 0L);
2572 case 7:
2573 return ((jjbitVec73[i2] & l2) != 0L);
2574 case 9:
2575 return ((jjbitVec74[i2] & l2) != 0L);
2576 case 10:
2577 return ((jjbitVec75[i2] & l2) != 0L);
2578 case 11:
2579 return ((jjbitVec76[i2] & l2) != 0L);
2580 case 12:
2581 return ((jjbitVec77[i2] & l2) != 0L);
2582 case 13:
2583 return ((jjbitVec78[i2] & l2) != 0L);
2584 case 14:
2585 return ((jjbitVec79[i2] & l2) != 0L);
2586 case 15:
2587 return ((jjbitVec80[i2] & l2) != 0L);
2588 case 16:
2589 return ((jjbitVec81[i2] & l2) != 0L);
2590 case 23:
2591 return ((jjbitVec82[i2] & l2) != 0L);
2592 case 24:
2593 return ((jjbitVec83[i2] & l2) != 0L);
2594 case 25:
2595 return ((jjbitVec60[i2] & l2) != 0L);
2596 case 26:
2597 return ((jjbitVec61[i2] & l2) != 0L);
2598 case 29:
2599 return ((jjbitVec62[i2] & l2) != 0L);
2600 case 32:
2601 return ((jjbitVec84[i2] & l2) != 0L);
2602 case 48:
2603 return ((jjbitVec85[i2] & l2) != 0L);
2604 case 168:
2605 return ((jjbitVec65[i2] & l2) != 0L);
2606 case 251:
2607 return ((jjbitVec86[i2] & l2) != 0L);
2608 case 254:
2609 return ((jjbitVec87[i2] & l2) != 0L);
2610 default :
2611 return false;
2612 }
2613 }
2614 private static final boolean jjCanMove_4(int hiByte, int i1, int i2, long l1, long l2)
2615 {
2616 switch(hiByte)
2617 {
2618 case 9:
2619 return ((jjbitVec88[i2] & l2) != 0L);
2620 case 10:
2621 return ((jjbitVec89[i2] & l2) != 0L);
2622 case 11:
2623 return ((jjbitVec90[i2] & l2) != 0L);
2624 case 12:
2625 return ((jjbitVec91[i2] & l2) != 0L);
2626 case 13:
2627 return ((jjbitVec92[i2] & l2) != 0L);
2628 case 15:
2629 return ((jjbitVec93[i2] & l2) != 0L);
2630 case 16:
2631 return ((jjbitVec94[i2] & l2) != 0L);
2632 case 23:
2633 return ((jjbitVec95[i2] & l2) != 0L);
2634 case 25:
2635 return ((jjbitVec60[i2] & l2) != 0L);
2636 case 26:
2637 return ((jjbitVec61[i2] & l2) != 0L);
2638 case 29:
2639 return ((jjbitVec62[i2] & l2) != 0L);
2640 case 168:
2641 return ((jjbitVec65[i2] & l2) != 0L);
2642 default :
2643 return false;
2644 }
2645 }
2646 private static final boolean jjCanMove_5(int hiByte, int i1, int i2, long l1, long l2)
2647 {
2648 switch(hiByte)
2649 {
2650 case 3:
2651 return ((jjbitVec69[i2] & l2) != 0L);
2652 case 4:
2653 return ((jjbitVec70[i2] & l2) != 0L);
2654 case 5:
2655 return ((jjbitVec71[i2] & l2) != 0L);
2656 case 6:
2657 return ((jjbitVec72[i2] & l2) != 0L);
2658 case 7:
2659 return ((jjbitVec73[i2] & l2) != 0L);
2660 case 9:
2661 return ((jjbitVec74[i2] & l2) != 0L);
2662 case 10:
2663 return ((jjbitVec96[i2] & l2) != 0L);
2664 case 11:
2665 return ((jjbitVec76[i2] & l2) != 0L);
2666 case 12:
2667 return ((jjbitVec77[i2] & l2) != 0L);
2668 case 13:
2669 return ((jjbitVec78[i2] & l2) != 0L);
2670 case 14:
2671 return ((jjbitVec79[i2] & l2) != 0L);
2672 case 15:
2673 return ((jjbitVec80[i2] & l2) != 0L);
2674 case 16:
2675 return ((jjbitVec81[i2] & l2) != 0L);
2676 case 23:
2677 return ((jjbitVec82[i2] & l2) != 0L);
2678 case 24:
2679 return ((jjbitVec83[i2] & l2) != 0L);
2680 case 32:
2681 return ((jjbitVec84[i2] & l2) != 0L);
2682 case 48:
2683 return ((jjbitVec85[i2] & l2) != 0L);
2684 case 251:
2685 return ((jjbitVec86[i2] & l2) != 0L);
2686 case 254:
2687 return ((jjbitVec87[i2] & l2) != 0L);
2688 default :
2689 return false;
2690 }
2691 }
2692 private static final boolean jjCanMove_6(int hiByte, int i1, int i2, long l1, long l2)
2693 {
2694 switch(hiByte)
2695 {
2696 case 6:
2697 return ((jjbitVec101[i2] & l2) != 0L);
2698 case 11:
2699 return ((jjbitVec102[i2] & l2) != 0L);
2700 case 13:
2701 return ((jjbitVec103[i2] & l2) != 0L);
2702 case 14:
2703 return ((jjbitVec104[i2] & l2) != 0L);
2704 case 15:
2705 return ((jjbitVec105[i2] & l2) != 0L);
2706 case 16:
2707 return ((jjbitVec106[i2] & l2) != 0L);
2708 case 19:
2709 return ((jjbitVec107[i2] & l2) != 0L);
2710 case 23:
2711 return ((jjbitVec108[i2] & l2) != 0L);
2712 default :
2713 if ((jjbitVec99[i1] & l1) != 0L)
2714 if ((jjbitVec100[i2] & l2) == 0L)
2715 return false;
2716 else
2717 return true;
2718 if ((jjbitVec97[i1] & l1) != 0L)
2719 if ((jjbitVec98[i2] & l2) == 0L)
2720 return false;
2721 else
2722 return true;
2723 return false;
2724 }
2725 }
2726 private static final boolean jjCanMove_7(int hiByte, int i1, int i2, long l1, long l2)
2727 {
2728 switch(hiByte)
2729 {
2730 case 32:
2731 return ((jjbitVec109[i2] & l2) != 0L);
2732 case 48:
2733 return ((jjbitVec110[i2] & l2) != 0L);
2734 case 254:
2735 return ((jjbitVec111[i2] & l2) != 0L);
2736 case 255:
2737 return ((jjbitVec112[i2] & l2) != 0L);
2738 default :
2739 return false;
2740 }
2741 }
2742 private static final boolean jjCanMove_8(int hiByte, int i1, int i2, long l1, long l2)
2743 {
2744 switch(hiByte)
2745 {
2746 case 0:
2747 return ((jjbitVec2[i2] & l2) != 0L);
2748 default :
2749 if ((jjbitVec25[i1] & l1) != 0L)
2750 return true;
2751 return false;
2752 }
2753 }
2754
2755
2756 public static final String[] jjstrLiteralImages = {
2757 null, null, null, null, null, null, null, null, null, null, null, null, null,
2758 null, null, null, null, null, null, null, null, null, null, null, null, null, null,
2759 null, null, null, null, null, null, null, null, null, null, null, null, null, null,
2760 null, null, null, null, null, null, null, null, null, null, null, null, null, null,
2761 null, null, null, null, null, null, null, null, null, null, null, null, null, null,
2762 null, null, };
2763
2764
2765 public static final String[] lexStateNames = {
2766 "DEFAULT",
2767 };
2768 static final long[] jjtoToken = {
2769 0x3ffffe0103fff01L, 0x7fL,
2770 };
2771 static final long[] jjtoSkip = {
2772 0xfeL, 0x0L,
2773 };
2774 static final long[] jjtoMore = {
2775 0x8000000000000000L, 0x0L,
2776 };
2777 protected JavaCharStream input_stream;
2778 private final int[] jjrounds = new int[277];
2779 private final int[] jjstateSet = new int[554];
2780 protected char curChar;
2781
2782 public JsonParserTokenManager(JavaCharStream stream){
2783 if (JavaCharStream.staticFlag)
2784 throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
2785 input_stream = stream;
2786 }
2787
2788
2789 public JsonParserTokenManager(JavaCharStream stream, int lexState){
2790 this(stream);
2791 SwitchTo(lexState);
2792 }
2793
2794
2795 public void ReInit(JavaCharStream stream)
2796 {
2797 jjmatchedPos = jjnewStateCnt = 0;
2798 curLexState = defaultLexState;
2799 input_stream = stream;
2800 ReInitRounds();
2801 }
2802 private void ReInitRounds()
2803 {
2804 int i;
2805 jjround = 0x80000001;
2806 for (i = 277; i-- > 0;)
2807 jjrounds[i] = 0x80000000;
2808 }
2809
2810
2811 public void ReInit(JavaCharStream stream, int lexState)
2812 {
2813 ReInit(stream);
2814 SwitchTo(lexState);
2815 }
2816
2817
2818 public void SwitchTo(int lexState)
2819 {
2820 if (lexState >= 1 || lexState < 0)
2821 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
2822 else
2823 curLexState = lexState;
2824 }
2825
2826 protected Token jjFillToken()
2827 {
2828 final Token t;
2829 final String curTokenImage;
2830 final int beginLine;
2831 final int endLine;
2832 final int beginColumn;
2833 final int endColumn;
2834 String im = jjstrLiteralImages[jjmatchedKind];
2835 curTokenImage = (im == null) ? input_stream.GetImage() : im;
2836 beginLine = input_stream.getBeginLine();
2837 beginColumn = input_stream.getBeginColumn();
2838 endLine = input_stream.getEndLine();
2839 endColumn = input_stream.getEndColumn();
2840 t = Token.newToken(jjmatchedKind, curTokenImage);
2841
2842 t.beginLine = beginLine;
2843 t.endLine = endLine;
2844 t.beginColumn = beginColumn;
2845 t.endColumn = endColumn;
2846
2847 return t;
2848 }
2849
2850 int curLexState = 0;
2851 int defaultLexState = 0;
2852 int jjnewStateCnt;
2853 int jjround;
2854 int jjmatchedPos;
2855 int jjmatchedKind;
2856
2857
2858 public Token getNextToken()
2859 {
2860 Token matchedToken;
2861 int curPos = 0;
2862
2863 EOFLoop :
2864 for (;;)
2865 {
2866 try
2867 {
2868 curChar = input_stream.BeginToken();
2869 }
2870 catch(java.io.IOException e)
2871 {
2872 jjmatchedKind = 0;
2873 matchedToken = jjFillToken();
2874 return matchedToken;
2875 }
2876
2877 for (;;)
2878 {
2879 try { input_stream.backup(0);
2880 while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L)
2881 curChar = input_stream.BeginToken();
2882 }
2883 catch (java.io.IOException e1) { continue EOFLoop; }
2884 jjmatchedKind = 0x7fffffff;
2885 jjmatchedPos = 0;
2886 curPos = jjMoveStringLiteralDfa0_0();
2887 if (jjmatchedKind != 0x7fffffff)
2888 {
2889 if (jjmatchedPos + 1 < curPos)
2890 input_stream.backup(curPos - jjmatchedPos - 1);
2891 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
2892 {
2893 matchedToken = jjFillToken();
2894 return matchedToken;
2895 }
2896 else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
2897 {
2898 continue EOFLoop;
2899 }
2900 curPos = 0;
2901 jjmatchedKind = 0x7fffffff;
2902 try {
2903 curChar = input_stream.readChar();
2904 continue;
2905 }
2906 catch (java.io.IOException e1) { }
2907 }
2908 int error_line = input_stream.getEndLine();
2909 int error_column = input_stream.getEndColumn();
2910 String error_after = null;
2911 boolean EOFSeen = false;
2912 try { input_stream.readChar(); input_stream.backup(1); }
2913 catch (java.io.IOException e1) {
2914 EOFSeen = true;
2915 error_after = curPos <= 1 ? "" : input_stream.GetImage();
2916 if (curChar == '\n' || curChar == '\r') {
2917 error_line++;
2918 error_column = 0;
2919 }
2920 else
2921 error_column++;
2922 }
2923 if (!EOFSeen) {
2924 input_stream.backup(1);
2925 error_after = curPos <= 1 ? "" : input_stream.GetImage();
2926 }
2927 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
2928 }
2929 }
2930 }
2931
2932 private void jjCheckNAdd(int state)
2933 {
2934 if (jjrounds[state] != jjround)
2935 {
2936 jjstateSet[jjnewStateCnt++] = state;
2937 jjrounds[state] = jjround;
2938 }
2939 }
2940 private void jjAddStates(int start, int end)
2941 {
2942 do {
2943 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
2944 } while (start++ != end);
2945 }
2946 private void jjCheckNAddTwoStates(int state1, int state2)
2947 {
2948 jjCheckNAdd(state1);
2949 jjCheckNAdd(state2);
2950 }
2951
2952 private void jjCheckNAddStates(int start, int end)
2953 {
2954 do {
2955 jjCheckNAdd(jjnextStates[start]);
2956 } while (start++ != end);
2957 }
2958
2959 }