EMMA Coverage Report (generated Tue May 18 22:13:27 CDT 2004)
[all classes][org.apache.velocity.runtime.parser]

COVERAGE SUMMARY FOR SOURCE FILE [ParserTokenManager.java]

nameclass, %method, %block, %line, %
ParserTokenManager.java100% (1/1)80%  (75/94)57%  (6034/10612)55%  (1159.7/2120)

COVERAGE BREAKDOWN BY CLASS AND METHOD

nameclass, %method, %block, %line, %
     
class ParserTokenManager100% (1/1)80%  (75/94)57%  (6034/10612)55%  (1159.7/2120)
ParserTokenManager (CharStream, int): void 0%   (0/1)0%   (0/7)0%   (0/3)
ReInit (CharStream, int): void 0%   (0/1)0%   (0/7)0%   (0/3)
jjCheckNAddStates (int): void 0%   (0/1)0%   (0/13)0%   (0/3)
jjMoveStringLiteralDfa2_1 (long, long): int 0%   (0/1)0%   (0/45)0%   (0/11)
jjMoveStringLiteralDfa2_2 (long, long): int 0%   (0/1)0%   (0/45)0%   (0/11)
jjMoveStringLiteralDfa3_1 (long, long): int 0%   (0/1)0%   (0/52)0%   (0/12)
jjMoveStringLiteralDfa3_2 (long, long): int 0%   (0/1)0%   (0/52)0%   (0/12)
jjMoveStringLiteralDfa4_1 (long, long): int 0%   (0/1)0%   (0/47)0%   (0/11)
jjMoveStringLiteralDfa4_2 (long, long): int 0%   (0/1)0%   (0/47)0%   (0/11)
jjMoveStringLiteralDfa4_5 (long, long): int 0%   (0/1)0%   (0/47)0%   (0/11)
jjStartNfaWithStates_1 (int, int, int): int 0%   (0/1)0%   (0/24)0%   (0/5)
jjStartNfaWithStates_2 (int, int, int): int 0%   (0/1)0%   (0/24)0%   (0/5)
jjStartNfaWithStates_5 (int, int, int): int 0%   (0/1)0%   (0/24)0%   (0/5)
jjStartNfaWithStates_6 (int, int, int): int 0%   (0/1)0%   (0/24)0%   (0/5)
jjStartNfaWithStates_7 (int, int, int): int 0%   (0/1)0%   (0/24)0%   (0/5)
jjStartNfaWithStates_8 (int, int, int): int 0%   (0/1)0%   (0/24)0%   (0/5)
jjStartNfa_1 (int, long): int 0%   (0/1)0%   (0/10)0%   (0/1)
jjStopStringLiteralDfa_1 (int, long): int 0%   (0/1)0%   (0/97)0%   (0/29)
setDebugStream (PrintStream): void 0%   (0/1)0%   (0/4)0%   (0/1)
jjStopStringLiteralDfa_2 (int, long): int 100% (1/1)24%  (21/89)22%  (6/27)
jjMoveStringLiteralDfa1_2 (long): int 100% (1/1)25%  (14/55)31%  (4/13)
jjStopStringLiteralDfa_0 (int, long): int 100% (1/1)28%  (27/97)24%  (7/29)
jjMoveNfa_6 (int, int): int 100% (1/1)30%  (94/312)31%  (21/67)
jjMoveNfa_7 (int, int): int 100% (1/1)30%  (94/312)31%  (21/67)
jjMoveStringLiteralDfa1_1 (long): int 100% (1/1)30%  (20/66)33%  (5/15)
jjStopStringLiteralDfa_4 (int, long): int 100% (1/1)33%  (50/152)29%  (13/45)
jjMoveNfa_1 (int, int): int 100% (1/1)36%  (264/742)40%  (64.7/163)
jjMoveNfa_2 (int, int): int 100% (1/1)36%  (150/420)42%  (38.7/91)
SwitchTo (int): void 100% (1/1)38%  (9/24)75%  (3/4)
jjMoveNfa_8 (int, int): int 100% (1/1)38%  (142/377)44%  (34.7/78)
jjStopStringLiteralDfa_5 (int, long): int 100% (1/1)39%  (35/89)37%  (10/27)
jjMoveStringLiteralDfa3_4 (long, long): int 100% (1/1)42%  (22/52)42%  (5/12)
jjMoveStringLiteralDfa3_5 (long, long): int 100% (1/1)42%  (22/52)42%  (5/12)
jjMoveNfa_4 (int, int): int 100% (1/1)45%  (348/766)49%  (87.6/178)
jjMoveStringLiteralDfa1_4 (long): int 100% (1/1)46%  (31/67)47%  (7/15)
stateStackPop (): boolean 100% (1/1)46%  (32/69)58%  (7/12)
jjMoveStringLiteralDfa2_4 (long, long): int 100% (1/1)49%  (22/45)45%  (5/11)
jjMoveNfa_0 (int, int): int 100% (1/1)52%  (439/842)59%  (107/182)
jjMoveStringLiteralDfa1_6 (long): int 100% (1/1)55%  (31/56)54%  (7/13)
jjMoveStringLiteralDfa1_7 (long): int 100% (1/1)55%  (31/56)54%  (7/13)
jjMoveNfa_5 (int, int): int 100% (1/1)55%  (233/420)61%  (55.1/91)
TokenLexicalActions (Token): void 100% (1/1)56%  (500/900)70%  (79/113)
jjMoveStringLiteralDfa1_8 (long): int 100% (1/1)56%  (25/45)55%  (6/11)
jjMoveStringLiteralDfa0_1 (): int 100% (1/1)56%  (32/57)54%  (7/13)
jjMoveStringLiteralDfa2_5 (long, long): int 100% (1/1)60%  (27/45)55%  (6/11)
jjMoveStringLiteralDfa4_0 (long, long): int 100% (1/1)62%  (29/47)55%  (6/11)
jjMoveStringLiteralDfa5_4 (long, long): int 100% (1/1)62%  (29/47)55%  (6/11)
jjMoveStringLiteralDfa0_7 (): int 100% (1/1)63%  (12/19)60%  (3/5)
jjMoveStringLiteralDfa1_5 (long): int 100% (1/1)64%  (35/55)62%  (8/13)
jjMoveStringLiteralDfa3_0 (long, long): int 100% (1/1)65%  (34/52)58%  (7/12)
jjMoveStringLiteralDfa4_4 (long, long): int 100% (1/1)68%  (27/40)60%  (6/10)
jjMoveStringLiteralDfa2_0 (long, long): int 100% (1/1)71%  (32/45)64%  (7/11)
jjStopStringLiteralDfa_6 (int, long): int 100% (1/1)71%  (10/14)60%  (3/5)
jjStopStringLiteralDfa_7 (int, long): int 100% (1/1)71%  (10/14)60%  (3/5)
jjStopStringLiteralDfa_8 (int, long): int 100% (1/1)71%  (10/14)60%  (3/5)
stateStackPush (): boolean 100% (1/1)72%  (44/61)89%  (8/9)
jjMoveStringLiteralDfa0_4 (): int 100% (1/1)74%  (20/27)71%  (5/7)
getNextToken (): Token 100% (1/1)76%  (315/416)77%  (78/101)
jjMoveStringLiteralDfa1_0 (long): int 100% (1/1)77%  (101/132)74%  (20/27)
jjStartNfaWithStates_0 (int, int, int): int 100% (1/1)79%  (19/24)94%  (4.7/5)
jjStartNfaWithStates_3 (int, int, int): int 100% (1/1)79%  (19/24)94%  (4.7/5)
jjStartNfaWithStates_4 (int, int, int): int 100% (1/1)79%  (19/24)94%  (4.7/5)
jjStopStringLiteralDfa_3 (int, long): int 100% (1/1)82%  (18/22)71%  (5/7)
RPARENHandler (): void 100% (1/1)84%  (31/37)75%  (9/12)
jjMoveNfa_3 (int, int): int 100% (1/1)85%  (567/664)84%  (128/153)
jjMoveStringLiteralDfa1_3 (long): int 100% (1/1)86%  (49/57)77%  (10/13)
jjMoveStringLiteralDfa0_2 (): int 100% (1/1)87%  (33/38)89%  (8/9)
MoreLexicalActions (): void 100% (1/1)87%  (286/328)89%  (62/70)
jjCanMove_0 (int, int, int, long, long): boolean 100% (1/1)88%  (23/26)78%  (3.9/5)
jjMoveStringLiteralDfa0_0 (): int 100% (1/1)94%  (102/109)92%  (24/26)
SkipLexicalActions (Token): void 100% (1/1)95%  (116/122)90%  (18/20)
jjFillToken (): Token 100% (1/1)98%  (43/44)100% (9/9)
<static initializer> 100% (1/1)100% (951/951)100% (10/10)
ParserTokenManager (CharStream): void 100% (1/1)100% (40/40)100% (13/13)
ReInit (CharStream): void 100% (1/1)100% (16/16)100% (5/5)
ReInitRounds (): void 100% (1/1)100% (18/18)100% (4/4)
clearStateVars (): void 100% (1/1)100% (22/22)100% (8/8)
jjAddStates (int, int): void 100% (1/1)100% (18/18)100% (3/3)
jjCheckNAdd (int): void 100% (1/1)100% (25/25)100% (4/4)
jjCheckNAddStates (int, int): void 100% (1/1)100% (10/10)100% (3/3)
jjCheckNAddTwoStates (int, int): void 100% (1/1)100% (7/7)100% (3/3)
jjMoveStringLiteralDfa0_3 (): int 100% (1/1)100% (22/22)100% (6/6)
jjMoveStringLiteralDfa0_5 (): int 100% (1/1)100% (33/33)100% (8/8)
jjMoveStringLiteralDfa0_6 (): int 100% (1/1)100% (19/19)100% (5/5)
jjMoveStringLiteralDfa0_8 (): int 100% (1/1)100% (15/15)100% (4/4)
jjStartNfa_0 (int, long): int 100% (1/1)100% (10/10)100% (1/1)
jjStartNfa_2 (int, long): int 100% (1/1)100% (10/10)100% (1/1)
jjStartNfa_3 (int, long): int 100% (1/1)100% (10/10)100% (1/1)
jjStartNfa_4 (int, long): int 100% (1/1)100% (10/10)100% (1/1)
jjStartNfa_5 (int, long): int 100% (1/1)100% (10/10)100% (1/1)
jjStartNfa_6 (int, long): int 100% (1/1)100% (10/10)100% (1/1)
jjStartNfa_7 (int, long): int 100% (1/1)100% (10/10)100% (1/1)
jjStartNfa_8 (int, long): int 100% (1/1)100% (10/10)100% (1/1)
jjStopAtPos (int, int): int 100% (1/1)100% (10/10)100% (3/3)

