KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > jboss > aop > pointcut > ast > PointcutExpressionParserTokenManager


1 /* Generated By:JJTree&JavaCC: Do not edit this line. PointcutExpressionParserTokenManager.java */
2 package org.jboss.aop.pointcut.ast;
3 import java.lang.reflect.Modifier JavaDoc;
4
5 public class PointcutExpressionParserTokenManager implements PointcutExpressionParserConstants
6 {
7   public java.io.PrintStream JavaDoc debugStream = System.out;
8   public void setDebugStream(java.io.PrintStream JavaDoc ds) { debugStream = ds; }
9 private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1)
10 {
11    switch (pos)
12    {
13       case 0:
14          if ((active0 & 0x40L) != 0L)
15          {
16             jjmatchedKind = 16;
17             return 1;
18          }
19          if ((active0 & 0xffa0L) != 0L)
20          {
21             jjmatchedKind = 16;
22             return 10;
23          }
24          return -1;
25       case 1:
26          if ((active0 & 0xffe0L) != 0L)
27          {
28             jjmatchedKind = 16;
29             jjmatchedPos = 1;
30             return 10;
31          }
32          return -1;
33       case 2:
34          if ((active0 & 0xffe0L) != 0L)
35          {
36             jjmatchedKind = 16;
37             jjmatchedPos = 2;
38             return 10;
39          }
40          return -1;
41       case 3:
42          if ((active0 & 0xe5a0L) != 0L)
43          {
44             jjmatchedKind = 16;
45             jjmatchedPos = 3;
46             return 10;
47          }
48          return -1;
49       case 4:
50          if ((active0 & 0xe580L) != 0L)
51          {
52             jjmatchedKind = 16;
53             jjmatchedPos = 4;
54             return 10;
55          }
56          return -1;
57       case 5:
58          if ((active0 & 0xc580L) != 0L)
59          {
60             jjmatchedKind = 16;
61             jjmatchedPos = 5;
62             return 10;
63          }
64          return -1;
65       case 6:
66          if ((active0 & 0x8580L) != 0L)
67          {
68             jjmatchedKind = 16;
69             jjmatchedPos = 6;
70             return 10;
71          }
72          return -1;
73       case 7:
74          if ((active0 & 0x8580L) != 0L)
75          {
76             jjmatchedKind = 16;
77             jjmatchedPos = 7;
78             return 10;
79          }
80          return -1;
81       case 8:
82          if ((active0 & 0x8180L) != 0L)
83          {
84             jjmatchedKind = 16;
85             jjmatchedPos = 8;
86             return 10;
87          }
88          return -1;
89       case 9:
90          if ((active0 & 0x8100L) != 0L)
91          {
92             jjmatchedKind = 16;
93             jjmatchedPos = 9;
94             return 10;
95          }
96          return -1;
97       case 10:
98          if ((active0 & 0x100L) != 0L)
99          {
100             jjmatchedKind = 16;
101             jjmatchedPos = 10;
102             return 10;
103          }
104          return -1;
105       case 11:
106          if ((active0 & 0x100L) != 0L)
107          {
108             jjmatchedKind = 16;
109             jjmatchedPos = 11;
110             return 10;
111          }
112          return -1;
113       default :
114          return -1;
115    }
116 }
117 private final int jjStartNfa_0(int pos, long active0, long active1)
118 {
119    return jjMoveNfa_0(jjStopStringLiteralDfa_0(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_0(int pos, int kind, int state)
128 {
129    jjmatchedKind = kind;
130    jjmatchedPos = pos;
131    try { curChar = input_stream.readChar(); }
132    catch(java.io.IOException JavaDoc e) { return pos + 1; }
133    return jjMoveNfa_0(state, pos + 1);
134 }
135 private final int jjMoveStringLiteralDfa0_0()
136 {
137    switch(curChar)
138    {
139       case 33:
140          return jjStopAtPos(0, 20);
141       case 40:
142          return jjStopAtPos(0, 86);
143       case 41:
144          return jjStopAtPos(0, 87);
145       case 97:
146          return jjMoveStringLiteralDfa1_0(0x40L);
147       case 99:
148          return jjMoveStringLiteralDfa1_0(0x120L);
149       case 101:
150          return jjMoveStringLiteralDfa1_0(0x80L);
151       case 102:
152          return jjMoveStringLiteralDfa1_0(0x2000L);
153       case 103:
154          return jjMoveStringLiteralDfa1_0(0x800L);
155       case 104:
156          return jjMoveStringLiteralDfa1_0(0x600L);
157       case 115:
158          return jjMoveStringLiteralDfa1_0(0x1000L);
159       case 119:
160          return jjMoveStringLiteralDfa1_0(0xc000L);
161       default :
162          return jjMoveNfa_0(0, 0);
163    }
164 }
165 private final int jjMoveStringLiteralDfa1_0(long active0)
166 {
167    try { curChar = input_stream.readChar(); }
168    catch(java.io.IOException JavaDoc e) {
169       jjStopStringLiteralDfa_0(0, active0, 0L);
170       return 1;
171    }
172    switch(curChar)
173    {
174       case 97:
175          return jjMoveStringLiteralDfa2_0(active0, 0x620L);
176       case 101:
177          return jjMoveStringLiteralDfa2_0(active0, 0x1800L);
178       case 105:
179          return jjMoveStringLiteralDfa2_0(active0, 0xe000L);
180       case 108:
181          return jjMoveStringLiteralDfa2_0(active0, 0x40L);
182       case 111:
183          return jjMoveStringLiteralDfa2_0(active0, 0x100L);
184       case 120:
185          return jjMoveStringLiteralDfa2_0(active0, 0x80L);
186       default :
187          break;
188    }
189    return jjStartNfa_0(0, active0, 0L);
190 }
191 private final int jjMoveStringLiteralDfa2_0(long old0, long active0)
192 {
193    if (((active0 &= old0)) == 0L)
194       return jjStartNfa_0(0, old0, 0L);
195    try { curChar = input_stream.readChar(); }
196    catch(java.io.IOException JavaDoc e) {
197       jjStopStringLiteralDfa_0(1, active0, 0L);
198       return 2;
199    }
200    switch(curChar)
201    {
202       case 101:
203          return jjMoveStringLiteralDfa3_0(active0, 0x2080L);
204       case 108:
205          return jjMoveStringLiteralDfa3_0(active0, 0x60L);
206       case 110:
207          return jjMoveStringLiteralDfa3_0(active0, 0x100L);
208       case 115:
209          return jjMoveStringLiteralDfa3_0(active0, 0x600L);
210       case 116:
211          return jjMoveStringLiteralDfa3_0(active0, 0xd800L);
212       default :
213          break;
214    }
215    return jjStartNfa_0(1, active0, 0L);
216 }
217 private final int jjMoveStringLiteralDfa3_0(long old0, long active0)
218 {
219    if (((active0 &= old0)) == 0L)
220       return jjStartNfa_0(1, old0, 0L);
221    try { curChar = input_stream.readChar(); }
222    catch(java.io.IOException JavaDoc e) {
223       jjStopStringLiteralDfa_0(2, active0, 0L);
224       return 3;
225    }
226    switch(curChar)
227    {
228       case 40:
229          if ((active0 & 0x40L) != 0L)
230             return jjStopAtPos(3, 6);
231          else if ((active0 & 0x200L) != 0L)
232             return jjStopAtPos(3, 9);
233          else if ((active0 & 0x800L) != 0L)
234             return jjStopAtPos(3, 11);
235          else if ((active0 & 0x1000L) != 0L)
236             return jjStopAtPos(3, 12);
237          break;
238       case 99:
239          return jjMoveStringLiteralDfa4_0(active0, 0x80L);
240       case 102:
241          return jjMoveStringLiteralDfa4_0(active0, 0x400L);
242       case 104:
243          return jjMoveStringLiteralDfa4_0(active0, 0xc000L);
244       case 108:
245          return jjMoveStringLiteralDfa4_0(active0, 0x2020L);
246       case 115:
247          return jjMoveStringLiteralDfa4_0(active0, 0x100L);
248       default :
249          break;
250    }
251    return jjStartNfa_0(2, active0, 0L);
252 }
253 private final int jjMoveStringLiteralDfa4_0(long old0, long active0)
254 {
255    if (((active0 &= old0)) == 0L)
256       return jjStartNfa_0(2, old0, 0L);
257    try { curChar = input_stream.readChar(); }
258    catch(java.io.IOException JavaDoc e) {
259       jjStopStringLiteralDfa_0(3, active0, 0L);
260       return 4;
261    }
262    switch(curChar)
263    {
264       case 40:
265          if ((active0 & 0x20L) != 0L)
266             return jjStopAtPos(4, 5);
267          break;
268       case 100:
269          return jjMoveStringLiteralDfa5_0(active0, 0x2000L);
270       case 105:
271          return jjMoveStringLiteralDfa5_0(active0, 0xc400L);
272       case 116:
273          return jjMoveStringLiteralDfa5_0(active0, 0x100L);
274       case 117:
275          return jjMoveStringLiteralDfa5_0(active0, 0x80L);
276       default :
277          break;
278    }
279    return jjStartNfa_0(3, active0, 0L);
280 }
281 private final int jjMoveStringLiteralDfa5_0(long old0, long active0)
282 {
283    if (((active0 &= old0)) == 0L)
284       return jjStartNfa_0(3, old0, 0L);
285    try { curChar = input_stream.readChar(); }
286    catch(java.io.IOException JavaDoc e) {
287       jjStopStringLiteralDfa_0(4, active0, 0L);
288       return 5;
289    }
290    switch(curChar)
291    {
292       case 40:
293          if ((active0 & 0x2000L) != 0L)
294             return jjStopAtPos(5, 13);
295          break;
296       case 101:
297          return jjMoveStringLiteralDfa6_0(active0, 0x400L);
298       case 110:
299          return jjMoveStringLiteralDfa6_0(active0, 0xc000L);
300       case 114:
301          return jjMoveStringLiteralDfa6_0(active0, 0x100L);
302       case 116:
303          return jjMoveStringLiteralDfa6_0(active0, 0x80L);
304       default :
305          break;
306    }
307    return jjStartNfa_0(4, active0, 0L);
308 }
309 private final int jjMoveStringLiteralDfa6_0(long old0, long active0)
310 {
311    if (((active0 &= old0)) == 0L)
312       return jjStartNfa_0(4, old0, 0L);
313    try { curChar = input_stream.readChar(); }
314    catch(java.io.IOException JavaDoc e) {
315       jjStopStringLiteralDfa_0(5, active0, 0L);
316       return 6;
317    }
318    switch(curChar)
319    {
320       case 40:
321          if ((active0 & 0x4000L) != 0L)
322             return jjStopAtPos(6, 14);
323          break;
324       case 99:
325          return jjMoveStringLiteralDfa7_0(active0, 0x8000L);
326       case 105:
327          return jjMoveStringLiteralDfa7_0(active0, 0x80L);
328       case 108:
329          return jjMoveStringLiteralDfa7_0(active0, 0x400L);
330       case 117:
331          return jjMoveStringLiteralDfa7_0(active0, 0x100L);
332       default :
333          break;
334    }
335    return jjStartNfa_0(5, active0, 0L);
336 }
337 private final int jjMoveStringLiteralDfa7_0(long old0, long active0)
338 {
339    if (((active0 &= old0)) == 0L)
340       return jjStartNfa_0(5, old0, 0L);
341    try { curChar = input_stream.readChar(); }
342    catch(java.io.IOException JavaDoc e) {
343       jjStopStringLiteralDfa_0(6, active0, 0L);
344       return 7;
345    }
346    switch(curChar)
347    {
348       case 99:
349          return jjMoveStringLiteralDfa8_0(active0, 0x100L);
350       case 100:
351          return jjMoveStringLiteralDfa8_0(active0, 0x400L);
352       case 111:
353          return jjMoveStringLiteralDfa8_0(active0, 0x8080L);
354       default :
355          break;
356    }
357    return jjStartNfa_0(6, active0, 0L);
358 }
359 private final int jjMoveStringLiteralDfa8_0(long old0, long active0)
360 {
361    if (((active0 &= old0)) == 0L)
362       return jjStartNfa_0(6, old0, 0L);
363    try { curChar = input_stream.readChar(); }
364    catch(java.io.IOException JavaDoc e) {
365       jjStopStringLiteralDfa_0(7, active0, 0L);
366       return 8;
367    }
368    switch(curChar)
369    {
370       case 40:
371          if ((active0 & 0x400L) != 0L)
372             return jjStopAtPos(8, 10);
373          break;
374       case 100:
375          return jjMoveStringLiteralDfa9_0(active0, 0x8000L);
376       case 110:
377          return jjMoveStringLiteralDfa9_0(active0, 0x80L);
378       case 116:
379          return jjMoveStringLiteralDfa9_0(active0, 0x100L);
380       default :
381          break;
382    }
383    return jjStartNfa_0(7, active0, 0L);
384 }
385 private final int jjMoveStringLiteralDfa9_0(long old0, long active0)
386 {
387    if (((active0 &= old0)) == 0L)
388       return jjStartNfa_0(7, old0, 0L);
389    try { curChar = input_stream.readChar(); }
390    catch(java.io.IOException JavaDoc e) {
391       jjStopStringLiteralDfa_0(8, active0, 0L);
392       return 9;
393    }
394    switch(curChar)
395    {
396       case 40:
397          if ((active0 & 0x80L) != 0L)
398             return jjStopAtPos(9, 7);
399          break;
400       case 101:
401          return jjMoveStringLiteralDfa10_0(active0, 0x8000L);
402       case 105:
403          return jjMoveStringLiteralDfa10_0(active0, 0x100L);
404       default :
405          break;
406    }
407    return jjStartNfa_0(8, active0, 0L);
408 }
409 private final int jjMoveStringLiteralDfa10_0(long old0, long active0)
410 {
411    if (((active0 &= old0)) == 0L)
412       return jjStartNfa_0(8, old0, 0L);
413    try { curChar = input_stream.readChar(); }
414    catch(java.io.IOException JavaDoc e) {
415       jjStopStringLiteralDfa_0(9, active0, 0L);
416       return 10;
417    }
418    switch(curChar)
419    {
420       case 40:
421          if ((active0 & 0x8000L) != 0L)
422             return jjStopAtPos(10, 15);
423          break;
424       case 111:
425          return jjMoveStringLiteralDfa11_0(active0, 0x100L);
426       default :
427          break;
428    }
429    return jjStartNfa_0(9, active0, 0L);
430 }
431 private final int jjMoveStringLiteralDfa11_0(long old0, long active0)
432 {
433    if (((active0 &= old0)) == 0L)
434       return jjStartNfa_0(9, old0, 0L);
435    try { curChar = input_stream.readChar(); }
436    catch(java.io.IOException JavaDoc e) {
437       jjStopStringLiteralDfa_0(10, active0, 0L);
438       return 11;
439    }
440    switch(curChar)
441    {
442       case 110:
443          return jjMoveStringLiteralDfa12_0(active0, 0x100L);
444       default :
445          break;
446    }
447    return jjStartNfa_0(10, active0, 0L);
448 }
449 private final int jjMoveStringLiteralDfa12_0(long old0, long active0)
450 {
451    if (((active0 &= old0)) == 0L)
452       return jjStartNfa_0(10, old0, 0L);
453    try { curChar = input_stream.readChar(); }
454    catch(java.io.IOException JavaDoc e) {
455       jjStopStringLiteralDfa_0(11, active0, 0L);
456       return 12;
457    }
458    switch(curChar)
459    {
460       case 40:
461          if ((active0 & 0x100L) != 0L)
462             return jjStopAtPos(12, 8);
463          break;
464       default :
465          break;
466    }
467    return jjStartNfa_0(11, active0, 0L);
468 }
469 private final void jjCheckNAdd(int state)
470 {
471    if (jjrounds[state] != jjround)
472    {
473       jjstateSet[jjnewStateCnt++] = state;
474       jjrounds[state] = jjround;
475    }
476 }
477 private final void jjAddStates(int start, int end)
478 {
479    do {
480       jjstateSet[jjnewStateCnt++] = jjnextStates[start];
481    } while (start++ != end);
482 }
483 private final void jjCheckNAddTwoStates(int state1, int state2)
484 {
485    jjCheckNAdd(state1);
486    jjCheckNAdd(state2);
487 }
488 private final void jjCheckNAddStates(int start, int end)
489 {
490    do {
491       jjCheckNAdd(jjnextStates[start]);
492    } while (start++ != end);
493 }
494 private final void jjCheckNAddStates(int start)
495 {
496    jjCheckNAdd(jjnextStates[start]);
497    jjCheckNAdd(jjnextStates[start + 1]);
498 }
499 private final int jjMoveNfa_0(int startState, int curPos)
500 {
501    int[] nextStates;
502    int startsAt = 0;
503    jjnewStateCnt = 10;
504    int i = 1;
505    jjstateSet[0] = startState;
506    int j, kind = 0x7fffffff;
507    for (;;)
508    {
509       if (++jjround == 0x7fffffff)
510          ReInitRounds();
511       if (curChar < 64)
512       {
513          long l = 1L << curChar;
514          MatchLoop: do
515          {
516             switch(jjstateSet[--i])
517             {
518                case 10:
519                   if ((0x3ff000000000000L & l) != 0L)
520                   {
521                      if (kind > 17)
522                         kind = 17;
523                      jjCheckNAdd(9);
524                   }
525                   else if (curChar == 46)
526                      jjCheckNAdd(8);
527                   if ((0x3ff000000000000L & l) != 0L)
528                   {
529                      if (kind > 16)
530                         kind = 16;
531                      jjCheckNAddTwoStates(6, 7);
532                   }
533                   break;
534                case 0:
535                   if ((0x3ff000000000000L & l) == 0L)
536                      break;
537                   if (kind > 16)
538                      kind = 16;
539                   jjCheckNAddStates(0, 2);
540                   break;
541                case 1:
542                   if ((0x3ff000000000000L & l) != 0L)
543                   {
544                      if (kind > 17)
545                         kind = 17;
546                      jjCheckNAdd(9);
547                   }
548                   else if (curChar == 46)
549                      jjCheckNAdd(8);
550                   if ((0x3ff000000000000L & l) != 0L)
551                   {
552                      if (kind > 16)
553                         kind = 16;
554                      jjCheckNAddTwoStates(6, 7);
555                   }
556                   break;
557                case 6:
558                   if ((0x3ff000000000000L & l) == 0L)
559                      break;
560                   if (kind > 16)
561                      kind = 16;
562                   jjCheckNAddTwoStates(6, 7);
563                   break;
564                case 7:
565                   if (curChar == 46)
566                      jjCheckNAdd(8);
567                   break;
568                case 8:
569                   if ((0x3ff000000000000L & l) == 0L)
570                      break;
571                   if (kind > 16)
572                      kind = 16;
573                   jjCheckNAddTwoStates(7, 8);
574                   break;
575                case 9:
576                   if ((0x3ff000000000000L & l) == 0L)
577                      break;
578                   if (kind > 17)
579                      kind = 17;
580                   jjCheckNAdd(9);
581                   break;
582                default : break;
583             }
584          } while(i != startsAt);
585       }
586       else if (curChar < 128)
587       {
588          long l = 1L << (curChar & 077);
589          MatchLoop: do
590          {
591             switch(jjstateSet[--i])
592             {
593                case 10:
594                   if ((0x7fffffe87fffffeL & l) != 0L)
595                   {
596                      if (kind > 17)
597                         kind = 17;
598                      jjCheckNAdd(9);
599                   }
600                   if ((0x7fffffe87fffffeL & l) != 0L)
601                   {
602                      if (kind > 16)
603                         kind = 16;
604                      jjCheckNAddTwoStates(6, 7);
605                   }
606                   break;
607                case 0:
608                   if ((0x7fffffe87fffffeL & l) != 0L)
609                   {
610                      if (kind > 16)
611                         kind = 16;
612                      jjCheckNAddStates(0, 2);
613                   }
614                   if ((0x800000008000L & l) != 0L)
615                      jjstateSet[jjnewStateCnt++] = 4;
616                   else if ((0x200000002L & l) != 0L)
617                      jjstateSet[jjnewStateCnt++] = 1;
618                   break;
619                case 1:
620                   if ((0x7fffffe87fffffeL & l) != 0L)
621                   {
622                      if (kind > 17)
623                         kind = 17;
624                      jjCheckNAdd(9);
625                   }
626                   if ((0x7fffffe87fffffeL & l) != 0L)
627                   {
628                      if (kind > 16)
629                         kind = 16;
630                      jjCheckNAddTwoStates(6, 7);
631                   }
632                   if ((0x400000004000L & l) != 0L)
633                      jjstateSet[jjnewStateCnt++] = 2;
634                   break;
635                case 2:
636                   if ((0x1000000010L & l) != 0L && kind > 3)
637                      kind = 3;
638                   break;
639                case 3:
640                   if ((0x800000008000L & l) != 0L)
641                      jjstateSet[jjnewStateCnt++] = 4;
642                   break;
643                case 4:
644                   if ((0x4000000040000L & l) != 0L && kind > 4)
645                      kind = 4;
646                   break;
647                case 5:
648                   if ((0x7fffffe87fffffeL & l) == 0L)
649                      break;
650                   if (kind > 16)
651                      kind = 16;
652                   jjCheckNAddStates(0, 2);
653                   break;
654                case 6:
655                   if ((0x7fffffe87fffffeL & l) == 0L)
656                      break;
657                   if (kind > 16)
658                      kind = 16;
659                   jjCheckNAddTwoStates(6, 7);
660                   break;
661                case 8:
662                   if ((0x7fffffe87fffffeL & l) == 0L)
663                      break;
664                   if (kind > 16)
665                      kind = 16;
666                   jjCheckNAddTwoStates(7, 8);
667                   break;
668                case 9:
669                   if ((0x7fffffe87fffffeL & l) == 0L)
670                      break;
671                   if (kind > 17)
672                      kind = 17;
673                   jjCheckNAdd(9);
674                   break;
675                default : break;
676             }
677          } while(i != startsAt);
678       }
679       else
680       {
681          int i2 = (curChar & 0xff) >> 6;
682          long l2 = 1L << (curChar & 077);
683          MatchLoop: do
684          {
685             switch(jjstateSet[--i])
686             {
687                default : break;
688             }
689          } while(i != startsAt);
690       }
691       if (kind != 0x7fffffff)
692       {
693          jjmatchedKind = kind;
694          jjmatchedPos = curPos;
695          kind = 0x7fffffff;
696       }
697       ++curPos;
698       if ((i = jjnewStateCnt) == (startsAt = 10 - (jjnewStateCnt = startsAt)))
699          return curPos;
700       try { curChar = input_stream.readChar(); }
701       catch(java.io.IOException JavaDoc e) { return curPos; }
702    }
703 }
704 private final int jjStopStringLiteralDfa_2(int pos, long active0)
705 {
706    switch (pos)
707    {
708       case 0:
709          if ((active0 & 0x7fe000000000L) != 0L)
710          {
711             jjmatchedKind = 55;
712             return 94;
713          }
714          return -1;
715       case 1:
716          if ((active0 & 0x7fe000000000L) != 0L)
717          {
718             jjmatchedKind = 55;
719             jjmatchedPos = 1;
720             return 94;
721          }
722          return -1;
723       case 2:
724          if ((active0 & 0x200000000000L) != 0L)
725             return 94;
726          if ((active0 & 0x5fe000000000L) != 0L)
727          {
728             jjmatchedKind = 55;
729             jjmatchedPos = 2;
730             return 94;
731          }
732          return -1;
733       case 3:
734          if ((active0 & 0x5fe000000000L) != 0L)
735          {
736             jjmatchedKind = 55;
737             jjmatchedPos = 3;
738             return 94;
739          }
740          return -1;
741       case 4:
742          if ((active0 & 0x4000000000L) != 0L)
743             return 94;
744          if ((active0 & 0x5fa000000000L) != 0L)
745          {
746             jjmatchedKind = 55;
747             jjmatchedPos = 4;
748             return 94;
749          }
750          return -1;
751       case 5:
752          if ((active0 & 0x11a000000000L) != 0L)
753          {
754             jjmatchedKind = 55;
755             jjmatchedPos = 5;
756             return 94;
757          }
758          if ((active0 & 0x4e0000000000L) != 0L)
759             return 94;
760          return -1;
761       case 6:
762          if ((active0 & 0x8000000000L) != 0L)
763             return 94;
764          if ((active0 & 0x112000000000L) != 0L)
765          {
766             jjmatchedKind = 55;
767             jjmatchedPos = 6;
768             return 94;
769          }
770          return -1;
771       case 7:
772          if ((active0 & 0x110000000000L) != 0L)
773          {
774             jjmatchedKind = 55;
775             jjmatchedPos = 7;
776             return 94;
777          }
778          if ((active0 & 0x2000000000L) != 0L)
779             return 94;
780          return -1;
781       case 8:
782          if ((active0 & 0x100000000000L) != 0L)
783          {
784             jjmatchedKind = 55;
785             jjmatchedPos = 8;
786             return 94;
787          }
788          if ((active0 & 0x10000000000L) != 0L)
789             return 94;
790          return -1;
791       case 9:
792          if ((active0 & 0x100000000000L) != 0L)
793          {
794             jjmatchedKind = 55;
795             jjmatchedPos = 9;
796             return 94;
797          }
798          return -1;
799       case 10:
800          if ((active0 & 0x100000000000L) != 0L)
801          {
802             jjmatchedKind = 55;
803             jjmatchedPos = 10;
804             return 94;
805          }
806          return -1;
807       default :
808          return -1;
809    }
810 }
811 private final int jjStartNfa_2(int pos, long active0)
812 {
813    return jjMoveNfa_2(jjStopStringLiteralDfa_2(pos, active0), pos + 1);
814 }
815 private final int jjStartNfaWithStates_2(int pos, int kind, int state)
816 {
817    jjmatchedKind = kind;
818    jjmatchedPos = pos;
819    try { curChar = input_stream.readChar(); }
820    catch(java.io.IOException JavaDoc e) { return pos + 1; }
821    return jjMoveNfa_2(state, pos + 1);
822 }
823 private final int jjMoveStringLiteralDfa0_2()
824 {
825    switch(curChar)
826    {
827       case 33:
828          return jjStopAtPos(0, 60);
829       case 40:
830          return jjStopAtPos(0, 61);
831       case 41:
832          return jjStopAtPos(0, 62);
833       case 44:
834          return jjStopAtPos(0, 50);
835       case 45:
836          return jjMoveStringLiteralDfa1_2(0x800000000000000L);
837       case 97:
838          return jjMoveStringLiteralDfa1_2(0x2000000000L);
839       case 102:
840          return jjMoveStringLiteralDfa1_2(0x4000000000L);
841       case 110:
842          return jjMoveStringLiteralDfa1_2(0x280000000000L);
843       case 112:
844          return jjMoveStringLiteralDfa1_2(0x38000000000L);
845       case 115:
846          return jjMoveStringLiteralDfa1_2(0x140000000000L);
847       case 116:
848          return jjMoveStringLiteralDfa1_2(0x400000000000L);
849       default :
850          return jjMoveNfa_2(0, 0);
851    }
852 }
853 private final int jjMoveStringLiteralDfa1_2(long active0)
854 {
855    try { curChar = input_stream.readChar(); }
856    catch(java.io.IOException JavaDoc e) {
857       jjStopStringLiteralDfa_2(0, active0);
858       return 1;
859    }
860    switch(curChar)
861    {
862       case 62:
863          if ((active0 & 0x800000000000000L) != 0L)
864             return jjStopAtPos(1, 59);
865          break;
866       case 97:
867          return jjMoveStringLiteralDfa2_2(active0, 0x80000000000L);
868       case 98:
869          return jjMoveStringLiteralDfa2_2(active0, 0x2000000000L);
870       case 101:
871          return jjMoveStringLiteralDfa2_2(active0, 0x200000000000L);
872       case 104:
873          return jjMoveStringLiteralDfa2_2(active0, 0x400000000000L);
874       case 105:
875          return jjMoveStringLiteralDfa2_2(active0, 0x4000000000L);
876       case 114:
877          return jjMoveStringLiteralDfa2_2(active0, 0x18000000000L);
878       case 116:
879          return jjMoveStringLiteralDfa2_2(active0, 0x40000000000L);
880       case 117:
881          return jjMoveStringLiteralDfa2_2(active0, 0x20000000000L);
882       case 121:
883          return jjMoveStringLiteralDfa2_2(active0, 0x100000000000L);
884       default :
885          break;
886    }
887    return jjStartNfa_2(0, active0);
888 }
889 private final int jjMoveStringLiteralDfa2_2(long old0, long active0)
890 {
891    if (((active0 &= old0)) == 0L)
892       return jjStartNfa_2(0, old0);
893    try { curChar = input_stream.readChar(); }
894    catch(java.io.IOException JavaDoc e) {
895       jjStopStringLiteralDfa_2(1, active0);
896       return 2;
897    }
898    switch(curChar)
899    {
900       case 97:
901          return jjMoveStringLiteralDfa3_2(active0, 0x40000000000L);
902       case 98:
903          return jjMoveStringLiteralDfa3_2(active0, 0x20000000000L);
904       case 105:
905          return jjMoveStringLiteralDfa3_2(active0, 0x8000000000L);
906       case 110:
907          return jjMoveStringLiteralDfa3_2(active0, 0x104000000000L);
908       case 111:
909          return jjMoveStringLiteralDfa3_2(active0, 0x10000000000L);
910       case 114:
911          return jjMoveStringLiteralDfa3_2(active0, 0x400000000000L);
912       case 115:
913          return jjMoveStringLiteralDfa3_2(active0, 0x2000000000L);
914       case 116:
915          return jjMoveStringLiteralDfa3_2(active0, 0x80000000000L);
916       case 119:
917          if ((active0 & 0x200000000000L) != 0L)
918             return jjStartNfaWithStates_2(2, 45, 94);
919          break;
920       default :
921          break;
922    }
923    return jjStartNfa_2(1, active0);
924 }
925 private final int jjMoveStringLiteralDfa3_2(long old0, long active0)
926 {
927    if (((active0 &= old0)) == 0L)
928       return jjStartNfa_2(1, old0);
929    try { curChar = input_stream.readChar(); }
930    catch(java.io.IOException JavaDoc e) {
931       jjStopStringLiteralDfa_2(2, active0);
932       return 3;
933    }
934    switch(curChar)
935    {
936       case 97:
937          return jjMoveStringLiteralDfa4_2(active0, 0x4000000000L);
938       case 99:
939          return jjMoveStringLiteralDfa4_2(active0, 0x100000000000L);
940       case 105:
941          return jjMoveStringLiteralDfa4_2(active0, 0x80000000000L);
942       case 108:
943          return jjMoveStringLiteralDfa4_2(active0, 0x20000000000L);
944       case 111:
945          return jjMoveStringLiteralDfa4_2(active0, 0x400000000000L);
946       case 116:
947          return jjMoveStringLiteralDfa4_2(active0, 0x52000000000L);
948       case 118:
949          return jjMoveStringLiteralDfa4_2(active0, 0x8000000000L);
950       default :
951          break;
952    }
953    return jjStartNfa_2(2, active0);
954 }
955 private final int jjMoveStringLiteralDfa4_2(long old0, long active0)
956 {
957    if (((active0 &= old0)) == 0L)
958       return jjStartNfa_2(2, old0);
959    try { curChar = input_stream.readChar(); }
960    catch(java.io.IOException JavaDoc e) {
961       jjStopStringLiteralDfa_2(3, active0);
962       return 4;
963    }
964    switch(curChar)
965    {
966       case 97:
967          return jjMoveStringLiteralDfa5_2(active0, 0x8000000000L);
968       case 101:
969          return jjMoveStringLiteralDfa5_2(active0, 0x10000000000L);
970       case 104:
971          return jjMoveStringLiteralDfa5_2(active0, 0x100000000000L);
972       case 105:
973          return jjMoveStringLiteralDfa5_2(active0, 0x60000000000L);
974       case 108:
975          if ((active0 & 0x4000000000L) != 0L)
976             return jjStartNfaWithStates_2(4, 38, 94);
977          break;
978       case 114:
979          return jjMoveStringLiteralDfa5_2(active0, 0x2000000000L);
980       case 118:
981          return jjMoveStringLiteralDfa5_2(active0, 0x80000000000L);
982       case 119:
983          return jjMoveStringLiteralDfa5_2(active0, 0x400000000000L);
984       default :
985          break;
986    }
987    return jjStartNfa_2(3, active0);
988 }
989 private final int jjMoveStringLiteralDfa5_2(long old0, long active0)
990 {
991    if (((active0 &= old0)) == 0L)
992       return jjStartNfa_2(3, old0);
993    try { curChar = input_stream.readChar(); }
994    catch(java.io.IOException JavaDoc e) {
995       jjStopStringLiteralDfa_2(4, active0);
996       return 5;
997    }
998    switch(curChar)
999    {
1000      case 97:
1001         return jjMoveStringLiteralDfa6_2(active0, 0x2000000000L);
1002      case 99:
1003         if ((active0 & 0x20000000000L) != 0L)
1004            return jjStartNfaWithStates_2(5, 41, 94);
1005         else if ((active0 & 0x40000000000L) != 0L)
1006            return jjStartNfaWithStates_2(5, 42, 94);
1007         return jjMoveStringLiteralDfa6_2(active0, 0x10000000000L);
1008      case 101:
1009         if ((active0 & 0x80000000000L) != 0L)
1010            return jjStartNfaWithStates_2(5, 43, 94);
1011         break;
1012      case 114:
1013         return jjMoveStringLiteralDfa6_2(active0, 0x100000000000L);
1014      case 115:
1015         if ((active0 & 0x400000000000L) != 0L)
1016            return jjStartNfaWithStates_2(5, 46, 94);
1017         break;
1018      case 116:
1019         return jjMoveStringLiteralDfa6_2(active0, 0x8000000000L);
1020      default :
1021         break;
1022   }
1023   return jjStartNfa_2(4, active0);
1024}
1025private final int jjMoveStringLiteralDfa6_2(long old0, long active0)
1026{
1027   if (((active0 &= old0)) == 0L)
1028      return jjStartNfa_2(4, old0);
1029   try { curChar = input_stream.readChar(); }
1030   catch(java.io.IOException JavaDoc e) {
1031      jjStopStringLiteralDfa_2(5, active0);
1032      return 6;
1033   }
1034   switch(curChar)
1035   {
1036      case 99:
1037         return jjMoveStringLiteralDfa7_2(active0, 0x2000000000L);
1038      case 101:
1039         if ((active0 & 0x8000000000L) != 0L)
1040            return jjStartNfaWithStates_2(6, 39, 94);
1041         break;
1042      case 111:
1043         return jjMoveStringLiteralDfa7_2(active0, 0x100000000000L);
1044      case 116:
1045         return jjMoveStringLiteralDfa7_2(active0, 0x10000000000L);
1046      default :
1047         break;
1048   }
1049   return jjStartNfa_2(5, active0);
1050}
1051private final int jjMoveStringLiteralDfa7_2(long old0, long active0)
1052{
1053   if (((active0 &= old0)) == 0L)
1054      return jjStartNfa_2(5, old0);
1055   try { curChar = input_stream.readChar(); }
1056   catch(java.io.IOException JavaDoc e) {
1057      jjStopStringLiteralDfa_2(6, active0);
1058      return 7;
1059   }
1060   switch(curChar)
1061   {
1062      case 101:
1063         return jjMoveStringLiteralDfa8_2(active0, 0x10000000000L);
1064      case 110:
1065         return jjMoveStringLiteralDfa8_2(active0, 0x100000000000L);
1066      case 116:
1067         if ((active0 & 0x2000000000L) != 0L)
1068            return jjStartNfaWithStates_2(7, 37, 94);
1069         break;
1070      default :
1071         break;
1072   }
1073   return jjStartNfa_2(6, active0);
1074}
1075private final int jjMoveStringLiteralDfa8_2(long old0, long active0)
1076{
1077   if (((active0 &= old0)) == 0L)
1078      return jjStartNfa_2(6, old0);
1079   try { curChar = input_stream.readChar(); }
1080   catch(java.io.IOException JavaDoc e) {
1081      jjStopStringLiteralDfa_2(7, active0);
1082      return 8;
1083   }
1084   switch(curChar)
1085   {
1086      case 100:
1087         if ((active0 & 0x10000000000L) != 0L)
1088            return jjStartNfaWithStates_2(8, 40, 94);
1089         break;
1090      case 105:
1091         return jjMoveStringLiteralDfa9_2(active0, 0x100000000000L);
1092      default :
1093         break;
1094   }
1095   return jjStartNfa_2(7, active0);
1096}
1097private final int jjMoveStringLiteralDfa9_2(long old0, long active0)
1098{
1099   if (((active0 &= old0)) == 0L)
1100      return jjStartNfa_2(7, old0);
1101   try { curChar = input_stream.readChar(); }
1102   catch(java.io.IOException JavaDoc e) {
1103      jjStopStringLiteralDfa_2(8, active0);
1104      return 9;
1105   }
1106   switch(curChar)
1107   {
1108      case 122:
1109         return jjMoveStringLiteralDfa10_2(active0, 0x100000000000L);
1110      default :
1111         break;
1112   }
1113   return jjStartNfa_2(8, active0);
1114}
1115private final int jjMoveStringLiteralDfa10_2(long old0, long active0)
1116{
1117   if (((active0 &= old0)) == 0L)
1118      return jjStartNfa_2(8, old0);
1119   try { curChar = input_stream.readChar(); }
1120   catch(java.io.IOException JavaDoc e) {
1121      jjStopStringLiteralDfa_2(9, active0);
1122      return 10;
1123   }
1124   switch(curChar)
1125   {
1126      case 101:
1127         return jjMoveStringLiteralDfa11_2(active0, 0x100000000000L);
1128      default :
1129         break;
1130   }
1131   return jjStartNfa_2(9, active0);
1132}
1133private final int jjMoveStringLiteralDfa11_2(long old0, long active0)
1134{
1135   if (((active0 &= old0)) == 0L)
1136      return jjStartNfa_2(9, old0);
1137   try { curChar = input_stream.readChar(); }
1138   catch(java.io.IOException JavaDoc e) {
1139      jjStopStringLiteralDfa_2(10, active0);
1140      return 11;
1141   }
1142   switch(curChar)
1143   {
1144      case 100:
1145         if ((active0 & 0x100000000000L) != 0L)
1146            return jjStartNfaWithStates_2(11, 44, 94);
1147         break;
1148      default :
1149         break;
1150   }
1151   return jjStartNfa_2(10, active0);
1152}
1153private final int jjMoveNfa_2(int startState, int curPos)
1154{
1155   int[] nextStates;
1156   int startsAt = 0;
1157   jjnewStateCnt = 94;
1158   int i = 1;
1159   jjstateSet[0] = startState;
1160   int j, kind = 0x7fffffff;
1161   for (;;)
1162   {
1163      if (++jjround == 0x7fffffff)
1164         ReInitRounds();
1165      if (curChar < 64)
1166      {
1167         long l = 1L << curChar;
1168         MatchLoop: do
1169         {
1170            switch(jjstateSet[--i])
1171            {
1172               case 0:
1173                  if ((0x3ff041000000000L & l) != 0L)
1174                  {
1175                     if (kind > 55)
1176                        kind = 55;
1177                     jjCheckNAddStates(3, 7);
1178                  }
1179                  if (curChar == 36)
1180                     jjAddStates(8, 11);
1181                  break;
1182               case 94:
1183                  if ((0x3ff041000000000L & l) != 0L)
1184                  {
1185                     if (kind > 55)
1186                        kind = 55;
1187                     jjCheckNAdd(93);
1188                  }
1189                  else if (curChar == 46)
1190                     jjCheckNAdd(87);
1191                  if ((0x3ff041000000000L & l) != 0L)
1192                     jjCheckNAddTwoStates(90, 92);
1193                  if ((0x3ff041000000000L & l) != 0L)
1194                     jjCheckNAddTwoStates(85, 86);
1195                  break;
1196               case 1:
1197                  if ((0x3ff041000000000L & l) == 0L)
1198                     break;
1199                  if (kind > 52)
1200                     kind = 52;
1201                  jjCheckNAddTwoStates(1, 2);
1202                  break;
1203               case 2:
1204                  if (curChar == 46)
1205                     jjCheckNAdd(3);
1206                  break;
1207               case 3:
1208                  if ((0x3ff041000000000L & l) == 0L)
1209                     break;
1210                  if (kind > 52)
1211                     kind = 52;
1212                  jjCheckNAddTwoStates(2, 3);
1213                  break;
1214               case 4:
1215                  if (curChar == 36)
1216                     jjAddStates(8, 11);
1217                  break;
1218               case 7:
1219                  if ((0x3ff041000000000L & l) != 0L)
1220                     jjCheckNAddStates(12, 14);
1221                  break;
1222               case 8:
1223                  if (curChar == 46)
1224                     jjCheckNAdd(9);
1225                  break;
1226               case 9:
1227                  if ((0x3ff041000000000L & l) != 0L)
1228                     jjCheckNAddStates(15, 17);
1229                  break;
1230               case 11:
1231                  if ((0x3ff041000000000L & l) != 0L)
1232                     jjCheckNAddStates(18, 21);
1233                  break;
1234               case 12:
1235                  if ((0x3ff041000000000L & l) != 0L)
1236                     jjCheckNAddTwoStates(12, 10);
1237                  break;
1238               case 13:
1239                  if ((0x3ff041000000000L & l) != 0L)
1240                     jjCheckNAddTwoStates(13, 14);
1241                  break;
1242               case 14:
1243                  if (curChar == 46)
1244                     jjCheckNAdd(15);
1245                  break;
1246               case 15:
1247                  if ((0x3ff041000000000L & l) != 0L)
1248                     jjCheckNAddStates(22, 25);
1249                  break;
1250               case 29:
1251                  if ((0x3ff000000000000L & l) != 0L)
1252                     jjCheckNAddStates(26, 28);
1253                  break;
1254               case 30:
1255                  if (curChar == 46)
1256                     jjCheckNAdd(31);
1257                  break;
1258               case 31:
1259                  if ((0x3ff000000000000L & l) != 0L)
1260                     jjCheckNAddStates(29, 31);
1261                  break;
1262               case 41:
1263                  if ((0x3ff041000000000L & l) != 0L)
1264                     jjCheckNAddTwoStates(41, 42);
1265                  break;
1266               case 42:
1267                  if (curChar == 46)
1268                     jjCheckNAdd(43);
1269                  break;
1270               case 43:
1271                  if ((0x3ff041000000000L & l) != 0L)
1272                     jjCheckNAddStates(32, 35);
1273                  break;
1274               case 48:
1275                  if ((0x3ff041000000000L & l) != 0L)
1276                     jjCheckNAddStates(36, 38);
1277                  break;
1278               case 49:
1279                  if (curChar == 46)
1280                     jjCheckNAdd(50);
1281                  break;
1282               case 50:
1283                  if ((0x3ff041000000000L & l) != 0L)
1284                     jjCheckNAddStates(39, 41);
1285                  break;
1286               case 62:
1287                  if ((0x3ff041000000000L & l) != 0L)
1288                     jjCheckNAddTwoStates(62, 63);
1289                  break;
1290               case 63:
1291                  if (curChar == 46)
1292                     jjCheckNAdd(64);
1293                  break;
1294               case 64:
1295                  if ((0x3ff041000000000L & l) != 0L)
1296                     jjCheckNAddStates(42, 45);
1297                  break;
1298               case 69:
1299                  if ((0x3ff041000000000L & l) != 0L)
1300                     jjCheckNAddStates(46, 48);
1301                  break;
1302               case 70:
1303                  if (curChar == 46)
1304                     jjCheckNAdd(71);
1305                  break;
1306               case 71:
1307                  if ((0x3ff041000000000L & l) != 0L)
1308                     jjCheckNAddStates(49, 51);
1309                  break;
1310               case 84:
1311                  if ((0x3ff041000000000L & l) == 0L)
1312                     break;
1313                  if (kind > 55)
1314                     kind = 55;
1315                  jjCheckNAddStates(3, 7);
1316                  break;
1317               case 85:
1318                  if ((0x3ff041000000000L & l) != 0L)
1319                     jjCheckNAddTwoStates(85, 86);
1320                  break;
1321               case 86:
1322                  if (curChar == 46)
1323                     jjCheckNAdd(87);
1324                  break;
1325               case 87:
1326                  if ((0x3ff041000000000L & l) == 0L)
1327                     break;
1328                  if (kind > 49)
1329                     kind = 49;
1330                  jjCheckNAddStates(52, 54);
1331                  break;
1332               case 90:
1333                  if ((0x3ff041000000000L & l) != 0L)
1334                     jjCheckNAddTwoStates(90, 92);
1335                  break;
1336               case 93:
1337                  if ((0x3ff041000000000L & l) == 0L)
1338                     break;
1339                  if (kind > 55)
1340                     kind = 55;
1341                  jjCheckNAdd(93);
1342                  break;
1343               default : break;
1344            }
1345         } while(i != startsAt);
1346      }
1347      else if (curChar < 128)
1348      {
1349         long l = 1L << (curChar & 077);
1350         MatchLoop: do
1351         {
1352            switch(jjstateSet[--i])
1353            {
1354               case 0:
1355                  if ((0x7fffffe87fffffeL & l) != 0L)
1356                  {
1357                     if (kind > 55)
1358                        kind = 55;
1359                     jjCheckNAddStates(3, 7);
1360                  }
1361                  else if (curChar == 64)
1362                     jjCheckNAdd(1);
1363                  break;
1364               case 94:
1365                  if ((0x7fffffe87fffffeL & l) != 0L)
1366                  {
1367                     if (kind > 55)
1368                        kind = 55;
1369                     jjCheckNAdd(93);
1370                  }
1371                  else if (curChar == 91)
1372                     jjstateSet[jjnewStateCnt++] = 91;
1373                  if ((0x7fffffe87fffffeL & l) != 0L)
1374                     jjCheckNAddTwoStates(90, 92);
1375                  if ((0x7fffffe87fffffeL & l) != 0L)
1376                     jjCheckNAddTwoStates(85, 86);
1377                  break;
1378               case 1:
1379                  if ((0x7fffffe87fffffeL & l) == 0L)
1380                     break;
1381                  if (kind > 52)
1382                     kind = 52;
1383                  jjCheckNAddTwoStates(1, 2);
1384                  break;
1385               case 3:
1386                  if ((0x7fffffe87fffffeL & l) == 0L)
1387                     break;
1388                  if (kind > 52)
1389                     kind = 52;
1390                  jjCheckNAddTwoStates(2, 3);
1391                  break;
1392               case 5:
1393                  if (curChar == 123)
1394                     jjAddStates(55, 56);
1395                  break;
1396               case 6:
1397                  if (curChar == 64)
1398                     jjCheckNAdd(7);
1399                  break;
1400               case 7:
1401                  if ((0x7fffffe87fffffeL & l) != 0L)
1402                     jjCheckNAddStates(12, 14);
1403                  break;
1404               case 9:
1405                  if ((0x7fffffe87fffffeL & l) != 0L)
1406                     jjCheckNAddStates(15, 17);
1407                  break;
1408               case 10:
1409                  if (curChar == 125 && kind > 47)
1410                     kind = 47;
1411                  break;
1412               case 11:
1413                  if ((0x7fffffe87fffffeL & l) != 0L)
1414                     jjCheckNAddStates(18, 21);
1415                  break;
1416               case 12:
1417                  if ((0x7fffffe87fffffeL & l) != 0L)
1418                     jjCheckNAddTwoStates(12, 10);
1419                  break;
1420               case 13:
1421                  if ((0x7fffffe87fffffeL & l) != 0L)
1422                     jjCheckNAddTwoStates(13, 14);
1423                  break;
1424               case 15:
1425                  if ((0x7fffffe87fffffeL & l) != 0L)
1426                     jjCheckNAddStates(22, 25);
1427                  break;
1428               case 16:
1429                  if (curChar == 93)
1430                     jjCheckNAddTwoStates(17, 10);
1431                  break;
1432               case 17:
1433                  if (curChar == 91)
1434                     jjstateSet[jjnewStateCnt++] = 16;
1435                  break;
1436               case 18:
1437                  if (curChar == 102)
1438                     jjstateSet[jjnewStateCnt++] = 5;
1439                  break;
1440               case 19:
1441                  if (curChar == 111)
1442                     jjstateSet[jjnewStateCnt++] = 18;
1443                  break;
1444               case 20:
1445                  if (curChar == 101)
1446                     jjstateSet[jjnewStateCnt++] = 19;
1447                  break;
1448               case 21:
1449                  if (curChar == 99)
1450                     jjstateSet[jjnewStateCnt++] = 20;
1451                  break;
1452               case 22:
1453                  if (curChar == 110)
1454                     jjstateSet[jjnewStateCnt++] = 21;
1455                  break;
1456               case 23:
1457                  if (curChar == 97)
1458                     jjstateSet[jjnewStateCnt++] = 22;
1459                  break;
1460               case 24:
1461                  if (curChar == 116)
1462                     jjstateSet[jjnewStateCnt++] = 23;
1463                  break;
1464               case 25:
1465                  if (curChar == 115)
1466                     jjstateSet[jjnewStateCnt++] = 24;
1467                  break;
1468               case 26:
1469                  if (curChar == 110)
1470                     jjstateSet[jjnewStateCnt++] = 25;
1471                  break;
1472               case 27:
1473                  if (curChar == 105)
1474                     jjstateSet[jjnewStateCnt++] = 26;
1475                  break;
1476               case 28:
1477                  if (curChar == 123)
1478                     jjCheckNAdd(29);
1479                  break;
1480               case 29:
1481                  if ((0x7fffffe87fffffeL & l) != 0L)
1482                     jjCheckNAddStates(26, 28);
1483                  break;
1484               case 31:
1485                  if ((0x7fffffe87fffffeL & l) != 0L)
1486                     jjCheckNAddStates(29, 31);
1487                  break;
1488               case 32:
1489                  if (curChar == 125 && kind > 48)
1490                     kind = 48;
1491                  break;
1492               case 33:
1493                  if (curChar == 102)
1494                     jjstateSet[jjnewStateCnt++] = 28;
1495                  break;
1496               case 34:
1497                  if (curChar == 101)
1498                     jjstateSet[jjnewStateCnt++] = 33;
1499                  break;
1500               case 35:
1501                  if (curChar == 100)
1502                     jjstateSet[jjnewStateCnt++] = 34;
1503                  break;
1504               case 36:
1505                  if (curChar == 101)
1506                     jjstateSet[jjnewStateCnt++] = 35;
1507                  break;
1508               case 37:
1509                  if (curChar == 112)
1510                     jjstateSet[jjnewStateCnt++] = 36;
1511                  break;
1512               case 38:
1513                  if (curChar == 121)
1514                     jjstateSet[jjnewStateCnt++] = 37;
1515                  break;
1516               case 39:
1517                  if (curChar == 116)
1518                     jjstateSet[jjnewStateCnt++] = 38;
1519                  break;
1520               case 40:
1521                  if (curChar == 123)
1522                     jjCheckNAddTwoStates(41, 47);
1523                  break;
1524               case 41:
1525                  if ((0x7fffffe87fffffeL & l) != 0L)
1526                     jjCheckNAddTwoStates(41, 42);
1527                  break;
1528               case 43:
1529                  if ((0x7fffffe87fffffeL & l) != 0L)
1530                     jjCheckNAddStates(32, 35);
1531                  break;
1532               case 44:
1533                  if (curChar == 93)
1534                     jjCheckNAddTwoStates(45, 46);
1535                  break;
1536               case 45:
1537                  if (curChar == 91)
1538                     jjstateSet[jjnewStateCnt++] = 44;
1539                  break;
1540               case 46:
1541                  if (curChar == 125 && kind > 53)
1542                     kind = 53;
1543                  break;
1544               case 47:
1545                  if (curChar == 64)
1546                     jjCheckNAdd(48);
1547                  break;
1548               case 48:
1549                  if ((0x7fffffe87fffffeL & l) != 0L)
1550                     jjCheckNAddStates(36, 38);
1551                  break;
1552               case 50:
1553                  if ((0x7fffffe87fffffeL & l) != 0L)
1554                     jjCheckNAddStates(39, 41);
1555                  break;
1556               case 51:
1557                  if (curChar == 115)
1558                     jjstateSet[jjnewStateCnt++] = 40;
1559                  break;
1560               case 52:
1561                  if (curChar == 116)
1562                     jjstateSet[jjnewStateCnt++] = 51;
1563                  break;
1564               case 53:
1565                  if (curChar == 110)
1566                     jjstateSet[jjnewStateCnt++] = 52;
1567                  break;
1568               case 54:
1569                  if (curChar == 101)
1570                     jjstateSet[jjnewStateCnt++] = 53;
1571                  break;
1572               case 55:
1573                  if (curChar == 109)
1574                     jjstateSet[jjnewStateCnt++] = 54;
1575                  break;
1576               case 56:
1577                  if (curChar == 101)
1578                     jjstateSet[jjnewStateCnt++] = 55;
1579                  break;
1580               case 57:
1581                  if (curChar == 108)
1582                     jjstateSet[jjnewStateCnt++] = 56;
1583                  break;
1584               case 58:
1585                  if (curChar == 112)
1586                     jjstateSet[jjnewStateCnt++] = 57;
1587                  break;
1588               case 59:
1589                  if (curChar == 109)
1590                     jjstateSet[jjnewStateCnt++] = 58;
1591                  break;
1592               case 60:
1593                  if (curChar == 105)
1594                     jjstateSet[jjnewStateCnt++] = 59;
1595                  break;
1596               case 61:
1597                  if (curChar == 123)
1598                     jjCheckNAddTwoStates(62, 68);
1599                  break;
1600               case 62:
1601                  if ((0x7fffffe87fffffeL & l) != 0L)
1602                     jjCheckNAddTwoStates(62, 63);
1603                  break;
1604               case 64:
1605                  if ((0x7fffffe87fffffeL & l) != 0L)
1606                     jjCheckNAddStates(42, 45);
1607                  break;
1608               case 65:
1609                  if (curChar == 93)
1610                     jjCheckNAddTwoStates(66, 67);
1611                  break;
1612               case 66:
1613                  if (curChar == 91)
1614                     jjstateSet[jjnewStateCnt++] = 65;
1615                  break;
1616               case 67:
1617                  if (curChar == 125 && kind > 54)
1618                     kind = 54;
1619                  break;
1620               case 68:
1621                  if (curChar == 64)
1622                     jjCheckNAdd(69);
1623                  break;
1624               case 69:
1625                  if ((0x7fffffe87fffffeL & l) != 0L)
1626                     jjCheckNAddStates(46, 48);
1627                  break;
1628               case 71:
1629                  if ((0x7fffffe87fffffeL & l) != 0L)
1630                     jjCheckNAddStates(49, 51);
1631                  break;
1632               case 72:
1633                  if (curChar == 103)
1634                     jjstateSet[jjnewStateCnt++] = 61;
1635                  break;
1636               case 73:
1637                  if (curChar == 110)
1638                     jjstateSet[jjnewStateCnt++] = 72;
1639                  break;
1640               case 74:
1641                  if (curChar == 105)
1642                     jjstateSet[jjnewStateCnt++] = 73;
1643                  break;
1644               case 75:
1645                  if (curChar == 116)
1646                     jjstateSet[jjnewStateCnt++] = 74;
1647                  break;
1648               case 76:
1649                  if (curChar == 110)
1650                     jjstateSet[jjnewStateCnt++] = 75;
1651                  break;
1652               case 77:
1653                  if (curChar == 101)
1654                     jjstateSet[jjnewStateCnt++] = 76;
1655                  break;
1656               case 78:
1657                  if (curChar == 109)
1658                     jjstateSet[jjnewStateCnt++] = 77;
1659                  break;
1660               case 79:
1661                  if (curChar == 101)
1662                     jjstateSet[jjnewStateCnt++] = 78;
1663                  break;
1664               case 80:
1665                  if (curChar == 108)
1666                     jjstateSet[jjnewStateCnt++] = 79;
1667                  break;
1668               case 81:
1669                  if (curChar == 112)
1670                     jjstateSet[jjnewStateCnt++] = 80;
1671                  break;
1672               case 82:
1673                  if (curChar == 109)
1674                     jjstateSet[jjnewStateCnt++] = 81;
1675                  break;
1676               case 83:
1677                  if (curChar == 105)
1678                     jjstateSet[jjnewStateCnt++] = 82;
1679                  break;
1680               case 84:
1681                  if ((0x7fffffe87fffffeL & l) == 0L)
1682                     break;
1683                  if (kind > 55)
1684                     kind = 55;
1685                  jjCheckNAddStates(3, 7);
1686                  break;
1687               case 85:
1688                  if ((0x7fffffe87fffffeL & l) != 0L)
1689                     jjCheckNAddTwoStates(85, 86);
1690                  break;
1691               case 87:
1692                  if ((0x7fffffe87fffffeL & l) == 0L)
1693                     break;
1694                  if (kind > 49)
1695                     kind = 49;
1696                  jjCheckNAddStates(52, 54);
1697                  break;
1698               case 88:
1699                  if (curChar != 93)
1700                     break;
1701                  if (kind > 49)
1702                     kind = 49;
1703                  jjCheckNAdd(89);
1704                  break;
1705               case 89:
1706                  if (curChar == 91)
1707                     jjstateSet[jjnewStateCnt++] = 88;
1708                  break;
1709               case 90:
1710                  if ((0x7fffffe87fffffeL & l) != 0L)
1711                     jjCheckNAddTwoStates(90, 92);
1712                  break;
1713               case 91:
1714                  if (curChar != 93)
1715                     break;
1716                  if (kind > 51)
1717                     kind = 51;
1718                  jjCheckNAdd(92);
1719                  break;
1720               case 92:
1721                  if (curChar == 91)
1722                     jjstateSet[jjnewStateCnt++] = 91;
1723                  break;
1724               case 93:
1725                  if ((0x7fffffe87fffffeL & l) == 0L)
1726                     break;
1727                  if (kind > 55)
1728                     kind = 55;
1729                  jjCheckNAdd(93);
1730                  break;
1731               default : break;
1732            }
1733         } while(i != startsAt);
1734      }
1735      else
1736      {
1737         int i2 = (curChar & 0xff) >> 6;
1738         long l2 = 1L << (curChar & 077);
1739         MatchLoop: do
1740         {
1741            switch(jjstateSet[--i])
1742            {
1743               default : break;
1744            }
1745         } while(i != startsAt);
1746      }
1747      if (kind != 0x7fffffff)
1748      {
1749         jjmatchedKind = kind;
1750         jjmatchedPos = curPos;
1751         kind = 0x7fffffff;
1752      }
1753      ++curPos;
1754      if ((i = jjnewStateCnt) == (startsAt = 94 - (jjnewStateCnt = startsAt)))
1755         return curPos;
1756      try { curChar = input_stream.readChar(); }
1757      catch(java.io.IOException JavaDoc e) { return curPos; }
1758   }
1759}
1760private final int jjStopStringLiteralDfa_1(int pos, long active0)
1761{
1762   switch (pos)
1763   {
1764      default :
1765         return -1;
1766   }
1767}
1768private final int jjStartNfa_1(int pos, long active0)
1769{
1770   return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0), pos + 1);
1771}
1772private final int jjStartNfaWithStates_1(int pos, int kind, int state)
1773{
1774   jjmatchedKind = kind;
1775   jjmatchedPos = pos;
1776   try { curChar = input_stream.readChar(); }
1777   catch(java.io.IOException JavaDoc e) { return pos + 1; }
1778   return jjMoveNfa_1(state, pos + 1);
1779}
1780private final int jjMoveStringLiteralDfa0_1()
1781{
1782   switch(curChar)
1783   {
1784      case 41:
1785         return jjStopAtPos(0, 34);
1786      case 44:
1787         return jjStopAtPos(0, 30);
1788      case 46:
1789         return jjMoveStringLiteralDfa1_1(0x800000L);
1790      default :
1791         return jjMoveNfa_1(0, 0);
1792   }
1793}
1794private final int jjMoveStringLiteralDfa1_1(long active0)
1795{
1796   try { curChar = input_stream.readChar(); }
1797   catch(java.io.IOException JavaDoc e) {
1798      jjStopStringLiteralDfa_1(0, active0);
1799      return 1;
1800   }
1801   switch(curChar)
1802   {
1803      case 46:
1804         if ((active0 & 0x800000L) != 0L)
1805            return jjStopAtPos(1, 23);
1806         break;
1807      default :
1808         break;
1809   }
1810   return jjStartNfa_1(0, active0);
1811}
1812private final int jjMoveNfa_1(int startState, int curPos)
1813{
1814   int[] nextStates;
1815   int startsAt = 0;
1816   jjnewStateCnt = 50;
1817   int i = 1;
1818   jjstateSet[0] = startState;
1819   int j, kind = 0x7fffffff;
1820   for (;;)
1821   {
1822      if (++jjround == 0x7fffffff)
1823         ReInitRounds();
1824      if (curChar < 64)
1825      {
1826         long l = 1L << curChar;
1827         MatchLoop: do
1828         {
1829            switch(jjstateSet[--i])
1830            {
1831               case 0:
1832                  if ((0x3ff041000000000L & l) != 0L)
1833                  {
1834                     if (kind > 29)
1835                        kind = 29;
1836                     jjCheckNAddStates(57, 61);
1837                  }
1838                  if (curChar == 36)
1839                     jjAddStates(62, 63);
1840                  break;
1841               case 1:
1842                  if ((0x3ff041000000000L & l) != 0L)
1843                     jjCheckNAddTwoStates(1, 2);
1844                  break;
1845               case 2:
1846                  if (curChar == 46)
1847                     jjCheckNAdd(3);
1848                  break;
1849               case 3:
1850                  if ((0x3ff041000000000L & l) == 0L)
1851                     break;
1852                  if (kind > 26)
1853                     kind = 26;
1854                  jjCheckNAddTwoStates(2, 3);
1855                  break;
1856               case 4:
1857                  if ((0x3ff041000000000L & l) == 0L)
1858                     break;
1859                  if (kind > 29)
1860                     kind = 29;
1861                  jjCheckNAddStates(57, 61);
1862                  break;
1863               case 5:
1864                  if ((0x3ff041000000000L & l) != 0L)
1865                     jjCheckNAddTwoStates(5, 6);
1866                  break;
1867               case 6:
1868                  if (curChar == 46)
1869                     jjCheckNAdd(7);
1870                  break;
1871               case 7:
1872                  if ((0x3ff041000000000L & l) == 0L)
1873                     break;
1874                  if (kind > 24)
1875                     kind = 24;
1876                  jjCheckNAddStates(0, 2);
1877                  break;
1878               case 10:
1879                  if ((0x3ff041000000000L & l) != 0L)
1880                     jjCheckNAddTwoStates(10, 12);
1881                  break;
1882               case 13:
1883                  if ((0x3ff041000000000L & l) == 0L)
1884                     break;
1885                  if (kind > 29)
1886                     kind = 29;
1887                  jjCheckNAdd(13);
1888                  break;
1889               case 14:
1890                  if (curChar == 36)
1891                     jjAddStates(62, 63);
1892                  break;
1893               case 17:
1894                  if ((0x3ff041000000000L & l) != 0L)
1895                     jjCheckNAddTwoStates(17, 18);
1896                  break;
1897               case 18:
1898                  if (curChar == 46)
1899                     jjCheckNAdd(19);
1900                  break;
1901               case 19:
1902                  if ((0x3ff041000000000L & l) != 0L)
1903                     jjCheckNAddStates(64, 66);
1904                  break;
1905               case 21:
1906                  if ((0x3ff041000000000L & l) != 0L)
1907                     jjCheckNAddStates(67, 70);
1908                  break;
1909               case 22:
1910                  if ((0x3ff041000000000L & l) != 0L)
1911                     jjCheckNAddTwoStates(22, 20);
1912                  break;
1913               case 23:
1914                  if ((0x3ff041000000000L & l) != 0L)
1915                     jjCheckNAddTwoStates(23, 24);
1916                  break;
1917               case 24:
1918                  if (curChar == 46)
1919                     jjCheckNAdd(25);
1920                  break;
1921               case 25:
1922                  if ((0x3ff041000000000L & l) != 0L)
1923                     jjCheckNAddStates(71, 74);
1924                  break;
1925               case 39:
1926                  if ((0x3ff000000000000L & l) != 0L)
1927                     jjCheckNAddStates(75, 77);
1928                  break;
1929               case 40:
1930                  if (curChar == 46)
1931                     jjCheckNAdd(41);
1932                  break;
1933               case 41:
1934                  if ((0x3ff000000000000L & l) != 0L)
1935                     jjCheckNAddStates(78, 80);
1936                  break;
1937               default : break;
1938            }
1939         } while(i != startsAt);
1940      }
1941      else if (curChar < 128)
1942      {
1943         long l = 1L << (curChar & 077);
1944         MatchLoop: do
1945         {
1946            switch(jjstateSet[--i])
1947            {
1948               case 0:
1949                  if ((0x7fffffe87fffffeL & l) != 0L)
1950                  {
1951                     if (kind > 29)
1952                        kind = 29;
1953                     jjCheckNAddStates(57, 61);
1954                  }
1955                  else if (curChar == 64)
1956                     jjCheckNAdd(1);
1957                  break;
1958               case 1:
1959                  if ((0x7fffffe87fffffeL & l) != 0L)
1960                     jjCheckNAddTwoStates(1, 2);
1961                  break;
1962               case 3:
1963                  if ((0x7fffffe87fffffeL & l) == 0L)
1964                     break;
1965                  if (kind > 26)
1966                     kind = 26;
1967                  jjCheckNAddTwoStates(2, 3);
1968                  break;
1969               case 4:
1970                  if ((0x7fffffe87fffffeL & l) == 0L)
1971                     break;
1972                  if (kind > 29)
1973                     kind = 29;
1974                  jjCheckNAddStates(57, 61);
1975                  break;
1976               case 5:
1977                  if ((0x7fffffe87fffffeL & l) != 0L)
1978                     jjCheckNAddTwoStates(5, 6);
1979                  break;
1980               case 7:
1981                  if ((0x7fffffe87fffffeL & l) == 0L)
1982                     break;
1983                  if (kind > 24)
1984                     kind = 24;
1985                  jjCheckNAddStates(0, 2);
1986                  break;
1987               case 8:
1988                  if (curChar != 93)
1989                     break;
1990                  if (kind > 24)
1991                     kind = 24;
1992                  jjCheckNAdd(9);
1993                  break;
1994               case 9:
1995                  if (curChar == 91)
1996                     jjstateSet[jjnewStateCnt++] = 8;
1997                  break;
1998               case 10:
1999                  if ((0x7fffffe87fffffeL & l) != 0L)
2000                     jjCheckNAddTwoStates(10, 12);
2001                  break;
2002               case 11:
2003                  if (curChar != 93)
2004                     break;
2005                  if (kind > 25)
2006                     kind = 25;
2007                  jjCheckNAdd(12);
2008                  break;
2009               case 12:
2010                  if (curChar == 91)
2011                     jjstateSet[jjnewStateCnt++] = 11;
2012                  break;
2013               case 13:
2014                  if ((0x7fffffe87fffffeL & l) == 0L)
2015                     break;
2016                  if (kind > 29)
2017                     kind = 29;
2018                  jjCheckNAdd(13);
2019                  break;
2020               case 15:
2021                  if (curChar == 123)
2022                     jjAddStates(81, 82);
2023                  break;
2024               case 16:
2025                  if (curChar == 64)
2026                     jjCheckNAdd(17);
2027                  break;
2028               case 17:
2029                  if ((0x7fffffe87fffffeL & l) != 0L)
2030                     jjCheckNAddTwoStates(17, 18);
2031                  break;
2032               case 19:
2033                  if ((0x7fffffe87fffffeL & l) != 0L)
2034                     jjCheckNAddStates(64, 66);
2035                  break;
2036               case 20:
2037                  if (curChar == 125 && kind > 27)
2038                     kind = 27;
2039                  break;
2040               case 21:
2041                  if ((0x7fffffe87fffffeL & l) != 0L)
2042                     jjCheckNAddStates(67, 70);
2043                  break;
2044               case 22:
2045                  if ((0x7fffffe87fffffeL & l) != 0L)
2046                     jjCheckNAddTwoStates(22, 20);
2047                  break;
2048               case 23:
2049                  if ((0x7fffffe87fffffeL & l) != 0L)
2050                     jjCheckNAddTwoStates(23, 24);
2051                  break;
2052               case 25:
2053                  if ((0x7fffffe87fffffeL & l) != 0L)
2054                     jjCheckNAddStates(71, 74);
2055                  break;
2056               case 26:
2057                  if (curChar == 93)
2058                     jjCheckNAddTwoStates(27, 20);
2059                  break;
2060               case 27:
2061                  if (curChar == 91)
2062                     jjstateSet[jjnewStateCnt++] = 26;
2063                  break;
2064               case 28:
2065                  if (curChar == 102)
2066                     jjstateSet[jjnewStateCnt++] = 15;
2067                  break;
2068               case 29:
2069                  if (curChar == 111)
2070                     jjstateSet[jjnewStateCnt++] = 28;
2071                  break;
2072               case 30:
2073                  if (curChar == 101)
2074                     jjstateSet[jjnewStateCnt++] = 29;
2075                  break;
2076               case 31:
2077                  if (curChar == 99)
2078                     jjstateSet[jjnewStateCnt++] = 30;
2079                  break;
2080               case 32:
2081                  if (curChar == 110)
2082                     jjstateSet[jjnewStateCnt++] = 31;
2083                  break;
2084               case 33:
2085                  if (curChar == 97)
2086                     jjstateSet[jjnewStateCnt++] = 32;
2087                  break;
2088               case 34:
2089                  if (curChar == 116)
2090                     jjstateSet[jjnewStateCnt++] = 33;
2091                  break;
2092               case 35:
2093                  if (curChar == 115)
2094                     jjstateSet[jjnewStateCnt++] = 34;
2095                  break;
2096               case 36:
2097                  if (curChar == 110)
2098                     jjstateSet[jjnewStateCnt++] = 35;
2099                  break;
2100               case 37:
2101                  if (curChar == 105)
2102                     jjstateSet[jjnewStateCnt++] = 36;
2103                  break;
2104               case 38:
2105                  if (curChar == 123)
2106                     jjCheckNAdd(39);
2107                  break;
2108               case 39:
2109                  if ((0x7fffffe87fffffeL & l) != 0L)
2110                     jjCheckNAddStates(75, 77);
2111                  break;
2112               case 41:
2113                  if ((0x7fffffe87fffffeL & l) != 0L)
2114                     jjCheckNAddStates(78, 80);
2115                  break;
2116               case 42:
2117                  if (curChar == 125 && kind > 28)
2118                     kind = 28;
2119                  break;
2120               case 43:
2121                  if (curChar == 102)
2122                     jjstateSet[jjnewStateCnt++] = 38;
2123                  break;
2124               case 44:
2125                  if (curChar == 101)
2126                     jjstateSet[jjnewStateCnt++] = 43;
2127                  break;
2128               case 45:
2129                  if (curChar == 100)
2130                     jjstateSet[jjnewStateCnt++] = 44;
2131                  break;
2132               case 46:
2133                  if (curChar == 101)
2134                     jjstateSet[jjnewStateCnt++] = 45;
2135                  break;
2136               case 47:
2137                  if (curChar == 112)
2138                     jjstateSet[jjnewStateCnt++] = 46;
2139                  break;
2140               case 48:
2141                  if (curChar == 121)
2142                     jjstateSet[jjnewStateCnt++] = 47;
2143                  break;
2144               case 49:
2145                  if (curChar == 116)
2146                     jjstateSet[jjnewStateCnt++] = 48;
2147                  break;
2148               default : break;
2149            }
2150         } while(i != startsAt);
2151      }
2152      else
2153      {
2154         int i2 = (curChar & 0xff) >> 6;
2155         long l2 = 1L << (curChar & 077);
2156         MatchLoop: do
2157         {
2158            switch(jjstateSet[--i])
2159            {
2160               default : break;
2161            }
2162         } while(i != startsAt);
2163      }
2164      if (kind != 0x7fffffff)
2165      {
2166         jjmatchedKind = kind;
2167         jjmatchedPos = curPos;
2168         kind = 0x7fffffff;
2169      }
2170      ++curPos;
2171      if ((i = jjnewStateCnt) == (startsAt = 50 - (jjnewStateCnt = startsAt)))
2172         return curPos;
2173      try { curChar = input_stream.readChar(); }
2174      catch(java.io.IOException JavaDoc e) { return curPos; }
2175   }
2176}
2177private final int jjStopStringLiteralDfa_3(int pos, long active0, long active1)
2178{
2179   switch (pos)
2180   {
2181      case 0:
2182         if ((active1 & 0x3feL) != 0L)
2183         {
2184            jjmatchedKind = 79;
2185            return 50;
2186         }
2187         return -1;
2188      case 1:
2189         if ((active1 & 0x3feL) != 0L)
2190         {
2191            jjmatchedKind = 79;
2192            jjmatchedPos = 1;
2193            return 50;
2194         }
2195         return -1;
2196      case 2:
2197         if ((active1 & 0x3feL) != 0L)
2198         {
2199            jjmatchedKind = 79;
2200            jjmatchedPos = 2;
2201            return 50;
2202         }
2203         return -1;
2204      case 3:
2205         if ((active1 & 0x3feL) != 0L)
2206         {
2207            jjmatchedKind = 79;
2208            jjmatchedPos = 3;
2209            return 50;
2210         }
2211         return -1;
2212      case 4:
2213         if ((active1 & 0x3faL) != 0L)
2214         {
2215            jjmatchedKind = 79;
2216            jjmatchedPos = 4;
2217            return 50;
2218         }
2219         if ((active1 & 0x4L) != 0L)
2220            return 50;
2221         return -1;
2222      case 5:
2223         if ((active1 & 0x160L) != 0L)
2224            return 50;
2225         if ((active1 & 0x29aL) != 0L)
2226         {
2227            jjmatchedKind = 79;
2228            jjmatchedPos = 5;
2229            return 50;
2230         }
2231         return -1;
2232      case 6:
2233         if ((active1 & 0x292L) != 0L)
2234         {
2235            jjmatchedKind = 79;
2236            jjmatchedPos = 6;
2237            return 50;
2238         }
2239         if ((active1 & 0x8L) != 0L)
2240            return 50;
2241         return -1;
2242      case 7:
2243         if ((active1 & 0x2L) != 0L)
2244            return 50;
2245         if ((active1 & 0x290L) != 0L)
2246         {
2247            jjmatchedKind = 79;
2248            jjmatchedPos = 7;
2249            return 50;
2250         }
2251         return -1;
2252      case 8:
2253         if ((active1 & 0x200L) != 0L)
2254         {
2255            jjmatchedKind = 79;
2256            jjmatchedPos = 8;
2257            return 50;
2258         }
2259         if ((active1 & 0x90L) != 0L)
2260            return 50;
2261         return -1;
2262      case 9:
2263         if ((active1 & 0x200L) != 0L)
2264         {
2265            jjmatchedKind = 79;
2266            jjmatchedPos = 9;
2267            return 50;
2268         }
2269         return -1;
2270      case 10:
2271         if ((active1 & 0x200L) != 0L)
2272         {
2273            jjmatchedKind = 79;
2274            jjmatchedPos = 10;
2275            return 50;
2276         }
2277         return -1;
2278      default :
2279         return -1;
2280   }
2281}
2282private final int jjStartNfa_3(int pos, long active0, long active1)
2283{
2284   return jjMoveNfa_3(jjStopStringLiteralDfa_3(pos, active0, active1), pos + 1);
2285}
2286private final int jjStartNfaWithStates_3(int pos, int kind, int state)
2287{
2288   jjmatchedKind = kind;
2289   jjmatchedPos = pos;
2290   try { curChar = input_stream.readChar(); }
2291   catch(java.io.IOException JavaDoc e) { return pos + 1; }
2292   return jjMoveNfa_3(state, pos + 1);
2293}
2294private final int jjMoveStringLiteralDfa0_3()
2295{
2296   switch(curChar)
2297   {
2298      case 33:
2299         return jjStopAtPos(0, 84);
2300      case 41:
2301         return jjStopAtPos(0, 85);
2302      case 45:
2303         return jjMoveStringLiteralDfa1_3(0x80000L);
2304      case 97:
2305         return jjMoveStringLiteralDfa1_3(0x2L);
2306      case 102:
2307         return jjMoveStringLiteralDfa1_3(0x4L);
2308      case 110:
2309         return jjMoveStringLiteralDfa1_3(0x100L);
2310      case 112:
2311         return jjMoveStringLiteralDfa1_3(0x38L);
2312      case 115:
2313         return jjMoveStringLiteralDfa1_3(0x240L);
2314      case 116:
2315         return jjMoveStringLiteralDfa1_3(0x80L);
2316      default :
2317         return jjMoveNfa_3(0, 0);
2318   }
2319}
2320private final int jjMoveStringLiteralDfa1_3(long active1)
2321{
2322   try { curChar = input_stream.readChar(); }
2323   catch(java.io.IOException JavaDoc e) {
2324      jjStopStringLiteralDfa_3(0, 0L, active1);
2325      return 1;
2326   }
2327   switch(curChar)
2328   {
2329      case 62:
2330         if ((active1 & 0x80000L) != 0L)
2331            return jjStopAtPos(1, 83);
2332         break;
2333      case 97:
2334         return jjMoveStringLiteralDfa2_3(active1, 0x100L);
2335      case 98:
2336         return jjMoveStringLiteralDfa2_3(active1, 0x2L);
2337      case 105:
2338         return jjMoveStringLiteralDfa2_3(active1, 0x4L);
2339      case 114:
2340         return jjMoveStringLiteralDfa2_3(active1, 0x98L);
2341      case 116:
2342         return jjMoveStringLiteralDfa2_3(active1, 0x40L);
2343      case 117:
2344         return jjMoveStringLiteralDfa2_3(active1, 0x20L);
2345      case 121:
2346         return jjMoveStringLiteralDfa2_3(active1, 0x200L);
2347      default :
2348         break;
2349   }
2350   return jjStartNfa_3(0, 0L, active1);
2351}
2352private final int jjMoveStringLiteralDfa2_3(long old1, long active1)
2353{
2354   if (((active1 &= old1)) == 0L)
2355      return jjStartNfa_3(0, 0L, old1);
2356   try { curChar = input_stream.readChar(); }
2357   catch(java.io.IOException JavaDoc e) {
2358      jjStopStringLiteralDfa_3(1, 0L, active1);
2359      return 2;
2360   }
2361   switch(curChar)
2362   {
2363      case 97:
2364         return jjMoveStringLiteralDfa3_3(active1, 0xc0L);
2365      case 98:
2366         return jjMoveStringLiteralDfa3_3(active1, 0x20L);
2367      case 105:
2368         return jjMoveStringLiteralDfa3_3(active1, 0x8L);
2369      case 110:
2370         return jjMoveStringLiteralDfa3_3(active1, 0x204L);
2371      case 111:
2372         return jjMoveStringLiteralDfa3_3(active1, 0x10L);
2373      case 115:
2374         return jjMoveStringLiteralDfa3_3(active1, 0x2L);
2375      case 116:
2376         return jjMoveStringLiteralDfa3_3(active1, 0x100L);
2377      default :
2378         break;
2379   }
2380   return jjStartNfa_3(1, 0L, active1);
2381}
2382private final int jjMoveStringLiteralDfa3_3(long old1, long active1)
2383{
2384   if (((active1 &= old1)) == 0L)
2385      return jjStartNfa_3(1, 0L, old1);
2386   try { curChar = input_stream.readChar(); }
2387   catch(java.io.IOException JavaDoc e) {
2388      jjStopStringLiteralDfa_3(2, 0L, active1);
2389      return 3;
2390   }
2391   switch(curChar)
2392   {
2393      case 97:
2394         return jjMoveStringLiteralDfa4_3(active1, 0x4L);
2395      case 99:
2396         return jjMoveStringLiteralDfa4_3(active1, 0x200L);
2397      case 105:
2398         return jjMoveStringLiteralDfa4_3(active1, 0x100L);
2399      case 108:
2400         return jjMoveStringLiteralDfa4_3(active1, 0x20L);
2401      case 110:
2402         return jjMoveStringLiteralDfa4_3(active1, 0x80L);
2403      case 116:
2404         return jjMoveStringLiteralDfa4_3(active1, 0x52L);
2405      case 118:
2406         return jjMoveStringLiteralDfa4_3(active1, 0x8L);
2407      default :
2408         break;
2409   }
2410   return jjStartNfa_3(2, 0L, active1);
2411}
2412private final int jjMoveStringLiteralDfa4_3(long old1, long active1)
2413{
2414   if (((active1 &= old1)) == 0L)
2415      return jjStartNfa_3(2, 0L, old1);
2416   try { curChar = input_stream.readChar(); }
2417   catch(java.io.IOException JavaDoc e) {
2418      jjStopStringLiteralDfa_3(3, 0L, active1);
2419      return 4;
2420   }
2421   switch(curChar)
2422   {
2423      case 97:
2424         return jjMoveStringLiteralDfa5_3(active1, 0x8L);
2425      case 101:
2426         return jjMoveStringLiteralDfa5_3(active1, 0x10L);
2427      case 104:
2428         return jjMoveStringLiteralDfa5_3(active1, 0x200L);
2429      case 105:
2430         return jjMoveStringLiteralDfa5_3(active1, 0x60L);
2431      case 108:
2432         if ((active1 & 0x4L) != 0L)
2433            return jjStartNfaWithStates_3(4, 66, 50);
2434         break;
2435      case 114:
2436         return jjMoveStringLiteralDfa5_3(active1, 0x2L);
2437      case 115:
2438         return jjMoveStringLiteralDfa5_3(active1, 0x80L);
2439      case 118:
2440         return jjMoveStringLiteralDfa5_3(active1, 0x100L);
2441      default :
2442         break;
2443   }
2444   return jjStartNfa_3(3, 0L, active1);
2445}
2446private final int jjMoveStringLiteralDfa5_3(long old1, long active1)
2447{
2448   if (((active1 &= old1)) == 0L)
2449      return jjStartNfa_3(3, 0L, old1);
2450   try { curChar = input_stream.readChar(); }
2451   catch(java.io.IOException JavaDoc e) {
2452      jjStopStringLiteralDfa_3(4, 0L, active1);
2453      return 5;
2454   }
2455   switch(curChar)
2456   {
2457      case 97:
2458         return jjMoveStringLiteralDfa6_3(active1, 0x2L);
2459      case 99:
2460         if ((active1 & 0x20L) != 0L)
2461            return jjStartNfaWithStates_3(5, 69, 50);
2462         else if ((active1 & 0x40L) != 0L)
2463            return jjStartNfaWithStates_3(5, 70, 50);
2464         return jjMoveStringLiteralDfa6_3(active1, 0x10L);
2465      case 101:
2466         if ((active1 & 0x100L) != 0L)
2467            return jjStartNfaWithStates_3(5, 72, 50);
2468         break;
2469      case 105:
2470         return jjMoveStringLiteralDfa6_3(active1, 0x80L);
2471      case 114:
2472         return jjMoveStringLiteralDfa6_3(active1, 0x200L);
2473      case 116:
2474         return jjMoveStringLiteralDfa6_3(active1, 0x8L);
2475      default :
2476         break;
2477   }
2478   return jjStartNfa_3(4, 0L, active1);
2479}
2480private final int jjMoveStringLiteralDfa6_3(long old1, long active1)
2481{
2482   if (((active1 &= old1)) == 0L)
2483      return jjStartNfa_3(4, 0L, old1);
2484   try { curChar = input_stream.readChar(); }
2485   catch(java.io.IOException JavaDoc e) {
2486      jjStopStringLiteralDfa_3(5, 0L, active1);
2487      return 6;
2488   }
2489   switch(curChar)
2490   {
2491      case 99:
2492         return jjMoveStringLiteralDfa7_3(active1, 0x2L);
2493      case 101:
2494         if ((active1 & 0x8L) != 0L)
2495            return jjStartNfaWithStates_3(6, 67, 50);
2496         return jjMoveStringLiteralDfa7_3(active1, 0x80L);
2497      case 111:
2498         return jjMoveStringLiteralDfa7_3(active1, 0x200L);
2499      case 116:
2500         return jjMoveStringLiteralDfa7_3(active1, 0x10L);
2501      default :
2502         break;
2503   }
2504   return jjStartNfa_3(5, 0L, active1);
2505}
2506private final int jjMoveStringLiteralDfa7_3(long old1, long active1)
2507{
2508   if (((active1 &= old1)) == 0L)
2509      return jjStartNfa_3(5, 0L, old1);
2510   try { curChar = input_stream.readChar(); }
2511   catch(java.io.IOException JavaDoc e) {
2512      jjStopStringLiteralDfa_3(6, 0L, active1);
2513      return 7;
2514   }
2515   switch(curChar)
2516   {
2517      case 101:
2518         return jjMoveStringLiteralDfa8_3(active1, 0x10L);
2519      case 110:
2520         return jjMoveStringLiteralDfa8_3(active1, 0x280L);
2521      case 116:
2522         if ((active1 & 0x2L) != 0L)
2523            return jjStartNfaWithStates_3(7, 65, 50);
2524         break;
2525      default :
2526         break;
2527   }
2528   return jjStartNfa_3(6, 0L, active1);
2529}
2530private final int jjMoveStringLiteralDfa8_3(long old1, long active1)
2531{
2532   if (((active1 &= old1)) == 0L)
2533      return jjStartNfa_3(6, 0L, old1);
2534   try { curChar = input_stream.readChar(); }
2535   catch(java.io.IOException JavaDoc e) {
2536      jjStopStringLiteralDfa_3(7, 0L, active1);
2537      return 8;
2538   }
2539   switch(curChar)
2540   {
2541      case 100:
2542         if ((active1 & 0x10L) != 0L)
2543            return jjStartNfaWithStates_3(8, 68, 50);
2544         break;
2545      case 105:
2546         return jjMoveStringLiteralDfa9_3(active1, 0x200L);
2547      case 116:
2548         if ((active1 & 0x80L) != 0L)
2549            return jjStartNfaWithStates_3(8, 71, 50);
2550         break;
2551      default :
2552         break;
2553   }
2554   return jjStartNfa_3(7, 0L, active1);
2555}
2556private final int jjMoveStringLiteralDfa9_3(long old1, long active1)
2557{
2558   if (((active1 &= old1)) == 0L)
2559      return jjStartNfa_3(7, 0L, old1);
2560   try { curChar = input_stream.readChar(); }
2561   catch(java.io.IOException JavaDoc e) {
2562      jjStopStringLiteralDfa_3(8, 0L, active1);
2563      return 9;
2564   }
2565   switch(curChar)
2566   {
2567      case 122:
2568         return jjMoveStringLiteralDfa10_3(active1, 0x200L);
2569      default :
2570         break;
2571   }
2572   return jjStartNfa_3(8, 0L, active1);
2573}
2574private final int jjMoveStringLiteralDfa10_3(long old1, long active1)
2575{
2576   if (((active1 &= old1)) == 0L)
2577      return jjStartNfa_3(8, 0L, old1);
2578   try { curChar = input_stream.readChar(); }
2579   catch(java.io.IOException JavaDoc e) {
2580      jjStopStringLiteralDfa_3(9, 0L, active1);
2581      return 10;
2582   }
2583   switch(curChar)
2584   {
2585      case 101:
2586         return jjMoveStringLiteralDfa11_3(active1, 0x200L);
2587      default :
2588         break;
2589   }
2590   return jjStartNfa_3(9, 0L, active1);
2591}
2592private final int jjMoveStringLiteralDfa11_3(long old1, long active1)
2593{
2594   if (((active1 &= old1)) == 0L)
2595      return jjStartNfa_3(9, 0L, old1);
2596   try { curChar = input_stream.readChar(); }
2597   catch(java.io.IOException JavaDoc e) {
2598      jjStopStringLiteralDfa_3(10, 0L, active1);
2599      return 11;
2600   }
2601   switch(curChar)
2602   {
2603      case 100:
2604         if ((active1 & 0x200L) != 0L)
2605            return jjStartNfaWithStates_3(11, 73, 50);
2606         break;
2607      default :
2608         break;
2609   }
2610   return jjStartNfa_3(10, 0L, active1);
2611}
2612private final int jjMoveNfa_3(int startState, int curPos)
2613{
2614   int[] nextStates;
2615   int startsAt = 0;
2616   jjnewStateCnt = 50;
2617   int i = 1;
2618   jjstateSet[0] = startState;
2619   int j, kind = 0x7fffffff;
2620   for (;;)
2621   {
2622      if (++jjround == 0x7fffffff)
2623         ReInitRounds();
2624      if (curChar < 64)
2625      {
2626         long l = 1L << curChar;
2627         MatchLoop: do
2628         {
2629            switch(jjstateSet[--i])
2630            {
2631               case 0:
2632                  if ((0x3ff041000000000L & l) != 0L)
2633                  {
2634                     if (kind > 79)
2635                        kind = 79;
2636                     jjCheckNAddStates(83, 87);
2637                  }
2638                  if (curChar == 36)
2639                     jjAddStates(88, 89);
2640                  break;
2641               case 50:
2642                  if ((0x3ff041000000000L & l) != 0L)
2643                  {
2644                     if (kind > 79)
2645                        kind = 79;
2646                     jjCheckNAdd(49);
2647                  }
2648                  else if (curChar == 46)
2649                     jjCheckNAdd(43);
2650                  if ((0x3ff041000000000L & l) != 0L)
2651                     jjCheckNAddTwoStates(46, 48);
2652                  if ((0x3ff041000000000L & l) != 0L)
2653                     jjCheckNAddTwoStates(41, 42);
2654                  break;
2655               case 1:
2656                  if ((0x3ff041000000000L & l) == 0L)
2657                     break;
2658                  if (kind > 78)
2659                     kind = 78;
2660                  jjCheckNAddTwoStates(1, 2);
2661                  break;
2662               case 2:
2663                  if (curChar == 46)
2664                     jjCheckNAdd(3);
2665                  break;
2666               case 3:
2667                  if ((0x3ff041000000000L & l) == 0L)
2668                     break;
2669                  if (kind > 78)
2670                     kind = 78;
2671                  jjCheckNAddTwoStates(2, 3);
2672                  break;
2673               case 4:
2674                  if (curChar == 36)
2675                     jjAddStates(88, 89);
2676                  break;
2677               case 7:
2678                  if ((0x3ff041000000000L & l) != 0L)
2679                     jjCheckNAddStates(12, 14);
2680                  break;
2681               case 8:
2682                  if (curChar == 46)
2683                     jjCheckNAdd(9);
2684                  break;
2685               case 9:
2686                  if ((0x3ff041000000000L & l) != 0L)
2687                     jjCheckNAddStates(15, 17);
2688                  break;
2689               case 11:
2690                  if ((0x3ff041000000000L & l) != 0L)
2691                     jjCheckNAddStates(18, 21);
2692                  break;
2693               case 12:
2694                  if ((0x3ff041000000000L & l) != 0L)
2695                     jjCheckNAddTwoStates(12, 10);
2696                  break;
2697               case 13:
2698                  if ((0x3ff041000000000L & l) != 0L)
2699                     jjCheckNAddTwoStates(13, 14);
2700                  break;
2701               case 14:
2702                  if (curChar == 46)
2703                     jjCheckNAdd(15);
2704                  break;
2705               case 15:
2706                  if ((0x3ff041000000000L & l) != 0L)
2707                     jjCheckNAddStates(22, 25);
2708                  break;
2709               case 29:
2710                  if ((0x3ff000000000000L & l) != 0L)
2711                     jjCheckNAddStates(26, 28);
2712                  break;
2713               case 30:
2714                  if (curChar == 46)
2715                     jjCheckNAdd(31);
2716                  break;
2717               case 31:
2718                  if ((0x3ff000000000000L & l) != 0L)
2719                     jjCheckNAddStates(29, 31);
2720                  break;
2721               case 40:
2722                  if ((0x3ff041000000000L & l) == 0L)
2723                     break;
2724                  if (kind > 79)
2725                     kind = 79;
2726                  jjCheckNAddStates(83, 87);
2727                  break;
2728               case 41:
2729                  if ((0x3ff041000000000L & l) != 0L)
2730                     jjCheckNAddTwoStates(41, 42);
2731                  break;
2732               case 42:
2733                  if (curChar == 46)
2734                     jjCheckNAdd(43);
2735                  break;
2736               case 43:
2737                  if ((0x3ff041000000000L & l) == 0L)
2738                     break;
2739                  if (kind > 76)
2740                     kind = 76;
2741                  jjCheckNAddStates(90, 92);
2742                  break;
2743               case 46:
2744                  if ((0x3ff041000000000L & l) != 0L)
2745                     jjCheckNAddTwoStates(46, 48);
2746                  break;
2747               case 49:
2748                  if ((0x3ff041000000000L & l) == 0L)
2749                     break;
2750                  if (kind > 79)
2751                     kind = 79;
2752                  jjCheckNAdd(49);
2753                  break;
2754               default : break;
2755            }
2756         } while(i != startsAt);
2757      }
2758      else if (curChar < 128)
2759      {
2760         long l = 1L << (curChar & 077);
2761         MatchLoop: do
2762         {
2763            switch(jjstateSet[--i])
2764            {
2765               case 0:
2766                  if ((0x7fffffe87fffffeL & l) != 0L)
2767                  {
2768                     if (kind > 79)
2769                        kind = 79;
2770                     jjCheckNAddStates(83, 87);
2771                  }
2772                  else if (curChar == 64)
2773                     jjCheckNAdd(1);
2774                  break;
2775               case 50:
2776                  if ((0x7fffffe87fffffeL & l) != 0L)
2777                  {
2778                     if (kind > 79)
2779                        kind = 79;
2780                     jjCheckNAdd(49);
2781                  }
2782                  else if (curChar == 91)
2783                     jjstateSet[jjnewStateCnt++] = 47;
2784                  if ((0x7fffffe87fffffeL & l) != 0L)
2785                     jjCheckNAddTwoStates(46, 48);
2786                  if ((0x7fffffe87fffffeL & l) != 0L)
2787                     jjCheckNAddTwoStates(41, 42);
2788                  break;
2789               case 1:
2790                  if ((0x7fffffe87fffffeL & l) == 0L)
2791                     break;
2792                  if (kind > 78)
2793                     kind = 78;
2794                  jjCheckNAddTwoStates(1, 2);
2795                  break;
2796               case 3:
2797                  if ((0x7fffffe87fffffeL & l) == 0L)
2798                     break;
2799                  if (kind > 78)
2800                     kind = 78;
2801                  jjCheckNAddTwoStates(2, 3);
2802                  break;
2803               case 5:
2804                  if (curChar == 123)
2805                     jjAddStates(55, 56);
2806                  break;
2807               case 6:
2808                  if (curChar == 64)
2809                     jjCheckNAdd(7);
2810                  break;
2811               case 7:
2812                  if ((0x7fffffe87fffffeL & l) != 0L)
2813                     jjCheckNAddStates(12, 14);
2814                  break;
2815               case 9:
2816                  if ((0x7fffffe87fffffeL & l) != 0L)
2817                     jjCheckNAddStates(15, 17);
2818                  break;
2819               case 10:
2820                  if (curChar == 125 && kind > 74)
2821                     kind = 74;
2822                  break;
2823               case 11:
2824                  if ((0x7fffffe87fffffeL & l) != 0L)
2825                     jjCheckNAddStates(18, 21);
2826                  break;
2827               case 12:
2828                  if ((0x7fffffe87fffffeL & l) != 0L)
2829                     jjCheckNAddTwoStates(12, 10);
2830                  break;
2831               case 13:
2832                  if ((0x7fffffe87fffffeL & l) != 0L)
2833                     jjCheckNAddTwoStates(13, 14);
2834                  break;
2835               case 15:
2836                  if ((0x7fffffe87fffffeL & l) != 0L)
2837                     jjCheckNAddStates(22, 25);
2838                  break;
2839               case 16:
2840                  if (curChar == 93)
2841                     jjCheckNAddTwoStates(17, 10);
2842                  break;
2843               case 17:
2844                  if (curChar == 91)
2845                     jjstateSet[jjnewStateCnt++] = 16;
2846                  break;
2847               case 18:
2848                  if (curChar == 102)
2849                     jjstateSet[jjnewStateCnt++] = 5;
2850                  break;
2851               case 19:
2852                  if (curChar == 111)
2853                     jjstateSet[jjnewStateCnt++] = 18;
2854                  break;
2855               case 20:
2856                  if (curChar == 101)
2857                     jjstateSet[jjnewStateCnt++] = 19;
2858                  break;
2859               case 21:
2860                  if (curChar == 99)
2861                     jjstateSet[jjnewStateCnt++] = 20;
2862                  break;
2863               case 22:
2864                  if (curChar == 110)
2865                     jjstateSet[jjnewStateCnt++] = 21;
2866                  break;
2867               case 23:
2868                  if (curChar == 97)
2869                     jjstateSet[jjnewStateCnt++] = 22;
2870                  break;
2871               case 24:
2872                  if (curChar == 116)
2873                     jjstateSet[jjnewStateCnt++] = 23;
2874                  break;
2875               case 25:
2876                  if (curChar == 115)
2877                     jjstateSet[jjnewStateCnt++] = 24;
2878                  break;
2879               case 26:
2880                  if (curChar == 110)
2881                     jjstateSet[jjnewStateCnt++] = 25;
2882                  break;
2883               case 27:
2884                  if (curChar == 105)
2885                     jjstateSet[jjnewStateCnt++] = 26;
2886                  break;
2887               case 28:
2888                  if (curChar == 123)
2889                     jjCheckNAdd(29);
2890                  break;
2891               case 29:
2892                  if ((0x7fffffe87fffffeL & l) != 0L)
2893                     jjCheckNAddStates(26, 28);
2894                  break;
2895               case 31:
2896                  if ((0x7fffffe87fffffeL & l) != 0L)
2897                     jjCheckNAddStates(29, 31);
2898                  break;
2899               case 32:
2900                  if (curChar == 125 && kind > 75)
2901                     kind = 75;
2902                  break;
2903               case 33:
2904                  if (curChar == 102)
2905                     jjstateSet[jjnewStateCnt++] = 28;
2906                  break;
2907               case 34:
2908                  if (curChar == 101)
2909                     jjstateSet[jjnewStateCnt++] = 33;
2910                  break;
2911               case 35:
2912                  if (curChar == 100)
2913                     jjstateSet[jjnewStateCnt++] = 34;
2914                  break;
2915               case 36:
2916                  if (curChar == 101)
2917                     jjstateSet[jjnewStateCnt++] = 35;
2918                  break;
2919               case 37:
2920                  if (curChar == 112)
2921                     jjstateSet[jjnewStateCnt++] = 36;
2922                  break;
2923               case 38:
2924                  if (curChar == 121)
2925                     jjstateSet[jjnewStateCnt++] = 37;
2926                  break;
2927               case 39:
2928                  if (curChar == 116)
2929                     jjstateSet[jjnewStateCnt++] = 38;
2930                  break;
2931               case 40:
2932                  if ((0x7fffffe87fffffeL & l) == 0L)
2933                     break;
2934                  if (kind > 79)
2935                     kind = 79;
2936                  jjCheckNAddStates(83, 87);
2937                  break;
2938               case 41:
2939                  if ((0x7fffffe87fffffeL & l) != 0L)
2940                     jjCheckNAddTwoStates(41, 42);
2941                  break;
2942               case 43:
2943                  if ((0x7fffffe87fffffeL & l) == 0L)
2944                     break;
2945                  if (kind > 76)
2946                     kind = 76;
2947                  jjCheckNAddStates(90, 92);
2948                  break;
2949               case 44:
2950                  if (curChar != 93)
2951                     break;
2952                  if (kind > 76)
2953                     kind = 76;
2954                  jjCheckNAdd(45);
2955                  break;
2956               case 45:
2957                  if (curChar == 91)
2958                     jjstateSet[jjnewStateCnt++] = 44;
2959                  break;
2960               case 46:
2961                  if ((0x7fffffe87fffffeL & l) != 0L)
2962                     jjCheckNAddTwoStates(46, 48);
2963                  break;
2964               case 47:
2965                  if (curChar != 93)
2966                     break;
2967                  if (kind > 77)
2968                     kind = 77;
2969                  jjCheckNAdd(48);
2970                  break;
2971               case 48:
2972                  if (curChar == 91)
2973                     jjstateSet[jjnewStateCnt++] = 47;
2974                  break;
2975               case 49:
2976                  if ((0x7fffffe87fffffeL & l) == 0L)
2977                     break;
2978                  if (kind > 79)
2979                     kind = 79;
2980                  jjCheckNAdd(49);
2981                  break;
2982               default : break;
2983            }
2984         } while(i != startsAt);
2985      }
2986      else
2987      {
2988         int i2 = (curChar & 0xff) >> 6;
2989         long l2 = 1L << (curChar & 077);
2990         MatchLoop: do
2991         {
2992            switch(jjstateSet[--i])
2993            {
2994               default : break;
2995            }
2996         } while(i != startsAt);
2997      }
2998      if (kind != 0x7fffffff)
2999      {
3000         jjmatchedKind = kind;
3001         jjmatchedPos = curPos;
3002         kind = 0x7fffffff;
3003      }
3004      ++curPos;
3005      if ((i = jjnewStateCnt) == (startsAt = 50 - (jjnewStateCnt = startsAt)))
3006         return curPos;
3007      try { curChar = input_stream.readChar(); }
3008      catch(java.io.IOException JavaDoc e) { return curPos; }
3009   }
3010}
3011static final int[] jjnextStates = {
3012   6, 7, 9, 85, 86, 90, 92, 93, 27, 39, 60, 83, 7, 8, 10, 8,
3013   9, 10, 12, 13, 14, 10, 14, 15, 17, 10, 29, 30, 32, 30, 31, 32,
3014   42, 43, 45, 46, 48, 49, 46, 49, 50, 46, 63, 64, 66, 67, 69, 70,
3015   67, 70, 71, 67, 86, 87, 89, 6, 11, 5, 6, 10, 12, 13, 37, 49,
3016   18, 19, 20, 22, 23, 24, 20, 24, 25, 27, 20, 39, 40, 42, 40, 41,
3017   42, 16, 21, 41, 42, 46, 48, 49, 27, 39, 42, 43, 45,
3018};
3019public static final String JavaDoc[] jjstrLiteralImages = {
3020"", null, null, null, null, "\143\141\154\154\50", "\141\154\154\50",
3021"\145\170\145\143\165\164\151\157\156\50", "\143\157\156\163\164\162\165\143\164\151\157\156\50", "\150\141\163\50",
3022"\150\141\163\146\151\145\154\144\50", "\147\145\164\50", "\163\145\164\50", "\146\151\145\154\144\50",
3023"\167\151\164\150\151\156\50", "\167\151\164\150\151\156\143\157\144\145\50", null, null, null, null, "\41",
3024null, null, "\56\56", null, null, null, null, null, null, "\54", null, null, null,
3025"\51", null, null, "\141\142\163\164\162\141\143\164", "\146\151\156\141\154",
3026"\160\162\151\166\141\164\145", "\160\162\157\164\145\143\164\145\144", "\160\165\142\154\151\143",
3027"\163\164\141\164\151\143", "\156\141\164\151\166\145",
3028"\163\171\156\143\150\162\157\156\151\172\145\144", "\156\145\167", "\164\150\162\157\167\163", null, null, null, "\54", null,
3029null, null, null, null, null, null, null, "\55\76", "\41", "\50", "\51", null, null,
3030"\141\142\163\164\162\141\143\164", "\146\151\156\141\154", "\160\162\151\166\141\164\145",
3031"\160\162\157\164\145\143\164\145\144", "\160\165\142\154\151\143", "\163\164\141\164\151\143",
3032"\164\162\141\156\163\151\145\156\164", "\156\141\164\151\166\145",
3033"\163\171\156\143\150\162\157\156\151\172\145\144", null, null, null, null, null, null, null, null, null, "\55\76", "\41", "\51",
3034"\50", "\51", };
3035public static final String JavaDoc[] lexStateNames = {
3036   "DEFAULT",
3037   "PARAMS",
3038   "BEHAVIOR",
3039   "FIELD_DECLARATION",
3040};
3041public static final int[] jjnewLexState = {
3042   -1, -1, -1, -1, -1, 2, 3, 2, 2, 2, 3, 3, 3, 3, 3, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3043   -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,
3044   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3045   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, -1,
3046};
3047static final long[] jjtoToken = {
3048   0x78ffffe47f93fff9L, 0xf8fffeL,
3049};
3050static final long[] jjtoSkip = {
3051   0x8000001800600006L, 0x1L,
3052};
3053protected SimpleCharStream input_stream;
3054private final int[] jjrounds = new int[94];
3055private final int[] jjstateSet = new int[188];
3056protected char curChar;
3057public PointcutExpressionParserTokenManager(SimpleCharStream stream)
3058{
3059   if (SimpleCharStream.staticFlag)
3060      throw new Error JavaDoc("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
3061   input_stream = stream;
3062}
3063public PointcutExpressionParserTokenManager(SimpleCharStream stream, int lexState)
3064{
3065   this(stream);
3066   SwitchTo(lexState);
3067}
3068public void ReInit(SimpleCharStream stream)
3069{
3070   jjmatchedPos = jjnewStateCnt = 0;
3071   curLexState = defaultLexState;
3072   input_stream = stream;
3073   ReInitRounds();
3074}
3075private final void ReInitRounds()
3076{
3077   int i;
3078   jjround = 0x80000001;
3079   for (i = 94; i-- > 0;)
3080      jjrounds[i] = 0x80000000;
3081}
3082public void ReInit(SimpleCharStream stream, int lexState)
3083{
3084   ReInit(stream);
3085   SwitchTo(lexState);
3086}
3087public void SwitchTo(int lexState)
3088{
3089   if (lexState >= 4 || lexState < 0)
3090      throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
3091   else
3092      curLexState = lexState;
3093}
3094
3095protected Token jjFillToken()
3096{
3097   Token t = Token.newToken(jjmatchedKind);
3098   t.kind = jjmatchedKind;
3099   String JavaDoc im = jjstrLiteralImages[jjmatchedKind];
3100   t.image = (im == null) ? input_stream.GetImage() : im;
3101   t.beginLine = input_stream.getBeginLine();
3102   t.beginColumn = input_stream.getBeginColumn();
3103   t.endLine = input_stream.getEndLine();
3104   t.endColumn = input_stream.getEndColumn();
3105   return t;
3106}
3107
3108int curLexState = 0;
3109int defaultLexState = 0;
3110int jjnewStateCnt;
3111int jjround;
3112int jjmatchedPos;
3113int jjmatchedKind;
3114
3115public Token getNextToken()
3116{
3117  int kind;
3118  Token specialToken = null;
3119  Token matchedToken;
3120  int curPos = 0;
3121
3122  EOFLoop :
3123  for (;;)
3124  {
3125   try
3126   {
3127      curChar = input_stream.BeginToken();
3128   }
3129   catch(java.io.IOException JavaDoc e)
3130   {
3131      jjmatchedKind = 0;
3132      matchedToken = jjFillToken();
3133      return matchedToken;
3134   }
3135
3136   switch(curLexState)
3137   {
3138     case 0:
3139       try { input_stream.backup(0);
3140          while (curChar <= 32 && (0x100000200L & (1L << curChar)) != 0L)
3141             curChar = input_stream.BeginToken();
3142       }
3143       catch (java.io.IOException JavaDoc e1) { continue EOFLoop; }
3144       jjmatchedKind = 0x7fffffff;
3145       jjmatchedPos = 0;
3146       curPos = jjMoveStringLiteralDfa0_0();
3147       break;
3148     case 1:
3149       try { input_stream.backup(0);
3150          while (curChar <= 32 && (0x100000200L & (1L << curChar)) != 0L)
3151             curChar = input_stream.BeginToken();
3152       }
3153       catch (java.io.IOException JavaDoc e1) { continue EOFLoop; }
3154       jjmatchedKind = 0x7fffffff;
3155       jjmatchedPos = 0;
3156       curPos = jjMoveStringLiteralDfa0_1();
3157       break;
3158     case 2:
3159       try { input_stream.backup(0);
3160          while (curChar <= 32 && (0x100000200L & (1L << curChar)) != 0L)
3161             curChar = input_stream.BeginToken();
3162       }
3163       catch (java.io.IOException JavaDoc e1) { continue EOFLoop; }
3164       jjmatchedKind = 0x7fffffff;
3165       jjmatchedPos = 0;
3166       curPos = jjMoveStringLiteralDfa0_2();
3167       break;
3168     case 3:
3169       try { input_stream.backup(0);
3170          while (curChar <= 32 && (0x100000200L & (1L << curChar)) != 0L)
3171             curChar = input_stream.BeginToken();
3172       }
3173       catch (java.io.IOException JavaDoc e1) { continue EOFLoop; }
3174       jjmatchedKind = 0x7fffffff;
3175       jjmatchedPos = 0;
3176       curPos = jjMoveStringLiteralDfa0_3();
3177       break;
3178   }
3179     if (jjmatchedKind != 0x7fffffff)
3180     {
3181        if (jjmatchedPos + 1 < curPos)
3182           input_stream.backup(curPos - jjmatchedPos - 1);
3183        if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
3184        {
3185           matchedToken = jjFillToken();
3186       if (jjnewLexState[jjmatchedKind] != -1)
3187         curLexState = jjnewLexState[jjmatchedKind];
3188           return matchedToken;
3189        }
3190        else
3191        {
3192         if (jjnewLexState[jjmatchedKind] != -1)
3193           curLexState = jjnewLexState[jjmatchedKind];
3194           continue EOFLoop;
3195        }
3196     }
3197     int error_line = input_stream.getEndLine();
3198     int error_column = input_stream.getEndColumn();
3199     String JavaDoc error_after = null;
3200     boolean EOFSeen = false;
3201     try { input_stream.readChar(); input_stream.backup(1); }
3202     catch (java.io.IOException JavaDoc e1) {
3203        EOFSeen = true;
3204        error_after = curPos <= 1 ? "" : input_stream.GetImage();
3205        if (curChar == '\n' || curChar == '\r') {
3206           error_line++;
3207           error_column = 0;
3208        }
3209        else
3210           error_column++;
3211     }
3212     if (!EOFSeen) {
3213        input_stream.backup(1);
3214        error_after = curPos <= 1 ? "" : input_stream.GetImage();
3215     }
3216     throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
3217  }
3218}
3219
3220}
3221
Popular Tags