KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > python > parser > PythonGrammarTokenManager


1 /* Generated By:JJTree&JavaCC: Do not edit this line. PythonGrammarTokenManager.java */
2 package org.python.parser;
3 import org.python.parser.ast.modType;
4
5 public class PythonGrammarTokenManager implements PythonGrammarConstants
6 {
7     int indentation[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
8     int level = 0;
9     int dedents = 0;
10     int parens = 0;
11     int indent;
12
13     boolean expect_indent = false;
14
15     boolean compound = false;
16
17     public boolean single_input = false;
18
19     // parsing of partial sentence (interactive) mode
20
public boolean partial = false;
21     // control whether empty new lines on EOF force sentence closing NEWLINE even if indent
22
// is expected,i.e. classic behavior at jython prompt (different from codeop behavior)
23
public boolean stdprompt = false;
24
25     public boolean generator_allowed = false;
26
27     static Token addDedent(Token previous) {
28         Token t = new Token();
29         t.kind = DEDENT;
30         t.beginLine = previous.beginLine;
31         t.endLine = previous.endLine;
32         t.beginColumn = previous.beginColumn;
33         t.endColumn = previous.endColumn;
34         t.image = "<DEDENT>";
35         t.specialToken = null;
36         t.next = null;
37         previous.next = t;
38         return t;
39     }
40
41     void CommonTokenAction(Token t) {
42         /*
43            if not partial: EOF is expanded to token sequences comprising
44                if single_input: [NEWLINE] necessary DEDENT NEWLINE (afterward EOF)
45                otherwise : [NEWLINE] necessary DEDENT EOF
46            if partial: EOF expansion happens only if EOF preceded by empty line (etc),
47            i.e. lexer is in MAYBE_FORCE_NEWLINE_IF_EOF state
48         */

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