1/* Generated By:JJTree&JavaCC: Do not edit this line. ParserTokenManager.java */
2package org.apache.velocity.runtime.parser;
3import java.io.*;
4import java.util.*;
5import org.apache.velocity.runtime.RuntimeServices;
6import org.apache.velocity.runtime.parser.node.*;
7import org.apache.velocity.runtime.directive.Directive;
8import org.apache.velocity.runtime.directive.Macro;
9import org.apache.velocity.runtime.directive.MacroParseException;
10import org.apache.velocity.util.StringUtils;
11 
12public class ParserTokenManager implements ParserConstants
13{
14    private int fileDepth = 0;
15 
16    private int lparen = 0;
17    private int rparen = 0;
18 
19    Stack stateStack = new Stack();
20    public boolean debugPrint = false;
21 
22    private boolean inReference;
23    public boolean inDirective;
24    private boolean inComment;
25    public  boolean inSet;
26 
27    /**
28     *  pushes the current state onto the 'state stack',
29     *  and maintains the parens counts
30     *  public because we need it in PD & VM handling
31     *
32     *  @return boolean : success.  It can fail if the state machine
33     *     gets messed up (do don't mess it up :)
34     */
35    public boolean stateStackPop()
36    {
37        Hashtable h;
38 
39        try
40        {
41            h = (Hashtable) stateStack.pop();
42        }
43        catch( EmptyStackException e)
44        {
45            lparen=0;
46            SwitchTo(DEFAULT);
47            return false;
48        }
49 
50        if( debugPrint )
51            System.out.println(
52                " stack pop (" + stateStack.size() + ") : lparen=" +
53                    ( (Integer) h.get("lparen")).intValue() +
54                        " newstate=" + ( (Integer) h.get("lexstate")).intValue() );
55 
56        lparen = ( (Integer) h.get("lparen")).intValue();
57        rparen = ( (Integer) h.get("rparen")).intValue();
58 
59        SwitchTo( ( (Integer) h.get("lexstate")).intValue() );
60 
61        return true;
62    }
63 
64    /**
65     *  pops a state off the stack, and restores paren counts
66     *
67     *  @return boolean : success of operation
68     */
69    public boolean stateStackPush()
70    {
71        if( debugPrint )
72            System.out.println(" (" + stateStack.size() + ") pushing cur state : " +
73                curLexState );
74 
75        Hashtable h = new Hashtable();
76 
77        h.put("lexstate", new Integer( curLexState ) );
78        h.put("lparen", new Integer( lparen ));
79        h.put("rparen", new Integer( rparen ));
80 
81        lparen = 0;
82 
83        stateStack.push( h );
84 
85        return true;
86    }
87 
88    /**
89     *  Clears all state variables, resets to
90     *  start values, clears stateStack.  Call
91     *  before parsing.
92     *  @return void
93     */
94    public void clearStateVars()
95    {
96        stateStack.clear();
97 
98        lparen = 0;
99        rparen = 0;
100        inReference = false;
101        inDirective = false;
102        inComment = false;
103        inSet = false;
104 
105        return;
106    }
107 
108    /**
109     *  handles the dropdown logic when encountering a RPAREN
110     */
111    private void RPARENHandler()
112    {
113        /*
114         *  Ultimately, we want to drop down to the state below
115         *  the one that has an open (if we hit bottom (DEFAULT),
116         *  that's fine. It's just text schmoo.
117         */
118 
119        boolean closed = false;
120 
121        if (inComment)
122            closed = true;
123 
124        while( !closed )
125        {
126            /*
127             * look at current state.  If we haven't seen a lparen
128             * in this state then we drop a state, because this
129             * lparen clearly closes our state
130             */
131 
132            if( lparen > 0)
133            {
134                /*
135                 *  if rparen + 1 == lparen, then this state is closed.
136                 * Otherwise, increment and keep parsing
137                 */
138 
139                 if( lparen == rparen + 1)
140                 {
141                       stateStackPop();
142                 }
143                else
144                {
145                    rparen++;
146                }
147 
148                 closed = true;
149            }
150            else
151            {
152                /*
153                 * now, drop a state
154                 */
155 
156                if(!stateStackPop())
157                    break;
158            }
159        }
160    }
161  public  java.io.PrintStream debugStream = System.out;
162  public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
163private final int jjStopStringLiteralDfa_0(int pos, long active0)
164{
165   switch (pos)
166   {
167      case 0:
168         if ((active0 & 0x6000000L) != 0L)
169         {
170            jjmatchedKind = 52;
171            return 33;
172         }
173         if ((active0 & 0x10000000L) != 0L)
174            return 31;
175         if ((active0 & 0xd000L) != 0L)
176            return 7;
177         return -1;
178      case 1:
179         if ((active0 & 0x6000000L) != 0L)
180         {
181            jjmatchedKind = 52;
182            jjmatchedPos = 1;
183            return 33;
184         }
185         if ((active0 & 0x4000L) != 0L)
186            return 5;
187         return -1;
188      case 2:
189         if ((active0 & 0x6000000L) != 0L)
190         {
191            jjmatchedKind = 52;
192            jjmatchedPos = 2;
193            return 33;
194         }
195         return -1;
196      case 3:
197         if ((active0 & 0x4000000L) != 0L)
198         {
199            jjmatchedKind = 52;
200            jjmatchedPos = 3;
201            return 33;
202         }
203         if ((active0 & 0x2000000L) != 0L)
204            return 33;
205         return -1;
206      default :
207         return -1;
208   }
209}
210private final int jjStartNfa_0(int pos, long active0)
211{
212   return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
213}
214private final int jjStopAtPos(int pos, int kind)
215{
216   jjmatchedKind = kind;
217   jjmatchedPos = pos;
218   return pos + 1;
219}
220private final int jjStartNfaWithStates_0(int pos, int kind, int state)
221{
222   jjmatchedKind = kind;
223   jjmatchedPos = pos;
224   try { curChar = input_stream.readChar(); }
225   catch(java.io.IOException e) { return pos + 1; }
226   return jjMoveNfa_0(state, pos + 1);
227}
228private final int jjMoveStringLiteralDfa0_0()
229{
230   switch(curChar)
231   {
232      case 33:
233         jjmatchedKind = 41;
234         return jjMoveStringLiteralDfa1_0(0x10000000000L);
235      case 35:
236         jjmatchedKind = 15;
237         return jjMoveStringLiteralDfa1_0(0x5000L);
238      case 37:
239         return jjStopAtPos(0, 32);
240      case 38:
241         return jjMoveStringLiteralDfa1_0(0x200000000L);
242      case 40:
243         return jjStopAtPos(0, 5);
244      case 42:
245         return jjStopAtPos(0, 30);
246      case 43:
247         return jjStopAtPos(0, 29);
248      case 44:
249         return jjStopAtPos(0, 3);
250      case 45:
251         return jjStartNfaWithStates_0(0, 28, 31);
252      case 46:
253         return jjMoveStringLiteralDfa1_0(0x10L);
254      case 47:
255         return jjStopAtPos(0, 31);
256      case 60:
257         jjmatchedKind = 35;
258         return jjMoveStringLiteralDfa1_0(0x1000000000L);
259      case 61:
260         jjmatchedKind = 42;
261         return jjMoveStringLiteralDfa1_0(0x8000000000L);
262      case 62:
263         jjmatchedKind = 37;
264         return jjMoveStringLiteralDfa1_0(0x4000000000L);
265      case 91:
266         return jjStopAtPos(0, 1);
267      case 93:
268         return jjStopAtPos(0, 2);
269      case 102:
270         return jjMoveStringLiteralDfa1_0(0x4000000L);
271      case 116:
272         return jjMoveStringLiteralDfa1_0(0x2000000L);
273      case 124:
274         return jjMoveStringLiteralDfa1_0(0x400000000L);
275      default :
276         return jjMoveNfa_0(0, 0);
277   }
278}
279private final int jjMoveStringLiteralDfa1_0(long active0)
280{
281   try { curChar = input_stream.readChar(); }
282   catch(java.io.IOException e) {
283      jjStopStringLiteralDfa_0(0, active0);
284      return 1;
285   }
286   switch(curChar)
287   {
288      case 35:
289         if ((active0 & 0x1000L) != 0L)
290            return jjStopAtPos(1, 12);
291         break;
292      case 38:
293         if ((active0 & 0x200000000L) != 0L)
294            return jjStopAtPos(1, 33);
295         break;
296      case 42:
297         if ((active0 & 0x4000L) != 0L)
298            return jjStartNfaWithStates_0(1, 14, 5);
299         break;
300      case 46:
301         if ((active0 & 0x10L) != 0L)
302            return jjStopAtPos(1, 4);
303         break;
304      case 61:
305         if ((active0 & 0x1000000000L) != 0L)
306            return jjStopAtPos(1, 36);
307         else if ((active0 & 0x4000000000L) != 0L)
308            return jjStopAtPos(1, 38);
309         else if ((active0 & 0x8000000000L) != 0L)
310            return jjStopAtPos(1, 39);
311         else if ((active0 & 0x10000000000L) != 0L)
312            return jjStopAtPos(1, 40);
313         break;
314      case 97:
315         return jjMoveStringLiteralDfa2_0(active0, 0x4000000L);
316      case 114:
317         return jjMoveStringLiteralDfa2_0(active0, 0x2000000L);
318      case 124:
319         if ((active0 & 0x400000000L) != 0L)
320            return jjStopAtPos(1, 34);
321         break;
322      default :
323         break;
324   }
325   return jjStartNfa_0(0, active0);
326}
327private final int jjMoveStringLiteralDfa2_0(long old0, long active0)
328{
329   if (((active0 &= old0)) == 0L)
330      return jjStartNfa_0(0, old0); 
331   try { curChar = input_stream.readChar(); }
332   catch(java.io.IOException e) {
333      jjStopStringLiteralDfa_0(1, active0);
334      return 2;
335   }
336   switch(curChar)
337   {
338      case 108:
339         return jjMoveStringLiteralDfa3_0(active0, 0x4000000L);
340      case 117:
341         return jjMoveStringLiteralDfa3_0(active0, 0x2000000L);
342      default :
343         break;
344   }
345   return jjStartNfa_0(1, active0);
346}
347private final int jjMoveStringLiteralDfa3_0(long old0, long active0)
348{
349   if (((active0 &= old0)) == 0L)
350      return jjStartNfa_0(1, old0); 
351   try { curChar = input_stream.readChar(); }
352   catch(java.io.IOException e) {
353      jjStopStringLiteralDfa_0(2, active0);
354      return 3;
355   }
356   switch(curChar)
357   {
358      case 101:
359         if ((active0 & 0x2000000L) != 0L)
360            return jjStartNfaWithStates_0(3, 25, 33);
361         break;
362      case 115:
363         return jjMoveStringLiteralDfa4_0(active0, 0x4000000L);
364      default :
365         break;
366   }
367   return jjStartNfa_0(2, active0);
368}
369private final int jjMoveStringLiteralDfa4_0(long old0, long active0)
370{
371   if (((active0 &= old0)) == 0L)
372      return jjStartNfa_0(2, old0); 
373   try { curChar = input_stream.readChar(); }
374   catch(java.io.IOException e) {
375      jjStopStringLiteralDfa_0(3, active0);
376      return 4;
377   }
378   switch(curChar)
379   {
380      case 101:
381         if ((active0 & 0x4000000L) != 0L)
382            return jjStartNfaWithStates_0(4, 26, 33);
383         break;
384      default :
385         break;
386   }
387   return jjStartNfa_0(3, active0);
388}
389private final void jjCheckNAdd(int state)
390{
391   if (jjrounds[state] != jjround)
392   {
393      jjstateSet[jjnewStateCnt++] = state;
394      jjrounds[state] = jjround;
395   }
396}
397private final void jjAddStates(int start, int end)
398{
399   do {
400      jjstateSet[jjnewStateCnt++] = jjnextStates[start];
401   } while (start++ != end);
402}
403private final void jjCheckNAddTwoStates(int state1, int state2)
404{
405   jjCheckNAdd(state1);
406   jjCheckNAdd(state2);
407}
408private final void jjCheckNAddStates(int start, int end)
409{
410   do {
411      jjCheckNAdd(jjnextStates[start]);
412   } while (start++ != end);
413}
414private final void jjCheckNAddStates(int start)
415{
416   jjCheckNAdd(jjnextStates[start]);
417   jjCheckNAdd(jjnextStates[start + 1]);
418}
419static final long[] jjbitVec0 = {
420   0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
421};
422static final long[] jjbitVec2 = {
423   0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
424};
425private final int jjMoveNfa_0(int startState, int curPos)
426{
427   int[] nextStates;
428   int startsAt = 0;
429   jjnewStateCnt = 42;
430   int i = 1;
431   jjstateSet[0] = startState;
432   int j, kind = 0x7fffffff;
433   for (;;)
434   {
435      if (++jjround == 0x7fffffff)
436         ReInitRounds();
437      if (curChar < 64)
438      {
439         long l = 1L << curChar;
440         MatchLoop: do
441         {
442            switch(jjstateSet[--i])
443            {
444               case 0:
445                  if ((0x3ff000000000000L & l) != 0L)
446                  {
447                     if (kind > 49)
448                        kind = 49;
449                     jjCheckNAdd(31);
450                  }
451                  else if ((0x2400L & l) != 0L)
452                  {
453                     if (kind > 27)
454                        kind = 27;
455                  }
456                  else if ((0x100000200L & l) != 0L)
457                  {
458                     if (kind > 23)
459                        kind = 23;
460                     jjCheckNAdd(9);
461                  }
462                  else if (curChar == 36)
463                  {
464                     if (kind > 10)
465                        kind = 10;
466                     jjCheckNAddTwoStates(39, 40);
467                  }
468                  else if (curChar == 45)
469                     jjCheckNAdd(31);
470                  else if (curChar == 39)
471                     jjCheckNAddStates(0, 2);
472                  else if (curChar == 34)
473                     jjCheckNAddStates(3, 5);
474                  else if (curChar == 35)
475                     jjstateSet[jjnewStateCnt++] = 7;
476                  else if (curChar == 41)
477                  {
478                     if (kind > 6)
479                        kind = 6;
480                     jjCheckNAddStates(6, 8);
481                  }
482                  if (curChar == 13)
483                     jjstateSet[jjnewStateCnt++] = 28;
484                  break;
485               case 1:
486                  if ((0x100000200L & l) != 0L)
487                     jjCheckNAddStates(6, 8);
488                  break;
489               case 2:
490                  if ((0x2400L & l) != 0L && kind > 6)
491                     kind = 6;
492                  break;
493               case 3:
494                  if (curChar == 10 && kind > 6)
495                     kind = 6;
496                  break;
497               case 4:
498                  if (curChar == 13)
499                     jjstateSet[jjnewStateCnt++] = 3;
500                  break;
501               case 5:
502                  if (curChar == 42)
503                     jjstateSet[jjnewStateCnt++] = 6;
504                  break;
505               case 6:
506                  if ((0xfffffff7ffffffffL & l) != 0L && kind > 13)
507                     kind = 13;
508                  break;
509               case 7:
510                  if (curChar == 42)
511                     jjstateSet[jjnewStateCnt++] = 5;
512                  break;
513               case 8:
514                  if (curChar == 35)
515                     jjstateSet[jjnewStateCnt++] = 7;
516                  break;
517               case 9:
518                  if ((0x100000200L & l) == 0L)
519                     break;
520                  if (kind > 23)
521                     kind = 23;
522                  jjCheckNAdd(9);
523                  break;
524               case 10:
525                  if (curChar == 34)
526                     jjCheckNAddStates(3, 5);
527                  break;
528               case 11:
529                  if ((0xfffffffbffffdbffL & l) != 0L)
530                     jjCheckNAddStates(3, 5);
531                  break;
532               case 12:
533                  if (curChar == 34 && kind > 24)
534                     kind = 24;
535                  break;
536               case 14:
537                  if ((0x8400000000L & l) != 0L)
538                     jjCheckNAddStates(3, 5);
539                  break;
540               case 15:
541                  if ((0xff000000000000L & l) != 0L)
542                     jjCheckNAddStates(9, 12);
543                  break;
544               case 16:
545                  if ((0xff000000000000L & l) != 0L)
546                     jjCheckNAddStates(3, 5);
547                  break;
548               case 17:
549                  if ((0xf000000000000L & l) != 0L)
550                     jjstateSet[jjnewStateCnt++] = 18;
551                  break;
552               case 18:
553                  if ((0xff000000000000L & l) != 0L)
554                     jjCheckNAdd(16);
555                  break;
556               case 19:
557                  if (curChar == 32)
558                     jjAddStates(13, 14);
559                  break;
560               case 20:
561                  if (curChar == 10)
562                     jjCheckNAddStates(3, 5);
563                  break;
564               case 21:
565                  if (curChar == 39)
566                     jjCheckNAddStates(0, 2);
567                  break;
568               case 22:
569                  if ((0xffffff7fffffdbffL & l) != 0L)
570                     jjCheckNAddStates(0, 2);
571                  break;
572               case 24:
573                  if (curChar == 32)
574                     jjAddStates(15, 16);
575                  break;
576               case 25:
577                  if (curChar == 10)
578                     jjCheckNAddStates(0, 2);
579                  break;
580               case 26:
581                  if (curChar == 39 && kind > 24)
582                     kind = 24;
583                  break;
584               case 27:
585                  if ((0x2400L & l) != 0L && kind > 27)
586                     kind = 27;
587                  break;
588               case 28:
589                  if (curChar == 10 && kind > 27)
590                     kind = 27;
591                  break;
592               case 29:
593                  if (curChar == 13)
594                     jjstateSet[jjnewStateCnt++] = 28;
595                  break;
596               case 30:
597                  if (curChar == 45)
598                     jjCheckNAdd(31);
599                  break;
600               case 31:
601                  if ((0x3ff000000000000L & l) == 0L)
602                     break;
603                  if (kind > 49)
604                     kind = 49;
605                  jjCheckNAdd(31);
606                  break;
607               case 33:
608                  if ((0x3ff000000000000L & l) == 0L)
609                     break;
610                  if (kind > 52)
611                     kind = 52;
612                  jjstateSet[jjnewStateCnt++] = 33;
613                  break;
614               case 36:
615                  if (curChar == 36 && kind > 10)
616                     kind = 10;
617                  break;
618               case 38:
619                  if (curChar == 36)
620                     jjCheckNAddTwoStates(39, 40);
621                  break;
622               case 40:
623                  if (curChar == 33 && kind > 11)
624                     kind = 11;
625                  break;
626               case 41:
627                  if (curChar != 36)
628                     break;
629                  if (kind > 10)
630                     kind = 10;
631                  jjCheckNAddTwoStates(39, 40);
632                  break;
633               default : break;
634            }
635         } while(i != startsAt);
636      }
637      else if (curChar < 128)
638      {
639         long l = 1L << (curChar & 077);
640         MatchLoop: do
641         {
642            switch(jjstateSet[--i])
643            {
644               case 0:
645                  if ((0x7fffffe87fffffeL & l) != 0L)
646                  {
647                     if (kind > 52)
648                        kind = 52;
649                     jjCheckNAdd(33);
650                  }
651                  else if (curChar == 92)
652                     jjCheckNAddStates(17, 20);
653                  break;
654               case 6:
655                  if (kind > 13)
656                     kind = 13;
657                  break;
658               case 11:
659                  if ((0xffffffffefffffffL & l) != 0L)
660                     jjCheckNAddStates(3, 5);
661                  break;
662               case 13:
663                  if (curChar == 92)
664                     jjAddStates(21, 25);
665                  break;
666               case 14:
667                  if ((0x14404410000000L & l) != 0L)
668                     jjCheckNAddStates(3, 5);
669                  break;
670               case 22:
671                  jjAddStates(0, 2);
672                  break;
673               case 23:
674                  if (curChar == 92)
675                     jjAddStates(15, 16);
676                  break;
677               case 32:
678               case 33:
679                  if ((0x7fffffe87fffffeL & l) == 0L)
680                     break;
681                  if (kind > 52)
682                     kind = 52;
683                  jjCheckNAdd(33);
684                  break;
685               case 34:
686                  if (curChar == 92)
687                     jjCheckNAddStates(17, 20);
688                  break;
689               case 35:
690                  if (curChar == 92)
691                     jjCheckNAddTwoStates(35, 36);
692                  break;
693               case 37:
694                  if (curChar == 92)
695                     jjCheckNAddTwoStates(37, 38);
696                  break;
697               case 39:
698                  if (curChar == 92)
699                     jjAddStates(26, 27);
700                  break;
701               default : break;
702            }
703         } while(i != startsAt);
704      }
705      else
706      {
707         int hiByte = (int)(curChar >> 8);
708         int i1 = hiByte >> 6;
709         long l1 = 1L << (hiByte & 077);
710         int i2 = (curChar & 0xff) >> 6;
711         long l2 = 1L << (curChar & 077);
712         MatchLoop: do
713         {
714            switch(jjstateSet[--i])
715            {
716               case 6:
717                  if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 13)
718                     kind = 13;
719                  break;
720               case 11:
721                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
722                     jjAddStates(3, 5);
723                  break;
724               case 22:
725                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
726                     jjAddStates(0, 2);
727                  break;
728               default : break;
729            }
730         } while(i != startsAt);
731      }
732      if (kind != 0x7fffffff)
733      {
734         jjmatchedKind = kind;
735         jjmatchedPos = curPos;
736         kind = 0x7fffffff;
737      }
738      ++curPos;
739      if ((i = jjnewStateCnt) == (startsAt = 42 - (jjnewStateCnt = startsAt)))
740         return curPos;
741      try { curChar = input_stream.readChar(); }
742      catch(java.io.IOException e) { return curPos; }
743   }
744}
745private final int jjStopStringLiteralDfa_6(int pos, long active0)
746{
747   switch (pos)
748   {
749      case 0:
750         if ((active0 & 0xd000L) != 0L)
751            return 2;
752         return -1;
753      default :
754         return -1;
755   }
756}
757private final int jjStartNfa_6(int pos, long active0)
758{
759   return jjMoveNfa_6(jjStopStringLiteralDfa_6(pos, active0), pos + 1);
760}
761private final int jjStartNfaWithStates_6(int pos, int kind, int state)
762{
763   jjmatchedKind = kind;
764   jjmatchedPos = pos;
765   try { curChar = input_stream.readChar(); }
766   catch(java.io.IOException e) { return pos + 1; }
767   return jjMoveNfa_6(state, pos + 1);
768}
769private final int jjMoveStringLiteralDfa0_6()
770{
771   switch(curChar)
772   {
773      case 35:
774         jjmatchedKind = 15;
775         return jjMoveStringLiteralDfa1_6(0x5000L);
776      case 42:
777         return jjMoveStringLiteralDfa1_6(0x200000L);
778      default :
779         return jjMoveNfa_6(3, 0);
780   }
781}
782private final int jjMoveStringLiteralDfa1_6(long active0)
783{
784   try { curChar = input_stream.readChar(); }
785   catch(java.io.IOException e) {
786      jjStopStringLiteralDfa_6(0, active0);
787      return 1;
788   }
789   switch(curChar)
790   {
791      case 35:
792         if ((active0 & 0x1000L) != 0L)
793            return jjStopAtPos(1, 12);
794         else if ((active0 & 0x200000L) != 0L)
795            return jjStopAtPos(1, 21);
796         break;
797      case 42:
798         if ((active0 & 0x4000L) != 0L)
799            return jjStartNfaWithStates_6(1, 14, 0);
800         break;
801      default :
802         break;
803   }
804   return jjStartNfa_6(0, active0);
805}
806private final int jjMoveNfa_6(int startState, int curPos)
807{
808   int[] nextStates;
809   int startsAt = 0;
810   jjnewStateCnt = 12;
811   int i = 1;
812   jjstateSet[0] = startState;
813   int j, kind = 0x7fffffff;
814   for (;;)
815   {
816      if (++jjround == 0x7fffffff)
817         ReInitRounds();
818      if (curChar < 64)
819      {
820         long l = 1L << curChar;
821         MatchLoop: do
822         {
823            switch(jjstateSet[--i])
824            {
825               case 3:
826                  if (curChar == 36)
827                  {
828                     if (kind > 10)
829                        kind = 10;
830                     jjCheckNAddTwoStates(9, 10);
831                  }
832                  else if (curChar == 35)
833                     jjstateSet[jjnewStateCnt++] = 2;
834                  break;
835               case 0:
836                  if (curChar == 42)
837                     jjstateSet[jjnewStateCnt++] = 1;
838                  break;
839               case 1:
840                  if ((0xfffffff7ffffffffL & l) != 0L && kind > 13)
841                     kind = 13;
842                  break;
843               case 2:
844                  if (curChar == 42)
845                     jjstateSet[jjnewStateCnt++] = 0;
846                  break;
847               case 6:
848                  if (curChar == 36 && kind > 10)
849                     kind = 10;
850                  break;
851               case 8:
852                  if (curChar == 36)
853                     jjCheckNAddTwoStates(9, 10);
854                  break;
855               case 10:
856                  if (curChar == 33 && kind > 11)
857                     kind = 11;
858                  break;
859               case 11:
860                  if (curChar != 36)
861                     break;
862                  if (kind > 10)
863                     kind = 10;
864                  jjCheckNAddTwoStates(9, 10);
865                  break;
866               default : break;
867            }
868         } while(i != startsAt);
869      }
870      else if (curChar < 128)
871      {
872         long l = 1L << (curChar & 077);
873         MatchLoop: do
874         {
875            switch(jjstateSet[--i])
876            {
877               case 3:
878                  if (curChar == 92)
879                     jjCheckNAddStates(28, 31);
880                  break;
881               case 1:
882                  if (kind > 13)
883                     kind = 13;
884                  break;
885               case 5:
886                  if (curChar == 92)
887                     jjCheckNAddTwoStates(5, 6);
888                  break;
889               case 7:
890                  if (curChar == 92)
891                     jjCheckNAddTwoStates(7, 8);
892                  break;
893               case 9:
894                  if (curChar == 92)
895                     jjAddStates(32, 33);
896                  break;
897               default : break;
898            }
899         } while(i != startsAt);
900      }
901      else
902      {
903         int hiByte = (int)(curChar >> 8);
904         int i1 = hiByte >> 6;
905         long l1 = 1L << (hiByte & 077);
906         int i2 = (curChar & 0xff) >> 6;
907         long l2 = 1L << (curChar & 077);
908         MatchLoop: do
909         {
910            switch(jjstateSet[--i])
911            {
912               case 1:
913                  if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 13)
914                     kind = 13;
915                  break;
916               default : break;
917            }
918         } while(i != startsAt);
919      }
920      if (kind != 0x7fffffff)
921      {
922         jjmatchedKind = kind;
923         jjmatchedPos = curPos;
924         kind = 0x7fffffff;
925      }
926      ++curPos;
927      if ((i = jjnewStateCnt) == (startsAt = 12 - (jjnewStateCnt = startsAt)))
928         return curPos;
929      try { curChar = input_stream.readChar(); }
930      catch(java.io.IOException e) { return curPos; }
931   }
932}
933private final int jjStopStringLiteralDfa_4(int pos, long active0)
934{
935   switch (pos)
936   {
937      case 0:
938         if ((active0 & 0xd000L) != 0L)
939            return 2;
940         if ((active0 & 0x200000000000L) != 0L)
941         {
942            jjmatchedKind = 52;
943            return 22;
944         }
945         if ((active0 & 0x900000000000L) != 0L)
946         {
947            jjmatchedKind = 52;
948            return 7;
949         }
950         return -1;
951      case 1:
952         if ((active0 & 0x4000L) != 0L)
953            return 0;
954         if ((active0 & 0x200000000000L) != 0L)
955         {
956            jjmatchedKind = 52;
957            jjmatchedPos = 1;
958            return 28;
959         }
960         if ((active0 & 0x800000000000L) != 0L)
961         {
962            jjmatchedKind = 52;
963            jjmatchedPos = 1;
964            return 7;
965         }
966         if ((active0 & 0x100000000000L) != 0L)
967            return 7;
968         return -1;
969      case 2:
970         if ((active0 & 0x200000000000L) != 0L)
971         {
972            jjmatchedKind = 52;
973            jjmatchedPos = 2;
974            return 23;
975         }
976         if ((active0 & 0x800000000000L) != 0L)
977         {
978            jjmatchedKind = 52;
979            jjmatchedPos = 2;
980            return 7;
981         }
982         return -1;
983      case 3:
984         if ((active0 & 0x800000000000L) != 0L)
985            return 7;
986         if ((active0 & 0x200000000000L) != 0L)
987         {
988            jjmatchedKind = 46;
989            jjmatchedPos = 3;
990            return 30;
991         }
992         return -1;
993      case 4:
994         if ((active0 & 0x200000000000L) != 0L)
995         {
996            jjmatchedKind = 52;
997            jjmatchedPos = 4;
998            return 7;
999         }
1000         return -1;
1001      default :
1002         return -1;
1003   }
1004}
1005private final int jjStartNfa_4(int pos, long active0)
1006{
1007   return jjMoveNfa_4(jjStopStringLiteralDfa_4(pos, active0), pos + 1);
1008}
1009private final int jjStartNfaWithStates_4(int pos, int kind, int state)
1010{
1011   jjmatchedKind = kind;
1012   jjmatchedPos = pos;
1013   try { curChar = input_stream.readChar(); }
1014   catch(java.io.IOException e) { return pos + 1; }
1015   return jjMoveNfa_4(state, pos + 1);
1016}
1017private final int jjMoveStringLiteralDfa0_4()
1018{
1019   switch(curChar)
1020   {
1021      case 35:
1022         jjmatchedKind = 15;
1023         return jjMoveStringLiteralDfa1_4(0x5000L);
1024      case 101:
1025         return jjMoveStringLiteralDfa1_4(0x200000000000L);
1026      case 105:
1027         return jjMoveStringLiteralDfa1_4(0x100000000000L);
1028      case 115:
1029         return jjMoveStringLiteralDfa1_4(0x800000000000L);
1030      default :
1031         return jjMoveNfa_4(3, 0);
1032   }
1033}
1034private final int jjMoveStringLiteralDfa1_4(long active0)
1035{
1036   try { curChar = input_stream.readChar(); }
1037   catch(java.io.IOException e) {
1038      jjStopStringLiteralDfa_4(0, active0);
1039      return 1;
1040   }
1041   switch(curChar)
1042   {
1043      case 35:
1044         if ((active0 & 0x1000L) != 0L)
1045            return jjStopAtPos(1, 12);
1046         break;
1047      case 42:
1048         if ((active0 & 0x4000L) != 0L)
1049            return jjStartNfaWithStates_4(1, 14, 0);
1050         break;
1051      case 102:
1052         if ((active0 & 0x100000000000L) != 0L)
1053            return jjStartNfaWithStates_4(1, 44, 7);
1054         break;
1055      case 108:
1056         return jjMoveStringLiteralDfa2_4(active0, 0x200000000000L);
1057      case 116:
1058         return jjMoveStringLiteralDfa2_4(active0, 0x800000000000L);
1059      default :
1060         break;
1061   }
1062   return jjStartNfa_4(0, active0);
1063}
1064private final int jjMoveStringLiteralDfa2_4(long old0, long active0)
1065{
1066   if (((active0 &= old0)) == 0L)
1067      return jjStartNfa_4(0, old0); 
1068   try { curChar = input_stream.readChar(); }
1069   catch(java.io.IOException e) {
1070      jjStopStringLiteralDfa_4(1, active0);
1071      return 2;
1072   }
1073   switch(curChar)
1074   {
1075      case 111:
1076         return jjMoveStringLiteralDfa3_4(active0, 0x800000000000L);
1077      case 115:
1078         return jjMoveStringLiteralDfa3_4(active0, 0x200000000000L);
1079      default :
1080         break;
1081   }
1082   return jjStartNfa_4(1, active0);
1083}
1084private final int jjMoveStringLiteralDfa3_4(long old0, long active0)
1085{
1086   if (((active0 &= old0)) == 0L)
1087      return jjStartNfa_4(1, old0); 
1088   try { curChar = input_stream.readChar(); }
1089   catch(java.io.IOException e) {
1090      jjStopStringLiteralDfa_4(2, active0);
1091      return 3;
1092   }
1093   switch(curChar)
1094   {
1095      case 101:
1096         return jjMoveStringLiteralDfa4_4(active0, 0x200000000000L);
1097      case 112:
1098         if ((active0 & 0x800000000000L) != 0L)
1099            return jjStartNfaWithStates_4(3, 47, 7);
1100         break;
1101      default :
1102         break;
1103   }
1104   return jjStartNfa_4(2, active0);
1105}
1106private final int jjMoveStringLiteralDfa4_4(long old0, long active0)
1107{
1108   if (((active0 &= old0)) == 0L)
1109      return jjStartNfa_4(2, old0); 
1110   try { curChar = input_stream.readChar(); }
1111   catch(java.io.IOException e) {
1112      jjStopStringLiteralDfa_4(3, active0);
1113      return 4;
1114   }
1115   switch(curChar)
1116   {
1117      case 105:
1118         return jjMoveStringLiteralDfa5_4(active0, 0x200000000000L);
1119      default :
1120         break;
1121   }
1122   return jjStartNfa_4(3, active0);
1123}
1124private final int jjMoveStringLiteralDfa5_4(long old0, long active0)
1125{
1126   if (((active0 &= old0)) == 0L)
1127      return jjStartNfa_4(3, old0); 
1128   try { curChar = input_stream.readChar(); }
1129   catch(java.io.IOException e) {
1130      jjStopStringLiteralDfa_4(4, active0);
1131      return 5;
1132   }
1133   switch(curChar)
1134   {
1135      case 102:
1136         if ((active0 & 0x200000000000L) != 0L)
1137            return jjStartNfaWithStates_4(5, 45, 7);
1138         break;
1139      default :
1140         break;
1141   }
1142   return jjStartNfa_4(4, active0);
1143}
1144private final int jjMoveNfa_4(int startState, int curPos)
1145{
1146   int[] nextStates;
1147   int startsAt = 0;
1148   jjnewStateCnt = 30;
1149   int i = 1;
1150   jjstateSet[0] = startState;
1151   int j, kind = 0x7fffffff;
1152   for (;;)
1153   {
1154      if (++jjround == 0x7fffffff)
1155         ReInitRounds();
1156      if (curChar < 64)
1157      {
1158         long l = 1L << curChar;
1159         MatchLoop: do
1160         {
1161            switch(jjstateSet[--i])
1162            {
1163               case 3:
1164                  if ((0x3ff000000000000L & l) != 0L)
1165                  {
1166                     if (kind > 49)
1167                        kind = 49;
1168                     jjCheckNAdd(5);
1169                  }
1170                  else if (curChar == 36)
1171                  {
1172                     if (kind > 10)
1173                        kind = 10;
1174                     jjCheckNAddTwoStates(13, 14);
1175                  }
1176                  else if (curChar == 45)
1177                     jjCheckNAdd(5);
1178                  else if (curChar == 35)
1179                     jjstateSet[jjnewStateCnt++] = 2;
1180                  break;
1181               case 30:
1182                  if ((0x3ff000000000000L & l) != 0L)
1183                  {
1184                     if (kind > 52)
1185                        kind = 52;
1186                     jjCheckNAdd(7);
1187                  }
1188                  else if ((0x2400L & l) != 0L)
1189                  {
1190                     if (kind > 46)
1191                        kind = 46;
1192                  }
1193                  else if ((0x100000200L & l) != 0L)
1194                     jjCheckNAddStates(34, 36);
1195                  if (curChar == 13)
1196                     jjstateSet[jjnewStateCnt++] = 26;
1197                  break;
1198               case 22:
1199               case 7:
1200                  if ((0x3ff000000000000L & l) == 0L)
1201                     break;
1202                  if (kind > 52)
1203                     kind = 52;
1204                  jjCheckNAdd(7);
1205                  break;
1206               case 28:
1207                  if ((0x3ff000000000000L & l) == 0L)
1208                     break;
1209                  if (kind > 52)
1210                     kind = 52;
1211                  jjCheckNAdd(7);
1212                  break;
1213               case 23:
1214                  if ((0x3ff000000000000L & l) == 0L)
1215                     break;
1216                  if (kind > 52)
1217                     kind = 52;
1218                  jjCheckNAdd(7);
1219                  break;
1220               case 0:
1221                  if (curChar == 42)
1222                     jjstateSet[jjnewStateCnt++] = 1;
1223                  break;
1224               case 1:
1225                  if ((0xfffffff7ffffffffL & l) != 0L && kind > 13)
1226                     kind = 13;
1227                  break;
1228               case 2:
1229                  if (curChar == 42)
1230                     jjstateSet[jjnewStateCnt++] = 0;
1231                  break;
1232               case 4:
1233                  if (curChar == 45)
1234                     jjCheckNAdd(5);
1235                  break;
1236               case 5:
1237                  if ((0x3ff000000000000L & l) == 0L)
1238                     break;
1239                  if (kind > 49)
1240                     kind = 49;
1241                  jjCheckNAdd(5);
1242                  break;
1243               case 10:
1244                  if (curChar == 36 && kind > 10)
1245                     kind = 10;
1246                  break;
1247               case 12:
1248                  if (curChar == 36)
1249                     jjCheckNAddTwoStates(13, 14);
1250                  break;
1251               case 14:
1252                  if (curChar == 33 && kind > 11)
1253                     kind = 11;
1254                  break;
1255               case 15:
1256                  if (curChar != 36)
1257                     break;
1258                  if (kind > 10)
1259                     kind = 10;
1260                  jjCheckNAddTwoStates(13, 14);
1261                  break;
1262               case 18:
1263                  if ((0x100000200L & l) != 0L)
1264                     jjAddStates(37, 39);
1265                  break;
1266               case 19:
1267                  if ((0x2400L & l) != 0L && kind > 43)
1268                     kind = 43;
1269                  break;
1270               case 20:
1271                  if (curChar == 10 && kind > 43)
1272                     kind = 43;
1273                  break;
1274               case 21:
1275                  if (curChar == 13)
1276                     jjstateSet[jjnewStateCnt++] = 20;
1277                  break;
1278               case 24:
1279                  if ((0x100000200L & l) != 0L)
1280                     jjCheckNAddStates(34, 36);
1281                  break;
1282               case 25:
1283                  if ((0x2400L & l) != 0L && kind > 46)
1284                     kind = 46;
1285                  break;
1286               case 26:
1287                  if (curChar == 10 && kind > 46)
1288                     kind = 46;
1289                  break;
1290               case 27:
1291                  if (curChar == 13)
1292                     jjstateSet[jjnewStateCnt++] = 26;
1293                  break;
1294               default : break;
1295            }
1296         } while(i != startsAt);
1297      }
1298      else if (curChar < 128)
1299      {
1300         long l = 1L << (curChar & 077);
1301         MatchLoop: do
1302         {
1303            switch(jjstateSet[--i])
1304            {
1305               case 3:
1306                  if ((0x7fffffe87fffffeL & l) != 0L)
1307                  {
1308                     if (kind > 52)
1309                        kind = 52;
1310                     jjCheckNAdd(7);
1311                  }
1312                  else if (curChar == 92)
1313                     jjCheckNAddStates(40, 43);
1314                  if (curChar == 101)
1315                     jjAddStates(44, 45);
1316                  break;
1317               case 30:
1318               case 7:
1319                  if ((0x7fffffe87fffffeL & l) == 0L)
1320                     break;
1321                  if (kind > 52)
1322                     kind = 52;
1323                  jjCheckNAdd(7);
1324                  break;
1325               case 22:
1326                  if ((0x7fffffe87fffffeL & l) != 0L)
1327                  {
1328                     if (kind > 52)
1329                        kind = 52;
1330                     jjCheckNAdd(7);
1331                  }
1332                  if (curChar == 108)
1333                     jjstateSet[jjnewStateCnt++] = 28;
1334                  else if (curChar == 110)
1335                     jjstateSet[jjnewStateCnt++] = 17;
1336                  break;
1337               case 28:
1338                  if ((0x7fffffe87fffffeL & l) != 0L)
1339                  {
1340                     if (kind > 52)
1341                        kind = 52;
1342                     jjCheckNAdd(7);
1343                  }
1344                  if (curChar == 115)
1345                     jjstateSet[jjnewStateCnt++] = 23;
1346                  break;
1347               case 23:
1348                  if ((0x7fffffe87fffffeL & l) != 0L)
1349                  {
1350                     if (kind > 52)
1351                        kind = 52;
1352                     jjCheckNAdd(7);
1353                  }
1354                  if (curChar == 101)
1355                  {
1356                     if (kind > 46)
1357                        kind = 46;
1358                     jjAddStates(34, 36);
1359                  }
1360                  break;
1361               case 1:
1362                  if (kind > 13)
1363                     kind = 13;
1364                  break;
1365               case 6:
1366                  if ((0x7fffffe87fffffeL & l) == 0L)
1367                     break;
1368                  if (kind > 52)
1369                     kind = 52;
1370                  jjCheckNAdd(7);
1371                  break;
1372               case 8:
1373                  if (curChar == 92)
1374                     jjCheckNAddStates(40, 43);
1375                  break;
1376               case 9:
1377                  if (curChar == 92)
1378                     jjCheckNAddTwoStates(9, 10);
1379                  break;
1380               case 11:
1381                  if (curChar == 92)
1382                     jjCheckNAddTwoStates(11, 12);
1383                  break;
1384               case 13:
1385                  if (curChar == 92)
1386                     jjAddStates(46, 47);
1387                  break;
1388               case 16:
1389                  if (curChar == 101)
1390                     jjAddStates(44, 45);
1391                  break;
1392               case 17:
1393                  if (curChar != 100)
1394                     break;
1395                  if (kind > 43)
1396                     kind = 43;
1397                  jjAddStates(37, 39);
1398                  break;
1399               case 29:
1400                  if (curChar == 108)
1401                     jjstateSet[jjnewStateCnt++] = 28;
1402                  break;
1403               default : break;
1404            }
1405         } while(i != startsAt);
1406      }
1407      else
1408      {
1409         int hiByte = (int)(curChar >> 8);
1410         int i1 = hiByte >> 6;
1411         long l1 = 1L << (hiByte & 077);
1412         int i2 = (curChar & 0xff) >> 6;
1413         long l2 = 1L << (curChar & 077);
1414         MatchLoop: do
1415         {
1416            switch(jjstateSet[--i])
1417            {
1418               case 1:
1419                  if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 13)
1420                     kind = 13;
1421                  break;
1422               default : break;
1423            }
1424         } while(i != startsAt);
1425      }
1426      if (kind != 0x7fffffff)
1427      {
1428         jjmatchedKind = kind;
1429         jjmatchedPos = curPos;
1430         kind = 0x7fffffff;
1431      }
1432      ++curPos;
1433      if ((i = jjnewStateCnt) == (startsAt = 30 - (jjnewStateCnt = startsAt)))
1434         return curPos;
1435      try { curChar = input_stream.readChar(); }
1436      catch(java.io.IOException e) { return curPos; }
1437   }
1438}
1439private final int jjStopStringLiteralDfa_3(int pos, long active0)
1440{
1441   switch (pos)
1442   {
1443      case 0:
1444         if ((active0 & 0x30000L) != 0L)
1445            return 9;
1446         if ((active0 & 0xd000L) != 0L)
1447            return 16;
1448         return -1;
1449      default :
1450         return -1;
1451   }
1452}
1453private final int jjStartNfa_3(int pos, long active0)
1454{
1455   return jjMoveNfa_3(jjStopStringLiteralDfa_3(pos, active0), pos + 1);
1456}
1457private final int jjStartNfaWithStates_3(int pos, int kind, int state)
1458{
1459   jjmatchedKind = kind;
1460   jjmatchedPos = pos;
1461   try { curChar = input_stream.readChar(); }
1462   catch(java.io.IOException e) { return pos + 1; }
1463   return jjMoveNfa_3(state, pos + 1);
1464}
1465private final int jjMoveStringLiteralDfa0_3()
1466{
1467   switch(curChar)
1468   {
1469      case 35:
1470         jjmatchedKind = 15;
1471         return jjMoveStringLiteralDfa1_3(0x5000L);
1472      case 92:
1473         jjmatchedKind = 17;
1474         return jjMoveStringLiteralDfa1_3(0x10000L);
1475      default :
1476         return jjMoveNfa_3(13, 0);
1477   }
1478}
1479private final int jjMoveStringLiteralDfa1_3(long active0)
1480{
1481   try { curChar = input_stream.readChar(); }
1482   catch(java.io.IOException e) {
1483      jjStopStringLiteralDfa_3(0, active0);
1484      return 1;
1485   }
1486   switch(curChar)
1487   {
1488      case 35:
1489         if ((active0 & 0x1000L) != 0L)
1490            return jjStopAtPos(1, 12);
1491         break;
1492      case 42:
1493         if ((active0 & 0x4000L) != 0L)
1494            return jjStartNfaWithStates_3(1, 14, 14);
1495         break;
1496      case 92:
1497         if ((active0 & 0x10000L) != 0L)
1498            return jjStartNfaWithStates_3(1, 16, 25);
1499         break;
1500      default :
1501         break;
1502   }
1503   return jjStartNfa_3(0, active0);
1504}
1505private final int jjMoveNfa_3(int startState, int curPos)
1506{
1507   int[] nextStates;
1508   int startsAt = 0;
1509   jjnewStateCnt = 25;
1510   int i = 1;
1511   jjstateSet[0] = startState;
1512   int j, kind = 0x7fffffff;
1513   for (;;)
1514   {
1515      if (++jjround == 0x7fffffff)
1516         ReInitRounds();
1517      if (curChar < 64)
1518      {
1519         long l = 1L << curChar;
1520         MatchLoop: do
1521         {
1522            switch(jjstateSet[--i])
1523            {
1524               case 16:
1525                  if (curChar == 42)
1526                     jjstateSet[jjnewStateCnt++] = 14;
1527                  break;
1528               case 13:
1529                  if ((0xffffffe7ffffffffL & l) != 0L)
1530                  {
1531                     if (kind > 18)
1532                        kind = 18;
1533                     jjCheckNAdd(7);
1534                  }
1535                  else if (curChar == 36)
1536                  {
1537                     if (kind > 10)
1538                        kind = 10;
1539                     jjCheckNAddTwoStates(22, 23);
1540                  }
1541                  else if (curChar == 35)
1542                     jjCheckNAddTwoStates(5, 16);
1543                  if ((0x100000200L & l) != 0L)
1544                     jjCheckNAddTwoStates(0, 6);
1545                  break;
1546               case 25:
1547                  if (curChar == 36)
1548                     jjCheckNAddTwoStates(22, 23);
1549                  if (curChar == 36)
1550                  {
1551                     if (kind > 10)
1552                        kind = 10;
1553                  }
1554                  break;
1555               case 9:
1556                  if (curChar == 36)
1557                     jjCheckNAddTwoStates(22, 23);
1558                  else if (curChar == 35)
1559                     jjstateSet[jjnewStateCnt++] = 11;
1560                  if (curChar == 36)
1561                  {
1562                     if (kind > 10)
1563                        kind = 10;
1564                  }
1565                  break;
1566               case 0:
1567                  if ((0x100000200L & l) != 0L)
1568                     jjCheckNAddTwoStates(0, 6);
1569                  break;
1570               case 2:
1571                  if (curChar == 32)
1572                     jjAddStates(48, 49);
1573                  break;
1574               case 3:
1575                  if (curChar == 40 && kind > 9)
1576                     kind = 9;
1577                  break;
1578               case 6:
1579                  if (curChar == 35)
1580                     jjCheckNAdd(5);
1581                  break;
1582               case 7:
1583                  if ((0xffffffe7ffffffffL & l) == 0L)
1584                     break;
1585                  if (kind > 18)
1586                     kind = 18;
1587                  jjCheckNAdd(7);
1588                  break;
1589               case 10:
1590                  if (curChar == 35)
1591                     jjstateSet[jjnewStateCnt++] = 11;
1592                  break;
1593               case 12:
1594                  if ((0x3ff000000000000L & l) == 0L)
1595                     break;
1596                  if (kind > 8)
1597                     kind = 8;
1598                  jjstateSet[jjnewStateCnt++] = 12;
1599                  break;
1600               case 14:
1601                  if (curChar == 42)
1602                     jjstateSet[jjnewStateCnt++] = 15;
1603                  break;
1604               case 15:
1605                  if ((0xfffffff7ffffffffL & l) != 0L && kind > 13)
1606                     kind = 13;
1607                  break;
1608               case 19:
1609                  if (curChar == 36 && kind > 10)
1610                     kind = 10;
1611                  break;
1612               case 21:
1613                  if (curChar == 36)
1614                     jjCheckNAddTwoStates(22, 23);
1615                  break;
1616               case 23:
1617                  if (curChar == 33 && kind > 11)
1618                     kind = 11;
1619                  break;
1620               case 24:
1621                  if (curChar != 36)
1622                     break;
1623                  if (kind > 10)
1624                     kind = 10;
1625                  jjCheckNAddTwoStates(22, 23);
1626                  break;
1627               default : break;
1628            }
1629         } while(i != startsAt);
1630      }
1631      else if (curChar < 128)
1632      {
1633         long l = 1L << (curChar & 077);
1634         MatchLoop: do
1635         {
1636            switch(jjstateSet[--i])
1637            {
1638               case 16:
1639               case 5:
1640                  if (curChar == 115)
1641                     jjstateSet[jjnewStateCnt++] = 4;
1642                  break;
1643               case 13:
1644                  if ((0xffffffffefffffffL & l) != 0L)
1645                  {
1646                     if (kind > 18)
1647                        kind = 18;
1648                     jjCheckNAdd(7);
1649                  }
1650                  else if (curChar == 92)
1651                     jjCheckNAddStates(50, 53);
1652                  if (curChar == 92)
1653                     jjAddStates(32, 33);
1654                  break;
1655               case 25:
1656                  if (curChar == 92)
1657                     jjAddStates(32, 33);
1658                  if (curChar == 92)
1659                     jjCheckNAddTwoStates(20, 21);
1660                  if (curChar == 92)
1661                     jjCheckNAddTwoStates(18, 19);
1662                  break;
1663               case 9:
1664                  if (curChar == 92)
1665                     jjCheckNAddTwoStates(20, 21);
1666                  if (curChar == 92)
1667                     jjCheckNAddTwoStates(18, 19);
1668                  if (curChar == 92)
1669                     jjstateSet[jjnewStateCnt++] = 8;
1670                  break;
1671               case 1:
1672                  if (curChar == 116)
1673                     jjAddStates(48, 49);
1674                  break;
1675               case 4:
1676                  if (curChar == 101)
1677                     jjstateSet[jjnewStateCnt++] = 1;
1678                  break;
1679               case 7:
1680                  if ((0xffffffffefffffffL & l) == 0L)
1681                     break;
1682                  if (kind > 18)
1683                     kind = 18;
1684                  jjCheckNAdd(7);
1685                  break;
1686               case 8:
1687                  if (curChar == 92)
1688                     jjAddStates(32, 33);
1689                  break;
1690               case 11:
1691               case 12:
1692                  if ((0x7fffffe87fffffeL & l) == 0L)
1693                     break;
1694                  if (kind > 8)
1695                     kind = 8;
1696                  jjCheckNAdd(12);
1697                  break;
1698               case 15:
1699                  if (kind > 13)
1700                     kind = 13;
1701                  break;
1702               case 17:
1703                  if (curChar == 92)
1704                     jjCheckNAddStates(50, 53);
1705                  break;
1706               case 18:
1707                  if (curChar == 92)
1708                     jjCheckNAddTwoStates(18, 19);
1709                  break;
1710               case 20:
1711                  if (curChar == 92)
1712                     jjCheckNAddTwoStates(20, 21);
1713                  break;
1714               case 22:
1715                  if (curChar == 92)
1716                     jjAddStates(54, 55);
1717                  break;
1718               default : break;
1719            }
1720         } while(i != startsAt);
1721      }
1722      else
1723      {
1724         int hiByte = (int)(curChar >> 8);
1725         int i1 = hiByte >> 6;
1726         long l1 = 1L << (hiByte & 077);
1727         int i2 = (curChar & 0xff) >> 6;
1728         long l2 = 1L << (curChar & 077);
1729         MatchLoop: do
1730         {
1731            switch(jjstateSet[--i])
1732            {
1733               case 13:
1734               case 7:
1735                  if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1736                     break;
1737                  if (kind > 18)
1738                     kind = 18;
1739                  jjCheckNAdd(7);
1740                  break;
1741               case 15:
1742                  if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 13)
1743                     kind = 13;
1744                  break;
1745               default : break;
1746            }
1747         } while(i != startsAt);
1748      }
1749      if (kind != 0x7fffffff)
1750      {
1751         jjmatchedKind = kind;
1752         jjmatchedPos = curPos;
1753         kind = 0x7fffffff;
1754      }
1755      ++curPos;
1756      if ((i = jjnewStateCnt) == (startsAt = 25 - (jjnewStateCnt = startsAt)))
1757         return curPos;
1758      try { curChar = input_stream.readChar(); }
1759      catch(java.io.IOException e) { return curPos; }
1760   }
1761}
1762private final int jjStopStringLiteralDfa_7(int pos, long active0)
1763{
1764   switch (pos)
1765   {
1766      case 0:
1767         if ((active0 & 0xd000L) != 0L)
1768            return 2;
1769         return -1;
1770      default :
1771         return -1;
1772   }
1773}
1774private final int jjStartNfa_7(int pos, long active0)
1775{
1776   return jjMoveNfa_7(jjStopStringLiteralDfa_7(pos, active0), pos + 1);
1777}
1778private final int jjStartNfaWithStates_7(int pos, int kind, int state)
1779{
1780   jjmatchedKind = kind;
1781   jjmatchedPos = pos;
1782   try { curChar = input_stream.readChar(); }
1783   catch(java.io.IOException e) { return pos + 1; }
1784   return jjMoveNfa_7(state, pos + 1);
1785}
1786private final int jjMoveStringLiteralDfa0_7()
1787{
1788   switch(curChar)
1789   {
1790      case 35:
1791         jjmatchedKind = 15;
1792         return jjMoveStringLiteralDfa1_7(0x5000L);
1793      case 42:
1794         return jjMoveStringLiteralDfa1_7(0x100000L);
1795      default :
1796         return jjMoveNfa_7(3, 0);
1797   }
1798}
1799private final int jjMoveStringLiteralDfa1_7(long active0)
1800{
1801   try { curChar = input_stream.readChar(); }
1802   catch(java.io.IOException e) {
1803      jjStopStringLiteralDfa_7(0, active0);
1804      return 1;
1805   }
1806   switch(curChar)
1807   {
1808      case 35:
1809         if ((active0 & 0x1000L) != 0L)
1810            return jjStopAtPos(1, 12);
1811         else if ((active0 & 0x100000L) != 0L)
1812            return jjStopAtPos(1, 20);
1813         break;
1814      case 42:
1815         if ((active0 & 0x4000L) != 0L)
1816            return jjStartNfaWithStates_7(1, 14, 0);
1817         break;
1818      default :
1819         break;
1820   }
1821   return jjStartNfa_7(0, active0);
1822}
1823private final int jjMoveNfa_7(int startState, int curPos)
1824{
1825   int[] nextStates;
1826   int startsAt = 0;
1827   jjnewStateCnt = 12;
1828   int i = 1;
1829   jjstateSet[0] = startState;
1830   int j, kind = 0x7fffffff;
1831   for (;;)
1832   {
1833      if (++jjround == 0x7fffffff)
1834         ReInitRounds();
1835      if (curChar < 64)
1836      {
1837         long l = 1L << curChar;
1838         MatchLoop: do
1839         {
1840            switch(jjstateSet[--i])
1841            {
1842               case 3:
1843                  if (curChar == 36)
1844                  {
1845                     if (kind > 10)
1846                        kind = 10;
1847                     jjCheckNAddTwoStates(9, 10);
1848                  }
1849                  else if (curChar == 35)
1850                     jjstateSet[jjnewStateCnt++] = 2;
1851                  break;
1852               case 0:
1853                  if (curChar == 42)
1854                     jjstateSet[jjnewStateCnt++] = 1;
1855                  break;
1856               case 1:
1857                  if ((0xfffffff7ffffffffL & l) != 0L && kind > 13)
1858                     kind = 13;
1859                  break;
1860               case 2:
1861                  if (curChar == 42)
1862                     jjstateSet[jjnewStateCnt++] = 0;
1863                  break;
1864               case 6:
1865                  if (curChar == 36 && kind > 10)
1866                     kind = 10;
1867                  break;
1868               case 8:
1869                  if (curChar == 36)
1870                     jjCheckNAddTwoStates(9, 10);
1871                  break;
1872               case 10:
1873                  if (curChar == 33 && kind > 11)
1874                     kind = 11;
1875                  break;
1876               case 11:
1877                  if (curChar != 36)
1878                     break;
1879                  if (kind > 10)
1880                     kind = 10;
1881                  jjCheckNAddTwoStates(9, 10);
1882                  break;
1883               default : break;
1884            }
1885         } while(i != startsAt);
1886      }
1887      else if (curChar < 128)
1888      {
1889         long l = 1L << (curChar & 077);
1890         MatchLoop: do
1891         {
1892            switch(jjstateSet[--i])
1893            {
1894               case 3:
1895                  if (curChar == 92)
1896                     jjCheckNAddStates(28, 31);
1897                  break;
1898               case 1:
1899                  if (kind > 13)
1900                     kind = 13;
1901                  break;
1902               case 5:
1903                  if (curChar == 92)
1904                     jjCheckNAddTwoStates(5, 6);
1905                  break;
1906               case 7:
1907                  if (curChar == 92)
1908                     jjCheckNAddTwoStates(7, 8);
1909                  break;
1910               case 9:
1911                  if (curChar == 92)
1912                     jjAddStates(32, 33);
1913                  break;
1914               default : break;
1915            }
1916         } while(i != startsAt);
1917      }
1918      else
1919      {
1920         int hiByte = (int)(curChar >> 8);
1921         int i1 = hiByte >> 6;
1922         long l1 = 1L << (hiByte & 077);
1923         int i2 = (curChar & 0xff) >> 6;
1924         long l2 = 1L << (curChar & 077);
1925         MatchLoop: do
1926         {
1927            switch(jjstateSet[--i])
1928            {
1929               case 1:
1930                  if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 13)
1931                     kind = 13;
1932                  break;
1933               default : break;
1934            }
1935         } while(i != startsAt);
1936      }
1937      if (kind != 0x7fffffff)
1938      {
1939         jjmatchedKind = kind;
1940         jjmatchedPos = curPos;
1941         kind = 0x7fffffff;
1942      }
1943      ++curPos;
1944      if ((i = jjnewStateCnt) == (startsAt = 12 - (jjnewStateCnt = startsAt)))
1945         return curPos;
1946      try { curChar = input_stream.readChar(); }
1947      catch(java.io.IOException e) { return curPos; }
1948   }
1949}
1950private final int jjStopStringLiteralDfa_8(int pos, long active0)
1951{
1952   switch (pos)
1953   {
1954      case 0:
1955         if ((active0 & 0xd000L) != 0L)
1956            return 2;
1957         return -1;
1958      default :
1959         return -1;
1960   }
1961}
1962private final int jjStartNfa_8(int pos, long active0)
1963{
1964   return jjMoveNfa_8(jjStopStringLiteralDfa_8(pos, active0), pos + 1);
1965}
1966private final int jjStartNfaWithStates_8(int pos, int kind, int state)
1967{
1968   jjmatchedKind = kind;
1969   jjmatchedPos = pos;
1970   try { curChar = input_stream.readChar(); }
1971   catch(java.io.IOException e) { return pos + 1; }
1972   return jjMoveNfa_8(state, pos + 1);
1973}
1974private final int jjMoveStringLiteralDfa0_8()
1975{
1976   switch(curChar)
1977   {
1978      case 35:
1979         jjmatchedKind = 15;
1980         return jjMoveStringLiteralDfa1_8(0x5000L);
1981      default :
1982         return jjMoveNfa_8(3, 0);
1983   }
1984}
1985private final int jjMoveStringLiteralDfa1_8(long active0)
1986{
1987   try { curChar = input_stream.readChar(); }
1988   catch(java.io.IOException e) {
1989      jjStopStringLiteralDfa_8(0, active0);
1990      return 1;
1991   }
1992   switch(curChar)
1993   {
1994      case 35:
1995         if ((active0 & 0x1000L) != 0L)
1996            return jjStopAtPos(1, 12);
1997         break;
1998      case 42:
1999         if ((active0 & 0x4000L) != 0L)
2000            return jjStartNfaWithStates_8(1, 14, 0);
2001         break;
2002      default :
2003         break;
2004   }
2005   return jjStartNfa_8(0, active0);
2006}
2007private final int jjMoveNfa_8(int startState, int curPos)
2008{
2009   int[] nextStates;
2010   int startsAt = 0;
2011   jjnewStateCnt = 15;
2012   int i = 1;
2013   jjstateSet[0] = startState;
2014   int j, kind = 0x7fffffff;
2015   for (;;)
2016   {
2017      if (++jjround == 0x7fffffff)
2018         ReInitRounds();
2019      if (curChar < 64)
2020      {
2021         long l = 1L << curChar;
2022         MatchLoop: do
2023         {
2024            switch(jjstateSet[--i])
2025            {
2026               case 3:
2027                  if ((0x2400L & l) != 0L)
2028                  {
2029                     if (kind > 19)
2030                        kind = 19;
2031                  }
2032                  else if (curChar == 36)
2033                  {
2034                     if (kind > 10)
2035                        kind = 10;
2036                     jjCheckNAddTwoStates(12, 13);
2037                  }
2038                  else if (curChar == 35)
2039                     jjstateSet[jjnewStateCnt++] = 2;
2040                  if (curChar == 13)
2041                     jjstateSet[jjnewStateCnt++] = 5;
2042                  break;
2043               case 0:
2044                  if (curChar == 42)
2045                     jjstateSet[jjnewStateCnt++] = 1;
2046                  break;
2047               case 1:
2048                  if ((0xfffffff7ffffffffL & l) != 0L && kind > 13)
2049                     kind = 13;
2050                  break;
2051               case 2:
2052                  if (curChar == 42)
2053                     jjstateSet[jjnewStateCnt++] = 0;
2054                  break;
2055               case 4:
2056                  if ((0x2400L & l) != 0L && kind > 19)
2057                     kind = 19;
2058                  break;
2059               case 5:
2060                  if (curChar == 10 && kind > 19)
2061                     kind = 19;
2062                  break;
2063               case 6:
2064                  if (curChar == 13)
2065                     jjstateSet[jjnewStateCnt++] = 5;
2066                  break;
2067               case 9:
2068                  if (curChar == 36 && kind > 10)
2069                     kind = 10;
2070                  break;
2071               case 11:
2072                  if (curChar == 36)
2073                     jjCheckNAddTwoStates(12, 13);
2074                  break;
2075               case 13:
2076                  if (curChar == 33 && kind > 11)
2077                     kind = 11;
2078                  break;
2079               case 14:
2080                  if (curChar != 36)
2081                     break;
2082                  if (kind > 10)
2083                     kind = 10;
2084                  jjCheckNAddTwoStates(12, 13);
2085                  break;
2086               default : break;
2087            }
2088         } while(i != startsAt);
2089      }
2090      else if (curChar < 128)
2091      {
2092         long l = 1L << (curChar & 077);
2093         MatchLoop: do
2094         {
2095            switch(jjstateSet[--i])
2096            {
2097               case 3:
2098                  if (curChar == 92)
2099                     jjCheckNAddStates(56, 59);
2100                  break;
2101               case 1:
2102                  if (kind > 13)
2103                     kind = 13;
2104                  break;
2105               case 8:
2106                  if (curChar == 92)
2107                     jjCheckNAddTwoStates(8, 9);
2108                  break;
2109               case 10:
2110                  if (curChar == 92)
2111                     jjCheckNAddTwoStates(10, 11);
2112                  break;
2113               case 12:
2114                  if (curChar == 92)
2115                     jjAddStates(60, 61);
2116                  break;
2117               default : break;
2118            }
2119         } while(i != startsAt);
2120      }
2121      else
2122      {
2123         int hiByte = (int)(curChar >> 8);
2124         int i1 = hiByte >> 6;
2125         long l1 = 1L << (hiByte & 077);
2126         int i2 = (curChar & 0xff) >> 6;
2127         long l2 = 1L << (curChar & 077);
2128         MatchLoop: do
2129         {
2130            switch(jjstateSet[--i])
2131            {
2132               case 1:
2133                  if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 13)
2134                     kind = 13;
2135                  break;
2136               default : break;
2137            }
2138         } while(i != startsAt);
2139      }
2140      if (kind != 0x7fffffff)
2141      {
2142         jjmatchedKind = kind;
2143         jjmatchedPos = curPos;
2144         kind = 0x7fffffff;
2145      }
2146      ++curPos;
2147      if ((i = jjnewStateCnt) == (startsAt = 15 - (jjnewStateCnt = startsAt)))
2148         return curPos;
2149      try { curChar = input_stream.readChar(); }
2150      catch(java.io.IOException e) { return curPos; }
2151   }
2152}
2153private final int jjStopStringLiteralDfa_5(int pos, long active0)
2154{
2155   switch (pos)
2156   {
2157      case 0:
2158         if ((active0 & 0xd000L) != 0L)
2159            return 2;
2160         if ((active0 & 0x6000000L) != 0L)
2161         {
2162            jjmatchedKind = 56;
2163            return 5;
2164         }
2165         return -1;
2166      case 1:
2167         if ((active0 & 0x4000L) != 0L)
2168            return 0;
2169         if ((active0 & 0x6000000L) != 0L)
2170         {
2171            jjmatchedKind = 56;
2172            jjmatchedPos = 1;
2173            return 5;
2174         }
2175         return -1;
2176      case 2:
2177         if ((active0 & 0x6000000L) != 0L)
2178         {
2179            jjmatchedKind = 56;
2180            jjmatchedPos = 2;
2181            return 5;
2182         }
2183         return -1;
2184      case 3:
2185         if ((active0 & 0x4000000L) != 0L)
2186         {
2187            jjmatchedKind = 56;
2188            jjmatchedPos = 3;
2189            return 5;
2190         }
2191         if ((active0 & 0x2000000L) != 0L)
2192            return 5;
2193         return -1;
2194      default :
2195         return -1;
2196   }
2197}
2198private final int jjStartNfa_5(int pos, long active0)
2199{
2200   return jjMoveNfa_5(jjStopStringLiteralDfa_5(pos, active0), pos + 1);
2201}
2202private final int jjStartNfaWithStates_5(int pos, int kind, int state)
2203{
2204   jjmatchedKind = kind;
2205   jjmatchedPos = pos;
2206   try { curChar = input_stream.readChar(); }
2207   catch(java.io.IOException e) { return pos + 1; }
2208   return jjMoveNfa_5(state, pos + 1);
2209}
2210private final int jjMoveStringLiteralDfa0_5()
2211{
2212   switch(curChar)
2213   {
2214      case 35:
2215         jjmatchedKind = 15;
2216         return jjMoveStringLiteralDfa1_5(0x5000L);
2217      case 102:
2218         return jjMoveStringLiteralDfa1_5(0x4000000L);
2219      case 116:
2220         return jjMoveStringLiteralDfa1_5(0x2000000L);
2221      case 123:
2222         return jjStopAtPos(0, 58);
2223      case 125:
2224         return jjStopAtPos(0, 59);
2225      default :
2226         return jjMoveNfa_5(3, 0);
2227   }
2228}
2229private final int jjMoveStringLiteralDfa1_5(long active0)
2230{
2231   try { curChar = input_stream.readChar(); }
2232   catch(java.io.IOException e) {
2233      jjStopStringLiteralDfa_5(0, active0);
2234      return 1;
2235   }
2236   switch(curChar)
2237   {
2238      case 35:
2239         if ((active0 & 0x1000L) != 0L)
2240            return jjStopAtPos(1, 12);
2241         break;
2242      case 42:
2243         if ((active0 & 0x4000L) != 0L)
2244            return jjStartNfaWithStates_5(1, 14, 0);
2245         break;
2246      case 97:
2247         return jjMoveStringLiteralDfa2_5(active0, 0x4000000L);
2248      case 114:
2249         return jjMoveStringLiteralDfa2_5(active0, 0x2000000L);
2250      default :
2251         break;
2252   }
2253   return jjStartNfa_5(0, active0);
2254}
2255private final int jjMoveStringLiteralDfa2_5(long old0, long active0)
2256{
2257   if (((active0 &= old0)) == 0L)
2258      return jjStartNfa_5(0, old0); 
2259   try { curChar = input_stream.readChar(); }
2260   catch(java.io.IOException e) {
2261      jjStopStringLiteralDfa_5(1, active0);
2262      return 2;
2263   }
2264   switch(curChar)
2265   {
2266      case 108:
2267         return jjMoveStringLiteralDfa3_5(active0, 0x4000000L);
2268      case 117:
2269         return jjMoveStringLiteralDfa3_5(active0, 0x2000000L);
2270      default :
2271         break;
2272   }
2273   return jjStartNfa_5(1, active0);
2274}
2275private final int jjMoveStringLiteralDfa3_5(long old0, long active0)
2276{
2277   if (((active0 &= old0)) == 0L)
2278      return jjStartNfa_5(1, old0); 
2279   try { curChar = input_stream.readChar(); }
2280   catch(java.io.IOException e) {
2281      jjStopStringLiteralDfa_5(2, active0);
2282      return 3;
2283   }
2284   switch(curChar)
2285   {
2286      case 101:
2287         if ((active0 & 0x2000000L) != 0L)
2288            return jjStartNfaWithStates_5(3, 25, 5);
2289         break;
2290      case 115:
2291         return jjMoveStringLiteralDfa4_5(active0, 0x4000000L);
2292      default :
2293         break;
2294   }
2295   return jjStartNfa_5(2, active0);
2296}
2297private final int jjMoveStringLiteralDfa4_5(long old0, long active0)
2298{
2299   if (((active0 &= old0)) == 0L)
2300      return jjStartNfa_5(2, old0); 
2301   try { curChar = input_stream.readChar(); }
2302   catch(java.io.IOException e) {
2303      jjStopStringLiteralDfa_5(3, active0);
2304      return 4;
2305   }
2306   switch(curChar)
2307   {
2308      case 101:
2309         if ((active0 & 0x4000000L) != 0L)
2310            return jjStartNfaWithStates_5(4, 26, 5);
2311         break;
2312      default :
2313         break;
2314   }
2315   return jjStartNfa_5(3, active0);
2316}
2317private final int jjMoveNfa_5(int startState, int curPos)
2318{
2319   int[] nextStates;
2320   int startsAt = 0;
2321   jjnewStateCnt = 16;
2322   int i = 1;
2323   jjstateSet[0] = startState;
2324   int j, kind = 0x7fffffff;
2325   for (;;)
2326   {
2327      if (++jjround == 0x7fffffff)
2328         ReInitRounds();
2329      if (curChar < 64)
2330      {
2331         long l = 1L << curChar;
2332         MatchLoop: do
2333         {
2334            switch(jjstateSet[--i])
2335            {
2336               case 3:
2337                  if (curChar == 36)
2338                  {
2339                     if (kind > 10)
2340                        kind = 10;
2341                     jjCheckNAddTwoStates(13, 14);
2342                  }
2343                  else if (curChar == 46)
2344                     jjstateSet[jjnewStateCnt++] = 7;
2345                  else if (curChar == 35)
2346                     jjstateSet[jjnewStateCnt++] = 2;
2347                  break;
2348               case 0:
2349                  if (curChar == 42)
2350                     jjstateSet[jjnewStateCnt++] = 1;
2351                  break;
2352               case 1:
2353                  if ((0xfffffff7ffffffffL & l) != 0L && kind > 13)
2354                     kind = 13;
2355                  break;
2356               case 2:
2357                  if (curChar == 42)
2358                     jjstateSet[jjnewStateCnt++] = 0;
2359                  break;
2360               case 5:
2361                  if ((0x3ff200000000000L & l) == 0L)
2362                     break;
2363                  if (kind > 56)
2364                     kind = 56;
2365                  jjstateSet[jjnewStateCnt++] = 5;
2366                  break;
2367               case 6:
2368                  if (curChar == 46)
2369                     jjstateSet[jjnewStateCnt++] = 7;
2370                  break;
2371               case 10:
2372                  if (curChar == 36 && kind > 10)
2373                     kind = 10;
2374                  break;
2375               case 12:
2376                  if (curChar == 36)
2377                     jjCheckNAddTwoStates(13, 14);
2378                  break;
2379               case 14:
2380                  if (curChar == 33 && kind > 11)
2381                     kind = 11;
2382                  break;
2383               case 15:
2384                  if (curChar != 36)
2385                     break;
2386                  if (kind > 10)
2387                     kind = 10;
2388                  jjCheckNAddTwoStates(13, 14);
2389                  break;
2390               default : break;
2391            }
2392         } while(i != startsAt);
2393      }
2394      else if (curChar < 128)
2395      {
2396         long l = 1L << (curChar & 077);
2397         MatchLoop: do
2398         {
2399            switch(jjstateSet[--i])
2400            {
2401               case 3:
2402                  if ((0x7fffffe87fffffeL & l) != 0L)
2403                  {
2404                     if (kind > 56)
2405                        kind = 56;
2406                     jjCheckNAdd(5);
2407                  }
2408                  else if (curChar == 92)
2409                     jjCheckNAddStates(40, 43);
2410                  break;
2411               case 1:
2412                  if (kind > 13)
2413                     kind = 13;
2414                  break;
2415               case 4:
2416               case 5:
2417                  if ((0x7fffffe87fffffeL & l) == 0L)
2418                     break;
2419                  if (kind > 56)
2420                     kind = 56;
2421                  jjCheckNAdd(5);
2422                  break;
2423               case 7:
2424                  if ((0x7fffffe07fffffeL & l) != 0L && kind > 57)
2425                     kind = 57;
2426                  break;
2427               case 8:
2428                  if (curChar == 92)
2429                     jjCheckNAddStates(40, 43);
2430                  break;
2431               case 9:
2432                  if (curChar == 92)
2433                     jjCheckNAddTwoStates(9, 10);
2434                  break;
2435               case 11:
2436                  if (curChar == 92)
2437                     jjCheckNAddTwoStates(11, 12);
2438                  break;
2439               case 13:
2440                  if (curChar == 92)
2441                     jjAddStates(46, 47);
2442                  break;
2443               default : break;
2444            }
2445         } while(i != startsAt);
2446      }
2447      else
2448      {
2449         int hiByte = (int)(curChar >> 8);
2450         int i1 = hiByte >> 6;
2451         long l1 = 1L << (hiByte & 077);
2452         int i2 = (curChar & 0xff) >> 6;
2453         long l2 = 1L << (curChar & 077);
2454         MatchLoop: do
2455         {
2456            switch(jjstateSet[--i])
2457            {
2458               case 1:
2459                  if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 13)
2460                     kind = 13;
2461                  break;
2462               default : break;
2463            }
2464         } while(i != startsAt);
2465      }
2466      if (kind != 0x7fffffff)
2467      {
2468         jjmatchedKind = kind;
2469         jjmatchedPos = curPos;
2470         kind = 0x7fffffff;
2471      }
2472      ++curPos;
2473      if ((i = jjnewStateCnt) == (startsAt = 16 - (jjnewStateCnt = startsAt)))
2474         return curPos;
2475      try { curChar = input_stream.readChar(); }
2476      catch(java.io.IOException e) { return curPos; }
2477   }
2478}
2479private final int jjStopStringLiteralDfa_1(int pos, long active0)
2480{
2481   switch (pos)
2482   {
2483      case 0:
2484         if ((active0 & 0xd000L) != 0L)
2485            return 2;
2486         if ((active0 & 0x6000000L) != 0L)
2487         {
2488            jjmatchedKind = 56;
2489            return 25;
2490         }
2491         if ((active0 & 0x10L) != 0L)
2492            return 27;
2493         return -1;
2494      case 1:
2495         if ((active0 & 0x4000L) != 0L)
2496            return 0;
2497         if ((active0 & 0x6000000L) != 0L)
2498         {
2499            jjmatchedKind = 56;
2500            jjmatchedPos = 1;
2501            return 25;
2502         }
2503         return -1;
2504      case 2:
2505         if ((active0 & 0x6000000L) != 0L)
2506         {
2507            jjmatchedKind = 56;
2508            jjmatchedPos = 2;
2509            return 25;
2510         }
2511         return -1;
2512      case 3:
2513         if ((active0 & 0x4000000L) != 0L)
2514         {
2515            jjmatchedKind = 56;
2516            jjmatchedPos = 3;
2517            return 25;
2518         }
2519         if ((active0 & 0x2000000L) != 0L)
2520            return 25;
2521         return -1;
2522      default :
2523         return -1;
2524   }
2525}
2526private final int jjStartNfa_1(int pos, long active0)
2527{
2528   return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0), pos + 1);
2529}
2530private final int jjStartNfaWithStates_1(int pos, int kind, int state)
2531{
2532   jjmatchedKind = kind;
2533   jjmatchedPos = pos;
2534   try { curChar = input_stream.readChar(); }
2535   catch(java.io.IOException e) { return pos + 1; }
2536   return jjMoveNfa_1(state, pos + 1);
2537}
2538private final int jjMoveStringLiteralDfa0_1()
2539{
2540   switch(curChar)
2541   {
2542      case 35:
2543         jjmatchedKind = 15;
2544         return jjMoveStringLiteralDfa1_1(0x5000L);
2545      case 41:
2546         return jjStopAtPos(0, 7);
2547      case 44:
2548         return jjStopAtPos(0, 3);
2549      case 46:
2550         return jjMoveStringLiteralDfa1_1(0x10L);
2551      case 91:
2552         return jjStopAtPos(0, 1);
2553      case 93:
2554         return jjStopAtPos(0, 2);
2555      case 102:
2556         return jjMoveStringLiteralDfa1_1(0x4000000L);
2557      case 116:
2558         return jjMoveStringLiteralDfa1_1(0x2000000L);
2559      case 123:
2560         return jjStopAtPos(0, 58);
2561      case 125:
2562         return jjStopAtPos(0, 59);
2563      default :
2564         return jjMoveNfa_1(3, 0);
2565   }
2566}
2567private final int jjMoveStringLiteralDfa1_1(long active0)
2568{
2569   try { curChar = input_stream.readChar(); }
2570   catch(java.io.IOException e) {
2571      jjStopStringLiteralDfa_1(0, active0);
2572      return 1;
2573   }
2574   switch(curChar)
2575   {
2576      case 35:
2577         if ((active0 & 0x1000L) != 0L)
2578            return jjStopAtPos(1, 12);
2579         break;
2580      case 42:
2581         if ((active0 & 0x4000L) != 0L)
2582            return jjStartNfaWithStates_1(1, 14, 0);
2583         break;
2584      case 46:
2585         if ((active0 & 0x10L) != 0L)
2586            return jjStopAtPos(1, 4);
2587         break;
2588      case 97:
2589         return jjMoveStringLiteralDfa2_1(active0, 0x4000000L);
2590      case 114:
2591         return jjMoveStringLiteralDfa2_1(active0, 0x2000000L);
2592      default :
2593         break;
2594   }
2595   return jjStartNfa_1(0, active0);
2596}
2597private final int jjMoveStringLiteralDfa2_1(long old0, long active0)
2598{
2599   if (((active0 &= old0)) == 0L)
2600      return jjStartNfa_1(0, old0); 
2601   try { curChar = input_stream.readChar(); }
2602   catch(java.io.IOException e) {
2603      jjStopStringLiteralDfa_1(1, active0);
2604      return 2;
2605   }
2606   switch(curChar)
2607   {
2608      case 108:
2609         return jjMoveStringLiteralDfa3_1(active0, 0x4000000L);
2610      case 117:
2611         return jjMoveStringLiteralDfa3_1(active0, 0x2000000L);
2612      default :
2613         break;
2614   }
2615   return jjStartNfa_1(1, active0);
2616}
2617private final int jjMoveStringLiteralDfa3_1(long old0, long active0)
2618{
2619   if (((active0 &= old0)) == 0L)
2620      return jjStartNfa_1(1, old0); 
2621   try { curChar = input_stream.readChar(); }
2622   catch(java.io.IOException e) {
2623      jjStopStringLiteralDfa_1(2, active0);
2624      return 3;
2625   }
2626   switch(curChar)
2627   {
2628      case 101:
2629         if ((active0 & 0x2000000L) != 0L)
2630            return jjStartNfaWithStates_1(3, 25, 25);
2631         break;
2632      case 115:
2633         return jjMoveStringLiteralDfa4_1(active0, 0x4000000L);
2634      default :
2635         break;
2636   }
2637   return jjStartNfa_1(2, active0);
2638}
2639private final int jjMoveStringLiteralDfa4_1(long old0, long active0)
2640{
2641   if (((active0 &= old0)) == 0L)
2642      return jjStartNfa_1(2, old0); 
2643   try { curChar = input_stream.readChar(); }
2644   catch(java.io.IOException e) {
2645      jjStopStringLiteralDfa_1(3, active0);
2646      return 4;
2647   }
2648   switch(curChar)
2649   {
2650      case 101:
2651         if ((active0 & 0x4000000L) != 0L)
2652            return jjStartNfaWithStates_1(4, 26, 25);
2653         break;
2654      default :
2655         break;
2656   }
2657   return jjStartNfa_1(3, active0);
2658}
2659private final int jjMoveNfa_1(int startState, int curPos)
2660{
2661   int[] nextStates;
2662   int startsAt = 0;
2663   jjnewStateCnt = 36;
2664   int i = 1;
2665   jjstateSet[0] = startState;
2666   int j, kind = 0x7fffffff;
2667   for (;;)
2668   {
2669      if (++jjround == 0x7fffffff)
2670         ReInitRounds();
2671      if (curChar < 64)
2672      {
2673         long l = 1L << curChar;
2674         MatchLoop: do
2675         {
2676            switch(jjstateSet[--i])
2677            {
2678               case 3:
2679                  if ((0x3ff000000000000L & l) != 0L)
2680                  {
2681                     if (kind > 49)
2682                        kind = 49;
2683                     jjCheckNAdd(23);
2684                  }
2685                  else if ((0x100000200L & l) != 0L)
2686                  {
2687                     if (kind > 23)
2688                        kind = 23;
2689                     jjCheckNAdd(4);
2690                  }
2691                  else if (curChar == 36)
2692                  {
2693                     if (kind > 10)
2694                        kind = 10;
2695                     jjCheckNAddTwoStates(33, 34);
2696                  }
2697                  else if (curChar == 46)
2698                     jjstateSet[jjnewStateCnt++] = 27;
2699                  else if (curChar == 45)
2700                     jjCheckNAdd(23);
2701                  else if (curChar == 39)
2702                     jjCheckNAddStates(62, 64);
2703                  else if (curChar == 34)
2704                     jjCheckNAddStates(65, 67);
2705                  else if (curChar == 35)
2706                     jjstateSet[jjnewStateCnt++] = 2;
2707                  break;
2708               case 0:
2709                  if (curChar == 42)
2710                     jjstateSet[jjnewStateCnt++] = 1;
2711                  break;
2712               case 1:
2713                  if ((0xfffffff7ffffffffL & l) != 0L && kind > 13)
2714                     kind = 13;
2715                  break;
2716               case 2:
2717                  if (curChar == 42)
2718                     jjstateSet[jjnewStateCnt++] = 0;
2719                  break;
2720               case 4:
2721                  if ((0x100000200L & l) == 0L)
2722                     break;
2723                  if (kind > 23)
2724                     kind = 23;
2725                  jjCheckNAdd(4);
2726                  break;
2727               case 5:
2728                  if (curChar == 34)
2729                     jjCheckNAddStates(65, 67);
2730                  break;
2731               case 6:
2732                  if ((0xfffffffbffffdbffL & l) != 0L)
2733                     jjCheckNAddStates(65, 67);
2734                  break;
2735               case 7:
2736                  if (curChar == 34 && kind > 24)
2737                     kind = 24;
2738                  break;
2739               case 9:
2740                  if ((0x8400000000L & l) != 0L)
2741                     jjCheckNAddStates(65, 67);
2742                  break;
2743               case 10:
2744                  if ((0xff000000000000L & l) != 0L)
2745                     jjCheckNAddStates(68, 71);
2746                  break;
2747               case 11:
2748                  if ((0xff000000000000L & l) != 0L)
2749                     jjCheckNAddStates(65, 67);
2750                  break;
2751               case 12:
2752                  if ((0xf000000000000L & l) != 0L)
2753                     jjstateSet[jjnewStateCnt++] = 13;
2754                  break;
2755               case 13:
2756                  if ((0xff000000000000L & l) != 0L)
2757                     jjCheckNAdd(11);
2758                  break;
2759               case 14:
2760                  if (curChar == 32)
2761                     jjAddStates(72, 73);
2762                  break;
2763               case 15:
2764                  if (curChar == 10)
2765                     jjCheckNAddStates(65, 67);
2766                  break;
2767               case 16:
2768                  if (curChar == 39)
2769                     jjCheckNAddStates(62, 64);
2770                  break;
2771               case 17:
2772                  if ((0xffffff7fffffdbffL & l) != 0L)
2773                     jjCheckNAddStates(62, 64);
2774                  break;
2775               case 19:
2776                  if (curChar == 32)
2777                     jjAddStates(13, 14);
2778                  break;
2779               case 20:
2780                  if (curChar == 10)
2781                     jjCheckNAddStates(62, 64);
2782                  break;
2783               case 21:
2784                  if (curChar == 39 && kind > 24)
2785                     kind = 24;
2786                  break;
2787               case 22:
2788                  if (curChar == 45)
2789                     jjCheckNAdd(23);
2790                  break;
2791               case 23:
2792                  if ((0x3ff000000000000L & l) == 0L)
2793                     break;
2794                  if (kind > 49)
2795                     kind = 49;
2796                  jjCheckNAdd(23);
2797                  break;
2798               case 25:
2799                  if ((0x3ff200000000000L & l) == 0L)
2800                     break;
2801                  if (kind > 56)
2802                     kind = 56;
2803                  jjstateSet[jjnewStateCnt++] = 25;
2804                  break;
2805               case 26:
2806                  if (curChar == 46)
2807                     jjstateSet[jjnewStateCnt++] = 27;
2808                  break;
2809               case 30:
2810                  if (curChar == 36 && kind > 10)
2811                     kind = 10;
2812                  break;
2813               case 32:
2814                  if (curChar == 36)
2815                     jjCheckNAddTwoStates(33, 34);
2816                  break;
2817               case 34:
2818                  if (curChar == 33 && kind > 11)
2819                     kind = 11;
2820                  break;
2821               case 35:
2822                  if (curChar != 36)
2823                     break;
2824                  if (kind > 10)
2825                     kind = 10;
2826                  jjCheckNAddTwoStates(33, 34);
2827                  break;
2828               default : break;
2829            }
2830         } while(i != startsAt);
2831      }
2832      else if (curChar < 128)
2833      {
2834         long l = 1L << (curChar & 077);
2835         MatchLoop: do
2836         {
2837            switch(jjstateSet[--i])
2838            {
2839               case 3:
2840                  if ((0x7fffffe87fffffeL & l) != 0L)
2841                  {
2842                     if (kind > 56)
2843                        kind = 56;
2844                     jjCheckNAdd(25);
2845                  }
2846                  else if (curChar == 92)
2847                     jjCheckNAddStates(74, 77);
2848                  break;
2849               case 1:
2850                  if (kind > 13)
2851                     kind = 13;
2852                  break;
2853               case 6:
2854                  if ((0xffffffffefffffffL & l) != 0L)
2855                     jjCheckNAddStates(65, 67);
2856                  break;
2857               case 8:
2858                  if (curChar == 92)
2859                     jjAddStates(78, 82);
2860                  break;
2861               case 9:
2862                  if ((0x14404410000000L & l) != 0L)
2863                     jjCheckNAddStates(65, 67);
2864                  break;
2865               case 17:
2866                  jjAddStates(62, 64);
2867                  break;
2868               case 18:
2869                  if (curChar == 92)
2870                     jjAddStates(13, 14);
2871                  break;
2872               case 24:
2873               case 25:
2874                  if ((0x7fffffe87fffffeL & l) == 0L)
2875                     break;
2876                  if (kind > 56)
2877                     kind = 56;
2878                  jjCheckNAdd(25);
2879                  break;
2880               case 27:
2881                  if ((0x7fffffe07fffffeL & l) != 0L && kind > 57)
2882                     kind = 57;
2883                  break;
2884               case 28:
2885                  if (curChar == 92)
2886                     jjCheckNAddStates(74, 77);
2887                  break;
2888               case 29:
2889                  if (curChar == 92)
2890                     jjCheckNAddTwoStates(29, 30);
2891                  break;
2892               case 31:
2893                  if (curChar == 92)
2894                     jjCheckNAddTwoStates(31, 32);
2895                  break;
2896               case 33:
2897                  if (curChar == 92)
2898                     jjAddStates(83, 84);
2899                  break;
2900               default : break;
2901            }
2902         } while(i != startsAt);
2903      }
2904      else
2905      {
2906         int hiByte = (int)(curChar >> 8);
2907         int i1 = hiByte >> 6;
2908         long l1 = 1L << (hiByte & 077);
2909         int i2 = (curChar & 0xff) >> 6;
2910         long l2 = 1L << (curChar & 077);
2911         MatchLoop: do
2912         {
2913            switch(jjstateSet[--i])
2914            {
2915               case 1:
2916                  if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 13)
2917                     kind = 13;
2918                  break;
2919               case 6:
2920                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
2921                     jjAddStates(65, 67);
2922                  break;
2923               case 17:
2924                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
2925                     jjAddStates(62, 64);
2926                  break;
2927               default : break;
2928            }
2929         } while(i != startsAt);
2930      }
2931      if (kind != 0x7fffffff)
2932      {
2933         jjmatchedKind = kind;
2934         jjmatchedPos = curPos;
2935         kind = 0x7fffffff;
2936      }
2937      ++curPos;
2938      if ((i = jjnewStateCnt) == (startsAt = 36 - (jjnewStateCnt = startsAt)))
2939         return curPos;
2940      try { curChar = input_stream.readChar(); }
2941      catch(java.io.IOException e) { return curPos; }
2942   }
2943}
2944private final int jjStopStringLiteralDfa_2(int pos, long active0)
2945{
2946   switch (pos)
2947   {
2948      case 0:
2949         if ((active0 & 0xd000L) != 0L)
2950            return 2;
2951         if ((active0 & 0x6000000L) != 0L)
2952         {
2953            jjmatchedKind = 56;
2954            return 5;
2955         }
2956         return -1;
2957      case 1:
2958         if ((active0 & 0x4000L) != 0L)
2959            return 0;
2960         if ((active0 & 0x6000000L) != 0L)
2961         {
2962            jjmatchedKind = 56;
2963            jjmatchedPos = 1;
2964            return 5;
2965         }
2966         return -1;
2967      case 2:
2968         if ((active0 & 0x6000000L) != 0L)
2969         {
2970            jjmatchedKind = 56;
2971            jjmatchedPos = 2;
2972            return 5;
2973         }
2974         return -1;
2975      case 3:
2976         if ((active0 & 0x4000000L) != 0L)
2977         {
2978            jjmatchedKind = 56;
2979            jjmatchedPos = 3;
2980            return 5;
2981         }
2982         if ((active0 & 0x2000000L) != 0L)
2983            return 5;
2984         return -1;
2985      default :
2986         return -1;
2987   }
2988}
2989private final int jjStartNfa_2(int pos, long active0)
2990{
2991   return jjMoveNfa_2(jjStopStringLiteralDfa_2(pos, active0), pos + 1);
2992}
2993private final int jjStartNfaWithStates_2(int pos, int kind, int state)
2994{
2995   jjmatchedKind = kind;
2996   jjmatchedPos = pos;
2997   try { curChar = input_stream.readChar(); }
2998   catch(java.io.IOException e) { return pos + 1; }
2999   return jjMoveNfa_2(state, pos + 1);
3000}
3001private final int jjMoveStringLiteralDfa0_2()
3002{
3003   switch(curChar)
3004   {
3005      case 35:
3006         jjmatchedKind = 15;
3007         return jjMoveStringLiteralDfa1_2(0x5000L);
3008      case 40:
3009         return jjStopAtPos(0, 5);
3010      case 102:
3011         return jjMoveStringLiteralDfa1_2(0x4000000L);
3012      case 116:
3013         return jjMoveStringLiteralDfa1_2(0x2000000L);
3014      case 123:
3015         return jjStopAtPos(0, 58);
3016      case 125:
3017         return jjStopAtPos(0, 59);
3018      default :
3019         return jjMoveNfa_2(3, 0);
3020   }
3021}
3022private final int jjMoveStringLiteralDfa1_2(long active0)
3023{
3024   try { curChar = input_stream.readChar(); }
3025   catch(java.io.IOException e) {
3026      jjStopStringLiteralDfa_2(0, active0);
3027      return 1;
3028   }
3029   switch(curChar)
3030   {
3031      case 35:
3032         if ((active0 & 0x1000L) != 0L)
3033            return jjStopAtPos(1, 12);
3034         break;
3035      case 42:
3036         if ((active0 & 0x4000L) != 0L)
3037            return jjStartNfaWithStates_2(1, 14, 0);
3038         break;
3039      case 97:
3040         return jjMoveStringLiteralDfa2_2(active0, 0x4000000L);
3041      case 114:
3042         return jjMoveStringLiteralDfa2_2(active0, 0x2000000L);
3043      default :
3044         break;
3045   }
3046   return jjStartNfa_2(0, active0);
3047}
3048private final int jjMoveStringLiteralDfa2_2(long old0, long active0)
3049{
3050   if (((active0 &= old0)) == 0L)
3051      return jjStartNfa_2(0, old0); 
3052   try { curChar = input_stream.readChar(); }
3053   catch(java.io.IOException e) {
3054      jjStopStringLiteralDfa_2(1, active0);
3055      return 2;
3056   }
3057   switch(curChar)
3058   {
3059      case 108:
3060         return jjMoveStringLiteralDfa3_2(active0, 0x4000000L);
3061      case 117:
3062         return jjMoveStringLiteralDfa3_2(active0, 0x2000000L);
3063      default :
3064         break;
3065   }
3066   return jjStartNfa_2(1, active0);
3067}
3068private final int jjMoveStringLiteralDfa3_2(long old0, long active0)
3069{
3070   if (((active0 &= old0)) == 0L)
3071      return jjStartNfa_2(1, old0); 
3072   try { curChar = input_stream.readChar(); }
3073   catch(java.io.IOException e) {
3074      jjStopStringLiteralDfa_2(2, active0);
3075      return 3;
3076   }
3077   switch(curChar)
3078   {
3079      case 101:
3080         if ((active0 & 0x2000000L) != 0L)
3081            return jjStartNfaWithStates_2(3, 25, 5);
3082         break;
3083      case 115:
3084         return jjMoveStringLiteralDfa4_2(active0, 0x4000000L);
3085      default :
3086         break;
3087   }
3088   return jjStartNfa_2(2, active0);
3089}
3090private final int jjMoveStringLiteralDfa4_2(long old0, long active0)
3091{
3092   if (((active0 &= old0)) == 0L)
3093      return jjStartNfa_2(2, old0); 
3094   try { curChar = input_stream.readChar(); }
3095   catch(java.io.IOException e) {
3096      jjStopStringLiteralDfa_2(3, active0);
3097      return 4;
3098   }
3099   switch(curChar)
3100   {
3101      case 101:
3102         if ((active0 & 0x4000000L) != 0L)
3103            return jjStartNfaWithStates_2(4, 26, 5);
3104         break;
3105      default :
3106         break;
3107   }
3108   return jjStartNfa_2(3, active0);
3109}
3110private final int jjMoveNfa_2(int startState, int curPos)
3111{
3112   int[] nextStates;
3113   int startsAt = 0;
3114   jjnewStateCnt = 16;
3115   int i = 1;
3116   jjstateSet[0] = startState;
3117   int j, kind = 0x7fffffff;
3118   for (;;)
3119   {
3120      if (++jjround == 0x7fffffff)
3121         ReInitRounds();
3122      if (curChar < 64)
3123      {
3124         long l = 1L << curChar;
3125         MatchLoop: do
3126         {
3127            switch(jjstateSet[--i])
3128            {
3129               case 3:
3130                  if (curChar == 36)
3131                  {
3132                     if (kind > 10)
3133                        kind = 10;
3134                     jjCheckNAddTwoStates(13, 14);
3135                  }
3136                  else if (curChar == 46)
3137                     jjstateSet[jjnewStateCnt++] = 7;
3138                  else if (curChar == 35)
3139                     jjstateSet[jjnewStateCnt++] = 2;
3140                  break;
3141               case 0:
3142                  if (curChar == 42)
3143                     jjstateSet[jjnewStateCnt++] = 1;
3144                  break;
3145               case 1:
3146                  if ((0xfffffff7ffffffffL & l) != 0L && kind > 13)
3147                     kind = 13;
3148                  break;
3149               case 2:
3150                  if (curChar == 42)
3151                     jjstateSet[jjnewStateCnt++] = 0;
3152                  break;
3153               case 5:
3154                  if ((0x3ff200000000000L & l) == 0L)
3155                     break;
3156                  if (kind > 56)
3157                     kind = 56;
3158                  jjstateSet[jjnewStateCnt++] = 5;
3159                  break;
3160               case 6:
3161                  if (curChar == 46)
3162                     jjstateSet[jjnewStateCnt++] = 7;
3163                  break;
3164               case 10:
3165                  if (curChar == 36 && kind > 10)
3166                     kind = 10;
3167                  break;
3168               case 12:
3169                  if (curChar == 36)
3170                     jjCheckNAddTwoStates(13, 14);
3171                  break;
3172               case 14:
3173                  if (curChar == 33 && kind > 11)
3174                     kind = 11;
3175                  break;
3176               case 15:
3177                  if (curChar != 36)
3178                     break;
3179                  if (kind > 10)
3180                     kind = 10;
3181                  jjCheckNAddTwoStates(13, 14);
3182                  break;
3183               default : break;
3184            }
3185         } while(i != startsAt);
3186      }
3187      else if (curChar < 128)
3188      {
3189         long l = 1L << (curChar & 077);
3190         MatchLoop: do
3191         {
3192            switch(jjstateSet[--i])
3193            {
3194               case 3:
3195                  if ((0x7fffffe87fffffeL & l) != 0L)
3196                  {
3197                     if (kind > 56)
3198                        kind = 56;
3199                     jjCheckNAdd(5);
3200                  }
3201                  else if (curChar == 92)
3202                     jjCheckNAddStates(40, 43);
3203                  break;
3204               case 1:
3205                  if (kind > 13)
3206                     kind = 13;
3207                  break;
3208               case 4:
3209               case 5:
3210                  if ((0x7fffffe87fffffeL & l) == 0L)
3211                     break;
3212                  if (kind > 56)
3213                     kind = 56;
3214                  jjCheckNAdd(5);
3215                  break;
3216               case 7:
3217                  if ((0x7fffffe07fffffeL & l) != 0L && kind > 57)
3218                     kind = 57;
3219                  break;
3220               case 8:
3221                  if (curChar == 92)
3222                     jjCheckNAddStates(40, 43);
3223                  break;
3224               case 9:
3225                  if (curChar == 92)
3226                     jjCheckNAddTwoStates(9, 10);
3227                  break;
3228               case 11:
3229                  if (curChar == 92)
3230                     jjCheckNAddTwoStates(11, 12);
3231                  break;
3232               case 13:
3233                  if (curChar == 92)
3234                     jjAddStates(46, 47);
3235                  break;
3236               default : break;
3237            }
3238         } while(i != startsAt);
3239      }
3240      else
3241      {
3242         int hiByte = (int)(curChar >> 8);
3243         int i1 = hiByte >> 6;
3244         long l1 = 1L << (hiByte & 077);
3245         int i2 = (curChar & 0xff) >> 6;
3246         long l2 = 1L << (curChar & 077);
3247         MatchLoop: do
3248         {
3249            switch(jjstateSet[--i])
3250            {
3251               case 1:
3252                  if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 13)
3253                     kind = 13;
3254                  break;
3255               default : break;
3256            }
3257         } while(i != startsAt);
3258      }
3259      if (kind != 0x7fffffff)
3260      {
3261         jjmatchedKind = kind;
3262         jjmatchedPos = curPos;
3263         kind = 0x7fffffff;
3264      }
3265      ++curPos;
3266      if ((i = jjnewStateCnt) == (startsAt = 16 - (jjnewStateCnt = startsAt)))
3267         return curPos;
3268      try { curChar = input_stream.readChar(); }
3269      catch(java.io.IOException e) { return curPos; }
3270   }
3271}
3272static final int[] jjnextStates = {
3273   22, 23, 26, 11, 12, 13, 1, 2, 4, 11, 16, 12, 13, 19, 20, 24, 
3274   25, 35, 36, 37, 38, 14, 15, 17, 19, 20, 39, 40, 5, 6, 7, 8, 
3275   9, 10, 24, 25, 27, 18, 19, 21, 9, 10, 11, 12, 22, 29, 13, 14, 
3276   2, 3, 18, 19, 20, 21, 22, 23, 8, 9, 10, 11, 12, 13, 17, 18, 
3277   21, 6, 7, 8, 6, 11, 7, 8, 14, 15, 29, 30, 31, 32, 9, 10, 
3278   12, 14, 15, 33, 34, 
3279};
3280private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
3281{
3282   switch(hiByte)
3283   {
3284      case 0:
3285         return ((jjbitVec2[i2] & l2) != 0L);
3286      default : 
3287         if ((jjbitVec0[i1] & l1) != 0L)
3288            return true;
3289         return false;
3290   }
3291}
3292public static final String[] jjstrLiteralImages = {
3293null, null, null, null, null, null, null, null, null, null, null, null, null, 
3294null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
3295null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
3296null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
3297null, null, null, null, null, null, null, };
3298public static final String[] lexStateNames = {
3299   "DIRECTIVE", 
3300   "REFMOD2", 
3301   "REFMODIFIER", 
3302   "DEFAULT", 
3303   "PRE_DIRECTIVE", 
3304   "REFERENCE", 
3305   "IN_MULTI_LINE_COMMENT", 
3306   "IN_FORMAL_COMMENT", 
3307   "IN_SINGLE_LINE_COMMENT", 
3308};
3309public static final int[] jjnewLexState = {
3310   -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, 
3311   -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, 
3312   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
3313};
3314static final long[] jjtoToken = {
3315   0xf12ffffffbf03ffL, 
3316};
3317static final long[] jjtoSkip = {
3318   0x3000000000000000L, 
3319};
3320static final long[] jjtoSpecial = {
3321   0x3000000000000000L, 
3322};
3323static final long[] jjtoMore = {
3324   0x40fc00L, 
3325};
3326private CharStream input_stream;
3327private final int[] jjrounds = new int[42];
3328private final int[] jjstateSet = new int[84];
3329StringBuffer image;
3330int jjimageLen;
3331int lengthOfMatch;
3332protected char curChar;
3333public ParserTokenManager(CharStream stream)
3334{
3335   input_stream = stream;
3336}
3337public ParserTokenManager(CharStream stream, int lexState)
3338{
3339   this(stream);
3340   SwitchTo(lexState);
3341}
3342public void ReInit(CharStream stream)
3343{
3344   jjmatchedPos = jjnewStateCnt = 0;
3345   curLexState = defaultLexState;
3346   input_stream = stream;
3347   ReInitRounds();
3348}
3349private final void ReInitRounds()
3350{
3351   int i;
3352   jjround = 0x80000001;
3353   for (i = 42; i-- > 0;)
3354      jjrounds[i] = 0x80000000;
3355}
3356public void ReInit(CharStream stream, int lexState)
3357{
3358   ReInit(stream);
3359   SwitchTo(lexState);
3360}
3361public void SwitchTo(int lexState)
3362{
3363   if (lexState >= 9 || lexState < 0)
3364      throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
3365   else
3366      curLexState = lexState;
3367}
3368 
3369private final Token jjFillToken()
3370{
3371   Token t = Token.newToken(jjmatchedKind);
3372   t.kind = jjmatchedKind;
3373   String im = jjstrLiteralImages[jjmatchedKind];
3374   t.image = (im == null) ? input_stream.GetImage() : im;
3375   t.beginLine = input_stream.getBeginLine();
3376   t.beginColumn = input_stream.getBeginColumn();
3377   t.endLine = input_stream.getEndLine();
3378   t.endColumn = input_stream.getEndColumn();
3379   return t;
3380}
3381 
3382int curLexState = 3;
3383int defaultLexState = 3;
3384int jjnewStateCnt;
3385int jjround;
3386int jjmatchedPos;
3387int jjmatchedKind;
3388 
3389public final Token getNextToken() 
3390{
3391  int kind;
3392  Token specialToken = null;
3393  Token matchedToken;
3394  int curPos = 0;
3395 
3396  EOFLoop :
3397  for (;;)
3398  {   
3399   try   
3400   {     
3401      curChar = input_stream.BeginToken();
3402   }     
3403   catch(java.io.IOException e)
3404   {        
3405      jjmatchedKind = 0;
3406      matchedToken = jjFillToken();
3407      matchedToken.specialToken = specialToken;
3408      return matchedToken;
3409   }
3410   image = null;
3411   jjimageLen = 0;
3412 
3413   for (;;)
3414   {
3415     switch(curLexState)
3416     {
3417       case 0:
3418         jjmatchedKind = 0x7fffffff;
3419         jjmatchedPos = 0;
3420         curPos = jjMoveStringLiteralDfa0_0();
3421         break;
3422       case 1:
3423         jjmatchedKind = 0x7fffffff;
3424         jjmatchedPos = 0;
3425         curPos = jjMoveStringLiteralDfa0_1();
3426         if (jjmatchedPos == 0 && jjmatchedKind > 60)
3427         {
3428            jjmatchedKind = 60;
3429         }
3430         break;
3431       case 2:
3432         jjmatchedKind = 0x7fffffff;
3433         jjmatchedPos = 0;
3434         curPos = jjMoveStringLiteralDfa0_2();
3435         if (jjmatchedPos == 0 && jjmatchedKind > 60)
3436         {
3437            jjmatchedKind = 60;
3438         }
3439         break;
3440       case 3:
3441         jjmatchedKind = 0x7fffffff;
3442         jjmatchedPos = 0;
3443         curPos = jjMoveStringLiteralDfa0_3();
3444         break;
3445       case 4:
3446         jjmatchedKind = 0x7fffffff;
3447         jjmatchedPos = 0;
3448         curPos = jjMoveStringLiteralDfa0_4();
3449         if (jjmatchedPos == 0 && jjmatchedKind > 61)
3450         {
3451            jjmatchedKind = 61;
3452         }
3453         break;
3454       case 5:
3455         jjmatchedKind = 0x7fffffff;
3456         jjmatchedPos = 0;
3457         curPos = jjMoveStringLiteralDfa0_5();
3458         if (jjmatchedPos == 0 && jjmatchedKind > 60)
3459         {
3460            jjmatchedKind = 60;
3461         }
3462         break;
3463       case 6:
3464         jjmatchedKind = 0x7fffffff;
3465         jjmatchedPos = 0;
3466         curPos = jjMoveStringLiteralDfa0_6();
3467         if (jjmatchedPos == 0 && jjmatchedKind > 22)
3468         {
3469            jjmatchedKind = 22;
3470         }
3471         break;
3472       case 7:
3473         jjmatchedKind = 0x7fffffff;
3474         jjmatchedPos = 0;
3475         curPos = jjMoveStringLiteralDfa0_7();
3476         if (jjmatchedPos == 0 && jjmatchedKind > 22)
3477         {
3478            jjmatchedKind = 22;
3479         }
3480         break;
3481       case 8:
3482         jjmatchedKind = 0x7fffffff;
3483         jjmatchedPos = 0;
3484         curPos = jjMoveStringLiteralDfa0_8();
3485         if (jjmatchedPos == 0 && jjmatchedKind > 22)
3486         {
3487            jjmatchedKind = 22;
3488         }
3489         break;
3490     }
3491     if (jjmatchedKind != 0x7fffffff)
3492     {
3493        if (jjmatchedPos + 1 < curPos)
3494           input_stream.backup(curPos - jjmatchedPos - 1);
3495        if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
3496        {
3497           matchedToken = jjFillToken();
3498           matchedToken.specialToken = specialToken;
3499           TokenLexicalActions(matchedToken);
3500       if (jjnewLexState[jjmatchedKind] != -1)
3501         curLexState = jjnewLexState[jjmatchedKind];
3502           return matchedToken;
3503        }
3504        else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
3505        {
3506           if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
3507           {
3508              matchedToken = jjFillToken();
3509              if (specialToken == null)
3510                 specialToken = matchedToken;
3511              else
3512              {
3513                 matchedToken.specialToken = specialToken;
3514                 specialToken = (specialToken.next = matchedToken);
3515              }
3516              SkipLexicalActions(matchedToken);
3517           }
3518           else 
3519              SkipLexicalActions(null);
3520         if (jjnewLexState[jjmatchedKind] != -1)
3521           curLexState = jjnewLexState[jjmatchedKind];
3522           continue EOFLoop;
3523        }
3524        MoreLexicalActions();
3525      if (jjnewLexState[jjmatchedKind] != -1)
3526        curLexState = jjnewLexState[jjmatchedKind];
3527        curPos = 0;
3528        jjmatchedKind = 0x7fffffff;
3529        try {
3530           curChar = input_stream.readChar();
3531           continue;
3532        }
3533        catch (java.io.IOException e1) { }
3534     }
3535     int error_line = input_stream.getEndLine();
3536     int error_column = input_stream.getEndColumn();
3537     String error_after = null;
3538     boolean EOFSeen = false;
3539     try { input_stream.readChar(); input_stream.backup(1); }
3540     catch (java.io.IOException e1) {
3541        EOFSeen = true;
3542        error_after = curPos <= 1 ? "" : input_stream.GetImage();
3543        if (curChar == '\n' || curChar == '\r') {
3544           error_line++;
3545           error_column = 0;
3546        }
3547        else
3548           error_column++;
3549     }
3550     if (!EOFSeen) {
3551        input_stream.backup(1);
3552        error_after = curPos <= 1 ? "" : input_stream.GetImage();
3553     }
3554     throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
3555   }
3556  }
3557}
3558 
3559final void SkipLexicalActions(Token matchedToken)
3560{
3561   switch(jjmatchedKind)
3562   {
3563      case 60 :
3564         if (image == null)
3565            image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
3566         else
3567            image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3568        /*
3569         * push every terminator character back into the stream
3570         */
3571 
3572        input_stream.backup(1);
3573 
3574        inReference = false;
3575 
3576        if ( debugPrint )
3577            System.out.print("REF_TERM :");
3578 
3579        stateStackPop();
3580         break;
3581      case 61 :
3582         if (image == null)
3583            image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
3584         else
3585            image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3586        if ( debugPrint )
3587            System.out.print("DIRECTIVE_TERM :");
3588 
3589        input_stream.backup(1);
3590        inDirective = false;
3591        stateStackPop();
3592         break;
3593      default :
3594         break;
3595   }
3596}
3597final void MoreLexicalActions()
3598{
3599   jjimageLen += (lengthOfMatch = jjmatchedPos + 1);
3600   switch(jjmatchedKind)
3601   {
3602      case 10 :
3603         if (image == null)
3604              image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen)));
3605         else
3606            image.append(input_stream.GetSuffix(jjimageLen));
3607         jjimageLen = 0;
3608        if (! inComment)
3609        {
3610            /*
3611             * if we find ourselves in REFERENCE, we need to pop down
3612             * to end the previous ref
3613             */
3614 
3615            if (curLexState == REFERENCE)
3616            {
3617                inReference = false;
3618                stateStackPop();
3619            }
3620 
3621            inReference = true;
3622 
3623            if ( debugPrint )
3624                System.out.print( "$  : going to " + REFERENCE );
3625 
3626            stateStackPush();
3627            SwitchTo(REFERENCE);
3628        }
3629         break;
3630      case 11 :
3631         if (image == null)
3632              image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen)));
3633         else
3634            image.append(input_stream.GetSuffix(jjimageLen));
3635         jjimageLen = 0;
3636        if (! inComment)
3637        {
3638            /*
3639             * if we find ourselves in REFERENCE, we need to pop down
3640             * to end the previous ref
3641             */
3642 
3643            if (curLexState == REFERENCE)
3644            {
3645                inReference = false;
3646                stateStackPop();
3647            }
3648 
3649            inReference = true;
3650 
3651            if ( debugPrint )
3652                System.out.print( "$!  : going to " + REFERENCE );
3653 
3654            stateStackPush();
3655            SwitchTo(REFERENCE);
3656        }
3657         break;
3658      case 12 :
3659         if (image == null)
3660              image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen)));
3661         else
3662            image.append(input_stream.GetSuffix(jjimageLen));
3663         jjimageLen = 0;
3664        if (!inComment)
3665        {
3666            if (curLexState == REFERENCE)
3667            {
3668                inReference = false;
3669                stateStackPop();
3670            }
3671 
3672            inComment = true;
3673            stateStackPush();
3674            SwitchTo(IN_SINGLE_LINE_COMMENT);
3675        }
3676         break;
3677      case 13 :
3678         if (image == null)
3679              image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen)));
3680         else
3681            image.append(input_stream.GetSuffix(jjimageLen));
3682         jjimageLen = 0;
3683        input_stream.backup(1);
3684        inComment = true;
3685        stateStackPush();
3686        SwitchTo( IN_FORMAL_COMMENT);
3687         break;
3688      case 14 :
3689         if (image == null)
3690              image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen)));
3691         else
3692            image.append(input_stream.GetSuffix(jjimageLen));
3693         jjimageLen = 0;
3694        inComment=true;
3695        stateStackPush();
3696        SwitchTo( IN_MULTI_LINE_COMMENT );
3697         break;
3698      case 15 :
3699         if (image == null)
3700              image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen)));
3701         else
3702            image.append(input_stream.GetSuffix(jjimageLen));
3703         jjimageLen = 0;
3704        if (! inComment)
3705        {
3706            /*
3707             * We can have the situation where #if($foo)$foo#end.
3708             * We need to transition out of REFERENCE before going to DIRECTIVE.
3709             * I don't really like this, but I can't think of a legal way
3710             * you are going into DIRECTIVE while in REFERENCE.  -gmj
3711             */
3712 
3713            if (curLexState == REFERENCE || curLexState == REFMODIFIER )
3714            {
3715                inReference = false;
3716                stateStackPop();
3717            }
3718 
3719            inDirective = true;
3720 
3721            if ( debugPrint )
3722                System.out.print("# :  going to " + DIRECTIVE );
3723 
3724            stateStackPush();
3725            SwitchTo(PRE_DIRECTIVE);
3726        }
3727         break;
3728      default : 
3729         break;
3730   }
3731}
3732final void TokenLexicalActions(Token matchedToken)
3733{
3734   switch(jjmatchedKind)
3735   {
3736      case 5 :
3737        if (image == null)
3738            image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
3739         else
3740            image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3741        if (!inComment)
3742            lparen++;
3743 
3744        /*
3745         * If in REFERENCE and we have seen the dot, then move
3746         * to REFMOD2 -> Modifier()
3747         */
3748 
3749        if (curLexState == REFMODIFIER )
3750            SwitchTo( REFMOD2 );
3751         break;
3752      case 6 :
3753        if (image == null)
3754            image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
3755         else
3756            image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3757       RPARENHandler();
3758         break;
3759      case 7 :
3760        if (image == null)
3761            image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
3762         else
3763            image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3764        /*
3765         * need to simply switch back to REFERENCE, not drop down the stack
3766         * because we can (infinitely) chain, ala
3767         * $foo.bar().blargh().woogie().doogie()
3768         */
3769 
3770        SwitchTo( REFERENCE );
3771         break;
3772      case 9 :
3773        if (image == null)
3774            image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
3775         else
3776            image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3777        if (! inComment)
3778        {
3779            inDirective = true;
3780 
3781            if ( debugPrint )
3782                System.out.print("#set :  going to " + DIRECTIVE );
3783 
3784            stateStackPush();
3785            inSet = true;
3786            SwitchTo(DIRECTIVE);
3787        }
3788 
3789        /*
3790         *  need the LPAREN action
3791         */
3792 
3793        if (!inComment)
3794        {
3795            lparen++;
3796 
3797            /*
3798             * If in REFERENCE and we have seen the dot, then move
3799             * to REFMOD2 -> Modifier()
3800             */
3801 
3802            if (curLexState == REFMODIFIER )
3803                SwitchTo( REFMOD2 );
3804        }
3805         break;
3806      case 19 :
3807        if (image == null)
3808            image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
3809         else
3810            image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3811     inComment = false;
3812     stateStackPop();
3813         break;
3814      case 20 :
3815        if (image == null)
3816            image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
3817         else
3818            image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3819    inComment = false;
3820    stateStackPop();
3821         break;
3822      case 21 :
3823        if (image == null)
3824            image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
3825         else
3826            image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3827    inComment = false;
3828    stateStackPop();
3829         break;
3830      case 24 :
3831        if (image == null)
3832            image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
3833         else
3834            image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3835        /*
3836         *  - if we are in DIRECTIVE and haven't seen ( yet, then also drop out.
3837         *      don't forget to account for the beloved yet wierd #set
3838         *  - finally, if we are in REFMOD2 (remember : $foo.bar( ) then " is ok!
3839         */
3840 
3841         if( curLexState == DIRECTIVE && !inSet && lparen == 0)
3842            stateStackPop();
3843         break;
3844      case 27 :
3845        if (image == null)
3846            image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
3847         else
3848            image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3849        if ( debugPrint )
3850            System.out.println(" NEWLINE :");
3851 
3852        stateStackPop();
3853 
3854        if (inSet)
3855            inSet = false;
3856 
3857        if (inDirective)
3858            inDirective = false;
3859         break;
3860      case 43 :
3861        if (image == null)
3862            image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
3863         else
3864            image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3865        inDirective = false;
3866        stateStackPop();
3867         break;
3868      case 44 :
3869        if (image == null)
3870            image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
3871         else
3872            image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3873        SwitchTo(DIRECTIVE);
3874         break;
3875      case 45 :
3876        if (image == null)
3877            image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
3878         else
3879            image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3880        SwitchTo(DIRECTIVE);
3881         break;
3882      case 46 :
3883        if (image == null)
3884            image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
3885         else
3886            image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3887        inDirective = false;
3888        stateStackPop();
3889         break;
3890      case 47 :
3891        if (image == null)
3892            image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
3893         else
3894            image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3895        matchedToken.kind = EOF;
3896        fileDepth = 0;
3897         break;
3898      case 49 :
3899        if (image == null)
3900            image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
3901         else
3902            image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3903        /*
3904         * check to see if we are in set
3905         *    ex.  #set $foo = $foo + 3
3906         *  because we want to handle the \n after
3907         */
3908 
3909        if ( lparen == 0 && !inSet && curLexState != REFMOD2)
3910        {
3911            stateStackPop();
3912        }
3913         break;
3914      case 57 :
3915        if (image == null)
3916            image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
3917         else
3918            image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3919        /*
3920         * push the alpha char back into the stream so the following identifier
3921         * is complete
3922         */
3923 
3924        input_stream.backup(1);
3925 
3926        /*
3927         * and munge the <DOT> so we just get a . when we have normal text that
3928         * looks like a ref.ident
3929         */
3930 
3931        matchedToken.image = ".";
3932 
3933        if ( debugPrint )
3934            System.out.print("DOT : switching to " + REFMODIFIER);
3935        SwitchTo(REFMODIFIER);
3936         break;
3937      case 59 :
3938        if (image == null)
3939            image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
3940         else
3941            image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3942        stateStackPop();
3943         break;
3944      default : 
3945         break;
3946   }
3947}
3948}

[all classes][org.apache.velocity.runtime.parser]
EMMA 2.0.4015 (stable) (C) Vladimir Roubtsov