1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.seasar.tuigwaa.cms.core.wiki.engine;
18 import java.util.List;
19 import java.util.ArrayList;
20 import org.apache.commons.logging.Log;
21 import org.apache.commons.logging.LogFactory;
22 import org.seasar.tuigwaa.cms.core.wiki.base.WikiHelper;
23
24 public class WikiParserTokenManager implements WikiParserConstants
25 {
26 private Log tokenLog = LogFactory.getLog(getClass());
27
28 private int nLexicalErrors_ = 0;
29
30 public int getNLexicalErrors(){
31 return nLexicalErrors_;
32 }
33 public java.io.PrintStream debugStream = System.out;
34 public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
35 private final int jjStopStringLiteralDfa_2(int pos, long active0, long active1)
36 {
37 switch (pos)
38 {
39 case 0:
40 if ((active0 & 0x1000L) != 0L || (active1 & 0x200L) != 0L)
41 return 71;
42 if ((active0 & 0x4003800000L) != 0L)
43 return 201;
44 if ((active0 & 0x400000000L) != 0L)
45 {
46 jjmatchedKind = 69;
47 return 15;
48 }
49 if ((active0 & 0x40000L) != 0L)
50 return 69;
51 if ((active0 & 0x4000L) != 0L)
52 return 65;
53 if ((active0 & 0xa00000000L) != 0L)
54 {
55 jjmatchedKind = 69;
56 return 202;
57 }
58 if ((active0 & 0x700000000200L) != 0L)
59 return 3;
60 return -1;
61 case 1:
62 if ((active0 & 0x4003000000L) != 0L)
63 return 201;
64 if ((active0 & 0xe00000000L) != 0L)
65 {
66 if (jjmatchedPos != 1)
67 {
68 jjmatchedKind = 69;
69 jjmatchedPos = 1;
70 }
71 return 202;
72 }
73 return -1;
74 case 2:
75 if ((active0 & 0x4002000000L) != 0L)
76 return 201;
77 if ((active0 & 0xe00000000L) != 0L)
78 {
79 if (jjmatchedPos != 2)
80 {
81 jjmatchedKind = 69;
82 jjmatchedPos = 2;
83 }
84 return 202;
85 }
86 return -1;
87 case 3:
88 if ((active0 & 0x4000000000L) != 0L)
89 return 201;
90 if ((active0 & 0xe00000000L) != 0L)
91 {
92 jjmatchedKind = 69;
93 jjmatchedPos = 3;
94 return 202;
95 }
96 return -1;
97 case 4:
98 if ((active0 & 0xc00000000L) != 0L)
99 {
100 jjmatchedKind = 69;
101 jjmatchedPos = 4;
102 return 202;
103 }
104 return -1;
105 case 5:
106 if ((active0 & 0x400000000L) != 0L)
107 {
108 jjmatchedKind = 69;
109 jjmatchedPos = 5;
110 return 202;
111 }
112 return -1;
113 default :
114 return -1;
115 }
116 }
117 private final int jjStartNfa_2(int pos, long active0, long active1)
118 {
119 return jjMoveNfa_2(jjStopStringLiteralDfa_2(pos, active0, active1), pos + 1);
120 }
121 private final int jjStopAtPos(int pos, int kind)
122 {
123 jjmatchedKind = kind;
124 jjmatchedPos = pos;
125 return pos + 1;
126 }
127 private final int jjStartNfaWithStates_2(int pos, int kind, int state)
128 {
129 jjmatchedKind = kind;
130 jjmatchedPos = pos;
131 try { curChar = input_stream.readChar(); }
132 catch(java.io.IOException e) { return pos + 1; }
133 return jjMoveNfa_2(state, pos + 1);
134 }
135 private final int jjMoveStringLiteralDfa0_2()
136 {
137 switch(curChar)
138 {
139 case 10:
140 jjmatchedKind = 9;
141 return jjMoveStringLiteralDfa1_2(0x700000000000L, 0x0L);
142 case 32:
143 return jjStopAtPos(0, 29);
144 case 37:
145 return jjMoveStringLiteralDfa1_2(0x800000000000000L, 0x0L);
146 case 40:
147 jjmatchedKind = 12;
148 return jjMoveStringLiteralDfa1_2(0x0L, 0x200L);
149 case 41:
150 jjmatchedKind = 13;
151 return jjMoveStringLiteralDfa1_2(0x0L, 0x400L);
152 case 42:
153 jjmatchedKind = 30;
154 return jjMoveStringLiteralDfa1_2(0x180000000L, 0x0L);
155 case 43:
156 jjmatchedKind = 26;
157 return jjMoveStringLiteralDfa1_2(0x18000000L, 0x0L);
158 case 44:
159 return jjStopAtPos(0, 49);
160 case 45:
161 jjmatchedKind = 23;
162 return jjMoveStringLiteralDfa1_2(0x4003000000L, 0x0L);
163 case 47:
164 return jjStartNfaWithStates_2(0, 18, 69);
165 case 58:
166 return jjStopAtPos(0, 48);
167 case 59:
168 return jjStopAtPos(0, 11);
169 case 60:
170 return jjStopAtPos(0, 19);
171 case 61:
172 return jjMoveStringLiteralDfa1_2(0x80000000000L, 0x0L);
173 case 62:
174 jjmatchedKind = 20;
175 return jjMoveStringLiteralDfa1_2(0x600000L, 0x0L);
176 case 67:
177 return jjMoveStringLiteralDfa1_2(0x400000000L, 0x0L);
178 case 76:
179 return jjMoveStringLiteralDfa1_2(0x200000000L, 0x0L);
180 case 82:
181 return jjMoveStringLiteralDfa1_2(0x800000000L, 0x0L);
182 case 91:
183 return jjStartNfaWithStates_2(0, 14, 65);
184 case 93:
185 return jjStopAtPos(0, 15);
186 case 123:
187 return jjStopAtPos(0, 16);
188 case 124:
189 return jjStopAtPos(0, 47);
190 case 125:
191 return jjStopAtPos(0, 17);
192 case 126:
193 return jjStopAtPos(0, 10);
194 default :
195 return jjMoveNfa_2(0, 0);
196 }
197 }
198 private final int jjMoveStringLiteralDfa1_2(long active0, long active1)
199 {
200 try { curChar = input_stream.readChar(); }
201 catch(java.io.IOException e) {
202 jjStopStringLiteralDfa_2(0, active0, active1);
203 return 1;
204 }
205 switch(curChar)
206 {
207 case 37:
208 if ((active0 & 0x800000000000000L) != 0L)
209 return jjStopAtPos(1, 59);
210 break;
211 case 40:
212 if ((active1 & 0x200L) != 0L)
213 return jjStopAtPos(1, 73);
214 break;
215 case 41:
216 if ((active1 & 0x400L) != 0L)
217 return jjStopAtPos(1, 74);
218 break;
219 case 42:
220 if ((active0 & 0x80000000L) != 0L)
221 {
222 jjmatchedKind = 31;
223 jjmatchedPos = 1;
224 }
225 return jjMoveStringLiteralDfa2_2(active0, 0x100000000L, active1, 0L);
226 case 43:
227 if ((active0 & 0x8000000L) != 0L)
228 {
229 jjmatchedKind = 27;
230 jjmatchedPos = 1;
231 }
232 return jjMoveStringLiteralDfa2_2(active0, 0x10000000L, active1, 0L);
233 case 44:
234 if ((active0 & 0x400000000000L) != 0L)
235 return jjStopAtPos(1, 46);
236 break;
237 case 45:
238 if ((active0 & 0x1000000L) != 0L)
239 {
240 jjmatchedKind = 24;
241 jjmatchedPos = 1;
242 }
243 return jjMoveStringLiteralDfa2_2(active0, 0x4002000000L, active1, 0L);
244 case 58:
245 if ((active0 & 0x200000000000L) != 0L)
246 return jjStopAtPos(1, 45);
247 break;
248 case 61:
249 if ((active0 & 0x80000000000L) != 0L)
250 return jjStopAtPos(1, 43);
251 break;
252 case 62:
253 if ((active0 & 0x200000L) != 0L)
254 {
255 jjmatchedKind = 21;
256 jjmatchedPos = 1;
257 }
258 return jjMoveStringLiteralDfa2_2(active0, 0x400000L, active1, 0L);
259 case 69:
260 return jjMoveStringLiteralDfa2_2(active0, 0x600000000L, active1, 0L);
261 case 73:
262 return jjMoveStringLiteralDfa2_2(active0, 0x800000000L, active1, 0L);
263 case 124:
264 if ((active0 & 0x100000000000L) != 0L)
265 return jjStopAtPos(1, 44);
266 break;
267 default :
268 break;
269 }
270 return jjStartNfa_2(0, active0, active1);
271 }
272 private final int jjMoveStringLiteralDfa2_2(long old0, long active0, long old1, long active1)
273 {
274 if (((active0 &= old0) | (active1 &= old1)) == 0L)
275 return jjStartNfa_2(0, old0, old1);
276 try { curChar = input_stream.readChar(); }
277 catch(java.io.IOException e) {
278 jjStopStringLiteralDfa_2(1, active0, 0L);
279 return 2;
280 }
281 switch(curChar)
282 {
283 case 42:
284 if ((active0 & 0x100000000L) != 0L)
285 return jjStopAtPos(2, 32);
286 break;
287 case 43:
288 if ((active0 & 0x10000000L) != 0L)
289 return jjStopAtPos(2, 28);
290 break;
291 case 45:
292 if ((active0 & 0x2000000L) != 0L)
293 {
294 jjmatchedKind = 25;
295 jjmatchedPos = 2;
296 }
297 return jjMoveStringLiteralDfa3_2(active0, 0x4000000000L);
298 case 62:
299 if ((active0 & 0x400000L) != 0L)
300 return jjStopAtPos(2, 22);
301 break;
302 case 70:
303 return jjMoveStringLiteralDfa3_2(active0, 0x200000000L);
304 case 71:
305 return jjMoveStringLiteralDfa3_2(active0, 0x800000000L);
306 case 78:
307 return jjMoveStringLiteralDfa3_2(active0, 0x400000000L);
308 default :
309 break;
310 }
311 return jjStartNfa_2(1, active0, 0L);
312 }
313 private final int jjMoveStringLiteralDfa3_2(long old0, long active0)
314 {
315 if (((active0 &= old0)) == 0L)
316 return jjStartNfa_2(1, old0, 0L);
317 try { curChar = input_stream.readChar(); }
318 catch(java.io.IOException e) {
319 jjStopStringLiteralDfa_2(2, active0, 0L);
320 return 3;
321 }
322 switch(curChar)
323 {
324 case 45:
325 if ((active0 & 0x4000000000L) != 0L)
326 return jjStartNfaWithStates_2(3, 38, 201);
327 break;
328 case 72:
329 return jjMoveStringLiteralDfa4_2(active0, 0x800000000L);
330 case 84:
331 return jjMoveStringLiteralDfa4_2(active0, 0x600000000L);
332 default :
333 break;
334 }
335 return jjStartNfa_2(2, active0, 0L);
336 }
337 private final int jjMoveStringLiteralDfa4_2(long old0, long active0)
338 {
339 if (((active0 &= old0)) == 0L)
340 return jjStartNfa_2(2, old0, 0L);
341 try { curChar = input_stream.readChar(); }
342 catch(java.io.IOException e) {
343 jjStopStringLiteralDfa_2(3, active0, 0L);
344 return 4;
345 }
346 switch(curChar)
347 {
348 case 58:
349 if ((active0 & 0x200000000L) != 0L)
350 return jjStopAtPos(4, 33);
351 break;
352 case 69:
353 return jjMoveStringLiteralDfa5_2(active0, 0x400000000L);
354 case 84:
355 return jjMoveStringLiteralDfa5_2(active0, 0x800000000L);
356 default :
357 break;
358 }
359 return jjStartNfa_2(3, active0, 0L);
360 }
361 private final int jjMoveStringLiteralDfa5_2(long old0, long active0)
362 {
363 if (((active0 &= old0)) == 0L)
364 return jjStartNfa_2(3, old0, 0L);
365 try { curChar = input_stream.readChar(); }
366 catch(java.io.IOException e) {
367 jjStopStringLiteralDfa_2(4, active0, 0L);
368 return 5;
369 }
370 switch(curChar)
371 {
372 case 58:
373 if ((active0 & 0x800000000L) != 0L)
374 return jjStopAtPos(5, 35);
375 break;
376 case 82:
377 return jjMoveStringLiteralDfa6_2(active0, 0x400000000L);
378 default :
379 break;
380 }
381 return jjStartNfa_2(4, active0, 0L);
382 }
383 private final int jjMoveStringLiteralDfa6_2(long old0, long active0)
384 {
385 if (((active0 &= old0)) == 0L)
386 return jjStartNfa_2(4, old0, 0L);
387 try { curChar = input_stream.readChar(); }
388 catch(java.io.IOException e) {
389 jjStopStringLiteralDfa_2(5, active0, 0L);
390 return 6;
391 }
392 switch(curChar)
393 {
394 case 58:
395 if ((active0 & 0x400000000L) != 0L)
396 return jjStopAtPos(6, 34);
397 break;
398 default :
399 break;
400 }
401 return jjStartNfa_2(5, active0, 0L);
402 }
403 private final void jjCheckNAdd(int state)
404 {
405 if (jjrounds[state] != jjround)
406 {
407 jjstateSet[jjnewStateCnt++] = state;
408 jjrounds[state] = jjround;
409 }
410 }
411 private final void jjAddStates(int start, int end)
412 {
413 do {
414 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
415 } while (start++ != end);
416 }
417 private final void jjCheckNAddTwoStates(int state1, int state2)
418 {
419 jjCheckNAdd(state1);
420 jjCheckNAdd(state2);
421 }
422 private final void jjCheckNAddStates(int start, int end)
423 {
424 do {
425 jjCheckNAdd(jjnextStates[start]);
426 } while (start++ != end);
427 }
428 private final void jjCheckNAddStates(int start)
429 {
430 jjCheckNAdd(jjnextStates[start]);
431 jjCheckNAdd(jjnextStates[start + 1]);
432 }
433 static final long[] jjbitVec0 = {
434 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
435 };
436 static final long[] jjbitVec2 = {
437 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
438 };
439 static final long[] jjbitVec3 = {
440 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffff007fffffL
441 };
442 static final long[] jjbitVec4 = {
443 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffL, 0x0L
444 };
445 private final int jjMoveNfa_2(int startState, int curPos)
446 {
447 int[] nextStates;
448 int startsAt = 0;
449 jjnewStateCnt = 201;
450 int i = 1;
451 jjstateSet[0] = startState;
452 int j, kind = 0x7fffffff;
453 for (;;)
454 {
455 if (++jjround == 0x7fffffff)
456 ReInitRounds();
457 if (curChar < 64)
458 {
459 long l = 1L << curChar;
460 MatchLoop: do
461 {
462 switch(jjstateSet[--i])
463 {
464 case 65:
465 if (curChar == 35)
466 jjstateSet[jjnewStateCnt++] = 66;
467 break;
468 case 202:
469 if ((0x83ffc00000000000L & l) != 0L)
470 {
471 if (kind > 69)
472 kind = 69;
473 jjCheckNAdd(69);
474 }
475 if ((0x3ff600000000000L & l) != 0L)
476 jjCheckNAddTwoStates(59, 60);
477 break;
478 case 0:
479 if ((0x83ffc00000000000L & l) != 0L)
480 {
481 if (kind > 69)
482 kind = 69;
483 jjCheckNAdd(69);
484 }
485 else if (curChar == 39)
486 jjCheckNAddStates(0, 2);
487 else if (curChar == 38)
488 jjCheckNAdd(75);
489 else if (curChar == 40)
490 jjstateSet[jjnewStateCnt++] = 71;
491 else if (curChar == 35)
492 jjCheckNAdd(5);
493 else if (curChar == 10)
494 jjstateSet[jjnewStateCnt++] = 3;
495 if ((0x3ff600000000000L & l) != 0L)
496 jjCheckNAddTwoStates(59, 60);
497 break;
498 case 15:
499 if ((0x83ffc00000000000L & l) != 0L)
500 {
501 if (kind > 69)
502 kind = 69;
503 jjCheckNAdd(69);
504 }
505 if ((0x3ff600000000000L & l) != 0L)
506 jjCheckNAddTwoStates(59, 60);
507 break;
508 case 201:
509 case 59:
510 if ((0x3ff600000000000L & l) != 0L)
511 jjCheckNAddTwoStates(59, 60);
512 break;
513 case 1:
514 if (curChar != 47)
515 break;
516 if (kind > 2)
517 kind = 2;
518 jjCheckNAdd(2);
519 break;
520 case 2:
521 if ((0xffffffffffffdbffL & l) == 0L)
522 break;
523 if (kind > 2)
524 kind = 2;
525 jjCheckNAdd(2);
526 break;
527 case 3:
528 if (curChar == 47)
529 jjstateSet[jjnewStateCnt++] = 1;
530 break;
531 case 4:
532 if (curChar == 35)
533 jjCheckNAdd(5);
534 break;
535 case 5:
536 if ((0x3ff000000000000L & l) == 0L)
537 break;
538 if (kind > 39)
539 kind = 39;
540 jjCheckNAdd(5);
541 break;
542 case 7:
543 if (curChar == 40)
544 jjAddStates(3, 4);
545 break;
546 case 9:
547 if (curChar == 41)
548 jjstateSet[jjnewStateCnt++] = 10;
549 break;
550 case 10:
551 if (curChar == 58 && kind > 40)
552 kind = 40;
553 break;
554 case 11:
555 if (curChar == 35)
556 jjCheckNAdd(12);
557 break;
558 case 12:
559 if ((0x3ff000000000000L & l) != 0L)
560 jjCheckNAddTwoStates(12, 9);
561 break;
562 case 18:
563 if (curChar == 40)
564 jjAddStates(5, 6);
565 break;
566 case 20:
567 if (curChar == 41)
568 jjstateSet[jjnewStateCnt++] = 21;
569 break;
570 case 21:
571 if (curChar == 58 && kind > 41)
572 kind = 41;
573 break;
574 case 22:
575 if (curChar == 35)
576 jjCheckNAdd(23);
577 break;
578 case 23:
579 if ((0x3ff000000000000L & l) != 0L)
580 jjCheckNAddTwoStates(23, 20);
581 break;
582 case 31:
583 if (curChar == 40)
584 jjCheckNAdd(32);
585 break;
586 case 32:
587 if ((0x3ff000000000000L & l) != 0L)
588 jjCheckNAddTwoStates(32, 33);
589 break;
590 case 33:
591 if (curChar == 41)
592 jjstateSet[jjnewStateCnt++] = 34;
593 break;
594 case 34:
595 if (curChar == 58 && kind > 42)
596 kind = 42;
597 break;
598 case 43:
599 if (curChar == 47)
600 jjCheckNAdd(44);
601 break;
602 case 44:
603 if ((0x3ff200000000000L & l) == 0L)
604 break;
605 if (kind > 62)
606 kind = 62;
607 jjCheckNAddStates(7, 10);
608 break;
609 case 45:
610 if (curChar == 46)
611 jjCheckNAdd(46);
612 break;
613 case 46:
614 if ((0x3ff200000000000L & l) == 0L)
615 break;
616 if (kind > 62)
617 kind = 62;
618 jjCheckNAddStates(11, 14);
619 break;
620 case 47:
621 if (curChar == 58)
622 jjCheckNAdd(48);
623 break;
624 case 48:
625 if ((0x3ff000000000000L & l) == 0L)
626 break;
627 if (kind > 62)
628 kind = 62;
629 jjCheckNAddTwoStates(48, 49);
630 break;
631 case 49:
632 if (curChar != 47)
633 break;
634 if (kind > 62)
635 kind = 62;
636 jjCheckNAddTwoStates(49, 50);
637 break;
638 case 50:
639 if ((0xa3ff686800000000L & l) == 0L)
640 break;
641 if (kind > 62)
642 kind = 62;
643 jjCheckNAddTwoStates(49, 50);
644 break;
645 case 51:
646 if (curChar == 47)
647 jjstateSet[jjnewStateCnt++] = 43;
648 break;
649 case 52:
650 if (curChar == 58)
651 jjstateSet[jjnewStateCnt++] = 51;
652 break;
653 case 61:
654 if ((0x3ff200000000000L & l) == 0L)
655 break;
656 if (kind > 62)
657 kind = 62;
658 jjCheckNAddTwoStates(61, 62);
659 break;
660 case 62:
661 if (curChar == 46)
662 jjCheckNAdd(63);
663 break;
664 case 63:
665 if ((0x3ff200000000000L & l) == 0L)
666 break;
667 if (kind > 62)
668 kind = 62;
669 jjCheckNAddTwoStates(62, 63);
670 break;
671 case 67:
672 if ((0x3ff000000000000L & l) != 0L)
673 jjAddStates(15, 16);
674 break;
675 case 69:
676 if ((0x83ffc00000000000L & l) == 0L)
677 break;
678 if (kind > 69)
679 kind = 69;
680 jjCheckNAdd(69);
681 break;
682 case 70:
683 if (curChar == 40)
684 jjstateSet[jjnewStateCnt++] = 71;
685 break;
686 case 71:
687 if ((0xa7fffedbffffdbffL & l) != 0L)
688 jjCheckNAddTwoStates(72, 73);
689 break;
690 case 72:
691 if ((0xa7ffffdbffffdbffL & l) != 0L)
692 jjCheckNAddTwoStates(72, 73);
693 break;
694 case 73:
695 if (curChar == 41 && kind > 70)
696 kind = 70;
697 break;
698 case 74:
699 if (curChar == 38)
700 jjCheckNAdd(75);
701 break;
702 case 75:
703 if ((0x3ff000000000000L & l) == 0L)
704 break;
705 if (kind > 71)
706 kind = 71;
707 jjCheckNAdd(75);
708 break;
709 case 82:
710 if (curChar == 39)
711 jjCheckNAddStates(0, 2);
712 break;
713 case 83:
714 if (curChar == 39 && kind > 60)
715 kind = 60;
716 break;
717 case 84:
718 case 85:
719 if (curChar == 39)
720 jjCheckNAdd(83);
721 break;
722 case 86:
723 if (curChar == 39)
724 jjstateSet[jjnewStateCnt++] = 85;
725 break;
726 case 87:
727 if (curChar == 39)
728 jjstateSet[jjnewStateCnt++] = 86;
729 break;
730 case 90:
731 if (curChar == 40)
732 jjCheckNAdd(91);
733 break;
734 case 91:
735 if ((0x3ff000000000000L & l) != 0L)
736 jjCheckNAddTwoStates(91, 92);
737 break;
738 case 92:
739 if (curChar == 41)
740 jjstateSet[jjnewStateCnt++] = 93;
741 break;
742 case 93:
743 if (curChar == 58 && kind > 36)
744 kind = 36;
745 break;
746 case 98:
747 if (curChar == 40)
748 jjCheckNAdd(99);
749 break;
750 case 99:
751 if ((0x3ff000000000000L & l) != 0L)
752 jjCheckNAddTwoStates(99, 100);
753 break;
754 case 100:
755 if (curChar == 41)
756 jjstateSet[jjnewStateCnt++] = 101;
757 break;
758 case 101:
759 if (curChar == 58 && kind > 37)
760 kind = 37;
761 break;
762 case 108:
763 if ((0xabffffb3ffffdbffL & l) != 0L)
764 jjCheckNAddStates(17, 19);
765 break;
766 case 109:
767 if (curChar == 35)
768 jjstateSet[jjnewStateCnt++] = 110;
769 break;
770 case 111:
771 if ((0x3ff000000000000L & l) != 0L)
772 jjCheckNAddTwoStates(111, 113);
773 break;
774 case 115:
775 if ((0xabffffb3ffffdbffL & l) != 0L)
776 jjAddStates(20, 21);
777 break;
778 case 116:
779 if (curChar == 58)
780 jjCheckNAddStates(22, 25);
781 break;
782 case 118:
783 if (curChar == 47)
784 jjCheckNAdd(119);
785 break;
786 case 119:
787 if ((0x3ff200000000000L & l) != 0L)
788 jjCheckNAddStates(26, 30);
789 break;
790 case 120:
791 if (curChar == 46)
792 jjCheckNAdd(121);
793 break;
794 case 121:
795 if ((0x3ff200000000000L & l) != 0L)
796 jjCheckNAddStates(31, 35);
797 break;
798 case 122:
799 if (curChar == 58)
800 jjCheckNAdd(123);
801 break;
802 case 123:
803 if ((0x3ff000000000000L & l) != 0L)
804 jjCheckNAddStates(36, 38);
805 break;
806 case 124:
807 if (curChar == 47)
808 jjCheckNAddStates(39, 41);
809 break;
810 case 125:
811 if ((0xa3ff686800000000L & l) != 0L)
812 jjCheckNAddStates(39, 41);
813 break;
814 case 128:
815 if (curChar == 47)
816 jjstateSet[jjnewStateCnt++] = 118;
817 break;
818 case 129:
819 if (curChar == 58)
820 jjstateSet[jjnewStateCnt++] = 128;
821 break;
822 case 136:
823 if ((0x3ff600000000000L & l) != 0L)
824 jjCheckNAddTwoStates(136, 137);
825 break;
826 case 138:
827 if ((0x3ff200000000000L & l) != 0L)
828 jjCheckNAddStates(42, 44);
829 break;
830 case 139:
831 if (curChar == 46)
832 jjCheckNAdd(140);
833 break;
834 case 140:
835 if ((0x3ff200000000000L & l) != 0L)
836 jjCheckNAddStates(45, 47);
837 break;
838 case 148:
839 if ((0xabffffb3ffffdbffL & l) != 0L)
840 jjAddStates(48, 49);
841 break;
842 case 149:
843 if (curChar == 58)
844 jjCheckNAdd(150);
845 break;
846 case 150:
847 if ((0xabffffb3ffffdbffL & l) != 0L)
848 jjCheckNAddStates(50, 52);
849 break;
850 case 151:
851 if (curChar == 35)
852 jjstateSet[jjnewStateCnt++] = 152;
853 break;
854 case 153:
855 if ((0x3ff000000000000L & l) != 0L)
856 jjCheckNAddTwoStates(153, 155);
857 break;
858 case 157:
859 if ((0xabffffb3ffffdbffL & l) != 0L)
860 jjAddStates(53, 54);
861 break;
862 case 158:
863 if (curChar == 62)
864 jjCheckNAddStates(55, 58);
865 break;
866 case 160:
867 if (curChar == 47)
868 jjCheckNAdd(161);
869 break;
870 case 161:
871 if ((0x3ff200000000000L & l) != 0L)
872 jjCheckNAddStates(59, 63);
873 break;
874 case 162:
875 if (curChar == 46)
876 jjCheckNAdd(163);
877 break;
878 case 163:
879 if ((0x3ff200000000000L & l) != 0L)
880 jjCheckNAddStates(64, 68);
881 break;
882 case 164:
883 if (curChar == 58)
884 jjCheckNAdd(165);
885 break;
886 case 165:
887 if ((0x3ff000000000000L & l) != 0L)
888 jjCheckNAddStates(69, 71);
889 break;
890 case 166:
891 if (curChar == 47)
892 jjCheckNAddStates(72, 74);
893 break;
894 case 167:
895 if ((0xa3ff686800000000L & l) != 0L)
896 jjCheckNAddStates(72, 74);
897 break;
898 case 170:
899 if (curChar == 47)
900 jjstateSet[jjnewStateCnt++] = 160;
901 break;
902 case 171:
903 if (curChar == 58)
904 jjstateSet[jjnewStateCnt++] = 170;
905 break;
906 case 178:
907 if ((0x3ff600000000000L & l) != 0L)
908 jjCheckNAddTwoStates(178, 179);
909 break;
910 case 180:
911 if ((0x3ff200000000000L & l) != 0L)
912 jjCheckNAddStates(75, 77);
913 break;
914 case 181:
915 if (curChar == 46)
916 jjCheckNAdd(182);
917 break;
918 case 182:
919 if ((0x3ff200000000000L & l) != 0L)
920 jjCheckNAddStates(78, 80);
921 break;
922 case 190:
923 if ((0xabffffb3ffffdbffL & l) != 0L)
924 jjAddStates(81, 82);
925 break;
926 case 191:
927 if (curChar == 62)
928 jjCheckNAddTwoStates(192, 198);
929 break;
930 case 192:
931 if ((0xabffffb3ffffdbffL & l) != 0L)
932 jjCheckNAddStates(83, 85);
933 break;
934 case 193:
935 if (curChar == 35)
936 jjstateSet[jjnewStateCnt++] = 194;
937 break;
938 case 195:
939 if ((0x3ff000000000000L & l) != 0L)
940 jjCheckNAddTwoStates(195, 197);
941 break;
942 case 198:
943 if (curChar == 35)
944 jjstateSet[jjnewStateCnt++] = 199;
945 break;
946 case 200:
947 if ((0x3ff000000000000L & l) != 0L)
948 jjCheckNAddTwoStates(200, 197);
949 break;
950 default : break;
951 }
952 } while(i != startsAt);
953 }
954 else if (curChar < 128)
955 {
956 long l = 1L << (curChar & 077);
957 MatchLoop: do
958 {
959 switch(jjstateSet[--i])
960 {
961 case 65:
962 if (curChar == 91)
963 jjCheckNAdd(190);
964 if (curChar == 91)
965 jjCheckNAdd(157);
966 if (curChar == 91)
967 jjCheckNAdd(148);
968 if (curChar == 91)
969 jjCheckNAdd(115);
970 if (curChar == 91)
971 jjCheckNAdd(108);
972 break;
973 case 202:
974 if ((0x7fffffec7fffffeL & l) != 0L)
975 {
976 if (kind > 69)
977 kind = 69;
978 jjCheckNAdd(69);
979 }
980 else if (curChar == 64)
981 jjCheckNAdd(61);
982 if ((0x7fffffe87fffffeL & l) != 0L)
983 jjCheckNAddTwoStates(59, 60);
984 if ((0x7fffffe00000000L & l) != 0L)
985 jjCheckNAddTwoStates(39, 40);
986 else if ((0x7fffffeL & l) != 0L)
987 jjCheckNAddTwoStates(38, 39);
988 break;
989 case 0:
990 if ((0x7fffffec7fffffeL & l) != 0L)
991 {
992 if (kind > 69)
993 kind = 69;
994 jjCheckNAdd(69);
995 }
996 else if (curChar == 91)
997 jjAddStates(86, 90);
998 if ((0x7fffffe87fffffeL & l) != 0L)
999 jjCheckNAddTwoStates(59, 60);
1000 else if (curChar == 91)
1001 jjstateSet[jjnewStateCnt++] = 65;
1002 if ((0x7fffffeL & l) != 0L)
1003 jjCheckNAddTwoStates(38, 39);
1004 else if (curChar == 104)
1005 jjAddStates(91, 92);
1006 else if (curChar == 110)
1007 jjstateSet[jjnewStateCnt++] = 57;
1008 else if (curChar == 102)
1009 jjstateSet[jjnewStateCnt++] = 53;
1010 if (curChar == 70)
1011 jjAddStates(93, 94);
1012 else if (curChar == 83)
1013 jjstateSet[jjnewStateCnt++] = 36;
1014 else if (curChar == 66)
1015 jjstateSet[jjnewStateCnt++] = 28;
1016 else if (curChar == 67)
1017 jjstateSet[jjnewStateCnt++] = 15;
1018 break;
1019 case 15:
1020 if ((0x7fffffec7fffffeL & l) != 0L)
1021 {
1022 if (kind > 69)
1023 kind = 69;
1024 jjCheckNAdd(69);
1025 }
1026 else if (curChar == 64)
1027 jjCheckNAdd(61);
1028 if ((0x7fffffe87fffffeL & l) != 0L)
1029 jjCheckNAddTwoStates(59, 60);
1030 if ((0x7fffffe00000000L & l) != 0L)
1031 jjCheckNAddTwoStates(39, 40);
1032 else if ((0x7fffffeL & l) != 0L)
1033 jjCheckNAddTwoStates(38, 39);
1034 if (curChar == 79)
1035 jjstateSet[jjnewStateCnt++] = 14;
1036 break;
1037 case 201:
1038 if ((0x7fffffe87fffffeL & l) != 0L)
1039 jjCheckNAddTwoStates(59, 60);
1040 else if (curChar == 64)
1041 jjCheckNAdd(61);
1042 break;
1043 case 2:
1044 if (kind > 2)
1045 kind = 2;
1046 jjstateSet[jjnewStateCnt++] = 2;
1047 break;
1048 case 5:
1049 if ((0x7fffffe87fffffeL & l) == 0L)
1050 break;
1051 if (kind > 39)
1052 kind = 39;
1053 jjstateSet[jjnewStateCnt++] = 5;
1054 break;
1055 case 6:
1056 if (curChar == 82)
1057 jjstateSet[jjnewStateCnt++] = 7;
1058 break;
1059 case 8:
1060 if ((0x7fffffe07fffffeL & l) != 0L)
1061 jjCheckNAddTwoStates(8, 9);
1062 break;
1063 case 12:
1064 if ((0x7e0000007eL & l) != 0L)
1065 jjCheckNAddTwoStates(12, 9);
1066 break;
1067 case 13:
1068 if (curChar == 79)
1069 jjstateSet[jjnewStateCnt++] = 6;
1070 break;
1071 case 14:
1072 if (curChar == 76)
1073 jjstateSet[jjnewStateCnt++] = 13;
1074 break;
1075 case 16:
1076 if (curChar == 67)
1077 jjstateSet[jjnewStateCnt++] = 15;
1078 break;
1079 case 17:
1080 if (curChar == 82)
1081 jjstateSet[jjnewStateCnt++] = 18;
1082 break;
1083 case 19:
1084 if ((0x7fffffe07fffffeL & l) != 0L)
1085 jjCheckNAddTwoStates(19, 20);
1086 break;
1087 case 23:
1088 if ((0x7e0000007eL & l) != 0L)
1089 jjCheckNAddTwoStates(23, 20);
1090 break;
1091 case 24:
1092 if (curChar == 79)
1093 jjstateSet[jjnewStateCnt++] = 17;
1094 break;
1095 case 25:
1096 if (curChar == 76)
1097 jjstateSet[jjnewStateCnt++] = 24;
1098 break;
1099 case 26:
1100 if (curChar == 79)
1101 jjstateSet[jjnewStateCnt++] = 25;
1102 break;
1103 case 27:
1104 if (curChar == 67)
1105 jjstateSet[jjnewStateCnt++] = 26;
1106 break;
1107 case 28:
1108 if (curChar == 71)
1109 jjstateSet[jjnewStateCnt++] = 27;
1110 break;
1111 case 29:
1112 if (curChar == 66)
1113 jjstateSet[jjnewStateCnt++] = 28;
1114 break;
1115 case 30:
1116 if (curChar == 69)
1117 jjstateSet[jjnewStateCnt++] = 31;
1118 break;
1119 case 35:
1120 if (curChar == 90)
1121 jjstateSet[jjnewStateCnt++] = 30;
1122 break;
1123 case 36:
1124 if (curChar == 73)
1125 jjstateSet[jjnewStateCnt++] = 35;
1126 break;
1127 case 37:
1128 if (curChar == 83)
1129 jjstateSet[jjnewStateCnt++] = 36;
1130 break;
1131 case 38:
1132 if ((0x7fffffeL & l) != 0L)
1133 jjCheckNAddTwoStates(38, 39);
1134 break;
1135 case 39:
1136 if ((0x7fffffe00000000L & l) != 0L)
1137 jjCheckNAddTwoStates(39, 40);
1138 break;
1139 case 40:
1140 if ((0x7fffffeL & l) != 0L)
1141 jjCheckNAddTwoStates(40, 41);
1142 break;
1143 case 41:
1144 if ((0x7fffffe00000000L & l) == 0L)
1145 break;
1146 if (kind > 61)
1147 kind = 61;
1148 jjCheckNAddTwoStates(40, 41);
1149 break;
1150 case 42:
1151 if (curChar == 112)
1152 jjCheckNAdd(52);
1153 break;
1154 case 44:
1155 if ((0x7fffffe07fffffeL & l) == 0L)
1156 break;
1157 if (kind > 62)
1158 kind = 62;
1159 jjCheckNAddStates(7, 10);
1160 break;
1161 case 46:
1162 if ((0x7fffffe07fffffeL & l) == 0L)
1163 break;
1164 if (kind > 62)
1165 kind = 62;
1166 jjCheckNAddStates(11, 14);
1167 break;
1168 case 50:
1169 if ((0x47fffffe87fffffeL & l) == 0L)
1170 break;
1171 if (kind > 62)
1172 kind = 62;
1173 jjCheckNAddTwoStates(49, 50);
1174 break;
1175 case 53:
1176 case 77:
1177 if (curChar == 116)
1178 jjCheckNAdd(42);
1179 break;
1180 case 54:
1181 if (curChar == 102)
1182 jjstateSet[jjnewStateCnt++] = 53;
1183 break;
1184 case 55:
1185 if (curChar == 115)
1186 jjCheckNAdd(52);
1187 break;
1188 case 56:
1189 if (curChar == 119)
1190 jjCheckNAdd(55);
1191 break;
1192 case 57:
1193 if (curChar == 101)
1194 jjstateSet[jjnewStateCnt++] = 56;
1195 break;
1196 case 58:
1197 if (curChar == 110)
1198 jjstateSet[jjnewStateCnt++] = 57;
1199 break;
1200 case 59:
1201 if ((0x7fffffe87fffffeL & l) != 0L)
1202 jjCheckNAddTwoStates(59, 60);
1203 break;
1204 case 60:
1205 if (curChar == 64)
1206 jjCheckNAdd(61);
1207 break;
1208 case 61:
1209 if ((0x7fffffe07fffffeL & l) == 0L)
1210 break;
1211 if (kind > 62)
1212 kind = 62;
1213 jjCheckNAddTwoStates(61, 62);
1214 break;
1215 case 63:
1216 if ((0x7fffffe07fffffeL & l) == 0L)
1217 break;
1218 if (kind > 62)
1219 kind = 62;
1220 jjCheckNAddTwoStates(62, 63);
1221 break;
1222 case 64:
1223 if (curChar == 91)
1224 jjstateSet[jjnewStateCnt++] = 65;
1225 break;
1226 case 66:
1227 if ((0x7fffffe07fffffeL & l) != 0L)
1228 jjCheckNAdd(67);
1229 break;
1230 case 67:
1231 if ((0x7fffffe07fffffeL & l) != 0L)
1232 jjCheckNAddTwoStates(67, 68);
1233 break;
1234 case 68:
1235 if (curChar == 93 && kind > 63)
1236 kind = 63;
1237 break;
1238 case 69:
1239 if ((0x7fffffec7fffffeL & l) == 0L)
1240 break;
1241 if (kind > 69)
1242 kind = 69;
1243 jjCheckNAdd(69);
1244 break;
1245 case 71:
1246 case 72:
1247 if ((0xc7ffffffd7ffffffL & l) != 0L)
1248 jjCheckNAddTwoStates(72, 73);
1249 break;
1250 case 75:
1251 if ((0x7fffffe87fffffeL & l) == 0L)
1252 break;
1253 if (kind > 71)
1254 kind = 71;
1255 jjstateSet[jjnewStateCnt++] = 75;
1256 break;
1257 case 76:
1258 if (curChar == 104)
1259 jjAddStates(91, 92);
1260 break;
1261 case 78:
1262 if (curChar == 116)
1263 jjstateSet[jjnewStateCnt++] = 77;
1264 break;
1265 case 79:
1266 if (curChar == 112)
1267 jjCheckNAdd(55);
1268 break;
1269 case 80:
1270 if (curChar == 116)
1271 jjstateSet[jjnewStateCnt++] = 79;
1272 break;
1273 case 81:
1274 if (curChar == 116)
1275 jjstateSet[jjnewStateCnt++] = 80;
1276 break;
1277 case 88:
1278 if (curChar == 70)
1279 jjAddStates(93, 94);
1280 break;
1281 case 89:
1282 if (curChar == 84)
1283 jjAddStates(95, 96);
1284 break;
1285 case 94:
1286 if (curChar == 70)
1287 jjstateSet[jjnewStateCnt++] = 89;
1288 break;
1289 case 95:
1290 if (curChar == 69)
1291 jjstateSet[jjnewStateCnt++] = 94;
1292 break;
1293 case 96:
1294 if (curChar == 76)
1295 jjstateSet[jjnewStateCnt++] = 95;
1296 break;
1297 case 97:
1298 if (curChar == 84)
1299 jjAddStates(97, 98);
1300 break;
1301 case 102:
1302 if (curChar == 72)
1303 jjstateSet[jjnewStateCnt++] = 97;
1304 break;
1305 case 103:
1306 if (curChar == 71)
1307 jjstateSet[jjnewStateCnt++] = 102;
1308 break;
1309 case 104:
1310 if (curChar == 73)
1311 jjstateSet[jjnewStateCnt++] = 103;
1312 break;
1313 case 105:
1314 if (curChar == 82)
1315 jjstateSet[jjnewStateCnt++] = 104;
1316 break;
1317 case 106:
1318 if (curChar == 91)
1319 jjAddStates(86, 90);
1320 break;
1321 case 107:
1322 if (curChar == 91)
1323 jjCheckNAdd(108);
1324 break;
1325 case 108:
1326 if ((0xffffffffd7ffffffL & l) != 0L)
1327 jjCheckNAddStates(17, 19);
1328 break;
1329 case 110:
1330 if ((0x7fffffe07fffffeL & l) != 0L)
1331 jjCheckNAdd(111);
1332 break;
1333 case 111:
1334 if ((0x7fffffe07fffffeL & l) != 0L)
1335 jjCheckNAddTwoStates(111, 113);
1336 break;
1337 case 112:
1338 if (curChar == 93 && kind > 64)
1339 kind = 64;
1340 break;
1341 case 113:
1342 if (curChar == 93)
1343 jjstateSet[jjnewStateCnt++] = 112;
1344 break;
1345 case 114:
1346 if (curChar == 91)
1347 jjCheckNAdd(115);
1348 break;
1349 case 115:
1350 if ((0xffffffffd7ffffffL & l) != 0L)
1351 jjCheckNAddTwoStates(115, 116);
1352 break;
1353 case 117:
1354 if (curChar == 112)
1355 jjCheckNAdd(129);
1356 break;
1357 case 119:
1358 if ((0x7fffffe07fffffeL & l) != 0L)
1359 jjCheckNAddStates(26, 30);
1360 break;
1361 case 121:
1362 if ((0x7fffffe07fffffeL & l) != 0L)
1363 jjCheckNAddStates(31, 35);
1364 break;
1365 case 125:
1366 if ((0x47fffffe87fffffeL & l) != 0L)
1367 jjCheckNAddStates(39, 41);
1368 break;
1369 case 126:
1370 if (curChar == 93 && kind > 65)
1371 kind = 65;
1372 break;
1373 case 127:
1374 if (curChar == 93)
1375 jjstateSet[jjnewStateCnt++] = 126;
1376 break;
1377 case 130:
1378 case 142:
1379 if (curChar == 116)
1380 jjCheckNAdd(117);
1381 break;
1382 case 131:
1383 if (curChar == 102)
1384 jjstateSet[jjnewStateCnt++] = 130;
1385 break;
1386 case 132:
1387 if (curChar == 115)
1388 jjCheckNAdd(129);
1389 break;
1390 case 133:
1391 if (curChar == 119)
1392 jjCheckNAdd(132);
1393 break;
1394 case 134:
1395 if (curChar == 101)
1396 jjstateSet[jjnewStateCnt++] = 133;
1397 break;
1398 case 135:
1399 if (curChar == 110)
1400 jjstateSet[jjnewStateCnt++] = 134;
1401 break;
1402 case 136:
1403 if ((0x7fffffe87fffffeL & l) != 0L)
1404 jjAddStates(99, 100);
1405 break;
1406 case 137:
1407 if (curChar == 64)
1408 jjCheckNAdd(138);
1409 break;
1410 case 138:
1411 if ((0x7fffffe07fffffeL & l) != 0L)
1412 jjCheckNAddStates(42, 44);
1413 break;
1414 case 140:
1415 if ((0x7fffffe07fffffeL & l) != 0L)
1416 jjCheckNAddStates(45, 47);
1417 break;
1418 case 141:
1419 if (curChar == 104)
1420 jjAddStates(101, 102);
1421 break;
1422 case 143:
1423 if (curChar == 116)
1424 jjstateSet[jjnewStateCnt++] = 142;
1425 break;
1426 case 144:
1427 if (curChar == 112)
1428 jjCheckNAdd(132);
1429 break;
1430 case 145:
1431 if (curChar == 116)
1432 jjstateSet[jjnewStateCnt++] = 144;
1433 break;
1434 case 146:
1435 if (curChar == 116)
1436 jjstateSet[jjnewStateCnt++] = 145;
1437 break;
1438 case 147:
1439 if (curChar == 91)
1440 jjCheckNAdd(148);
1441 break;
1442 case 148:
1443 if ((0xffffffffd7ffffffL & l) != 0L)
1444 jjCheckNAddTwoStates(148, 149);
1445 break;
1446 case 150:
1447 if ((0xffffffffd7ffffffL & l) != 0L)
1448 jjCheckNAddStates(50, 52);
1449 break;
1450 case 152:
1451 if ((0x7fffffe07fffffeL & l) != 0L)
1452 jjCheckNAdd(153);
1453 break;
1454 case 153:
1455 if ((0x7fffffe07fffffeL & l) != 0L)
1456 jjCheckNAddTwoStates(153, 155);
1457 break;
1458 case 154:
1459 if (curChar == 93 && kind > 66)
1460 kind = 66;
1461 break;
1462 case 155:
1463 if (curChar == 93)
1464 jjstateSet[jjnewStateCnt++] = 154;
1465 break;
1466 case 156:
1467 if (curChar == 91)
1468 jjCheckNAdd(157);
1469 break;
1470 case 157:
1471 if ((0xffffffffd7ffffffL & l) != 0L)
1472 jjCheckNAddTwoStates(157, 158);
1473 break;
1474 case 159:
1475 if (curChar == 112)
1476 jjCheckNAdd(171);
1477 break;
1478 case 161:
1479 if ((0x7fffffe07fffffeL & l) != 0L)
1480 jjCheckNAddStates(59, 63);
1481 break;
1482 case 163:
1483 if ((0x7fffffe07fffffeL & l) != 0L)
1484 jjCheckNAddStates(64, 68);
1485 break;
1486 case 167:
1487 if ((0x47fffffe87fffffeL & l) != 0L)
1488 jjCheckNAddStates(72, 74);
1489 break;
1490 case 168:
1491 if (curChar == 93 && kind > 67)
1492 kind = 67;
1493 break;
1494 case 169:
1495 if (curChar == 93)
1496 jjstateSet[jjnewStateCnt++] = 168;
1497 break;
1498 case 172:
1499 case 184:
1500 if (curChar == 116)
1501 jjCheckNAdd(159);
1502 break;
1503 case 173:
1504 if (curChar == 102)
1505 jjstateSet[jjnewStateCnt++] = 172;
1506 break;
1507 case 174:
1508 if (curChar == 115)
1509 jjCheckNAdd(171);
1510 break;
1511 case 175:
1512 if (curChar == 119)
1513 jjCheckNAdd(174);
1514 break;
1515 case 176:
1516 if (curChar == 101)
1517 jjstateSet[jjnewStateCnt++] = 175;
1518 break;
1519 case 177:
1520 if (curChar == 110)
1521 jjstateSet[jjnewStateCnt++] = 176;
1522 break;
1523 case 178:
1524 if ((0x7fffffe87fffffeL & l) != 0L)
1525 jjAddStates(103, 104);
1526 break;
1527 case 179:
1528 if (curChar == 64)
1529 jjCheckNAdd(180);
1530 break;
1531 case 180:
1532 if ((0x7fffffe07fffffeL & l) != 0L)
1533 jjCheckNAddStates(75, 77);
1534 break;
1535 case 182:
1536 if ((0x7fffffe07fffffeL & l) != 0L)
1537 jjCheckNAddStates(78, 80);
1538 break;
1539 case 183:
1540 if (curChar == 104)
1541 jjAddStates(105, 106);
1542 break;
1543 case 185:
1544 if (curChar == 116)
1545 jjstateSet[jjnewStateCnt++] = 184;
1546 break;
1547 case 186:
1548 if (curChar == 112)
1549 jjCheckNAdd(174);
1550 break;
1551 case 187:
1552 if (curChar == 116)
1553 jjstateSet[jjnewStateCnt++] = 186;
1554 break;
1555 case 188:
1556 if (curChar == 116)
1557 jjstateSet[jjnewStateCnt++] = 187;
1558 break;
1559 case 189:
1560 if (curChar == 91)
1561 jjCheckNAdd(190);
1562 break;
1563 case 190:
1564 if ((0xffffffffd7ffffffL & l) != 0L)
1565 jjCheckNAddTwoStates(190, 191);
1566 break;
1567 case 192:
1568 if ((0xffffffffd7ffffffL & l) != 0L)
1569 jjCheckNAddStates(83, 85);
1570 break;
1571 case 194:
1572 if ((0x7fffffe07fffffeL & l) != 0L)
1573 jjCheckNAdd(195);
1574 break;
1575 case 195:
1576 if ((0x7fffffe07fffffeL & l) != 0L)
1577 jjCheckNAddTwoStates(195, 197);
1578 break;
1579 case 196:
1580 if (curChar == 93 && kind > 68)
1581 kind = 68;
1582 break;
1583 case 197:
1584 if (curChar == 93)
1585 jjstateSet[jjnewStateCnt++] = 196;
1586 break;
1587 case 199:
1588 if ((0x7fffffe07fffffeL & l) != 0L)
1589 jjCheckNAdd(200);
1590 break;
1591 case 200:
1592 if ((0x7fffffe07fffffeL & l) != 0L)
1593 jjCheckNAddTwoStates(200, 197);
1594 break;
1595 default : break;
1596 }
1597 } while(i != startsAt);
1598 }
1599 else
1600 {
1601 int hiByte = (int)(curChar >> 8);
1602 int i1 = hiByte >> 6;
1603 long l1 = 1L << (hiByte & 077);
1604 int i2 = (curChar & 0xff) >> 6;
1605 long l2 = 1L << (curChar & 077);
1606 MatchLoop: do
1607 {
1608 switch(jjstateSet[--i])
1609 {
1610 case 202:
1611 case 69:
1612 if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1613 break;
1614 if (kind > 69)
1615 kind = 69;
1616 jjCheckNAdd(69);
1617 break;
1618 case 0:
1619 if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1620 break;
1621 if (kind > 69)
1622 kind = 69;
1623 jjCheckNAdd(69);
1624 break;
1625 case 15:
1626 if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1627 break;
1628 if (kind > 69)
1629 kind = 69;
1630 jjCheckNAdd(69);
1631 break;
1632 case 2:
1633 if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1634 break;
1635 if (kind > 2)
1636 kind = 2;
1637 jjstateSet[jjnewStateCnt++] = 2;
1638 break;
1639 case 71:
1640 case 72:
1641 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1642 jjCheckNAddTwoStates(72, 73);
1643 break;
1644 case 108:
1645 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1646 jjAddStates(17, 19);
1647 break;
1648 case 115:
1649 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1650 jjAddStates(20, 21);
1651 break;
1652 case 148:
1653 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1654 jjAddStates(48, 49);
1655 break;
1656 case 150:
1657 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1658 jjAddStates(50, 52);
1659 break;
1660 case 157:
1661 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1662 jjAddStates(53, 54);
1663 break;
1664 case 190:
1665 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1666 jjAddStates(81, 82);
1667 break;
1668 case 192:
1669 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1670 jjAddStates(83, 85);
1671 break;
1672 default : break;
1673 }
1674 } while(i != startsAt);
1675 }
1676 if (kind != 0x7fffffff)
1677 {
1678 jjmatchedKind = kind;
1679 jjmatchedPos = curPos;
1680 kind = 0x7fffffff;
1681 }
1682 ++curPos;
1683 if ((i = jjnewStateCnt) == (startsAt = 201 - (jjnewStateCnt = startsAt)))
1684 return curPos;
1685 try { curChar = input_stream.readChar(); }
1686 catch(java.io.IOException e) { return curPos; }
1687 }
1688 }
1689 private final int jjStopStringLiteralDfa_1(int pos, long active0)
1690 {
1691 switch (pos)
1692 {
1693 case 0:
1694 if ((active0 & 0x1000L) != 0L)
1695 return 71;
1696 if ((active0 & 0x4003800000L) != 0L)
1697 return 201;
1698 if ((active0 & 0x400000000L) != 0L)
1699 {
1700 jjmatchedKind = 69;
1701 return 15;
1702 }
1703 if ((active0 & 0x40000L) != 0L)
1704 return 69;
1705 if ((active0 & 0x4000L) != 0L)
1706 return 65;
1707 if ((active0 & 0xa00000000L) != 0L)
1708 {
1709 jjmatchedKind = 69;
1710 return 202;
1711 }
1712 if ((active0 & 0x700000000200L) != 0L)
1713 return 3;
1714 return -1;
1715 case 1:
1716 if ((active0 & 0x4003000000L) != 0L)
1717 return 201;
1718 if ((active0 & 0xe00000000L) != 0L)
1719 {
1720 if (jjmatchedPos != 1)
1721 {
1722 jjmatchedKind = 69;
1723 jjmatchedPos = 1;
1724 }
1725 return 202;
1726 }
1727 return -1;
1728 case 2:
1729 if ((active0 & 0x4002000000L) != 0L)
1730 return 201;
1731 if ((active0 & 0xe00000000L) != 0L)
1732 {
1733 if (jjmatchedPos != 2)
1734 {
1735 jjmatchedKind = 69;
1736 jjmatchedPos = 2;
1737 }
1738 return 202;
1739 }
1740 return -1;
1741 case 3:
1742 if ((active0 & 0x4000000000L) != 0L)
1743 return 201;
1744 if ((active0 & 0xe00000000L) != 0L)
1745 {
1746 jjmatchedKind = 69;
1747 jjmatchedPos = 3;
1748 return 202;
1749 }
1750 return -1;
1751 case 4:
1752 if ((active0 & 0xc00000000L) != 0L)
1753 {
1754 jjmatchedKind = 69;
1755 jjmatchedPos = 4;
1756 return 202;
1757 }
1758 return -1;
1759 case 5:
1760 if ((active0 & 0x400000000L) != 0L)
1761 {
1762 jjmatchedKind = 69;
1763 jjmatchedPos = 5;
1764 return 202;
1765 }
1766 return -1;
1767 default :
1768 return -1;
1769 }
1770 }
1771 private final int jjStartNfa_1(int pos, long active0)
1772 {
1773 return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0), pos + 1);
1774 }
1775 private final int jjStartNfaWithStates_1(int pos, int kind, int state)
1776 {
1777 jjmatchedKind = kind;
1778 jjmatchedPos = pos;
1779 try { curChar = input_stream.readChar(); }
1780 catch(java.io.IOException e) { return pos + 1; }
1781 return jjMoveNfa_1(state, pos + 1);
1782 }
1783 private final int jjMoveStringLiteralDfa0_1()
1784 {
1785 switch(curChar)
1786 {
1787 case 10:
1788 jjmatchedKind = 9;
1789 return jjMoveStringLiteralDfa1_1(0x700000000000L);
1790 case 32:
1791 return jjStopAtPos(0, 29);
1792 case 37:
1793 return jjMoveStringLiteralDfa1_1(0x800000000000000L);
1794 case 40:
1795 return jjStartNfaWithStates_1(0, 12, 71);
1796 case 41:
1797 return jjStopAtPos(0, 13);
1798 case 42:
1799 jjmatchedKind = 30;
1800 return jjMoveStringLiteralDfa1_1(0x180000000L);
1801 case 43:
1802 jjmatchedKind = 26;
1803 return jjMoveStringLiteralDfa1_1(0x18000000L);
1804 case 45:
1805 jjmatchedKind = 23;
1806 return jjMoveStringLiteralDfa1_1(0x4003000000L);
1807 case 47:
1808 return jjStartNfaWithStates_1(0, 18, 69);
1809 case 59:
1810 return jjStopAtPos(0, 11);
1811 case 60:
1812 return jjStopAtPos(0, 19);
1813 case 61:
1814 return jjMoveStringLiteralDfa1_1(0x80000000000L);
1815 case 62:
1816 jjmatchedKind = 20;
1817 return jjMoveStringLiteralDfa1_1(0x8000000600000L);
1818 case 67:
1819 return jjMoveStringLiteralDfa1_1(0x400000000L);
1820 case 76:
1821 return jjMoveStringLiteralDfa1_1(0x200000000L);
1822 case 82:
1823 return jjMoveStringLiteralDfa1_1(0x800000000L);
1824 case 91:
1825 return jjStartNfaWithStates_1(0, 14, 65);
1826 case 93:
1827 return jjStopAtPos(0, 15);
1828 case 123:
1829 return jjStopAtPos(0, 16);
1830 case 124:
1831 return jjStopAtPos(0, 50);
1832 case 125:
1833 return jjStopAtPos(0, 17);
1834 case 126:
1835 jjmatchedKind = 10;
1836 return jjMoveStringLiteralDfa1_1(0x10000000000000L);
1837 default :
1838 return jjMoveNfa_1(0, 0);
1839 }
1840 }
1841 private final int jjMoveStringLiteralDfa1_1(long active0)
1842 {
1843 try { curChar = input_stream.readChar(); }
1844 catch(java.io.IOException e) {
1845 jjStopStringLiteralDfa_1(0, active0);
1846 return 1;
1847 }
1848 switch(curChar)
1849 {
1850 case 37:
1851 if ((active0 & 0x800000000000000L) != 0L)
1852 return jjStopAtPos(1, 59);
1853 break;
1854 case 42:
1855 if ((active0 & 0x80000000L) != 0L)
1856 {
1857 jjmatchedKind = 31;
1858 jjmatchedPos = 1;
1859 }
1860 return jjMoveStringLiteralDfa2_1(active0, 0x100000000L);
1861 case 43:
1862 if ((active0 & 0x8000000L) != 0L)
1863 {
1864 jjmatchedKind = 27;
1865 jjmatchedPos = 1;
1866 }
1867 return jjMoveStringLiteralDfa2_1(active0, 0x10000000L);
1868 case 44:
1869 if ((active0 & 0x400000000000L) != 0L)
1870 return jjStopAtPos(1, 46);
1871 break;
1872 case 45:
1873 if ((active0 & 0x1000000L) != 0L)
1874 {
1875 jjmatchedKind = 24;
1876 jjmatchedPos = 1;
1877 }
1878 return jjMoveStringLiteralDfa2_1(active0, 0x4002000000L);
1879 case 58:
1880 if ((active0 & 0x200000000000L) != 0L)
1881 return jjStopAtPos(1, 45);
1882 break;
1883 case 61:
1884 if ((active0 & 0x80000000000L) != 0L)
1885 return jjStopAtPos(1, 43);
1886 break;
1887 case 62:
1888 if ((active0 & 0x200000L) != 0L)
1889 {
1890 jjmatchedKind = 21;
1891 jjmatchedPos = 1;
1892 }
1893 return jjMoveStringLiteralDfa2_1(active0, 0x400000L);
1894 case 69:
1895 return jjMoveStringLiteralDfa2_1(active0, 0x600000000L);
1896 case 73:
1897 return jjMoveStringLiteralDfa2_1(active0, 0x800000000L);
1898 case 124:
1899 if ((active0 & 0x100000000000L) != 0L)
1900 return jjStopAtPos(1, 44);
1901 else if ((active0 & 0x8000000000000L) != 0L)
1902 return jjStopAtPos(1, 51);
1903 else if ((active0 & 0x10000000000000L) != 0L)
1904 return jjStopAtPos(1, 52);
1905 break;
1906 default :
1907 break;
1908 }
1909 return jjStartNfa_1(0, active0);
1910 }
1911 private final int jjMoveStringLiteralDfa2_1(long old0, long active0)
1912 {
1913 if (((active0 &= old0)) == 0L)
1914 return jjStartNfa_1(0, old0);
1915 try { curChar = input_stream.readChar(); }
1916 catch(java.io.IOException e) {
1917 jjStopStringLiteralDfa_1(1, active0);
1918 return 2;
1919 }
1920 switch(curChar)
1921 {
1922 case 42:
1923 if ((active0 & 0x100000000L) != 0L)
1924 return jjStopAtPos(2, 32);
1925 break;
1926 case 43:
1927 if ((active0 & 0x10000000L) != 0L)
1928 return jjStopAtPos(2, 28);
1929 break;
1930 case 45:
1931 if ((active0 & 0x2000000L) != 0L)
1932 {
1933 jjmatchedKind = 25;
1934 jjmatchedPos = 2;
1935 }
1936 return jjMoveStringLiteralDfa3_1(active0, 0x4000000000L);
1937 case 62:
1938 if ((active0 & 0x400000L) != 0L)
1939 return jjStopAtPos(2, 22);
1940 break;
1941 case 70:
1942 return jjMoveStringLiteralDfa3_1(active0, 0x200000000L);
1943 case 71:
1944 return jjMoveStringLiteralDfa3_1(active0, 0x800000000L);
1945 case 78:
1946 return jjMoveStringLiteralDfa3_1(active0, 0x400000000L);
1947 default :
1948 break;
1949 }
1950 return jjStartNfa_1(1, active0);
1951 }
1952 private final int jjMoveStringLiteralDfa3_1(long old0, long active0)
1953 {
1954 if (((active0 &= old0)) == 0L)
1955 return jjStartNfa_1(1, old0);
1956 try { curChar = input_stream.readChar(); }
1957 catch(java.io.IOException e) {
1958 jjStopStringLiteralDfa_1(2, active0);
1959 return 3;
1960 }
1961 switch(curChar)
1962 {
1963 case 45:
1964 if ((active0 & 0x4000000000L) != 0L)
1965 return jjStartNfaWithStates_1(3, 38, 201);
1966 break;
1967 case 72:
1968 return jjMoveStringLiteralDfa4_1(active0, 0x800000000L);
1969 case 84:
1970 return jjMoveStringLiteralDfa4_1(active0, 0x600000000L);
1971 default :
1972 break;
1973 }
1974 return jjStartNfa_1(2, active0);
1975 }
1976 private final int jjMoveStringLiteralDfa4_1(long old0, long active0)
1977 {
1978 if (((active0 &= old0)) == 0L)
1979 return jjStartNfa_1(2, old0);
1980 try { curChar = input_stream.readChar(); }
1981 catch(java.io.IOException e) {
1982 jjStopStringLiteralDfa_1(3, active0);
1983 return 4;
1984 }
1985 switch(curChar)
1986 {
1987 case 58:
1988 if ((active0 & 0x200000000L) != 0L)
1989 return jjStopAtPos(4, 33);
1990 break;
1991 case 69:
1992 return jjMoveStringLiteralDfa5_1(active0, 0x400000000L);
1993 case 84:
1994 return jjMoveStringLiteralDfa5_1(active0, 0x800000000L);
1995 default :
1996 break;
1997 }
1998 return jjStartNfa_1(3, active0);
1999 }
2000 private final int jjMoveStringLiteralDfa5_1(long old0, long active0)
2001 {
2002 if (((active0 &= old0)) == 0L)
2003 return jjStartNfa_1(3, old0);
2004 try { curChar = input_stream.readChar(); }
2005 catch(java.io.IOException e) {
2006 jjStopStringLiteralDfa_1(4, active0);
2007 return 5;
2008 }
2009 switch(curChar)
2010 {
2011 case 58:
2012 if ((active0 & 0x800000000L) != 0L)
2013 return jjStopAtPos(5, 35);
2014 break;
2015 case 82:
2016 return jjMoveStringLiteralDfa6_1(active0, 0x400000000L);
2017 default :
2018 break;
2019 }
2020 return jjStartNfa_1(4, active0);
2021 }
2022 private final int jjMoveStringLiteralDfa6_1(long old0, long active0)
2023 {
2024 if (((active0 &= old0)) == 0L)
2025 return jjStartNfa_1(4, old0);
2026 try { curChar = input_stream.readChar(); }
2027 catch(java.io.IOException e) {
2028 jjStopStringLiteralDfa_1(5, active0);
2029 return 6;
2030 }
2031 switch(curChar)
2032 {
2033 case 58:
2034 if ((active0 & 0x400000000L) != 0L)
2035 return jjStopAtPos(6, 34);
2036 break;
2037 default :
2038 break;
2039 }
2040 return jjStartNfa_1(5, active0);
2041 }
2042 private final int jjMoveNfa_1(int startState, int curPos)
2043 {
2044 int[] nextStates;
2045 int startsAt = 0;
2046 jjnewStateCnt = 201;
2047 int i = 1;
2048 jjstateSet[0] = startState;
2049 int j, kind = 0x7fffffff;
2050 for (;;)
2051 {
2052 if (++jjround == 0x7fffffff)
2053 ReInitRounds();
2054 if (curChar < 64)
2055 {
2056 long l = 1L << curChar;
2057 MatchLoop: do
2058 {
2059 switch(jjstateSet[--i])
2060 {
2061 case 65:
2062 if (curChar == 35)
2063 jjstateSet[jjnewStateCnt++] = 66;
2064 break;
2065 case 202:
2066 if ((0x83ffc00000000000L & l) != 0L)
2067 {
2068 if (kind > 69)
2069 kind = 69;
2070 jjCheckNAdd(69);
2071 }
2072 if ((0x3ff600000000000L & l) != 0L)
2073 jjCheckNAddTwoStates(59, 60);
2074 break;
2075 case 0:
2076 if ((0x83ffc00000000000L & l) != 0L)
2077 {
2078 if (kind > 69)
2079 kind = 69;
2080 jjCheckNAdd(69);
2081 }
2082 else if (curChar == 39)
2083 jjCheckNAddStates(0, 2);
2084 else if (curChar == 38)
2085 jjCheckNAdd(75);
2086 else if (curChar == 40)
2087 jjstateSet[jjnewStateCnt++] = 71;
2088 else if (curChar == 35)
2089 jjCheckNAdd(5);
2090 else if (curChar == 10)
2091 jjstateSet[jjnewStateCnt++] = 3;
2092 if ((0x3ff600000000000L & l) != 0L)
2093 jjCheckNAddTwoStates(59, 60);
2094 break;
2095 case 15:
2096 if ((0x83ffc00000000000L & l) != 0L)
2097 {
2098 if (kind > 69)
2099 kind = 69;
2100 jjCheckNAdd(69);
2101 }
2102 if ((0x3ff600000000000L & l) != 0L)
2103 jjCheckNAddTwoStates(59, 60);
2104 break;
2105 case 201:
2106 case 59:
2107 if ((0x3ff600000000000L & l) != 0L)
2108 jjCheckNAddTwoStates(59, 60);
2109 break;
2110 case 1:
2111 if (curChar != 47)
2112 break;
2113 if (kind > 2)
2114 kind = 2;
2115 jjCheckNAdd(2);
2116 break;
2117 case 2:
2118 if ((0xffffffffffffdbffL & l) == 0L)
2119 break;
2120 if (kind > 2)
2121 kind = 2;
2122 jjCheckNAdd(2);
2123 break;
2124 case 3:
2125 if (curChar == 47)
2126 jjstateSet[jjnewStateCnt++] = 1;
2127 break;
2128 case 4:
2129 if (curChar == 35)
2130 jjCheckNAdd(5);
2131 break;
2132 case 5:
2133 if ((0x3ff000000000000L & l) == 0L)
2134 break;
2135 if (kind > 39)
2136 kind = 39;
2137 jjCheckNAdd(5);
2138 break;
2139 case 7:
2140 if (curChar == 40)
2141 jjAddStates(3, 4);
2142 break;
2143 case 9:
2144 if (curChar == 41)
2145 jjstateSet[jjnewStateCnt++] = 10;
2146 break;
2147 case 10:
2148 if (curChar == 58 && kind > 40)
2149 kind = 40;
2150 break;
2151 case 11:
2152 if (curChar == 35)
2153 jjCheckNAdd(12);
2154 break;
2155 case 12:
2156 if ((0x3ff000000000000L & l) != 0L)
2157 jjCheckNAddTwoStates(12, 9);
2158 break;
2159 case 18:
2160 if (curChar == 40)
2161 jjAddStates(5, 6);
2162 break;
2163 case 20:
2164 if (curChar == 41)
2165 jjstateSet[jjnewStateCnt++] = 21;
2166 break;
2167 case 21:
2168 if (curChar == 58 && kind > 41)
2169 kind = 41;
2170 break;
2171 case 22:
2172 if (curChar == 35)
2173 jjCheckNAdd(23);
2174 break;
2175 case 23:
2176 if ((0x3ff000000000000L & l) != 0L)
2177 jjCheckNAddTwoStates(23, 20);
2178 break;
2179 case 31:
2180 if (curChar == 40)
2181 jjCheckNAdd(32);
2182 break;
2183 case 32:
2184 if ((0x3ff000000000000L & l) != 0L)
2185 jjCheckNAddTwoStates(32, 33);
2186 break;
2187 case 33:
2188 if (curChar == 41)
2189 jjstateSet[jjnewStateCnt++] = 34;
2190 break;
2191 case 34:
2192 if (curChar == 58 && kind > 42)
2193 kind = 42;
2194 break;
2195 case 43:
2196 if (curChar == 47)
2197 jjCheckNAdd(44);
2198 break;
2199 case 44:
2200 if ((0x3ff200000000000L & l) == 0L)
2201 break;
2202 if (kind > 62)
2203 kind = 62;
2204 jjCheckNAddStates(7, 10);
2205 break;
2206 case 45:
2207 if (curChar == 46)
2208 jjCheckNAdd(46);
2209 break;
2210 case 46:
2211 if ((0x3ff200000000000L & l) == 0L)
2212 break;
2213 if (kind > 62)
2214 kind = 62;
2215 jjCheckNAddStates(11, 14);
2216 break;
2217 case 47:
2218 if (curChar == 58)
2219 jjCheckNAdd(48);
2220 break;
2221 case 48:
2222 if ((0x3ff000000000000L & l) == 0L)
2223 break;
2224 if (kind > 62)
2225 kind = 62;
2226 jjCheckNAddTwoStates(48, 49);
2227 break;
2228 case 49:
2229 if (curChar != 47)
2230 break;
2231 if (kind > 62)
2232 kind = 62;
2233 jjCheckNAddTwoStates(49, 50);
2234 break;
2235 case 50:
2236 if ((0xa3ff686800000000L & l) == 0L)
2237 break;
2238 if (kind > 62)
2239 kind = 62;
2240 jjCheckNAddTwoStates(49, 50);
2241 break;
2242 case 51:
2243 if (curChar == 47)
2244 jjstateSet[jjnewStateCnt++] = 43;
2245 break;
2246 case 52:
2247 if (curChar == 58)
2248 jjstateSet[jjnewStateCnt++] = 51;
2249 break;
2250 case 61:
2251 if ((0x3ff200000000000L & l) == 0L)
2252 break;
2253 if (kind > 62)
2254 kind = 62;
2255 jjCheckNAddTwoStates(61, 62);
2256 break;
2257 case 62:
2258 if (curChar == 46)
2259 jjCheckNAdd(63);
2260 break;
2261 case 63:
2262 if ((0x3ff200000000000L & l) == 0L)
2263 break;
2264 if (kind > 62)
2265 kind = 62;
2266 jjCheckNAddTwoStates(62, 63);
2267 break;
2268 case 67:
2269 if ((0x3ff000000000000L & l) != 0L)
2270 jjAddStates(15, 16);
2271 break;
2272 case 69:
2273 if ((0x83ffc00000000000L & l) == 0L)
2274 break;
2275 if (kind > 69)
2276 kind = 69;
2277 jjCheckNAdd(69);
2278 break;
2279 case 70:
2280 if (curChar == 40)
2281 jjstateSet[jjnewStateCnt++] = 71;
2282 break;
2283 case 71:
2284 if ((0xa7fffedbffffdbffL & l) != 0L)
2285 jjCheckNAddTwoStates(72, 73);
2286 break;
2287 case 72:
2288 if ((0xa7ffffdbffffdbffL & l) != 0L)
2289 jjCheckNAddTwoStates(72, 73);
2290 break;
2291 case 73:
2292 if (curChar == 41 && kind > 70)
2293 kind = 70;
2294 break;
2295 case 74:
2296 if (curChar == 38)
2297 jjCheckNAdd(75);
2298 break;
2299 case 75:
2300 if ((0x3ff000000000000L & l) == 0L)
2301 break;
2302 if (kind > 71)
2303 kind = 71;
2304 jjCheckNAdd(75);
2305 break;
2306 case 82:
2307 if (curChar == 39)
2308 jjCheckNAddStates(0, 2);
2309 break;
2310 case 83:
2311 if (curChar == 39 && kind > 60)
2312 kind = 60;
2313 break;
2314 case 84:
2315 case 85:
2316 if (curChar == 39)
2317 jjCheckNAdd(83);
2318 break;
2319 case 86:
2320 if (curChar == 39)
2321 jjstateSet[jjnewStateCnt++] = 85;
2322 break;
2323 case 87:
2324 if (curChar == 39)
2325 jjstateSet[jjnewStateCnt++] = 86;
2326 break;
2327 case 90:
2328 if (curChar == 40)
2329 jjCheckNAdd(91);
2330 break;
2331 case 91:
2332 if ((0x3ff000000000000L & l) != 0L)
2333 jjCheckNAddTwoStates(91, 92);
2334 break;
2335 case 92:
2336 if (curChar == 41)
2337 jjstateSet[jjnewStateCnt++] = 93;
2338 break;
2339 case 93:
2340 if (curChar == 58 && kind > 36)
2341 kind = 36;
2342 break;
2343 case 98:
2344 if (curChar == 40)
2345 jjCheckNAdd(99);
2346 break;
2347 case 99:
2348 if ((0x3ff000000000000L & l) != 0L)
2349 jjCheckNAddTwoStates(99, 100);
2350 break;
2351 case 100:
2352 if (curChar == 41)
2353 jjstateSet[jjnewStateCnt++] = 101;
2354 break;
2355 case 101:
2356 if (curChar == 58 && kind > 37)
2357 kind = 37;
2358 break;
2359 case 108:
2360 if ((0xabffffb3ffffdbffL & l) != 0L)
2361 jjCheckNAddStates(17, 19);
2362 break;
2363 case 109:
2364 if (curChar == 35)
2365 jjstateSet[jjnewStateCnt++] = 110;
2366 break;
2367 case 111:
2368 if ((0x3ff000000000000L & l) != 0L)
2369 jjCheckNAddTwoStates(111, 113);
2370 break;
2371 case 115:
2372 if ((0xabffffb3ffffdbffL & l) != 0L)
2373 jjAddStates(20, 21);
2374 break;
2375 case 116:
2376 if (curChar == 58)
2377 jjCheckNAddStates(22, 25);
2378 break;
2379 case 118:
2380 if (curChar == 47)
2381 jjCheckNAdd(119);
2382 break;
2383 case 119:
2384 if ((0x3ff200000000000L & l) != 0L)
2385 jjCheckNAddStates(26, 30);
2386 break;
2387 case 120:
2388 if (curChar == 46)
2389 jjCheckNAdd(121);
2390 break;
2391 case 121:
2392 if ((0x3ff200000000000L & l) != 0L)
2393 jjCheckNAddStates(31, 35);
2394 break;
2395 case 122:
2396 if (curChar == 58)
2397 jjCheckNAdd(123);
2398 break;
2399 case 123:
2400 if ((0x3ff000000000000L & l) != 0L)
2401 jjCheckNAddStates(36, 38);
2402 break;
2403 case 124:
2404 if (curChar == 47)
2405 jjCheckNAddStates(39, 41);
2406 break;
2407 case 125:
2408 if ((0xa3ff686800000000L & l) != 0L)
2409 jjCheckNAddStates(39, 41);
2410 break;
2411 case 128:
2412 if (curChar == 47)
2413 jjstateSet[jjnewStateCnt++] = 118;
2414 break;
2415 case 129:
2416 if (curChar == 58)
2417 jjstateSet[jjnewStateCnt++] = 128;
2418 break;
2419 case 136:
2420 if ((0x3ff600000000000L & l) != 0L)
2421 jjCheckNAddTwoStates(136, 137);
2422 break;
2423 case 138:
2424 if ((0x3ff200000000000L & l) != 0L)
2425 jjCheckNAddStates(42, 44);
2426 break;
2427 case 139:
2428 if (curChar == 46)
2429 jjCheckNAdd(140);
2430 break;
2431 case 140:
2432 if ((0x3ff200000000000L & l) != 0L)
2433 jjCheckNAddStates(45, 47);
2434 break;
2435 case 148:
2436 if ((0xabffffb3ffffdbffL & l) != 0L)
2437 jjAddStates(48, 49);
2438 break;
2439 case 149:
2440 if (curChar == 58)
2441 jjCheckNAdd(150);
2442 break;
2443 case 150:
2444 if ((0xabffffb3ffffdbffL & l) != 0L)
2445 jjCheckNAddStates(50, 52);
2446 break;
2447 case 151:
2448 if (curChar == 35)
2449 jjstateSet[jjnewStateCnt++] = 152;
2450 break;
2451 case 153:
2452 if ((0x3ff000000000000L & l) != 0L)
2453 jjCheckNAddTwoStates(153, 155);
2454 break;
2455 case 157:
2456 if ((0xabffffb3ffffdbffL & l) != 0L)
2457 jjAddStates(53, 54);
2458 break;
2459 case 158:
2460 if (curChar == 62)
2461 jjCheckNAddStates(55, 58);
2462 break;
2463 case 160:
2464 if (curChar == 47)
2465 jjCheckNAdd(161);
2466 break;
2467 case 161:
2468 if ((0x3ff200000000000L & l) != 0L)
2469 jjCheckNAddStates(59, 63);
2470 break;
2471 case 162:
2472 if (curChar == 46)
2473 jjCheckNAdd(163);
2474 break;
2475 case 163:
2476 if ((0x3ff200000000000L & l) != 0L)
2477 jjCheckNAddStates(64, 68);
2478 break;
2479 case 164:
2480 if (curChar == 58)
2481 jjCheckNAdd(165);
2482 break;
2483 case 165:
2484 if ((0x3ff000000000000L & l) != 0L)
2485 jjCheckNAddStates(69, 71);
2486 break;
2487 case 166:
2488 if (curChar == 47)
2489 jjCheckNAddStates(72, 74);
2490 break;
2491 case 167:
2492 if ((0xa3ff686800000000L & l) != 0L)
2493 jjCheckNAddStates(72, 74);
2494 break;
2495 case 170:
2496 if (curChar == 47)
2497 jjstateSet[jjnewStateCnt++] = 160;
2498 break;
2499 case 171:
2500 if (curChar == 58)
2501 jjstateSet[jjnewStateCnt++] = 170;
2502 break;
2503 case 178:
2504 if ((0x3ff600000000000L & l) != 0L)
2505 jjCheckNAddTwoStates(178, 179);
2506 break;
2507 case 180:
2508 if ((0x3ff200000000000L & l) != 0L)
2509 jjCheckNAddStates(75, 77);
2510 break;
2511 case 181:
2512 if (curChar == 46)
2513 jjCheckNAdd(182);
2514 break;
2515 case 182:
2516 if ((0x3ff200000000000L & l) != 0L)
2517 jjCheckNAddStates(78, 80);
2518 break;
2519 case 190:
2520 if ((0xabffffb3ffffdbffL & l) != 0L)
2521 jjAddStates(81, 82);
2522 break;
2523 case 191:
2524 if (curChar == 62)
2525 jjCheckNAddTwoStates(192, 198);
2526 break;
2527 case 192:
2528 if ((0xabffffb3ffffdbffL & l) != 0L)
2529 jjCheckNAddStates(83, 85);
2530 break;
2531 case 193:
2532 if (curChar == 35)
2533 jjstateSet[jjnewStateCnt++] = 194;
2534 break;
2535 case 195:
2536 if ((0x3ff000000000000L & l) != 0L)
2537 jjCheckNAddTwoStates(195, 197);
2538 break;
2539 case 198:
2540 if (curChar == 35)
2541 jjstateSet[jjnewStateCnt++] = 199;
2542 break;
2543 case 200:
2544 if ((0x3ff000000000000L & l) != 0L)
2545 jjCheckNAddTwoStates(200, 197);
2546 break;
2547 default : break;
2548 }
2549 } while(i != startsAt);
2550 }
2551 else if (curChar < 128)
2552 {
2553 long l = 1L << (curChar & 077);
2554 MatchLoop: do
2555 {
2556 switch(jjstateSet[--i])
2557 {
2558 case 65:
2559 if (curChar == 91)
2560 jjCheckNAdd(190);
2561 if (curChar == 91)
2562 jjCheckNAdd(157);
2563 if (curChar == 91)
2564 jjCheckNAdd(148);
2565 if (curChar == 91)
2566 jjCheckNAdd(115);
2567 if (curChar == 91)
2568 jjCheckNAdd(108);
2569 break;
2570 case 202:
2571 if ((0x7fffffec7fffffeL & l) != 0L)
2572 {
2573 if (kind > 69)
2574 kind = 69;
2575 jjCheckNAdd(69);
2576 }
2577 else if (curChar == 64)
2578 jjCheckNAdd(61);
2579 if ((0x7fffffe87fffffeL & l) != 0L)
2580 jjCheckNAddTwoStates(59, 60);
2581 if ((0x7fffffe00000000L & l) != 0L)
2582 jjCheckNAddTwoStates(39, 40);
2583 else if ((0x7fffffeL & l) != 0L)
2584 jjCheckNAddTwoStates(38, 39);
2585 break;
2586 case 0:
2587 if ((0x7fffffec7fffffeL & l) != 0L)
2588 {
2589 if (kind > 69)
2590 kind = 69;
2591 jjCheckNAdd(69);
2592 }
2593 else if (curChar == 91)
2594 jjAddStates(86, 90);
2595 if ((0x7fffffe87fffffeL & l) != 0L)
2596 jjCheckNAddTwoStates(59, 60);
2597 else if (curChar == 91)
2598 jjstateSet[jjnewStateCnt++] = 65;
2599 if ((0x7fffffeL & l) != 0L)
2600 jjCheckNAddTwoStates(38, 39);
2601 else if (curChar == 104)
2602 jjAddStates(91, 92);
2603 else if (curChar == 110)
2604 jjstateSet[jjnewStateCnt++] = 57;
2605 else if (curChar == 102)
2606 jjstateSet[jjnewStateCnt++] = 53;
2607 if (curChar == 70)
2608 jjAddStates(93, 94);
2609 else if (curChar == 83)
2610 jjstateSet[jjnewStateCnt++] = 36;
2611 else if (curChar == 66)
2612 jjstateSet[jjnewStateCnt++] = 28;
2613 else if (curChar == 67)
2614 jjstateSet[jjnewStateCnt++] = 15;
2615 break;
2616 case 15:
2617 if ((0x7fffffec7fffffeL & l) != 0L)
2618 {
2619 if (kind > 69)
2620 kind = 69;
2621 jjCheckNAdd(69);
2622 }
2623 else if (curChar == 64)
2624 jjCheckNAdd(61);
2625 if ((0x7fffffe87fffffeL & l) != 0L)
2626 jjCheckNAddTwoStates(59, 60);
2627 if ((0x7fffffe00000000L & l) != 0L)
2628 jjCheckNAddTwoStates(39, 40);
2629 else if ((0x7fffffeL & l) != 0L)
2630 jjCheckNAddTwoStates(38, 39);
2631 if (curChar == 79)
2632 jjstateSet[jjnewStateCnt++] = 14;
2633 break;
2634 case 201:
2635 if ((0x7fffffe87fffffeL & l) != 0L)
2636 jjCheckNAddTwoStates(59, 60);
2637 else if (curChar == 64)
2638 jjCheckNAdd(61);
2639 break;
2640 case 2:
2641 if (kind > 2)
2642 kind = 2;
2643 jjstateSet[jjnewStateCnt++] = 2;
2644 break;
2645 case 5:
2646 if ((0x7fffffe87fffffeL & l) == 0L)
2647 break;
2648 if (kind > 39)
2649 kind = 39;
2650 jjstateSet[jjnewStateCnt++] = 5;
2651 break;
2652 case 6:
2653 if (curChar == 82)
2654 jjstateSet[jjnewStateCnt++] = 7;
2655 break;
2656 case 8:
2657 if ((0x7fffffe07fffffeL & l) != 0L)
2658 jjCheckNAddTwoStates(8, 9);
2659 break;
2660 case 12:
2661 if ((0x7e0000007eL & l) != 0L)
2662 jjCheckNAddTwoStates(12, 9);
2663 break;
2664 case 13:
2665 if (curChar == 79)
2666 jjstateSet[jjnewStateCnt++] = 6;
2667 break;
2668 case 14:
2669 if (curChar == 76)
2670 jjstateSet[jjnewStateCnt++] = 13;
2671 break;
2672 case 16:
2673 if (curChar == 67)
2674 jjstateSet[jjnewStateCnt++] = 15;
2675 break;
2676 case 17:
2677 if (curChar == 82)
2678 jjstateSet[jjnewStateCnt++] = 18;
2679 break;
2680 case 19:
2681 if ((0x7fffffe07fffffeL & l) != 0L)
2682 jjCheckNAddTwoStates(19, 20);
2683 break;
2684 case 23:
2685 if ((0x7e0000007eL & l) != 0L)
2686 jjCheckNAddTwoStates(23, 20);
2687 break;
2688 case 24:
2689 if (curChar == 79)
2690 jjstateSet[jjnewStateCnt++] = 17;
2691 break;
2692 case 25:
2693 if (curChar == 76)
2694 jjstateSet[jjnewStateCnt++] = 24;
2695 break;
2696 case 26:
2697 if (curChar == 79)
2698 jjstateSet[jjnewStateCnt++] = 25;
2699 break;
2700 case 27:
2701 if (curChar == 67)
2702 jjstateSet[jjnewStateCnt++] = 26;
2703 break;
2704 case 28:
2705 if (curChar == 71)
2706 jjstateSet[jjnewStateCnt++] = 27;
2707 break;
2708 case 29:
2709 if (curChar == 66)
2710 jjstateSet[jjnewStateCnt++] = 28;
2711 break;
2712 case 30:
2713 if (curChar == 69)
2714 jjstateSet[jjnewStateCnt++] = 31;
2715 break;
2716 case 35:
2717 if (curChar == 90)
2718 jjstateSet[jjnewStateCnt++] = 30;
2719 break;
2720 case 36:
2721 if (curChar == 73)
2722 jjstateSet[jjnewStateCnt++] = 35;
2723 break;
2724 case 37:
2725 if (curChar == 83)
2726 jjstateSet[jjnewStateCnt++] = 36;
2727 break;
2728 case 38:
2729 if ((0x7fffffeL & l) != 0L)
2730 jjCheckNAddTwoStates(38, 39);
2731 break;
2732 case 39:
2733 if ((0x7fffffe00000000L & l) != 0L)
2734 jjCheckNAddTwoStates(39, 40);
2735 break;
2736 case 40:
2737 if ((0x7fffffeL & l) != 0L)
2738 jjCheckNAddTwoStates(40, 41);
2739 break;
2740 case 41:
2741 if ((0x7fffffe00000000L & l) == 0L)
2742 break;
2743 if (kind > 61)
2744 kind = 61;
2745 jjCheckNAddTwoStates(40, 41);
2746 break;
2747 case 42:
2748 if (curChar == 112)
2749 jjCheckNAdd(52);
2750 break;
2751 case 44:
2752 if ((0x7fffffe07fffffeL & l) == 0L)
2753 break;
2754 if (kind > 62)
2755 kind = 62;
2756 jjCheckNAddStates(7, 10);
2757 break;
2758 case 46:
2759 if ((0x7fffffe07fffffeL & l) == 0L)
2760 break;
2761 if (kind > 62)
2762 kind = 62;
2763 jjCheckNAddStates(11, 14);
2764 break;
2765 case 50:
2766 if ((0x47fffffe87fffffeL & l) == 0L)
2767 break;
2768 if (kind > 62)
2769 kind = 62;
2770 jjCheckNAddTwoStates(49, 50);
2771 break;
2772 case 53:
2773 case 77:
2774 if (curChar == 116)
2775 jjCheckNAdd(42);
2776 break;
2777 case 54:
2778 if (curChar == 102)
2779 jjstateSet[jjnewStateCnt++] = 53;
2780 break;
2781 case 55:
2782 if (curChar == 115)
2783 jjCheckNAdd(52);
2784 break;
2785 case 56:
2786 if (curChar == 119)
2787 jjCheckNAdd(55);
2788 break;
2789 case 57:
2790 if (curChar == 101)
2791 jjstateSet[jjnewStateCnt++] = 56;
2792 break;
2793 case 58:
2794 if (curChar == 110)
2795 jjstateSet[jjnewStateCnt++] = 57;
2796 break;
2797 case 59:
2798 if ((0x7fffffe87fffffeL & l) != 0L)
2799 jjCheckNAddTwoStates(59, 60);
2800 break;
2801 case 60:
2802 if (curChar == 64)
2803 jjCheckNAdd(61);
2804 break;
2805 case 61:
2806 if ((0x7fffffe07fffffeL & l) == 0L)
2807 break;
2808 if (kind > 62)
2809 kind = 62;
2810 jjCheckNAddTwoStates(61, 62);
2811 break;
2812 case 63:
2813 if ((0x7fffffe07fffffeL & l) == 0L)
2814 break;
2815 if (kind > 62)
2816 kind = 62;
2817 jjCheckNAddTwoStates(62, 63);
2818 break;
2819 case 64:
2820 if (curChar == 91)
2821 jjstateSet[jjnewStateCnt++] = 65;
2822 break;
2823 case 66:
2824 if ((0x7fffffe07fffffeL & l) != 0L)
2825 jjCheckNAdd(67);
2826 break;
2827 case 67:
2828 if ((0x7fffffe07fffffeL & l) != 0L)
2829 jjCheckNAddTwoStates(67, 68);
2830 break;
2831 case 68:
2832 if (curChar == 93 && kind > 63)
2833 kind = 63;
2834 break;
2835 case 69:
2836 if ((0x7fffffec7fffffeL & l) == 0L)
2837 break;
2838 if (kind > 69)
2839 kind = 69;
2840 jjCheckNAdd(69);
2841 break;
2842 case 71:
2843 case 72:
2844 if ((0xc7ffffffd7ffffffL & l) != 0L)
2845 jjCheckNAddTwoStates(72, 73);
2846 break;
2847 case 75:
2848 if ((0x7fffffe87fffffeL & l) == 0L)
2849 break;
2850 if (kind > 71)
2851 kind = 71;
2852 jjstateSet[jjnewStateCnt++] = 75;
2853 break;
2854 case 76:
2855 if (curChar == 104)
2856 jjAddStates(91, 92);
2857 break;
2858 case 78:
2859 if (curChar == 116)
2860 jjstateSet[jjnewStateCnt++] = 77;
2861 break;
2862 case 79:
2863 if (curChar == 112)
2864 jjCheckNAdd(55);
2865 break;
2866 case 80:
2867 if (curChar == 116)
2868 jjstateSet[jjnewStateCnt++] = 79;
2869 break;
2870 case 81:
2871 if (curChar == 116)
2872 jjstateSet[jjnewStateCnt++] = 80;
2873 break;
2874 case 88:
2875 if (curChar == 70)
2876 jjAddStates(93, 94);
2877 break;
2878 case 89:
2879 if (curChar == 84)
2880 jjAddStates(95, 96);
2881 break;
2882 case 94:
2883 if (curChar == 70)
2884 jjstateSet[jjnewStateCnt++] = 89;
2885 break;
2886 case 95:
2887 if (curChar == 69)
2888 jjstateSet[jjnewStateCnt++] = 94;
2889 break;
2890 case 96:
2891 if (curChar == 76)
2892 jjstateSet[jjnewStateCnt++] = 95;
2893 break;
2894 case 97:
2895 if (curChar == 84)
2896 jjAddStates(97, 98);
2897 break;
2898 case 102:
2899 if (curChar == 72)
2900 jjstateSet[jjnewStateCnt++] = 97;
2901 break;
2902 case 103:
2903 if (curChar == 71)
2904 jjstateSet[jjnewStateCnt++] = 102;
2905 break;
2906 case 104:
2907 if (curChar == 73)
2908 jjstateSet[jjnewStateCnt++] = 103;
2909 break;
2910 case 105:
2911 if (curChar == 82)
2912 jjstateSet[jjnewStateCnt++] = 104;
2913 break;
2914 case 106:
2915 if (curChar == 91)
2916 jjAddStates(86, 90);
2917 break;
2918 case 107:
2919 if (curChar == 91)
2920 jjCheckNAdd(108);
2921 break;
2922 case 108:
2923 if ((0xffffffffd7ffffffL & l) != 0L)
2924 jjCheckNAddStates(17, 19);
2925 break;
2926 case 110:
2927 if ((0x7fffffe07fffffeL & l) != 0L)
2928 jjCheckNAdd(111);
2929 break;
2930 case 111:
2931 if ((0x7fffffe07fffffeL & l) != 0L)
2932 jjCheckNAddTwoStates(111, 113);
2933 break;
2934 case 112:
2935 if (curChar == 93 && kind > 64)
2936 kind = 64;
2937 break;
2938 case 113:
2939 if (curChar == 93)
2940 jjstateSet[jjnewStateCnt++] = 112;
2941 break;
2942 case 114:
2943 if (curChar == 91)
2944 jjCheckNAdd(115);
2945 break;
2946 case 115:
2947 if ((0xffffffffd7ffffffL & l) != 0L)
2948 jjCheckNAddTwoStates(115, 116);
2949 break;
2950 case 117:
2951 if (curChar == 112)
2952 jjCheckNAdd(129);
2953 break;
2954 case 119:
2955 if ((0x7fffffe07fffffeL & l) != 0L)
2956 jjCheckNAddStates(26, 30);
2957 break;
2958 case 121:
2959 if ((0x7fffffe07fffffeL & l) != 0L)
2960 jjCheckNAddStates(31, 35);
2961 break;
2962 case 125:
2963 if ((0x47fffffe87fffffeL & l) != 0L)
2964 jjCheckNAddStates(39, 41);
2965 break;
2966 case 126:
2967 if (curChar == 93 && kind > 65)
2968 kind = 65;
2969 break;
2970 case 127:
2971 if (curChar == 93)
2972 jjstateSet[jjnewStateCnt++] = 126;
2973 break;
2974 case 130:
2975 case 142:
2976 if (curChar == 116)
2977 jjCheckNAdd(117);
2978 break;
2979 case 131:
2980 if (curChar == 102)
2981 jjstateSet[jjnewStateCnt++] = 130;
2982 break;
2983 case 132:
2984 if (curChar == 115)
2985 jjCheckNAdd(129);
2986 break;
2987 case 133:
2988 if (curChar == 119)
2989 jjCheckNAdd(132);
2990 break;
2991 case 134:
2992 if (curChar == 101)
2993 jjstateSet[jjnewStateCnt++] = 133;
2994 break;
2995 case 135:
2996 if (curChar == 110)
2997 jjstateSet[jjnewStateCnt++] = 134;
2998 break;
2999 case 136:
3000 if ((0x7fffffe87fffffeL & l) != 0L)
3001 jjAddStates(99, 100);
3002 break;
3003 case 137:
3004 if (curChar == 64)
3005 jjCheckNAdd(138);
3006 break;
3007 case 138:
3008 if ((0x7fffffe07fffffeL & l) != 0L)
3009 jjCheckNAddStates(42, 44);
3010 break;
3011 case 140:
3012 if ((0x7fffffe07fffffeL & l) != 0L)
3013 jjCheckNAddStates(45, 47);
3014 break;
3015 case 141:
3016 if (curChar == 104)
3017 jjAddStates(101, 102);
3018 break;
3019 case 143:
3020 if (curChar == 116)
3021 jjstateSet[jjnewStateCnt++] = 142;
3022 break;
3023 case 144:
3024 if (curChar == 112)
3025 jjCheckNAdd(132);
3026 break;
3027 case 145:
3028 if (curChar == 116)
3029 jjstateSet[jjnewStateCnt++] = 144;
3030 break;
3031 case 146:
3032 if (curChar == 116)
3033 jjstateSet[jjnewStateCnt++] = 145;
3034 break;
3035 case 147:
3036 if (curChar == 91)
3037 jjCheckNAdd(148);
3038 break;
3039 case 148:
3040 if ((0xffffffffd7ffffffL & l) != 0L)
3041 jjCheckNAddTwoStates(148, 149);
3042 break;
3043 case 150:
3044 if ((0xffffffffd7ffffffL & l) != 0L)
3045 jjCheckNAddStates(50, 52);
3046 break;
3047 case 152:
3048 if ((0x7fffffe07fffffeL & l) != 0L)
3049 jjCheckNAdd(153);
3050 break;
3051 case 153:
3052 if ((0x7fffffe07fffffeL & l) != 0L)
3053 jjCheckNAddTwoStates(153, 155);
3054 break;
3055 case 154:
3056 if (curChar == 93 && kind > 66)
3057 kind = 66;
3058 break;
3059 case 155:
3060 if (curChar == 93)
3061 jjstateSet[jjnewStateCnt++] = 154;
3062 break;
3063 case 156:
3064 if (curChar == 91)
3065 jjCheckNAdd(157);
3066 break;
3067 case 157:
3068 if ((0xffffffffd7ffffffL & l) != 0L)
3069 jjCheckNAddTwoStates(157, 158);
3070 break;
3071 case 159:
3072 if (curChar == 112)
3073 jjCheckNAdd(171);
3074 break;
3075 case 161:
3076 if ((0x7fffffe07fffffeL & l) != 0L)
3077 jjCheckNAddStates(59, 63);
3078 break;
3079 case 163:
3080 if ((0x7fffffe07fffffeL & l) != 0L)
3081 jjCheckNAddStates(64, 68);
3082 break;
3083 case 167:
3084 if ((0x47fffffe87fffffeL & l) != 0L)
3085 jjCheckNAddStates(72, 74);
3086 break;
3087 case 168:
3088 if (curChar == 93 && kind > 67)
3089 kind = 67;
3090 break;
3091 case 169:
3092 if (curChar == 93)
3093 jjstateSet[jjnewStateCnt++] = 168;
3094 break;
3095 case 172:
3096 case 184:
3097 if (curChar == 116)
3098 jjCheckNAdd(159);
3099 break;
3100 case 173:
3101 if (curChar == 102)
3102 jjstateSet[jjnewStateCnt++] = 172;
3103 break;
3104 case 174:
3105 if (curChar == 115)
3106 jjCheckNAdd(171);
3107 break;
3108 case 175:
3109 if (curChar == 119)
3110 jjCheckNAdd(174);
3111 break;
3112 case 176:
3113 if (curChar == 101)
3114 jjstateSet[jjnewStateCnt++] = 175;
3115 break;
3116 case 177:
3117 if (curChar == 110)
3118 jjstateSet[jjnewStateCnt++] = 176;
3119 break;
3120 case 178:
3121 if ((0x7fffffe87fffffeL & l) != 0L)
3122 jjAddStates(103, 104);
3123 break;
3124 case 179:
3125 if (curChar == 64)
3126 jjCheckNAdd(180);
3127 break;
3128 case 180:
3129 if ((0x7fffffe07fffffeL & l) != 0L)
3130 jjCheckNAddStates(75, 77);
3131 break;
3132 case 182:
3133 if ((0x7fffffe07fffffeL & l) != 0L)
3134 jjCheckNAddStates(78, 80);
3135 break;
3136 case 183:
3137 if (curChar == 104)
3138 jjAddStates(105, 106);
3139 break;
3140 case 185:
3141 if (curChar == 116)
3142 jjstateSet[jjnewStateCnt++] = 184;
3143 break;
3144 case 186:
3145 if (curChar == 112)
3146 jjCheckNAdd(174);
3147 break;
3148 case 187:
3149 if (curChar == 116)
3150 jjstateSet[jjnewStateCnt++] = 186;
3151 break;
3152 case 188:
3153 if (curChar == 116)
3154 jjstateSet[jjnewStateCnt++] = 187;
3155 break;
3156 case 189:
3157 if (curChar == 91)
3158 jjCheckNAdd(190);
3159 break;
3160 case 190:
3161 if ((0xffffffffd7ffffffL & l) != 0L)
3162 jjCheckNAddTwoStates(190, 191);
3163 break;
3164 case 192:
3165 if ((0xffffffffd7ffffffL & l) != 0L)
3166 jjCheckNAddStates(83, 85);
3167 break;
3168 case 194:
3169 if ((0x7fffffe07fffffeL & l) != 0L)
3170 jjCheckNAdd(195);
3171 break;
3172 case 195:
3173 if ((0x7fffffe07fffffeL & l) != 0L)
3174 jjCheckNAddTwoStates(195, 197);
3175 break;
3176 case 196:
3177 if (curChar == 93 && kind > 68)
3178 kind = 68;
3179 break;
3180 case 197:
3181 if (curChar == 93)
3182 jjstateSet[jjnewStateCnt++] = 196;
3183 break;
3184 case 199:
3185 if ((0x7fffffe07fffffeL & l) != 0L)
3186 jjCheckNAdd(200);
3187 break;
3188 case 200:
3189 if ((0x7fffffe07fffffeL & l) != 0L)
3190 jjCheckNAddTwoStates(200, 197);
3191 break;
3192 default : break;
3193 }
3194 } while(i != startsAt);
3195 }
3196 else
3197 {
3198 int hiByte = (int)(curChar >> 8);
3199 int i1 = hiByte >> 6;
3200 long l1 = 1L << (hiByte & 077);
3201 int i2 = (curChar & 0xff) >> 6;
3202 long l2 = 1L << (curChar & 077);
3203 MatchLoop: do
3204 {
3205 switch(jjstateSet[--i])
3206 {
3207 case 202:
3208 case 69:
3209 if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
3210 break;
3211 if (kind > 69)
3212 kind = 69;
3213 jjCheckNAdd(69);
3214 break;
3215 case 0:
3216 if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
3217 break;
3218 if (kind > 69)
3219 kind = 69;
3220 jjCheckNAdd(69);
3221 break;
3222 case 15:
3223 if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
3224 break;
3225 if (kind > 69)
3226 kind = 69;
3227 jjCheckNAdd(69);
3228 break;
3229 case 2:
3230 if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
3231 break;
3232 if (kind > 2)
3233 kind = 2;
3234 jjstateSet[jjnewStateCnt++] = 2;
3235 break;
3236 case 71:
3237 case 72:
3238 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
3239 jjCheckNAddTwoStates(72, 73);
3240 break;
3241 case 108:
3242 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
3243 jjAddStates(17, 19);
3244 break;
3245 case 115:
3246 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
3247 jjAddStates(20, 21);
3248 break;
3249 case 148:
3250 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
3251 jjAddStates(48, 49);
3252 break;
3253 case 150:
3254 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
3255 jjAddStates(50, 52);
3256 break;
3257 case 157:
3258 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
3259 jjAddStates(53, 54);
3260 break;
3261 case 190:
3262 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
3263 jjAddStates(81, 82);
3264 break;
3265 case 192:
3266 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
3267 jjAddStates(83, 85);
3268 break;
3269 default : break;
3270 }
3271 } while(i != startsAt);
3272 }
3273 if (kind != 0x7fffffff)
3274 {
3275 jjmatchedKind = kind;
3276 jjmatchedPos = curPos;
3277 kind = 0x7fffffff;
3278 }
3279 ++curPos;
3280 if ((i = jjnewStateCnt) == (startsAt = 201 - (jjnewStateCnt = startsAt)))
3281 return curPos;
3282 try { curChar = input_stream.readChar(); }
3283 catch(java.io.IOException e) { return curPos; }
3284 }
3285 }
3286 private final int jjStopStringLiteralDfa_0(int pos, long active0)
3287 {
3288 switch (pos)
3289 {
3290 case 0:
3291 if ((active0 & 0x1000L) != 0L)
3292 return 71;
3293 if ((active0 & 0x4003800000L) != 0L)
3294 return 201;
3295 if ((active0 & 0x400000000L) != 0L)
3296 {
3297 jjmatchedKind = 69;
3298 return 15;
3299 }
3300 if ((active0 & 0x40000L) != 0L)
3301 return 69;
3302 if ((active0 & 0x4000L) != 0L)
3303 return 65;
3304 if ((active0 & 0xa00000000L) != 0L)
3305 {
3306 jjmatchedKind = 69;
3307 return 202;
3308 }
3309 if ((active0 & 0x700000000200L) != 0L)
3310 return 3;
3311 return -1;
3312 case 1:
3313 if ((active0 & 0x4003000000L) != 0L)
3314 return 201;
3315 if ((active0 & 0xe00000000L) != 0L)
3316 {
3317 if (jjmatchedPos != 1)
3318 {
3319 jjmatchedKind = 69;
3320 jjmatchedPos = 1;
3321 }
3322 return 202;
3323 }
3324 return -1;
3325 case 2:
3326 if ((active0 & 0x4002000000L) != 0L)
3327 return 201;
3328 if ((active0 & 0xe00000000L) != 0L)
3329 {
3330 if (jjmatchedPos != 2)
3331 {
3332 jjmatchedKind = 69;
3333 jjmatchedPos = 2;
3334 }
3335 return 202;
3336 }
3337 return -1;
3338 case 3:
3339 if ((active0 & 0x4000000000L) != 0L)
3340 return 201;
3341 if ((active0 & 0xe00000000L) != 0L)
3342 {
3343 jjmatchedKind = 69;
3344 jjmatchedPos = 3;
3345 return 202;
3346 }
3347 return -1;
3348 case 4:
3349 if ((active0 & 0xc00000000L) != 0L)
3350 {
3351 jjmatchedKind = 69;
3352 jjmatchedPos = 4;
3353 return 202;
3354 }
3355 return -1;
3356 case 5:
3357 if ((active0 & 0x400000000L) != 0L)
3358 {
3359 jjmatchedKind = 69;
3360 jjmatchedPos = 5;
3361 return 202;
3362 }
3363 return -1;
3364 default :
3365 return -1;
3366 }
3367 }
3368 private final int jjStartNfa_0(int pos, long active0)
3369 {
3370 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
3371 }
3372 private final int jjStartNfaWithStates_0(int pos, int kind, int state)
3373 {
3374 jjmatchedKind = kind;
3375 jjmatchedPos = pos;
3376 try { curChar = input_stream.readChar(); }
3377 catch(java.io.IOException e) { return pos + 1; }
3378 return jjMoveNfa_0(state, pos + 1);
3379 }
3380 private final int jjMoveStringLiteralDfa0_0()
3381 {
3382 switch(curChar)
3383 {
3384 case 10:
3385 jjmatchedKind = 9;
3386 return jjMoveStringLiteralDfa1_0(0x700000000000L);
3387 case 32:
3388 return jjStopAtPos(0, 29);
3389 case 37:
3390 return jjMoveStringLiteralDfa1_0(0x800000000000000L);
3391 case 40:
3392 return jjStartNfaWithStates_0(0, 12, 71);
3393 case 41:
3394 return jjStopAtPos(0, 13);
3395 case 42:
3396 jjmatchedKind = 30;
3397 return jjMoveStringLiteralDfa1_0(0x180000000L);
3398 case 43:
3399 jjmatchedKind = 26;
3400 return jjMoveStringLiteralDfa1_0(0x18000000L);
3401 case 44:
3402 return jjStopAtPos(0, 53);
3403 case 45:
3404 jjmatchedKind = 23;
3405 return jjMoveStringLiteralDfa1_0(0x4003000000L);
3406 case 47:
3407 return jjStartNfaWithStates_0(0, 18, 69);
3408 case 59:
3409 return jjStopAtPos(0, 11);
3410 case 60:
3411 return jjStopAtPos(0, 19);
3412 case 61:
3413 return jjMoveStringLiteralDfa1_0(0x80000000000L);
3414 case 62:
3415 jjmatchedKind = 20;
3416 return jjMoveStringLiteralDfa1_0(0x600000L);
3417 case 67:
3418 return jjMoveStringLiteralDfa1_0(0x400000000L);
3419 case 76:
3420 return jjMoveStringLiteralDfa1_0(0x200000000L);
3421 case 82:
3422 return jjMoveStringLiteralDfa1_0(0x800000000L);
3423 case 91:
3424 return jjStartNfaWithStates_0(0, 14, 65);
3425 case 93:
3426 return jjStopAtPos(0, 15);
3427 case 123:
3428 return jjStopAtPos(0, 16);
3429 case 125:
3430 return jjStopAtPos(0, 17);
3431 case 126:
3432 return jjStopAtPos(0, 10);
3433 default :
3434 return jjMoveNfa_0(0, 0);
3435 }
3436 }
3437 private final int jjMoveStringLiteralDfa1_0(long active0)
3438 {
3439 try { curChar = input_stream.readChar(); }
3440 catch(java.io.IOException e) {
3441 jjStopStringLiteralDfa_0(0, active0);
3442 return 1;
3443 }
3444 switch(curChar)
3445 {
3446 case 37:
3447 if ((active0 & 0x800000000000000L) != 0L)
3448 return jjStopAtPos(1, 59);
3449 break;
3450 case 42:
3451 if ((active0 & 0x80000000L) != 0L)
3452 {
3453 jjmatchedKind = 31;
3454 jjmatchedPos = 1;
3455 }
3456 return jjMoveStringLiteralDfa2_0(active0, 0x100000000L);
3457 case 43:
3458 if ((active0 & 0x8000000L) != 0L)
3459 {
3460 jjmatchedKind = 27;
3461 jjmatchedPos = 1;
3462 }
3463 return jjMoveStringLiteralDfa2_0(active0, 0x10000000L);
3464 case 44:
3465 if ((active0 & 0x400000000000L) != 0L)
3466 return jjStopAtPos(1, 46);
3467 break;
3468 case 45:
3469 if ((active0 & 0x1000000L) != 0L)
3470 {
3471 jjmatchedKind = 24;
3472 jjmatchedPos = 1;
3473 }
3474 return jjMoveStringLiteralDfa2_0(active0, 0x4002000000L);
3475 case 58:
3476 if ((active0 & 0x200000000000L) != 0L)
3477 return jjStopAtPos(1, 45);
3478 break;
3479 case 61:
3480 if ((active0 & 0x80000000000L) != 0L)
3481 return jjStopAtPos(1, 43);
3482 break;
3483 case 62:
3484 if ((active0 & 0x200000L) != 0L)
3485 {
3486 jjmatchedKind = 21;
3487 jjmatchedPos = 1;
3488 }
3489 return jjMoveStringLiteralDfa2_0(active0, 0x400000L);
3490 case 69:
3491 return jjMoveStringLiteralDfa2_0(active0, 0x600000000L);
3492 case 73:
3493 return jjMoveStringLiteralDfa2_0(active0, 0x800000000L);
3494 case 124:
3495 if ((active0 & 0x100000000000L) != 0L)
3496 return jjStopAtPos(1, 44);
3497 break;
3498 default :
3499 break;
3500 }
3501 return jjStartNfa_0(0, active0);
3502 }
3503 private final int jjMoveStringLiteralDfa2_0(long old0, long active0)
3504 {
3505 if (((active0 &= old0)) == 0L)
3506 return jjStartNfa_0(0, old0);
3507 try { curChar = input_stream.readChar(); }
3508 catch(java.io.IOException e) {
3509 jjStopStringLiteralDfa_0(1, active0);
3510 return 2;
3511 }
3512 switch(curChar)
3513 {
3514 case 42:
3515 if ((active0 & 0x100000000L) != 0L)
3516 return jjStopAtPos(2, 32);
3517 break;
3518 case 43:
3519 if ((active0 & 0x10000000L) != 0L)
3520 return jjStopAtPos(2, 28);
3521 break;
3522 case 45:
3523 if ((active0 & 0x2000000L) != 0L)
3524 {
3525 jjmatchedKind = 25;
3526 jjmatchedPos = 2;
3527 }
3528 return jjMoveStringLiteralDfa3_0(active0, 0x4000000000L);
3529 case 62:
3530 if ((active0 & 0x400000L) != 0L)
3531 return jjStopAtPos(2, 22);
3532 break;
3533 case 70:
3534 return jjMoveStringLiteralDfa3_0(active0, 0x200000000L);
3535 case 71:
3536 return jjMoveStringLiteralDfa3_0(active0, 0x800000000L);
3537 case 78:
3538 return jjMoveStringLiteralDfa3_0(active0, 0x400000000L);
3539 default :
3540 break;
3541 }
3542 return jjStartNfa_0(1, active0);
3543 }
3544 private final int jjMoveStringLiteralDfa3_0(long old0, long active0)
3545 {
3546 if (((active0 &= old0)) == 0L)
3547 return jjStartNfa_0(1, old0);
3548 try { curChar = input_stream.readChar(); }
3549 catch(java.io.IOException e) {
3550 jjStopStringLiteralDfa_0(2, active0);
3551 return 3;
3552 }
3553 switch(curChar)
3554 {
3555 case 45:
3556 if ((active0 & 0x4000000000L) != 0L)
3557 return jjStartNfaWithStates_0(3, 38, 201);
3558 break;
3559 case 72:
3560 return jjMoveStringLiteralDfa4_0(active0, 0x800000000L);
3561 case 84:
3562 return jjMoveStringLiteralDfa4_0(active0, 0x600000000L);
3563 default :
3564 break;
3565 }
3566 return jjStartNfa_0(2, active0);
3567 }
3568 private final int jjMoveStringLiteralDfa4_0(long old0, long active0)
3569 {
3570 if (((active0 &= old0)) == 0L)
3571 return jjStartNfa_0(2, old0);
3572 try { curChar = input_stream.readChar(); }
3573 catch(java.io.IOException e) {
3574 jjStopStringLiteralDfa_0(3, active0);
3575 return 4;
3576 }
3577 switch(curChar)
3578 {
3579 case 58:
3580 if ((active0 & 0x200000000L) != 0L)
3581 return jjStopAtPos(4, 33);
3582 break;
3583 case 69:
3584 return jjMoveStringLiteralDfa5_0(active0, 0x400000000L);
3585 case 84:
3586 return jjMoveStringLiteralDfa5_0(active0, 0x800000000L);
3587 default :
3588 break;
3589 }
3590 return jjStartNfa_0(3, active0);
3591 }
3592 private final int jjMoveStringLiteralDfa5_0(long old0, long active0)
3593 {
3594 if (((active0 &= old0)) == 0L)
3595 return jjStartNfa_0(3, old0);
3596 try { curChar = input_stream.readChar(); }
3597 catch(java.io.IOException e) {
3598 jjStopStringLiteralDfa_0(4, active0);
3599 return 5;
3600 }
3601 switch(curChar)
3602 {
3603 case 58:
3604 if ((active0 & 0x800000000L) != 0L)
3605 return jjStopAtPos(5, 35);
3606 break;
3607 case 82:
3608 return jjMoveStringLiteralDfa6_0(active0, 0x400000000L);
3609 default :
3610 break;
3611 }
3612 return jjStartNfa_0(4, active0);
3613 }
3614 private final int jjMoveStringLiteralDfa6_0(long old0, long active0)
3615 {
3616 if (((active0 &= old0)) == 0L)
3617 return jjStartNfa_0(4, old0);
3618 try { curChar = input_stream.readChar(); }
3619 catch(java.io.IOException e) {
3620 jjStopStringLiteralDfa_0(5, active0);
3621 return 6;
3622 }
3623 switch(curChar)
3624 {
3625 case 58:
3626 if ((active0 & 0x400000000L) != 0L)
3627 return jjStopAtPos(6, 34);
3628 break;
3629 default :
3630 break;
3631 }
3632 return jjStartNfa_0(5, active0);
3633 }
3634 private final int jjMoveNfa_0(int startState, int curPos)
3635 {
3636 int[] nextStates;
3637 int startsAt = 0;
3638 jjnewStateCnt = 201;
3639 int i = 1;
3640 jjstateSet[0] = startState;
3641 int j, kind = 0x7fffffff;
3642 for (;;)
3643 {
3644 if (++jjround == 0x7fffffff)
3645 ReInitRounds();
3646 if (curChar < 64)
3647 {
3648 long l = 1L << curChar;
3649 MatchLoop: do
3650 {
3651 switch(jjstateSet[--i])
3652 {
3653 case 65:
3654 if (curChar == 35)
3655 jjstateSet[jjnewStateCnt++] = 66;
3656 break;
3657 case 202:
3658 if ((0x83ffc00000000000L & l) != 0L)
3659 {
3660 if (kind > 69)
3661 kind = 69;
3662 jjCheckNAdd(69);
3663 }
3664 if ((0x3ff600000000000L & l) != 0L)
3665 jjCheckNAddTwoStates(59, 60);
3666 break;
3667 case 0:
3668 if ((0x83ffc00000000000L & l) != 0L)
3669 {
3670 if (kind > 69)
3671 kind = 69;
3672 jjCheckNAdd(69);
3673 }
3674 else if (curChar == 39)
3675 jjCheckNAddStates(0, 2);
3676 else if (curChar == 38)
3677 jjCheckNAdd(75);
3678 else if (curChar == 40)
3679 jjstateSet[jjnewStateCnt++] = 71;
3680 else if (curChar == 35)
3681 jjCheckNAdd(5);
3682 else if (curChar == 10)
3683 jjstateSet[jjnewStateCnt++] = 3;
3684 if ((0x3ff600000000000L & l) != 0L)
3685 jjCheckNAddTwoStates(59, 60);
3686 break;
3687 case 15:
3688 if ((0x83ffc00000000000L & l) != 0L)
3689 {
3690 if (kind > 69)
3691 kind = 69;
3692 jjCheckNAdd(69);
3693 }
3694 if ((0x3ff600000000000L & l) != 0L)
3695 jjCheckNAddTwoStates(59, 60);
3696 break;
3697 case 201:
3698 case 59:
3699 if ((0x3ff600000000000L & l) != 0L)
3700 jjCheckNAddTwoStates(59, 60);
3701 break;
3702 case 1:
3703 if (curChar != 47)
3704 break;
3705 if (kind > 2)
3706 kind = 2;
3707 jjCheckNAdd(2);
3708 break;
3709 case 2:
3710 if ((0xffffffffffffdbffL & l) == 0L)
3711 break;
3712 if (kind > 2)
3713 kind = 2;
3714 jjCheckNAdd(2);
3715 break;
3716 case 3:
3717 if (curChar == 47)
3718 jjstateSet[jjnewStateCnt++] = 1;
3719 break;
3720 case 4:
3721 if (curChar == 35)
3722 jjCheckNAdd(5);
3723 break;
3724 case 5:
3725 if ((0x3ff000000000000L & l) == 0L)
3726 break;
3727 if (kind > 39)
3728 kind = 39;
3729 jjCheckNAdd(5);
3730 break;
3731 case 7:
3732 if (curChar == 40)
3733 jjAddStates(3, 4);
3734 break;
3735 case 9:
3736 if (curChar == 41)
3737 jjstateSet[jjnewStateCnt++] = 10;
3738 break;
3739 case 10:
3740 if (curChar == 58 && kind > 40)
3741 kind = 40;
3742 break;
3743 case 11:
3744 if (curChar == 35)
3745 jjCheckNAdd(12);
3746 break;
3747 case 12:
3748 if ((0x3ff000000000000L & l) != 0L)
3749 jjCheckNAddTwoStates(12, 9);
3750 break;
3751 case 18:
3752 if (curChar == 40)
3753 jjAddStates(5, 6);
3754 break;
3755 case 20:
3756 if (curChar == 41)
3757 jjstateSet[jjnewStateCnt++] = 21;
3758 break;
3759 case 21:
3760 if (curChar == 58 && kind > 41)
3761 kind = 41;
3762 break;
3763 case 22:
3764 if (curChar == 35)
3765 jjCheckNAdd(23);
3766 break;
3767 case 23:
3768 if ((0x3ff000000000000L & l) != 0L)
3769 jjCheckNAddTwoStates(23, 20);
3770 break;
3771 case 31:
3772 if (curChar == 40)
3773 jjCheckNAdd(32);
3774 break;
3775 case 32:
3776 if ((0x3ff000000000000L & l) != 0L)
3777 jjCheckNAddTwoStates(32, 33);
3778 break;
3779 case 33:
3780 if (curChar == 41)
3781 jjstateSet[jjnewStateCnt++] = 34;
3782 break;
3783 case 34:
3784 if (curChar == 58 && kind > 42)
3785 kind = 42;
3786 break;
3787 case 43:
3788 if (curChar == 47)
3789 jjCheckNAdd(44);
3790 break;
3791 case 44:
3792 if ((0x3ff200000000000L & l) == 0L)
3793 break;
3794 if (kind > 62)
3795 kind = 62;
3796 jjCheckNAddStates(7, 10);
3797 break;
3798 case 45:
3799 if (curChar == 46)
3800 jjCheckNAdd(46);
3801 break;
3802 case 46:
3803 if ((0x3ff200000000000L & l) == 0L)
3804 break;
3805 if (kind > 62)
3806 kind = 62;
3807 jjCheckNAddStates(11, 14);
3808 break;
3809 case 47:
3810 if (curChar == 58)
3811 jjCheckNAdd(48);
3812 break;
3813 case 48:
3814 if ((0x3ff000000000000L & l) == 0L)
3815 break;
3816 if (kind > 62)
3817 kind = 62;
3818 jjCheckNAddTwoStates(48, 49);
3819 break;
3820 case 49:
3821 if (curChar != 47)
3822 break;
3823 if (kind > 62)
3824 kind = 62;
3825 jjCheckNAddTwoStates(49, 50);
3826 break;
3827 case 50:
3828 if ((0xa3ff686800000000L & l) == 0L)
3829 break;
3830 if (kind > 62)
3831 kind = 62;
3832 jjCheckNAddTwoStates(49, 50);
3833 break;
3834 case 51:
3835 if (curChar == 47)
3836 jjstateSet[jjnewStateCnt++] = 43;
3837 break;
3838 case 52:
3839 if (curChar == 58)
3840 jjstateSet[jjnewStateCnt++] = 51;
3841 break;
3842 case 61:
3843 if ((0x3ff200000000000L & l) == 0L)
3844 break;
3845 if (kind > 62)
3846 kind = 62;
3847 jjCheckNAddTwoStates(61, 62);
3848 break;
3849 case 62:
3850 if (curChar == 46)
3851 jjCheckNAdd(63);
3852 break;
3853 case 63:
3854 if ((0x3ff200000000000L & l) == 0L)
3855 break;
3856 if (kind > 62)
3857 kind = 62;
3858 jjCheckNAddTwoStates(62, 63);
3859 break;
3860 case 67:
3861 if ((0x3ff000000000000L & l) != 0L)
3862 jjAddStates(15, 16);
3863 break;
3864 case 69:
3865 if ((0x83ffc00000000000L & l) == 0L)
3866 break;
3867 if (kind > 69)
3868 kind = 69;
3869 jjCheckNAdd(69);
3870 break;
3871 case 70:
3872 if (curChar == 40)
3873 jjstateSet[jjnewStateCnt++] = 71;
3874 break;
3875 case 71:
3876 if ((0xa7fffedbffffdbffL & l) != 0L)
3877 jjCheckNAddTwoStates(72, 73);
3878 break;
3879 case 72:
3880 if ((0xa7ffffdbffffdbffL & l) != 0L)
3881 jjCheckNAddTwoStates(72, 73);
3882 break;
3883 case 73:
3884 if (curChar == 41 && kind > 70)
3885 kind = 70;
3886 break;
3887 case 74:
3888 if (curChar == 38)
3889 jjCheckNAdd(75);
3890 break;
3891 case 75:
3892 if ((0x3ff000000000000L & l) == 0L)
3893 break;
3894 if (kind > 71)
3895 kind = 71;
3896 jjCheckNAdd(75);
3897 break;
3898 case 82:
3899 if (curChar == 39)
3900 jjCheckNAddStates(0, 2);
3901 break;
3902 case 83:
3903 if (curChar == 39 && kind > 60)
3904 kind = 60;
3905 break;
3906 case 84:
3907 case 85:
3908 if (curChar == 39)
3909 jjCheckNAdd(83);
3910 break;
3911 case 86:
3912 if (curChar == 39)
3913 jjstateSet[jjnewStateCnt++] = 85;
3914 break;
3915 case 87:
3916 if (curChar == 39)
3917 jjstateSet[jjnewStateCnt++] = 86;
3918 break;
3919 case 90:
3920 if (curChar == 40)
3921 jjCheckNAdd(91);
3922 break;
3923 case 91:
3924 if ((0x3ff000000000000L & l) != 0L)
3925 jjCheckNAddTwoStates(91, 92);
3926 break;
3927 case 92:
3928 if (curChar == 41)
3929 jjstateSet[jjnewStateCnt++] = 93;
3930 break;
3931 case 93:
3932 if (curChar == 58 && kind > 36)
3933 kind = 36;
3934 break;
3935 case 98:
3936 if (curChar == 40)
3937 jjCheckNAdd(99);
3938 break;
3939 case 99:
3940 if ((0x3ff000000000000L & l) != 0L)
3941 jjCheckNAddTwoStates(99, 100);
3942 break;
3943 case 100:
3944 if (curChar == 41)
3945 jjstateSet[jjnewStateCnt++] = 101;
3946 break;
3947 case 101:
3948 if (curChar == 58 && kind > 37)
3949 kind = 37;
3950 break;
3951 case 108:
3952 if ((0xabffffb3ffffdbffL & l) != 0L)
3953 jjCheckNAddStates(17, 19);
3954 break;
3955 case 109:
3956 if (curChar == 35)
3957 jjstateSet[jjnewStateCnt++] = 110;
3958 break;
3959 case 111:
3960 if ((0x3ff000000000000L & l) != 0L)
3961 jjCheckNAddTwoStates(111, 113);
3962 break;
3963 case 115:
3964 if ((0xabffffb3ffffdbffL & l) != 0L)
3965 jjAddStates(20, 21);
3966 break;
3967 case 116:
3968 if (curChar == 58)
3969 jjCheckNAddStates(22, 25);
3970 break;
3971 case 118:
3972 if (curChar == 47)
3973 jjCheckNAdd(119);
3974 break;
3975 case 119:
3976 if ((0x3ff200000000000L & l) != 0L)
3977 jjCheckNAddStates(26, 30);
3978 break;
3979 case 120:
3980 if (curChar == 46)
3981 jjCheckNAdd(121);
3982 break;
3983 case 121:
3984 if ((0x3ff200000000000L & l) != 0L)
3985 jjCheckNAddStates(31, 35);
3986 break;
3987 case 122:
3988 if (curChar == 58)
3989 jjCheckNAdd(123);
3990 break;
3991 case 123:
3992 if ((0x3ff000000000000L & l) != 0L)
3993 jjCheckNAddStates(36, 38);
3994 break;
3995 case 124:
3996 if (curChar == 47)
3997 jjCheckNAddStates(39, 41);
3998 break;
3999 case 125:
4000 if ((0xa3ff686800000000L & l) != 0L)
4001 jjCheckNAddStates(39, 41);
4002 break;
4003 case 128:
4004 if (curChar == 47)
4005 jjstateSet[jjnewStateCnt++] = 118;
4006 break;
4007 case 129:
4008 if (curChar == 58)
4009 jjstateSet[jjnewStateCnt++] = 128;
4010 break;
4011 case 136:
4012 if ((0x3ff600000000000L & l) != 0L)
4013 jjCheckNAddTwoStates(136, 137);
4014 break;
4015 case 138:
4016 if ((0x3ff200000000000L & l) != 0L)
4017 jjCheckNAddStates(42, 44);
4018 break;
4019 case 139:
4020 if (curChar == 46)
4021 jjCheckNAdd(140);
4022 break;
4023 case 140:
4024 if ((0x3ff200000000000L & l) != 0L)
4025 jjCheckNAddStates(45, 47);
4026 break;
4027 case 148:
4028 if ((0xabffffb3ffffdbffL & l) != 0L)
4029 jjAddStates(48, 49);
4030 break;
4031 case 149:
4032 if (curChar == 58)
4033 jjCheckNAdd(150);
4034 break;
4035 case 150:
4036 if ((0xabffffb3ffffdbffL & l) != 0L)
4037 jjCheckNAddStates(50, 52);
4038 break;
4039 case 151:
4040 if (curChar == 35)
4041 jjstateSet[jjnewStateCnt++] = 152;
4042 break;
4043 case 153:
4044 if ((0x3ff000000000000L & l) != 0L)
4045 jjCheckNAddTwoStates(153, 155);
4046 break;
4047 case 157:
4048 if ((0xabffffb3ffffdbffL & l) != 0L)
4049 jjAddStates(53, 54);
4050 break;
4051 case 158:
4052 if (curChar == 62)
4053 jjCheckNAddStates(55, 58);
4054 break;
4055 case 160:
4056 if (curChar == 47)
4057 jjCheckNAdd(161);
4058 break;
4059 case 161:
4060 if ((0x3ff200000000000L & l) != 0L)
4061 jjCheckNAddStates(59, 63);
4062 break;
4063 case 162:
4064 if (curChar == 46)
4065 jjCheckNAdd(163);
4066 break;
4067 case 163:
4068 if ((0x3ff200000000000L & l) != 0L)
4069 jjCheckNAddStates(64, 68);
4070 break;
4071 case 164:
4072 if (curChar == 58)
4073 jjCheckNAdd(165);
4074 break;
4075 case 165:
4076 if ((0x3ff000000000000L & l) != 0L)
4077 jjCheckNAddStates(69, 71);
4078 break;
4079 case 166:
4080 if (curChar == 47)
4081 jjCheckNAddStates(72, 74);
4082 break;
4083 case 167:
4084 if ((0xa3ff686800000000L & l) != 0L)
4085 jjCheckNAddStates(72, 74);
4086 break;
4087 case 170:
4088 if (curChar == 47)
4089 jjstateSet[jjnewStateCnt++] = 160;
4090 break;
4091 case 171:
4092 if (curChar == 58)
4093 jjstateSet[jjnewStateCnt++] = 170;
4094 break;
4095 case 178:
4096 if ((0x3ff600000000000L & l) != 0L)
4097 jjCheckNAddTwoStates(178, 179);
4098 break;
4099 case 180:
4100 if ((0x3ff200000000000L & l) != 0L)
4101 jjCheckNAddStates(75, 77);
4102 break;
4103 case 181:
4104 if (curChar == 46)
4105 jjCheckNAdd(182);
4106 break;
4107 case 182:
4108 if ((0x3ff200000000000L & l) != 0L)
4109 jjCheckNAddStates(78, 80);
4110 break;
4111 case 190:
4112 if ((0xabffffb3ffffdbffL & l) != 0L)
4113 jjAddStates(81, 82);
4114 break;
4115 case 191:
4116 if (curChar == 62)
4117 jjCheckNAddTwoStates(192, 198);
4118 break;
4119 case 192:
4120 if ((0xabffffb3ffffdbffL & l) != 0L)
4121 jjCheckNAddStates(83, 85);
4122 break;
4123 case 193:
4124 if (curChar == 35)
4125 jjstateSet[jjnewStateCnt++] = 194;
4126 break;
4127 case 195:
4128 if ((0x3ff000000000000L & l) != 0L)
4129 jjCheckNAddTwoStates(195, 197);
4130 break;
4131 case 198:
4132 if (curChar == 35)
4133 jjstateSet[jjnewStateCnt++] = 199;
4134 break;
4135 case 200:
4136 if ((0x3ff000000000000L & l) != 0L)
4137 jjCheckNAddTwoStates(200, 197);
4138 break;
4139 default : break;
4140 }
4141 } while(i != startsAt);
4142 }
4143 else if (curChar < 128)
4144 {
4145 long l = 1L << (curChar & 077);
4146 MatchLoop: do
4147 {
4148 switch(jjstateSet[--i])
4149 {
4150 case 65:
4151 if (curChar == 91)
4152 jjCheckNAdd(190);
4153 if (curChar == 91)
4154 jjCheckNAdd(157);
4155 if (curChar == 91)
4156 jjCheckNAdd(148);
4157 if (curChar == 91)
4158 jjCheckNAdd(115);
4159 if (curChar == 91)
4160 jjCheckNAdd(108);
4161 break;
4162 case 202:
4163 if ((0x7fffffec7fffffeL & l) != 0L)
4164 {
4165 if (kind > 69)
4166 kind = 69;
4167 jjCheckNAdd(69);
4168 }
4169 else if (curChar == 64)
4170 jjCheckNAdd(61);
4171 if ((0x7fffffe87fffffeL & l) != 0L)
4172 jjCheckNAddTwoStates(59, 60);
4173 if ((0x7fffffe00000000L & l) != 0L)
4174 jjCheckNAddTwoStates(39, 40);
4175 else if ((0x7fffffeL & l) != 0L)
4176 jjCheckNAddTwoStates(38, 39);
4177 break;
4178 case 0:
4179 if ((0x7fffffec7fffffeL & l) != 0L)
4180 {
4181 if (kind > 69)
4182 kind = 69;
4183 jjCheckNAdd(69);
4184 }
4185 else if (curChar == 91)
4186 jjAddStates(86, 90);
4187 if ((0x7fffffe87fffffeL & l) != 0L)
4188 jjCheckNAddTwoStates(59, 60);
4189 else if (curChar == 91)
4190 jjstateSet[jjnewStateCnt++] = 65;
4191 if ((0x7fffffeL & l) != 0L)
4192 jjCheckNAddTwoStates(38, 39);
4193 else if (curChar == 104)
4194 jjAddStates(91, 92);
4195 else if (curChar == 110)
4196 jjstateSet[jjnewStateCnt++] = 57;
4197 else if (curChar == 102)
4198 jjstateSet[jjnewStateCnt++] = 53;
4199 if (curChar == 70)
4200 jjAddStates(93, 94);
4201 else if (curChar == 83)
4202 jjstateSet[jjnewStateCnt++] = 36;
4203 else if (curChar == 66)
4204 jjstateSet[jjnewStateCnt++] = 28;
4205 else if (curChar == 67)
4206 jjstateSet[jjnewStateCnt++] = 15;
4207 break;
4208 case 15:
4209 if ((0x7fffffec7fffffeL & l) != 0L)
4210 {
4211 if (kind > 69)
4212 kind = 69;
4213 jjCheckNAdd(69);
4214 }
4215 else if (curChar == 64)
4216 jjCheckNAdd(61);
4217 if ((0x7fffffe87fffffeL & l) != 0L)
4218 jjCheckNAddTwoStates(59, 60);
4219 if ((0x7fffffe00000000L & l) != 0L)
4220 jjCheckNAddTwoStates(39, 40);
4221 else if ((0x7fffffeL & l) != 0L)
4222 jjCheckNAddTwoStates(38, 39);
4223 if (curChar == 79)
4224 jjstateSet[jjnewStateCnt++] = 14;
4225 break;
4226 case 201:
4227 if ((0x7fffffe87fffffeL & l) != 0L)
4228 jjCheckNAddTwoStates(59, 60);
4229 else if (curChar == 64)
4230 jjCheckNAdd(61);
4231 break;
4232 case 2:
4233 if (kind > 2)
4234 kind = 2;
4235 jjstateSet[jjnewStateCnt++] = 2;
4236 break;
4237 case 5:
4238 if ((0x7fffffe87fffffeL & l) == 0L)
4239 break;
4240 if (kind > 39)
4241 kind = 39;
4242 jjstateSet[jjnewStateCnt++] = 5;
4243 break;
4244 case 6:
4245 if (curChar == 82)
4246 jjstateSet[jjnewStateCnt++] = 7;
4247 break;
4248 case 8:
4249 if ((0x7fffffe07fffffeL & l) != 0L)
4250 jjCheckNAddTwoStates(8, 9);
4251 break;
4252 case 12:
4253 if ((0x7e0000007eL & l) != 0L)
4254 jjCheckNAddTwoStates(12, 9);
4255 break;
4256 case 13:
4257 if (curChar == 79)
4258 jjstateSet[jjnewStateCnt++] = 6;
4259 break;
4260 case 14:
4261 if (curChar == 76)
4262 jjstateSet[jjnewStateCnt++] = 13;
4263 break;
4264 case 16:
4265 if (curChar == 67)
4266 jjstateSet[jjnewStateCnt++] = 15;
4267 break;
4268 case 17:
4269 if (curChar == 82)
4270 jjstateSet[jjnewStateCnt++] = 18;
4271 break;
4272 case 19:
4273 if ((0x7fffffe07fffffeL & l) != 0L)
4274 jjCheckNAddTwoStates(19, 20);
4275 break;
4276 case 23:
4277 if ((0x7e0000007eL & l) != 0L)
4278 jjCheckNAddTwoStates(23, 20);
4279 break;
4280 case 24:
4281 if (curChar == 79)
4282 jjstateSet[jjnewStateCnt++] = 17;
4283 break;
4284 case 25:
4285 if (curChar == 76)
4286 jjstateSet[jjnewStateCnt++] = 24;
4287 break;
4288 case 26:
4289 if (curChar == 79)
4290 jjstateSet[jjnewStateCnt++] = 25;
4291 break;
4292 case 27:
4293 if (curChar == 67)
4294 jjstateSet[jjnewStateCnt++] = 26;
4295 break;
4296 case 28:
4297 if (curChar == 71)
4298 jjstateSet[jjnewStateCnt++] = 27;
4299 break;
4300 case 29:
4301 if (curChar == 66)
4302 jjstateSet[jjnewStateCnt++] = 28;
4303 break;
4304 case 30:
4305 if (curChar == 69)
4306 jjstateSet[jjnewStateCnt++] = 31;
4307 break;
4308 case 35:
4309 if (curChar == 90)
4310 jjstateSet[jjnewStateCnt++] = 30;
4311 break;
4312 case 36:
4313 if (curChar == 73)
4314 jjstateSet[jjnewStateCnt++] = 35;
4315 break;
4316 case 37:
4317 if (curChar == 83)
4318 jjstateSet[jjnewStateCnt++] = 36;
4319 break;
4320 case 38:
4321 if ((0x7fffffeL & l) != 0L)
4322 jjCheckNAddTwoStates(38, 39);
4323 break;
4324 case 39:
4325 if ((0x7fffffe00000000L & l) != 0L)
4326 jjCheckNAddTwoStates(39, 40);
4327 break;
4328 case 40:
4329 if ((0x7fffffeL & l) != 0L)
4330 jjCheckNAddTwoStates(40, 41);
4331 break;
4332 case 41:
4333 if ((0x7fffffe00000000L & l) == 0L)
4334 break;
4335 if (kind > 61)
4336 kind = 61;
4337 jjCheckNAddTwoStates(40, 41);
4338 break;
4339 case 42:
4340 if (curChar == 112)
4341 jjCheckNAdd(52);
4342 break;
4343 case 44:
4344 if ((0x7fffffe07fffffeL & l) == 0L)
4345 break;
4346 if (kind > 62)
4347 kind = 62;
4348 jjCheckNAddStates(7, 10);
4349 break;
4350 case 46:
4351 if ((0x7fffffe07fffffeL & l) == 0L)
4352 break;
4353 if (kind > 62)
4354 kind = 62;
4355 jjCheckNAddStates(11, 14);
4356 break;
4357 case 50:
4358 if ((0x47fffffe87fffffeL & l) == 0L)
4359 break;
4360 if (kind > 62)
4361 kind = 62;
4362 jjCheckNAddTwoStates(49, 50);
4363 break;
4364 case 53:
4365 case 77:
4366 if (curChar == 116)
4367 jjCheckNAdd(42);
4368 break;
4369 case 54:
4370 if (curChar == 102)
4371 jjstateSet[jjnewStateCnt++] = 53;
4372 break;
4373 case 55:
4374 if (curChar == 115)
4375 jjCheckNAdd(52);
4376 break;
4377 case 56:
4378 if (curChar == 119)
4379 jjCheckNAdd(55);
4380 break;
4381 case 57:
4382 if (curChar == 101)
4383 jjstateSet[jjnewStateCnt++] = 56;
4384 break;
4385 case 58:
4386 if (curChar == 110)
4387 jjstateSet[jjnewStateCnt++] = 57;
4388 break;
4389 case 59:
4390 if ((0x7fffffe87fffffeL & l) != 0L)
4391 jjCheckNAddTwoStates(59, 60);
4392 break;
4393 case 60:
4394 if (curChar == 64)
4395 jjCheckNAdd(61);
4396 break;
4397 case 61:
4398 if ((0x7fffffe07fffffeL & l) == 0L)
4399 break;
4400 if (kind > 62)
4401 kind = 62;
4402 jjCheckNAddTwoStates(61, 62);
4403 break;
4404 case 63:
4405 if ((0x7fffffe07fffffeL & l) == 0L)
4406 break;
4407 if (kind > 62)
4408 kind = 62;
4409 jjCheckNAddTwoStates(62, 63);
4410 break;
4411 case 64:
4412 if (curChar == 91)
4413 jjstateSet[jjnewStateCnt++] = 65;
4414 break;
4415 case 66:
4416 if ((0x7fffffe07fffffeL & l) != 0L)
4417 jjCheckNAdd(67);
4418 break;
4419 case 67:
4420 if ((0x7fffffe07fffffeL & l) != 0L)
4421 jjCheckNAddTwoStates(67, 68);
4422 break;
4423 case 68:
4424 if (curChar == 93 && kind > 63)
4425 kind = 63;
4426 break;
4427 case 69:
4428 if ((0x7fffffec7fffffeL & l) == 0L)
4429 break;
4430 if (kind > 69)
4431 kind = 69;
4432 jjCheckNAdd(69);
4433 break;
4434 case 71:
4435 case 72:
4436 if ((0xc7ffffffd7ffffffL & l) != 0L)
4437 jjCheckNAddTwoStates(72, 73);
4438 break;
4439 case 75:
4440 if ((0x7fffffe87fffffeL & l) == 0L)
4441 break;
4442 if (kind > 71)
4443 kind = 71;
4444 jjstateSet[jjnewStateCnt++] = 75;
4445 break;
4446 case 76:
4447 if (curChar == 104)
4448 jjAddStates(91, 92);
4449 break;
4450 case 78:
4451 if (curChar == 116)
4452 jjstateSet[jjnewStateCnt++] = 77;
4453 break;
4454 case 79:
4455 if (curChar == 112)
4456 jjCheckNAdd(55);
4457 break;
4458 case 80:
4459 if (curChar == 116)
4460 jjstateSet[jjnewStateCnt++] = 79;
4461 break;
4462 case 81:
4463 if (curChar == 116)
4464 jjstateSet[jjnewStateCnt++] = 80;
4465 break;
4466 case 88:
4467 if (curChar == 70)
4468 jjAddStates(93, 94);
4469 break;
4470 case 89:
4471 if (curChar == 84)
4472 jjAddStates(95, 96);
4473 break;
4474 case 94:
4475 if (curChar == 70)
4476 jjstateSet[jjnewStateCnt++] = 89;
4477 break;
4478 case 95:
4479 if (curChar == 69)
4480 jjstateSet[jjnewStateCnt++] = 94;
4481 break;
4482 case 96:
4483 if (curChar == 76)
4484 jjstateSet[jjnewStateCnt++] = 95;
4485 break;
4486 case 97:
4487 if (curChar == 84)
4488 jjAddStates(97, 98);
4489 break;
4490 case 102:
4491 if (curChar == 72)
4492 jjstateSet[jjnewStateCnt++] = 97;
4493 break;
4494 case 103:
4495 if (curChar == 71)
4496 jjstateSet[jjnewStateCnt++] = 102;
4497 break;
4498 case 104:
4499 if (curChar == 73)
4500 jjstateSet[jjnewStateCnt++] = 103;
4501 break;
4502 case 105:
4503 if (curChar == 82)
4504 jjstateSet[jjnewStateCnt++] = 104;
4505 break;
4506 case 106:
4507 if (curChar == 91)
4508 jjAddStates(86, 90);
4509 break;
4510 case 107:
4511 if (curChar == 91)
4512 jjCheckNAdd(108);
4513 break;
4514 case 108:
4515 if ((0xffffffffd7ffffffL & l) != 0L)
4516 jjCheckNAddStates(17, 19);
4517 break;
4518 case 110:
4519 if ((0x7fffffe07fffffeL & l) != 0L)
4520 jjCheckNAdd(111);
4521 break;
4522 case 111:
4523 if ((0x7fffffe07fffffeL & l) != 0L)
4524 jjCheckNAddTwoStates(111, 113);
4525 break;
4526 case 112:
4527 if (curChar == 93 && kind > 64)
4528 kind = 64;
4529 break;
4530 case 113:
4531 if (curChar == 93)
4532 jjstateSet[jjnewStateCnt++] = 112;
4533 break;
4534 case 114:
4535 if (curChar == 91)
4536 jjCheckNAdd(115);
4537 break;
4538 case 115:
4539 if ((0xffffffffd7ffffffL & l) != 0L)
4540 jjCheckNAddTwoStates(115, 116);
4541 break;
4542 case 117:
4543 if (curChar == 112)
4544 jjCheckNAdd(129);
4545 break;
4546 case 119:
4547 if ((0x7fffffe07fffffeL & l) != 0L)
4548 jjCheckNAddStates(26, 30);
4549 break;
4550 case 121:
4551 if ((0x7fffffe07fffffeL & l) != 0L)
4552 jjCheckNAddStates(31, 35);
4553 break;
4554 case 125:
4555 if ((0x47fffffe87fffffeL & l) != 0L)
4556 jjCheckNAddStates(39, 41);
4557 break;
4558 case 126:
4559 if (curChar == 93 && kind > 65)
4560 kind = 65;
4561 break;
4562 case 127:
4563 if (curChar == 93)
4564 jjstateSet[jjnewStateCnt++] = 126;
4565 break;
4566 case 130:
4567 case 142:
4568 if (curChar == 116)
4569 jjCheckNAdd(117);
4570 break;
4571 case 131:
4572 if (curChar == 102)
4573 jjstateSet[jjnewStateCnt++] = 130;
4574 break;
4575 case 132:
4576 if (curChar == 115)
4577 jjCheckNAdd(129);
4578 break;
4579 case 133:
4580 if (curChar == 119)
4581 jjCheckNAdd(132);
4582 break;
4583 case 134:
4584 if (curChar == 101)
4585 jjstateSet[jjnewStateCnt++] = 133;
4586 break;
4587 case 135:
4588 if (curChar == 110)
4589 jjstateSet[jjnewStateCnt++] = 134;
4590 break;
4591 case 136:
4592 if ((0x7fffffe87fffffeL & l) != 0L)
4593 jjAddStates(99, 100);
4594 break;
4595 case 137:
4596 if (curChar == 64)
4597 jjCheckNAdd(138);
4598 break;
4599 case 138:
4600 if ((0x7fffffe07fffffeL & l) != 0L)
4601 jjCheckNAddStates(42, 44);
4602 break;
4603 case 140:
4604 if ((0x7fffffe07fffffeL & l) != 0L)
4605 jjCheckNAddStates(45, 47);
4606 break;
4607 case 141:
4608 if (curChar == 104)
4609 jjAddStates(101, 102);
4610 break;
4611 case 143:
4612 if (curChar == 116)
4613 jjstateSet[jjnewStateCnt++] = 142;
4614 break;
4615 case 144:
4616 if (curChar == 112)
4617 jjCheckNAdd(132);
4618 break;
4619 case 145:
4620 if (curChar == 116)
4621 jjstateSet[jjnewStateCnt++] = 144;
4622 break;
4623 case 146:
4624 if (curChar == 116)
4625 jjstateSet[jjnewStateCnt++] = 145;
4626 break;
4627 case 147:
4628 if (curChar == 91)
4629 jjCheckNAdd(148);
4630 break;
4631 case 148:
4632 if ((0xffffffffd7ffffffL & l) != 0L)
4633 jjCheckNAddTwoStates(148, 149);
4634 break;
4635 case 150:
4636 if ((0xffffffffd7ffffffL & l) != 0L)
4637 jjCheckNAddStates(50, 52);
4638 break;
4639 case 152:
4640 if ((0x7fffffe07fffffeL & l) != 0L)
4641 jjCheckNAdd(153);
4642 break;
4643 case 153:
4644 if ((0x7fffffe07fffffeL & l) != 0L)
4645 jjCheckNAddTwoStates(153, 155);
4646 break;
4647 case 154:
4648 if (curChar == 93 && kind > 66)
4649 kind = 66;
4650 break;
4651 case 155:
4652 if (curChar == 93)
4653 jjstateSet[jjnewStateCnt++] = 154;
4654 break;
4655 case 156:
4656 if (curChar == 91)
4657 jjCheckNAdd(157);
4658 break;
4659 case 157:
4660 if ((0xffffffffd7ffffffL & l) != 0L)
4661 jjCheckNAddTwoStates(157, 158);
4662 break;
4663 case 159:
4664 if (curChar == 112)
4665 jjCheckNAdd(171);
4666 break;
4667 case 161:
4668 if ((0x7fffffe07fffffeL & l) != 0L)
4669 jjCheckNAddStates(59, 63);
4670 break;
4671 case 163:
4672 if ((0x7fffffe07fffffeL & l) != 0L)
4673 jjCheckNAddStates(64, 68);
4674 break;
4675 case 167:
4676 if ((0x47fffffe87fffffeL & l) != 0L)
4677 jjCheckNAddStates(72, 74);
4678 break;
4679 case 168:
4680 if (curChar == 93 && kind > 67)
4681 kind = 67;
4682 break;
4683 case 169:
4684 if (curChar == 93)
4685 jjstateSet[jjnewStateCnt++] = 168;
4686 break;
4687 case 172:
4688 case 184:
4689 if (curChar == 116)
4690 jjCheckNAdd(159);
4691 break;
4692 case 173:
4693 if (curChar == 102)
4694 jjstateSet[jjnewStateCnt++] = 172;
4695 break;
4696 case 174:
4697 if (curChar == 115)
4698 jjCheckNAdd(171);
4699 break;
4700 case 175:
4701 if (curChar == 119)
4702 jjCheckNAdd(174);
4703 break;
4704 case 176:
4705 if (curChar == 101)
4706 jjstateSet[jjnewStateCnt++] = 175;
4707 break;
4708 case 177:
4709 if (curChar == 110)
4710 jjstateSet[jjnewStateCnt++] = 176;
4711 break;
4712 case 178:
4713 if ((0x7fffffe87fffffeL & l) != 0L)
4714 jjAddStates(103, 104);
4715 break;
4716 case 179:
4717 if (curChar == 64)
4718 jjCheckNAdd(180);
4719 break;
4720 case 180:
4721 if ((0x7fffffe07fffffeL & l) != 0L)
4722 jjCheckNAddStates(75, 77);
4723 break;
4724 case 182:
4725 if ((0x7fffffe07fffffeL & l) != 0L)
4726 jjCheckNAddStates(78, 80);
4727 break;
4728 case 183:
4729 if (curChar == 104)
4730 jjAddStates(105, 106);
4731 break;
4732 case 185:
4733 if (curChar == 116)
4734 jjstateSet[jjnewStateCnt++] = 184;
4735 break;
4736 case 186:
4737 if (curChar == 112)
4738 jjCheckNAdd(174);
4739 break;
4740 case 187:
4741 if (curChar == 116)
4742 jjstateSet[jjnewStateCnt++] = 186;
4743 break;
4744 case 188:
4745 if (curChar == 116)
4746 jjstateSet[jjnewStateCnt++] = 187;
4747 break;
4748 case 189:
4749 if (curChar == 91)
4750 jjCheckNAdd(190);
4751 break;
4752 case 190:
4753 if ((0xffffffffd7ffffffL & l) != 0L)
4754 jjCheckNAddTwoStates(190, 191);
4755 break;
4756 case 192:
4757 if ((0xffffffffd7ffffffL & l) != 0L)
4758 jjCheckNAddStates(83, 85);
4759 break;
4760 case 194:
4761 if ((0x7fffffe07fffffeL & l) != 0L)
4762 jjCheckNAdd(195);
4763 break;
4764 case 195:
4765 if ((0x7fffffe07fffffeL & l) != 0L)
4766 jjCheckNAddTwoStates(195, 197);
4767 break;
4768 case 196:
4769 if (curChar == 93 && kind > 68)
4770 kind = 68;
4771 break;
4772 case 197:
4773 if (curChar == 93)
4774 jjstateSet[jjnewStateCnt++] = 196;
4775 break;
4776 case 199:
4777 if ((0x7fffffe07fffffeL & l) != 0L)
4778 jjCheckNAdd(200);
4779 break;
4780 case 200:
4781 if ((0x7fffffe07fffffeL & l) != 0L)
4782 jjCheckNAddTwoStates(200, 197);
4783 break;
4784 default : break;
4785 }
4786 } while(i != startsAt);
4787 }
4788 else
4789 {
4790 int hiByte = (int)(curChar >> 8);
4791 int i1 = hiByte >> 6;
4792 long l1 = 1L << (hiByte & 077);
4793 int i2 = (curChar & 0xff) >> 6;
4794 long l2 = 1L << (curChar & 077);
4795 MatchLoop: do
4796 {
4797 switch(jjstateSet[--i])
4798 {
4799 case 202:
4800 case 69:
4801 if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
4802 break;
4803 if (kind > 69)
4804 kind = 69;
4805 jjCheckNAdd(69);
4806 break;
4807 case 0:
4808 if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
4809 break;
4810 if (kind > 69)
4811 kind = 69;
4812 jjCheckNAdd(69);
4813 break;
4814 case 15:
4815 if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
4816 break;
4817 if (kind > 69)
4818 kind = 69;
4819 jjCheckNAdd(69);
4820 break;
4821 case 2:
4822 if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
4823 break;
4824 if (kind > 2)
4825 kind = 2;
4826 jjstateSet[jjnewStateCnt++] = 2;
4827 break;
4828 case 71:
4829 case 72:
4830 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
4831 jjCheckNAddTwoStates(72, 73);
4832 break;
4833 case 108:
4834 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
4835 jjAddStates(17, 19);
4836 break;
4837 case 115:
4838 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
4839 jjAddStates(20, 21);
4840 break;
4841 case 148:
4842 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
4843 jjAddStates(48, 49);
4844 break;
4845 case 150:
4846 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
4847 jjAddStates(50, 52);
4848 break;
4849 case 157:
4850 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
4851 jjAddStates(53, 54);
4852 break;
4853 case 190:
4854 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
4855 jjAddStates(81, 82);
4856 break;
4857 case 192:
4858 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
4859 jjAddStates(83, 85);
4860 break;
4861 default : break;
4862 }
4863 } while(i != startsAt);
4864 }
4865 if (kind != 0x7fffffff)
4866 {
4867 jjmatchedKind = kind;
4868 jjmatchedPos = curPos;
4869 kind = 0x7fffffff;
4870 }
4871 ++curPos;
4872 if ((i = jjnewStateCnt) == (startsAt = 201 - (jjnewStateCnt = startsAt)))
4873 return curPos;
4874 try { curChar = input_stream.readChar(); }
4875 catch(java.io.IOException e) { return curPos; }
4876 }
4877 }
4878 static final int[] jjnextStates = {
4879 83, 84, 87, 8, 11, 19, 22, 44, 45, 47, 49, 45, 46, 47, 49, 67,
4880 68, 108, 109, 113, 115, 116, 131, 135, 136, 141, 119, 120, 122, 124, 127, 120,
4881 121, 122, 124, 127, 123, 124, 127, 124, 125, 127, 138, 139, 127, 139, 140, 127,
4882 148, 149, 150, 151, 155, 157, 158, 173, 177, 178, 183, 161, 162, 164, 166, 169,
4883 162, 163, 164, 166, 169, 165, 166, 169, 166, 167, 169, 180, 181, 169, 181, 182,
4884 169, 190, 191, 192, 193, 197, 107, 114, 147, 156, 189, 78, 81, 96, 105, 90,
4885 93, 98, 101, 136, 137, 143, 146, 178, 179, 185, 188,
4886 };
4887 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
4888 {
4889 switch(hiByte)
4890 {
4891 case 0:
4892 return ((jjbitVec2[i2] & l2) != 0L);
4893 default :
4894 if ((jjbitVec0[i1] & l1) != 0L)
4895 return true;
4896 return false;
4897 }
4898 }
4899 private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2)
4900 {
4901 switch(hiByte)
4902 {
4903 case 215:
4904 return ((jjbitVec4[i2] & l2) != 0L);
4905 default :
4906 if ((jjbitVec3[i1] & l1) != 0L)
4907 return true;
4908 return false;
4909 }
4910 }
4911 public static final String[] jjstrLiteralImages = {
4912 "", null, null, null, null, null, null, null, null, "\12", "\176", "\73",
4913 "\50", "\51", "\133", "\135", "\173", "\175", "\57", "\74", "\76", "\76\76",
4914 "\76\76\76", "\55", "\55\55", "\55\55\55", "\53", "\53\53", "\53\53\53", "\40", "\52",
4915 "\52\52", "\52\52\52", "\114\105\106\124\72", "\103\105\116\124\105\122\72",
4916 "\122\111\107\110\124\72", null, null, "\55\55\55\55", null, null, null, null, "\75\75", "\12\174",
4917 "\12\72", "\12\54", "\174", "\72", "\54", "\174", "\76\174", "\176\174", "\54", null,
4918 null, null, null, null, "\45\45", null, null, null, null, null, null, null, null,
4919 null, null, null, null, null, "\50\50", "\51\51", };
4920 public static final String[] lexStateNames = {
4921 "CTAB",
4922 "NTAB",
4923 "DEFAULT",
4924 };
4925 public static final int[] jjnewLexState = {
4926 -1, -1, -1, -1, -1, -1, -1, -1, -1, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4927 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 0, -1, -1, -1,
4928 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4929 };
4930 static final long[] jjtoToken = {
4931 0xf83ffffffffffe01L, 0x7ffL,
4932 };
4933 static final long[] jjtoSkip = {
4934 0x6L, 0x0L,
4935 };
4936 protected JavaCharStream input_stream;
4937 private final int[] jjrounds = new int[201];
4938 private final int[] jjstateSet = new int[402];
4939 StringBuffer image;
4940 int jjimageLen;
4941 int lengthOfMatch;
4942 protected char curChar;
4943 public WikiParserTokenManager(JavaCharStream stream)
4944 {
4945 if (JavaCharStream.staticFlag)
4946 throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
4947 input_stream = stream;
4948 }
4949 public WikiParserTokenManager(JavaCharStream stream, int lexState)
4950 {
4951 this(stream);
4952 SwitchTo(lexState);
4953 }
4954 public void ReInit(JavaCharStream stream)
4955 {
4956 jjmatchedPos = jjnewStateCnt = 0;
4957 curLexState = defaultLexState;
4958 input_stream = stream;
4959 ReInitRounds();
4960 }
4961 private final void ReInitRounds()
4962 {
4963 int i;
4964 jjround = 0x80000001;
4965 for (i = 201; i-- > 0;)
4966 jjrounds[i] = 0x80000000;
4967 }
4968 public void ReInit(JavaCharStream stream, int lexState)
4969 {
4970 ReInit(stream);
4971 SwitchTo(lexState);
4972 }
4973 public void SwitchTo(int lexState)
4974 {
4975 if (lexState >= 3 || lexState < 0)
4976 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
4977 else
4978 curLexState = lexState;
4979 }
4980
4981 protected Token jjFillToken()
4982 {
4983 Token t = Token.newToken(jjmatchedKind);
4984 t.kind = jjmatchedKind;
4985 String im = jjstrLiteralImages[jjmatchedKind];
4986 t.image = (im == null) ? input_stream.GetImage() : im;
4987 t.beginLine = input_stream.getBeginLine();
4988 t.beginColumn = input_stream.getBeginColumn();
4989 t.endLine = input_stream.getEndLine();
4990 t.endColumn = input_stream.getEndColumn();
4991 return t;
4992 }
4993
4994 int curLexState = 2;
4995 int defaultLexState = 2;
4996 int jjnewStateCnt;
4997 int jjround;
4998 int jjmatchedPos;
4999 int jjmatchedKind;
5000
5001 public Token getNextToken()
5002 {
5003 int kind;
5004 Token specialToken = null;
5005 Token matchedToken;
5006 int curPos = 0;
5007
5008 EOFLoop :
5009 for (;;)
5010 {
5011 try
5012 {
5013 curChar = input_stream.BeginToken();
5014 }
5015 catch(java.io.IOException e)
5016 {
5017 jjmatchedKind = 0;
5018 matchedToken = jjFillToken();
5019 return matchedToken;
5020 }
5021 image = null;
5022 jjimageLen = 0;
5023
5024 switch(curLexState)
5025 {
5026 case 0:
5027 try { input_stream.backup(0);
5028 while (curChar <= 13 && (0x2000L & (1L << curChar)) != 0L)
5029 curChar = input_stream.BeginToken();
5030 }
5031 catch (java.io.IOException e1) { continue EOFLoop; }
5032 jjmatchedKind = 0x7fffffff;
5033 jjmatchedPos = 0;
5034 curPos = jjMoveStringLiteralDfa0_0();
5035 if (jjmatchedPos == 0 && jjmatchedKind > 72)
5036 {
5037 jjmatchedKind = 72;
5038 }
5039 break;
5040 case 1:
5041 try { input_stream.backup(0);
5042 while (curChar <= 13 && (0x2000L & (1L << curChar)) != 0L)
5043 curChar = input_stream.BeginToken();
5044 }
5045 catch (java.io.IOException e1) { continue EOFLoop; }
5046 jjmatchedKind = 0x7fffffff;
5047 jjmatchedPos = 0;
5048 curPos = jjMoveStringLiteralDfa0_1();
5049 if (jjmatchedPos == 0 && jjmatchedKind > 72)
5050 {
5051 jjmatchedKind = 72;
5052 }
5053 break;
5054 case 2:
5055 try { input_stream.backup(0);
5056 while (curChar <= 13 && (0x2000L & (1L << curChar)) != 0L)
5057 curChar = input_stream.BeginToken();
5058 }
5059 catch (java.io.IOException e1) { continue EOFLoop; }
5060 jjmatchedKind = 0x7fffffff;
5061 jjmatchedPos = 0;
5062 curPos = jjMoveStringLiteralDfa0_2();
5063 if (jjmatchedPos == 0 && jjmatchedKind > 72)
5064 {
5065 jjmatchedKind = 72;
5066 }
5067 break;
5068 }
5069 if (jjmatchedKind != 0x7fffffff)
5070 {
5071 if (jjmatchedPos + 1 < curPos)
5072 input_stream.backup(curPos - jjmatchedPos - 1);
5073 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
5074 {
5075 matchedToken = jjFillToken();
5076 TokenLexicalActions(matchedToken);
5077 if (jjnewLexState[jjmatchedKind] != -1)
5078 curLexState = jjnewLexState[jjmatchedKind];
5079 return matchedToken;
5080 }
5081 else
5082 {
5083 if (jjnewLexState[jjmatchedKind] != -1)
5084 curLexState = jjnewLexState[jjmatchedKind];
5085 continue EOFLoop;
5086 }
5087 }
5088 int error_line = input_stream.getEndLine();
5089 int error_column = input_stream.getEndColumn();
5090 String error_after = null;
5091 boolean EOFSeen = false;
5092 try { input_stream.readChar(); input_stream.backup(1); }
5093 catch (java.io.IOException e1) {
5094 EOFSeen = true;
5095 error_after = curPos <= 1 ? "" : input_stream.GetImage();
5096 if (curChar == '\n' || curChar == '\r') {
5097 error_line++;
5098 error_column = 0;
5099 }
5100 else
5101 error_column++;
5102 }
5103 if (!EOFSeen) {
5104 input_stream.backup(1);
5105 error_after = curPos <= 1 ? "" : input_stream.GetImage();
5106 }
5107 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
5108 }
5109 }
5110
5111 void TokenLexicalActions(Token matchedToken)
5112 {
5113 switch(jjmatchedKind)
5114 {
5115 case 72 :
5116 if (image == null)
5117 image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
5118 else
5119 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
5120 ++nLexicalErrors_;
5121 tokenLog.info("unknown token " + image);
5122 break;
5123 default :
5124 break;
5125 }
5126 }
5127 }