1/*
2 * Copyright (c) 1999, 2014, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.  Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26/* Generated By:JavaCC: Do not edit this line. ExpressionParserTokenManager.java */
27package com.sun.tools.example.debug.expr;
28import com.sun.jdi.*;
29import java.util.Stack;
30import java.util.List;
31import java.util.ArrayList;
32
33/** Token Manager. */
34public class ExpressionParserTokenManager implements ExpressionParserConstants
35{
36
37  /** Debug output. */
38  public  java.io.PrintStream debugStream = System.out;
39  /** Set debug output. */
40  public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
41private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1)
42{
43   switch (pos)
44   {
45      case 0:
46         if ((active1 & 0x100200000000L) != 0L)
47            return 49;
48         if ((active1 & 0x4000L) != 0L)
49            return 4;
50         if ((active0 & 0x7fffffffffffe00L) != 0L)
51         {
52            jjmatchedKind = 67;
53            return 28;
54         }
55         return -1;
56      case 1:
57         if ((active0 & 0x40300000L) != 0L)
58            return 28;
59         if ((active0 & 0x7ffffffbfcffe00L) != 0L)
60         {
61            if (jjmatchedPos != 1)
62            {
63               jjmatchedKind = 67;
64               jjmatchedPos = 1;
65            }
66            return 28;
67         }
68         return -1;
69      case 2:
70         if ((active0 & 0x80004c10000000L) != 0L)
71            return 28;
72         if ((active0 & 0x77fffb3afeffe00L) != 0L)
73         {
74            if (jjmatchedPos != 2)
75            {
76               jjmatchedKind = 67;
77               jjmatchedPos = 2;
78            }
79            return 28;
80         }
81         return -1;
82      case 3:
83         if ((active0 & 0x63bff2b8faf4e00L) != 0L)
84         {
85            jjmatchedKind = 67;
86            jjmatchedPos = 3;
87            return 28;
88         }
89         if ((active0 & 0x14400902040b000L) != 0L)
90            return 28;
91         return -1;
92      case 4:
93         if ((active0 & 0x418a0000f034800L) != 0L)
94            return 28;
95         if ((active0 & 0x2235f2b80ac0600L) != 0L)
96         {
97            if (jjmatchedPos != 4)
98            {
99               jjmatchedKind = 67;
100               jjmatchedPos = 4;
101            }
102            return 28;
103         }
104         return -1;
105      case 5:
106         if ((active0 & 0x11582100200000L) != 0L)
107            return 28;
108         if ((active0 & 0x222070a848c0600L) != 0L)
109         {
110            jjmatchedKind = 67;
111            jjmatchedPos = 5;
112            return 28;
113         }
114         return -1;
115      case 6:
116         if ((active0 & 0x222040a80040200L) != 0L)
117         {
118            jjmatchedKind = 67;
119            jjmatchedPos = 6;
120            return 28;
121         }
122         if ((active0 & 0x30004880400L) != 0L)
123            return 28;
124         return -1;
125      case 7:
126         if ((active0 & 0x200000000040200L) != 0L)
127            return 28;
128         if ((active0 & 0x22040a80000000L) != 0L)
129         {
130            jjmatchedKind = 67;
131            jjmatchedPos = 7;
132            return 28;
133         }
134         return -1;
135      case 8:
136         if ((active0 & 0x20040800000000L) != 0L)
137            return 28;
138         if ((active0 & 0x2000280000000L) != 0L)
139         {
140            jjmatchedKind = 67;
141            jjmatchedPos = 8;
142            return 28;
143         }
144         return -1;
145      case 9:
146         if ((active0 & 0x2000000000000L) != 0L)
147         {
148            jjmatchedKind = 67;
149            jjmatchedPos = 9;
150            return 28;
151         }
152         if ((active0 & 0x280000000L) != 0L)
153            return 28;
154         return -1;
155      case 10:
156         if ((active0 & 0x2000000000000L) != 0L)
157         {
158            jjmatchedKind = 67;
159            jjmatchedPos = 10;
160            return 28;
161         }
162         return -1;
163      default :
164         return -1;
165   }
166}
167private final int jjStartNfa_0(int pos, long active0, long active1)
168{
169   return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1);
170}
171private int jjStopAtPos(int pos, int kind)
172{
173   jjmatchedKind = kind;
174   jjmatchedPos = pos;
175   return pos + 1;
176}
177private int jjMoveStringLiteralDfa0_0()
178{
179   switch(curChar)
180   {
181      case 33:
182         jjmatchedKind = 82;
183         return jjMoveStringLiteralDfa1_0(0x0L, 0x2000000L);
184      case 37:
185         jjmatchedKind = 101;
186         return jjMoveStringLiteralDfa1_0(0x0L, 0x1000000000000L);
187      case 38:
188         jjmatchedKind = 98;
189         return jjMoveStringLiteralDfa1_0(0x0L, 0x200008000000L);
190      case 40:
191         return jjStopAtPos(0, 70);
192      case 41:
193         return jjStopAtPos(0, 71);
194      case 42:
195         jjmatchedKind = 96;
196         return jjMoveStringLiteralDfa1_0(0x0L, 0x80000000000L);
197      case 43:
198         jjmatchedKind = 94;
199         return jjMoveStringLiteralDfa1_0(0x0L, 0x20010000000L);
200      case 44:
201         return jjStopAtPos(0, 77);
202      case 45:
203         jjmatchedKind = 95;
204         return jjMoveStringLiteralDfa1_0(0x0L, 0x40020000000L);
205      case 46:
206         return jjStartNfaWithStates_0(0, 78, 4);
207      case 47:
208         jjmatchedKind = 97;
209         return jjMoveStringLiteralDfa1_0(0x0L, 0x100000000000L);
210      case 58:
211         return jjStopAtPos(0, 85);
212      case 59:
213         return jjStopAtPos(0, 76);
214      case 60:
215         jjmatchedKind = 81;
216         return jjMoveStringLiteralDfa1_0(0x0L, 0x2004000800000L);
217      case 61:
218         jjmatchedKind = 79;
219         return jjMoveStringLiteralDfa1_0(0x0L, 0x400000L);
220      case 62:
221         jjmatchedKind = 80;
222         return jjMoveStringLiteralDfa1_0(0x0L, 0xc018001000000L);
223      case 63:
224         return jjStopAtPos(0, 84);
225      case 91:
226         return jjStopAtPos(0, 74);
227      case 93:
228         return jjStopAtPos(0, 75);
229      case 94:
230         jjmatchedKind = 100;
231         return jjMoveStringLiteralDfa1_0(0x0L, 0x800000000000L);
232      case 97:
233         return jjMoveStringLiteralDfa1_0(0x200L, 0x0L);
234      case 98:
235         return jjMoveStringLiteralDfa1_0(0x1c00L, 0x0L);
236      case 99:
237         return jjMoveStringLiteralDfa1_0(0x7e000L, 0x0L);
238      case 100:
239         return jjMoveStringLiteralDfa1_0(0x380000L, 0x0L);
240      case 101:
241         return jjMoveStringLiteralDfa1_0(0xc00000L, 0x0L);
242      case 102:
243         return jjMoveStringLiteralDfa1_0(0x1f000000L, 0x0L);
244      case 103:
245         return jjMoveStringLiteralDfa1_0(0x20000000L, 0x0L);
246      case 105:
247         return jjMoveStringLiteralDfa1_0(0xfc0000000L, 0x0L);
248      case 108:
249         return jjMoveStringLiteralDfa1_0(0x1000000000L, 0x0L);
250      case 110:
251         return jjMoveStringLiteralDfa1_0(0xe000000000L, 0x0L);
252      case 112:
253         return jjMoveStringLiteralDfa1_0(0xf0000000000L, 0x0L);
254      case 114:
255         return jjMoveStringLiteralDfa1_0(0x100000000000L, 0x0L);
256      case 115:
257         return jjMoveStringLiteralDfa1_0(0x3e00000000000L, 0x0L);
258      case 116:
259         return jjMoveStringLiteralDfa1_0(0xfc000000000000L, 0x0L);
260      case 118:
261         return jjMoveStringLiteralDfa1_0(0x300000000000000L, 0x0L);
262      case 119:
263         return jjMoveStringLiteralDfa1_0(0x400000000000000L, 0x0L);
264      case 123:
265         return jjStopAtPos(0, 72);
266      case 124:
267         jjmatchedKind = 99;
268         return jjMoveStringLiteralDfa1_0(0x0L, 0x400004000000L);
269      case 125:
270         return jjStopAtPos(0, 73);
271      case 126:
272         return jjStopAtPos(0, 83);
273      default :
274         return jjMoveNfa_0(0, 0);
275   }
276}
277private int jjMoveStringLiteralDfa1_0(long active0, long active1)
278{
279   try { curChar = input_stream.readChar(); }
280   catch(java.io.IOException e) {
281      jjStopStringLiteralDfa_0(0, active0, active1);
282      return 1;
283   }
284   switch(curChar)
285   {
286      case 38:
287         if ((active1 & 0x8000000L) != 0L)
288            return jjStopAtPos(1, 91);
289         break;
290      case 43:
291         if ((active1 & 0x10000000L) != 0L)
292            return jjStopAtPos(1, 92);
293         break;
294      case 45:
295         if ((active1 & 0x20000000L) != 0L)
296            return jjStopAtPos(1, 93);
297         break;
298      case 60:
299         if ((active1 & 0x4000000000L) != 0L)
300         {
301            jjmatchedKind = 102;
302            jjmatchedPos = 1;
303         }
304         return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x2000000000000L);
305      case 61:
306         if ((active1 & 0x400000L) != 0L)
307            return jjStopAtPos(1, 86);
308         else if ((active1 & 0x800000L) != 0L)
309            return jjStopAtPos(1, 87);
310         else if ((active1 & 0x1000000L) != 0L)
311            return jjStopAtPos(1, 88);
312         else if ((active1 & 0x2000000L) != 0L)
313            return jjStopAtPos(1, 89);
314         else if ((active1 & 0x20000000000L) != 0L)
315            return jjStopAtPos(1, 105);
316         else if ((active1 & 0x40000000000L) != 0L)
317            return jjStopAtPos(1, 106);
318         else if ((active1 & 0x80000000000L) != 0L)
319            return jjStopAtPos(1, 107);
320         else if ((active1 & 0x100000000000L) != 0L)
321            return jjStopAtPos(1, 108);
322         else if ((active1 & 0x200000000000L) != 0L)
323            return jjStopAtPos(1, 109);
324         else if ((active1 & 0x400000000000L) != 0L)
325            return jjStopAtPos(1, 110);
326         else if ((active1 & 0x800000000000L) != 0L)
327            return jjStopAtPos(1, 111);
328         else if ((active1 & 0x1000000000000L) != 0L)
329            return jjStopAtPos(1, 112);
330         break;
331      case 62:
332         if ((active1 & 0x8000000000L) != 0L)
333         {
334            jjmatchedKind = 103;
335            jjmatchedPos = 1;
336         }
337         return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0xc010000000000L);
338      case 97:
339         return jjMoveStringLiteralDfa2_0(active0, 0x12001006000L, active1, 0L);
340      case 98:
341         return jjMoveStringLiteralDfa2_0(active0, 0x200L, active1, 0L);
342      case 101:
343         return jjMoveStringLiteralDfa2_0(active0, 0x104000080000L, active1, 0L);
344      case 102:
345         if ((active0 & 0x40000000L) != 0L)
346            return jjStartNfaWithStates_0(1, 30, 28);
347         break;
348      case 104:
349         return jjMoveStringLiteralDfa2_0(active0, 0x41c200000008000L, active1, 0L);
350      case 105:
351         return jjMoveStringLiteralDfa2_0(active0, 0x6000000L, active1, 0L);
352      case 108:
353         return jjMoveStringLiteralDfa2_0(active0, 0x8410000L, active1, 0L);
354      case 109:
355         return jjMoveStringLiteralDfa2_0(active0, 0x180000000L, active1, 0L);
356      case 110:
357         return jjMoveStringLiteralDfa2_0(active0, 0xe00000000L, active1, 0L);
358      case 111:
359         if ((active0 & 0x100000L) != 0L)
360         {
361            jjmatchedKind = 20;
362            jjmatchedPos = 1;
363         }
364         return jjMoveStringLiteralDfa2_0(active0, 0x300001030260400L, active1, 0L);
365      case 114:
366         return jjMoveStringLiteralDfa2_0(active0, 0xe0060000000800L, active1, 0L);
367      case 116:
368         return jjMoveStringLiteralDfa2_0(active0, 0x400000000000L, active1, 0L);
369      case 117:
370         return jjMoveStringLiteralDfa2_0(active0, 0x888000000000L, active1, 0L);
371      case 119:
372         return jjMoveStringLiteralDfa2_0(active0, 0x1000000000000L, active1, 0L);
373      case 120:
374         return jjMoveStringLiteralDfa2_0(active0, 0x800000L, active1, 0L);
375      case 121:
376         return jjMoveStringLiteralDfa2_0(active0, 0x2000000001000L, active1, 0L);
377      case 124:
378         if ((active1 & 0x4000000L) != 0L)
379            return jjStopAtPos(1, 90);
380         break;
381      default :
382         break;
383   }
384   return jjStartNfa_0(0, active0, active1);
385}
386private int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long active1)
387{
388   if (((active0 &= old0) | (active1 &= old1)) == 0L)
389      return jjStartNfa_0(0, old0, old1);
390   try { curChar = input_stream.readChar(); }
391   catch(java.io.IOException e) {
392      jjStopStringLiteralDfa_0(1, active0, active1);
393      return 2;
394   }
395   switch(curChar)
396   {
397      case 61:
398         if ((active1 & 0x2000000000000L) != 0L)
399            return jjStopAtPos(2, 113);
400         else if ((active1 & 0x4000000000000L) != 0L)
401            return jjStopAtPos(2, 114);
402         break;
403      case 62:
404         if ((active1 & 0x10000000000L) != 0L)
405         {
406            jjmatchedKind = 104;
407            jjmatchedPos = 2;
408         }
409         return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x8000000000000L);
410      case 97:
411         return jjMoveStringLiteralDfa3_0(active0, 0x20400000018000L, active1, 0L);
412      case 98:
413         return jjMoveStringLiteralDfa3_0(active0, 0x80000000000L, active1, 0L);
414      case 99:
415         return jjMoveStringLiteralDfa3_0(active0, 0x10000000000L, active1, 0L);
416      case 101:
417         return jjMoveStringLiteralDfa3_0(active0, 0x800L, active1, 0L);
418      case 102:
419         return jjMoveStringLiteralDfa3_0(active0, 0x80000L, active1, 0L);
420      case 105:
421         return jjMoveStringLiteralDfa3_0(active0, 0x505020000000000L, active1, 0L);
422      case 108:
423         return jjMoveStringLiteralDfa3_0(active0, 0x200008001000000L, active1, 0L);
424      case 110:
425         return jjMoveStringLiteralDfa3_0(active0, 0x2001006060000L, active1, 0L);
426      case 111:
427         return jjMoveStringLiteralDfa3_0(active0, 0x240008000400L, active1, 0L);
428      case 112:
429         return jjMoveStringLiteralDfa3_0(active0, 0x800180000000L, active1, 0L);
430      case 114:
431         if ((active0 & 0x10000000L) != 0L)
432            return jjStartNfaWithStates_0(2, 28, 28);
433         return jjMoveStringLiteralDfa3_0(active0, 0x18000000000000L, active1, 0L);
434      case 115:
435         return jjMoveStringLiteralDfa3_0(active0, 0x200402200L, active1, 0L);
436      case 116:
437         if ((active0 & 0x400000000L) != 0L)
438         {
439            jjmatchedKind = 34;
440            jjmatchedPos = 2;
441         }
442         return jjMoveStringLiteralDfa3_0(active0, 0x102820805000L, active1, 0L);
443      case 117:
444         return jjMoveStringLiteralDfa3_0(active0, 0x40000000200000L, active1, 0L);
445      case 119:
446         if ((active0 & 0x4000000000L) != 0L)
447            return jjStartNfaWithStates_0(2, 38, 28);
448         break;
449      case 121:
450         if ((active0 & 0x80000000000000L) != 0L)
451            return jjStartNfaWithStates_0(2, 55, 28);
452         break;
453      default :
454         break;
455   }
456   return jjStartNfa_0(1, active0, active1);
457}
458private int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long active1)
459{
460   if (((active0 &= old0) | (active1 &= old1)) == 0L)
461      return jjStartNfa_0(1, old0, old1);
462   try { curChar = input_stream.readChar(); }
463   catch(java.io.IOException e) {
464      jjStopStringLiteralDfa_0(2, active0, active1);
465      return 3;
466   }
467   switch(curChar)
468   {
469      case 61:
470         if ((active1 & 0x8000000000000L) != 0L)
471            return jjStopAtPos(3, 115);
472         break;
473      case 97:
474         return jjMoveStringLiteralDfa4_0(active0, 0x20000000e080800L, active1, 0L);
475      case 98:
476         return jjMoveStringLiteralDfa4_0(active0, 0x200000L, active1, 0L);
477      case 99:
478         return jjMoveStringLiteralDfa4_0(active0, 0x2000000004000L, active1, 0L);
479      case 100:
480         if ((active0 & 0x100000000000000L) != 0L)
481            return jjStartNfaWithStates_0(3, 56, 28);
482         break;
483      case 101:
484         if ((active0 & 0x1000L) != 0L)
485            return jjStartNfaWithStates_0(3, 12, 28);
486         else if ((active0 & 0x2000L) != 0L)
487            return jjStartNfaWithStates_0(3, 13, 28);
488         else if ((active0 & 0x400000L) != 0L)
489            return jjStartNfaWithStates_0(3, 22, 28);
490         else if ((active0 & 0x40000000000000L) != 0L)
491            return jjStartNfaWithStates_0(3, 54, 28);
492         return jjMoveStringLiteralDfa4_0(active0, 0x800800800000L, active1, 0L);
493      case 103:
494         if ((active0 & 0x1000000000L) != 0L)
495            return jjStartNfaWithStates_0(3, 36, 28);
496         break;
497      case 105:
498         return jjMoveStringLiteralDfa4_0(active0, 0x2000000000L, active1, 0L);
499      case 107:
500         return jjMoveStringLiteralDfa4_0(active0, 0x10000000000L, active1, 0L);
501      case 108:
502         if ((active0 & 0x8000000000L) != 0L)
503            return jjStartNfaWithStates_0(3, 39, 28);
504         return jjMoveStringLiteralDfa4_0(active0, 0x400080080000400L, active1, 0L);
505      case 110:
506         return jjMoveStringLiteralDfa4_0(active0, 0x20000000000000L, active1, 0L);
507      case 111:
508         if ((active0 & 0x20000000L) != 0L)
509            return jjStartNfaWithStates_0(3, 29, 28);
510         return jjMoveStringLiteralDfa4_0(active0, 0x18000100000000L, active1, 0L);
511      case 114:
512         if ((active0 & 0x8000L) != 0L)
513            return jjStartNfaWithStates_0(3, 15, 28);
514         return jjMoveStringLiteralDfa4_0(active0, 0x200000000000L, active1, 0L);
515      case 115:
516         if ((active0 & 0x4000000000000L) != 0L)
517            return jjStartNfaWithStates_0(3, 50, 28);
518         return jjMoveStringLiteralDfa4_0(active0, 0x1030000L, active1, 0L);
519      case 116:
520         return jjMoveStringLiteralDfa4_0(active0, 0x1440200040200L, active1, 0L);
521      case 117:
522         return jjMoveStringLiteralDfa4_0(active0, 0x100000000000L, active1, 0L);
523      case 118:
524         return jjMoveStringLiteralDfa4_0(active0, 0x20000000000L, active1, 0L);
525      default :
526         break;
527   }
528   return jjStartNfa_0(2, active0, active1);
529}
530private int jjMoveStringLiteralDfa4_0(long old0, long active0, long old1, long active1)
531{
532   if (((active0 &= old0) | (active1 &= old1)) == 0L)
533      return jjStartNfa_0(2, old0, old1);
534   try { curChar = input_stream.readChar(); }
535   catch(java.io.IOException e) {
536      jjStopStringLiteralDfa_0(3, active0, 0L);
537      return 4;
538   }
539   switch(curChar)
540   {
541      case 97:
542         return jjMoveStringLiteralDfa5_0(active0, 0x30200000000L);
543      case 99:
544         return jjMoveStringLiteralDfa5_0(active0, 0x1000000000000L);
545      case 101:
546         if ((active0 & 0x1000000L) != 0L)
547            return jjStartNfaWithStates_0(4, 24, 28);
548         else if ((active0 & 0x400000000000000L) != 0L)
549            return jjStartNfaWithStates_0(4, 58, 28);
550         return jjMoveStringLiteralDfa5_0(active0, 0x40080000400L);
551      case 104:
552         if ((active0 & 0x4000L) != 0L)
553            return jjStartNfaWithStates_0(4, 14, 28);
554         return jjMoveStringLiteralDfa5_0(active0, 0x2000000000000L);
555      case 105:
556         return jjMoveStringLiteralDfa5_0(active0, 0x480000040000L);
557      case 107:
558         if ((active0 & 0x800L) != 0L)
559            return jjStartNfaWithStates_0(4, 11, 28);
560         break;
561      case 108:
562         if ((active0 & 0x2000000L) != 0L)
563         {
564            jjmatchedKind = 25;
565            jjmatchedPos = 4;
566         }
567         return jjMoveStringLiteralDfa5_0(active0, 0x4200000L);
568      case 110:
569         return jjMoveStringLiteralDfa5_0(active0, 0x800000L);
570      case 114:
571         if ((active0 & 0x800000000000L) != 0L)
572            return jjStartNfaWithStates_0(4, 47, 28);
573         return jjMoveStringLiteralDfa5_0(active0, 0x100900000200L);
574      case 115:
575         if ((active0 & 0x10000L) != 0L)
576            return jjStartNfaWithStates_0(4, 16, 28);
577         return jjMoveStringLiteralDfa5_0(active0, 0x20000000000000L);
578      case 116:
579         if ((active0 & 0x20000L) != 0L)
580            return jjStartNfaWithStates_0(4, 17, 28);
581         else if ((active0 & 0x8000000L) != 0L)
582            return jjStartNfaWithStates_0(4, 27, 28);
583         else if ((active0 & 0x200000000000L) != 0L)
584            return jjStartNfaWithStates_0(4, 45, 28);
585         return jjMoveStringLiteralDfa5_0(active0, 0x200000000000000L);
586      case 117:
587         return jjMoveStringLiteralDfa5_0(active0, 0x80000L);
588      case 118:
589         return jjMoveStringLiteralDfa5_0(active0, 0x2000000000L);
590      case 119:
591         if ((active0 & 0x8000000000000L) != 0L)
592         {
593            jjmatchedKind = 51;
594            jjmatchedPos = 4;
595         }
596         return jjMoveStringLiteralDfa5_0(active0, 0x10000000000000L);
597      default :
598         break;
599   }
600   return jjStartNfa_0(3, active0, 0L);
601}
602private int jjMoveStringLiteralDfa5_0(long old0, long active0)
603{
604   if (((active0 &= old0)) == 0L)
605      return jjStartNfa_0(3, old0, 0L);
606   try { curChar = input_stream.readChar(); }
607   catch(java.io.IOException e) {
608      jjStopStringLiteralDfa_0(4, active0, 0L);
609      return 5;
610   }
611   switch(curChar)
612   {
613      case 97:
614         return jjMoveStringLiteralDfa6_0(active0, 0x600L);
615      case 99:
616         if ((active0 & 0x80000000000L) != 0L)
617            return jjStartNfaWithStates_0(5, 43, 28);
618         else if ((active0 & 0x400000000000L) != 0L)
619            return jjStartNfaWithStates_0(5, 46, 28);
620         return jjMoveStringLiteralDfa6_0(active0, 0x40000000000L);
621      case 100:
622         return jjMoveStringLiteralDfa6_0(active0, 0x800000L);
623      case 101:
624         if ((active0 & 0x200000L) != 0L)
625            return jjStartNfaWithStates_0(5, 21, 28);
626         else if ((active0 & 0x2000000000L) != 0L)
627            return jjStartNfaWithStates_0(5, 37, 28);
628         break;
629      case 102:
630         return jjMoveStringLiteralDfa6_0(active0, 0x800000000L);
631      case 103:
632         return jjMoveStringLiteralDfa6_0(active0, 0x10000000000L);
633      case 104:
634         if ((active0 & 0x1000000000000L) != 0L)
635            return jjStartNfaWithStates_0(5, 48, 28);
636         break;
637      case 105:
638         return jjMoveStringLiteralDfa6_0(active0, 0x220000000000000L);
639      case 108:
640         return jjMoveStringLiteralDfa6_0(active0, 0x4080000L);
641      case 109:
642         return jjMoveStringLiteralDfa6_0(active0, 0x80000000L);
643      case 110:
644         if ((active0 & 0x100000000000L) != 0L)
645            return jjStartNfaWithStates_0(5, 44, 28);
646         return jjMoveStringLiteralDfa6_0(active0, 0x200040000L);
647      case 114:
648         return jjMoveStringLiteralDfa6_0(active0, 0x2000000000000L);
649      case 115:
650         if ((active0 & 0x10000000000000L) != 0L)
651            return jjStartNfaWithStates_0(5, 52, 28);
652         break;
653      case 116:
654         if ((active0 & 0x100000000L) != 0L)
655            return jjStartNfaWithStates_0(5, 32, 28);
656         return jjMoveStringLiteralDfa6_0(active0, 0x20000000000L);
657      default :
658         break;
659   }
660   return jjStartNfa_0(4, active0, 0L);
661}
662private int jjMoveStringLiteralDfa6_0(long old0, long active0)
663{
664   if (((active0 &= old0)) == 0L)
665      return jjStartNfa_0(4, old0, 0L);
666   try { curChar = input_stream.readChar(); }
667   catch(java.io.IOException e) {
668      jjStopStringLiteralDfa_0(5, active0, 0L);
669      return 6;
670   }
671   switch(curChar)
672   {
673      case 97:
674         return jjMoveStringLiteralDfa7_0(active0, 0x800000000L);
675      case 99:
676         return jjMoveStringLiteralDfa7_0(active0, 0x200000200L);
677      case 101:
678         if ((active0 & 0x10000000000L) != 0L)
679            return jjStartNfaWithStates_0(6, 40, 28);
680         else if ((active0 & 0x20000000000L) != 0L)
681            return jjStartNfaWithStates_0(6, 41, 28);
682         return jjMoveStringLiteralDfa7_0(active0, 0x20000080000000L);
683      case 108:
684         return jjMoveStringLiteralDfa7_0(active0, 0x200000000000000L);
685      case 110:
686         if ((active0 & 0x400L) != 0L)
687            return jjStartNfaWithStates_0(6, 10, 28);
688         break;
689      case 111:
690         return jjMoveStringLiteralDfa7_0(active0, 0x2000000000000L);
691      case 115:
692         if ((active0 & 0x800000L) != 0L)
693            return jjStartNfaWithStates_0(6, 23, 28);
694         break;
695      case 116:
696         if ((active0 & 0x80000L) != 0L)
697            return jjStartNfaWithStates_0(6, 19, 28);
698         return jjMoveStringLiteralDfa7_0(active0, 0x40000000000L);
699      case 117:
700         return jjMoveStringLiteralDfa7_0(active0, 0x40000L);
701      case 121:
702         if ((active0 & 0x4000000L) != 0L)
703            return jjStartNfaWithStates_0(6, 26, 28);
704         break;
705      default :
706         break;
707   }
708   return jjStartNfa_0(5, active0, 0L);
709}
710private int jjMoveStringLiteralDfa7_0(long old0, long active0)
711{
712   if (((active0 &= old0)) == 0L)
713      return jjStartNfa_0(5, old0, 0L);
714   try { curChar = input_stream.readChar(); }
715   catch(java.io.IOException e) {
716      jjStopStringLiteralDfa_0(6, active0, 0L);
717      return 7;
718   }
719   switch(curChar)
720   {
721      case 99:
722         return jjMoveStringLiteralDfa8_0(active0, 0x800000000L);
723      case 101:
724         if ((active0 & 0x40000L) != 0L)
725            return jjStartNfaWithStates_0(7, 18, 28);
726         else if ((active0 & 0x200000000000000L) != 0L)
727            return jjStartNfaWithStates_0(7, 57, 28);
728         return jjMoveStringLiteralDfa8_0(active0, 0x40200000000L);
729      case 110:
730         return jjMoveStringLiteralDfa8_0(active0, 0x22000080000000L);
731      case 116:
732         if ((active0 & 0x200L) != 0L)
733            return jjStartNfaWithStates_0(7, 9, 28);
734         break;
735      default :
736         break;
737   }
738   return jjStartNfa_0(6, active0, 0L);
739}
740private int jjMoveStringLiteralDfa8_0(long old0, long active0)
741{
742   if (((active0 &= old0)) == 0L)
743      return jjStartNfa_0(6, old0, 0L);
744   try { curChar = input_stream.readChar(); }
745   catch(java.io.IOException e) {
746      jjStopStringLiteralDfa_0(7, active0, 0L);
747      return 8;
748   }
749   switch(curChar)
750   {
751      case 100:
752         if ((active0 & 0x40000000000L) != 0L)
753            return jjStartNfaWithStates_0(8, 42, 28);
754         break;
755      case 101:
756         if ((active0 & 0x800000000L) != 0L)
757            return jjStartNfaWithStates_0(8, 35, 28);
758         break;
759      case 105:
760         return jjMoveStringLiteralDfa9_0(active0, 0x2000000000000L);
761      case 111:
762         return jjMoveStringLiteralDfa9_0(active0, 0x200000000L);
763      case 116:
764         if ((active0 & 0x20000000000000L) != 0L)
765            return jjStartNfaWithStates_0(8, 53, 28);
766         return jjMoveStringLiteralDfa9_0(active0, 0x80000000L);
767      default :
768         break;
769   }
770   return jjStartNfa_0(7, active0, 0L);
771}
772private int jjMoveStringLiteralDfa9_0(long old0, long active0)
773{
774   if (((active0 &= old0)) == 0L)
775      return jjStartNfa_0(7, old0, 0L);
776   try { curChar = input_stream.readChar(); }
777   catch(java.io.IOException e) {
778      jjStopStringLiteralDfa_0(8, active0, 0L);
779      return 9;
780   }
781   switch(curChar)
782   {
783      case 102:
784         if ((active0 & 0x200000000L) != 0L)
785            return jjStartNfaWithStates_0(9, 33, 28);
786         break;
787      case 115:
788         if ((active0 & 0x80000000L) != 0L)
789            return jjStartNfaWithStates_0(9, 31, 28);
790         break;
791      case 122:
792         return jjMoveStringLiteralDfa10_0(active0, 0x2000000000000L);
793      default :
794         break;
795   }
796   return jjStartNfa_0(8, active0, 0L);
797}
798private int jjMoveStringLiteralDfa10_0(long old0, long active0)
799{
800   if (((active0 &= old0)) == 0L)
801      return jjStartNfa_0(8, old0, 0L);
802   try { curChar = input_stream.readChar(); }
803   catch(java.io.IOException e) {
804      jjStopStringLiteralDfa_0(9, active0, 0L);
805      return 10;
806   }
807   switch(curChar)
808   {
809      case 101:
810         return jjMoveStringLiteralDfa11_0(active0, 0x2000000000000L);
811      default :
812         break;
813   }
814   return jjStartNfa_0(9, active0, 0L);
815}
816private int jjMoveStringLiteralDfa11_0(long old0, long active0)
817{
818   if (((active0 &= old0)) == 0L)
819      return jjStartNfa_0(9, old0, 0L);
820   try { curChar = input_stream.readChar(); }
821   catch(java.io.IOException e) {
822      jjStopStringLiteralDfa_0(10, active0, 0L);
823      return 11;
824   }
825   switch(curChar)
826   {
827      case 100:
828         if ((active0 & 0x2000000000000L) != 0L)
829            return jjStartNfaWithStates_0(11, 49, 28);
830         break;
831      default :
832         break;
833   }
834   return jjStartNfa_0(10, active0, 0L);
835}
836private int jjStartNfaWithStates_0(int pos, int kind, int state)
837{
838   jjmatchedKind = kind;
839   jjmatchedPos = pos;
840   try { curChar = input_stream.readChar(); }
841   catch(java.io.IOException e) { return pos + 1; }
842   return jjMoveNfa_0(state, pos + 1);
843}
844static final long[] jjbitVec0 = {
845   0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
846};
847static final long[] jjbitVec2 = {
848   0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
849};
850static final long[] jjbitVec3 = {
851   0x1ff00000fffffffeL, 0xffffffffffffc000L, 0xffffffffL, 0x600000000000000L
852};
853static final long[] jjbitVec4 = {
854   0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL
855};
856static final long[] jjbitVec5 = {
857   0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
858};
859static final long[] jjbitVec6 = {
860   0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffL, 0x0L
861};
862static final long[] jjbitVec7 = {
863   0xffffffffffffffffL, 0xffffffffffffffffL, 0x0L, 0x0L
864};
865static final long[] jjbitVec8 = {
866   0x3fffffffffffL, 0x0L, 0x0L, 0x0L
867};
868private int jjMoveNfa_0(int startState, int curPos)
869{
870   int startsAt = 0;
871   jjnewStateCnt = 67;
872   int i = 1;
873   jjstateSet[0] = startState;
874   int kind = 0x7fffffff;
875   for (;;)
876   {
877      if (++jjround == 0x7fffffff)
878         ReInitRounds();
879      if (curChar < 64)
880      {
881         long l = 1L << curChar;
882         do
883         {
884            switch(jjstateSet[--i])
885            {
886               case 49:
887                  if (curChar == 42)
888                     jjCheckNAddTwoStates(62, 63);
889                  else if (curChar == 47)
890                     jjCheckNAddStates(0, 2);
891                  if (curChar == 42)
892                     jjstateSet[jjnewStateCnt++] = 54;
893                  break;
894               case 0:
895                  if ((0x3ff000000000000L & l) != 0L)
896                     jjCheckNAddStates(3, 9);
897                  else if (curChar == 47)
898                     jjAddStates(10, 12);
899                  else if (curChar == 36)
900                  {
901                     if (kind > 67)
902                        kind = 67;
903                     jjCheckNAdd(28);
904                  }
905                  else if (curChar == 34)
906                     jjCheckNAddStates(13, 15);
907                  else if (curChar == 39)
908                     jjAddStates(16, 17);
909                  else if (curChar == 46)
910                     jjCheckNAdd(4);
911                  if ((0x3fe000000000000L & l) != 0L)
912                  {
913                     if (kind > 59)
914                        kind = 59;
915                     jjCheckNAddTwoStates(1, 2);
916                  }
917                  else if (curChar == 48)
918                  {
919                     if (kind > 59)
920                        kind = 59;
921                     jjCheckNAddStates(18, 20);
922                  }
923                  break;
924               case 1:
925                  if ((0x3ff000000000000L & l) == 0L)
926                     break;
927                  if (kind > 59)
928                     kind = 59;
929                  jjCheckNAddTwoStates(1, 2);
930                  break;
931               case 3:
932                  if (curChar == 46)
933                     jjCheckNAdd(4);
934                  break;
935               case 4:
936                  if ((0x3ff000000000000L & l) == 0L)
937                     break;
938                  if (kind > 63)
939                     kind = 63;
940                  jjCheckNAddStates(21, 23);
941                  break;
942               case 6:
943                  if ((0x280000000000L & l) != 0L)
944                     jjCheckNAdd(7);
945                  break;
946               case 7:
947                  if ((0x3ff000000000000L & l) == 0L)
948                     break;
949                  if (kind > 63)
950                     kind = 63;
951                  jjCheckNAddTwoStates(7, 8);
952                  break;
953               case 9:
954                  if (curChar == 39)
955                     jjAddStates(16, 17);
956                  break;
957               case 10:
958                  if ((0xffffff7fffffdbffL & l) != 0L)
959                     jjCheckNAdd(11);
960                  break;
961               case 11:
962                  if (curChar == 39 && kind > 65)
963                     kind = 65;
964                  break;
965               case 13:
966                  if ((0x8400000000L & l) != 0L)
967                     jjCheckNAdd(11);
968                  break;
969               case 14:
970                  if ((0xff000000000000L & l) != 0L)
971                     jjCheckNAddTwoStates(15, 11);
972                  break;
973               case 15:
974                  if ((0xff000000000000L & l) != 0L)
975                     jjCheckNAdd(11);
976                  break;
977               case 16:
978                  if ((0xf000000000000L & l) != 0L)
979                     jjstateSet[jjnewStateCnt++] = 17;
980                  break;
981               case 17:
982                  if ((0xff000000000000L & l) != 0L)
983                     jjCheckNAdd(15);
984                  break;
985               case 18:
986                  if (curChar == 34)
987                     jjCheckNAddStates(13, 15);
988                  break;
989               case 19:
990                  if ((0xfffffffbffffdbffL & l) != 0L)
991                     jjCheckNAddStates(13, 15);
992                  break;
993               case 21:
994                  if ((0x8400000000L & l) != 0L)
995                     jjCheckNAddStates(13, 15);
996                  break;
997               case 22:
998                  if (curChar == 34 && kind > 66)
999                     kind = 66;
1000                  break;
1001               case 23:
1002                  if ((0xff000000000000L & l) != 0L)
1003                     jjCheckNAddStates(24, 27);
1004                  break;
1005               case 24:
1006                  if ((0xff000000000000L & l) != 0L)
1007                     jjCheckNAddStates(13, 15);
1008                  break;
1009               case 25:
1010                  if ((0xf000000000000L & l) != 0L)
1011                     jjstateSet[jjnewStateCnt++] = 26;
1012                  break;
1013               case 26:
1014                  if ((0xff000000000000L & l) != 0L)
1015                     jjCheckNAdd(24);
1016                  break;
1017               case 27:
1018                  if (curChar != 36)
1019                     break;
1020                  if (kind > 67)
1021                     kind = 67;
1022                  jjCheckNAdd(28);
1023                  break;
1024               case 28:
1025                  if ((0x3ff001000000000L & l) == 0L)
1026                     break;
1027                  if (kind > 67)
1028                     kind = 67;
1029                  jjCheckNAdd(28);
1030                  break;
1031               case 29:
1032                  if ((0x3ff000000000000L & l) != 0L)
1033                     jjCheckNAddStates(3, 9);
1034                  break;
1035               case 30:
1036                  if ((0x3ff000000000000L & l) != 0L)
1037                     jjCheckNAddTwoStates(30, 31);
1038                  break;
1039               case 31:
1040                  if (curChar != 46)
1041                     break;
1042                  if (kind > 63)
1043                     kind = 63;
1044                  jjCheckNAddStates(28, 30);
1045                  break;
1046               case 32:
1047                  if ((0x3ff000000000000L & l) == 0L)
1048                     break;
1049                  if (kind > 63)
1050                     kind = 63;
1051                  jjCheckNAddStates(28, 30);
1052                  break;
1053               case 34:
1054                  if ((0x280000000000L & l) != 0L)
1055                     jjCheckNAdd(35);
1056                  break;
1057               case 35:
1058                  if ((0x3ff000000000000L & l) == 0L)
1059                     break;
1060                  if (kind > 63)
1061                     kind = 63;
1062                  jjCheckNAddTwoStates(35, 8);
1063                  break;
1064               case 36:
1065                  if ((0x3ff000000000000L & l) != 0L)
1066                     jjCheckNAddTwoStates(36, 37);
1067                  break;
1068               case 38:
1069                  if ((0x280000000000L & l) != 0L)
1070                     jjCheckNAdd(39);
1071                  break;
1072               case 39:
1073                  if ((0x3ff000000000000L & l) == 0L)
1074                     break;
1075                  if (kind > 63)
1076                     kind = 63;
1077                  jjCheckNAddTwoStates(39, 8);
1078                  break;
1079               case 40:
1080                  if ((0x3ff000000000000L & l) != 0L)
1081                     jjCheckNAddStates(31, 33);
1082                  break;
1083               case 42:
1084                  if ((0x280000000000L & l) != 0L)
1085                     jjCheckNAdd(43);
1086                  break;
1087               case 43:
1088                  if ((0x3ff000000000000L & l) != 0L)
1089                     jjCheckNAddTwoStates(43, 8);
1090                  break;
1091               case 44:
1092                  if (curChar != 48)
1093                     break;
1094                  if (kind > 59)
1095                     kind = 59;
1096                  jjCheckNAddStates(18, 20);
1097                  break;
1098               case 46:
1099                  if ((0x3ff000000000000L & l) == 0L)
1100                     break;
1101                  if (kind > 59)
1102                     kind = 59;
1103                  jjCheckNAddTwoStates(46, 2);
1104                  break;
1105               case 47:
1106                  if ((0xff000000000000L & l) == 0L)
1107                     break;
1108                  if (kind > 59)
1109                     kind = 59;
1110                  jjCheckNAddTwoStates(47, 2);
1111                  break;
1112               case 48:
1113                  if (curChar == 47)
1114                     jjAddStates(10, 12);
1115                  break;
1116               case 50:
1117                  if ((0xffffffffffffdbffL & l) != 0L)
1118                     jjCheckNAddStates(0, 2);
1119                  break;
1120               case 51:
1121                  if ((0x2400L & l) != 0L && kind > 6)
1122                     kind = 6;
1123                  break;
1124               case 52:
1125                  if (curChar == 10 && kind > 6)
1126                     kind = 6;
1127                  break;
1128               case 53:
1129                  if (curChar == 13)
1130                     jjstateSet[jjnewStateCnt++] = 52;
1131                  break;
1132               case 54:
1133                  if (curChar == 42)
1134                     jjCheckNAddTwoStates(55, 56);
1135                  break;
1136               case 55:
1137                  if ((0xfffffbffffffffffL & l) != 0L)
1138                     jjCheckNAddTwoStates(55, 56);
1139                  break;
1140               case 56:
1141                  if (curChar == 42)
1142                     jjCheckNAddStates(34, 36);
1143                  break;
1144               case 57:
1145                  if ((0xffff7bffffffffffL & l) != 0L)
1146                     jjCheckNAddTwoStates(58, 56);
1147                  break;
1148               case 58:
1149                  if ((0xfffffbffffffffffL & l) != 0L)
1150                     jjCheckNAddTwoStates(58, 56);
1151                  break;
1152               case 59:
1153                  if (curChar == 47 && kind > 7)
1154                     kind = 7;
1155                  break;
1156               case 60:
1157                  if (curChar == 42)
1158                     jjstateSet[jjnewStateCnt++] = 54;
1159                  break;
1160               case 61:
1161                  if (curChar == 42)
1162                     jjCheckNAddTwoStates(62, 63);
1163                  break;
1164               case 62:
1165                  if ((0xfffffbffffffffffL & l) != 0L)
1166                     jjCheckNAddTwoStates(62, 63);
1167                  break;
1168               case 63:
1169                  if (curChar == 42)
1170                     jjCheckNAddStates(37, 39);
1171                  break;
1172               case 64:
1173                  if ((0xffff7bffffffffffL & l) != 0L)
1174                     jjCheckNAddTwoStates(65, 63);
1175                  break;
1176               case 65:
1177                  if ((0xfffffbffffffffffL & l) != 0L)
1178                     jjCheckNAddTwoStates(65, 63);
1179                  break;
1180               case 66:
1181                  if (curChar == 47 && kind > 8)
1182                     kind = 8;
1183                  break;
1184               default : break;
1185            }
1186         } while(i != startsAt);
1187      }
1188      else if (curChar < 128)
1189      {
1190         long l = 1L << (curChar & 077);
1191         do
1192         {
1193            switch(jjstateSet[--i])
1194            {
1195               case 0:
1196               case 28:
1197                  if ((0x7fffffe87fffffeL & l) == 0L)
1198                     break;
1199                  if (kind > 67)
1200                     kind = 67;
1201                  jjCheckNAdd(28);
1202                  break;
1203               case 2:
1204                  if ((0x100000001000L & l) != 0L && kind > 59)
1205                     kind = 59;
1206                  break;
1207               case 5:
1208                  if ((0x2000000020L & l) != 0L)
1209                     jjAddStates(40, 41);
1210                  break;
1211               case 8:
1212                  if ((0x5000000050L & l) != 0L && kind > 63)
1213                     kind = 63;
1214                  break;
1215               case 10:
1216                  if ((0xffffffffefffffffL & l) != 0L)
1217                     jjCheckNAdd(11);
1218                  break;
1219               case 12:
1220                  if (curChar == 92)
1221                     jjAddStates(42, 44);
1222                  break;
1223               case 13:
1224                  if ((0x14404410000000L & l) != 0L)
1225                     jjCheckNAdd(11);
1226                  break;
1227               case 19:
1228                  if ((0xffffffffefffffffL & l) != 0L)
1229                     jjCheckNAddStates(13, 15);
1230                  break;
1231               case 20:
1232                  if (curChar == 92)
1233                     jjAddStates(45, 47);
1234                  break;
1235               case 21:
1236                  if ((0x14404410000000L & l) != 0L)
1237                     jjCheckNAddStates(13, 15);
1238                  break;
1239               case 33:
1240                  if ((0x2000000020L & l) != 0L)
1241                     jjAddStates(48, 49);
1242                  break;
1243               case 37:
1244                  if ((0x2000000020L & l) != 0L)
1245                     jjAddStates(50, 51);
1246                  break;
1247               case 41:
1248                  if ((0x2000000020L & l) != 0L)
1249                     jjAddStates(52, 53);
1250                  break;
1251               case 45:
1252                  if ((0x100000001000000L & l) != 0L)
1253                     jjCheckNAdd(46);
1254                  break;
1255               case 46:
1256                  if ((0x7e0000007eL & l) == 0L)
1257                     break;
1258                  if (kind > 59)
1259                     kind = 59;
1260                  jjCheckNAddTwoStates(46, 2);
1261                  break;
1262               case 50:
1263                  jjAddStates(0, 2);
1264                  break;
1265               case 55:
1266                  jjCheckNAddTwoStates(55, 56);
1267                  break;
1268               case 57:
1269               case 58:
1270                  jjCheckNAddTwoStates(58, 56);
1271                  break;
1272               case 62:
1273                  jjCheckNAddTwoStates(62, 63);
1274                  break;
1275               case 64:
1276               case 65:
1277                  jjCheckNAddTwoStates(65, 63);
1278                  break;
1279               default : break;
1280            }
1281         } while(i != startsAt);
1282      }
1283      else
1284      {
1285         int hiByte = (curChar >> 8);
1286         int i1 = hiByte >> 6;
1287         long l1 = 1L << (hiByte & 077);
1288         int i2 = (curChar & 0xff) >> 6;
1289         long l2 = 1L << (curChar & 077);
1290         do
1291         {
1292            switch(jjstateSet[--i])
1293            {
1294               case 0:
1295               case 28:
1296                  if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1297                     break;
1298                  if (kind > 67)
1299                     kind = 67;
1300                  jjCheckNAdd(28);
1301                  break;
1302               case 10:
1303                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1304                     jjstateSet[jjnewStateCnt++] = 11;
1305                  break;
1306               case 19:
1307                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1308                     jjAddStates(13, 15);
1309                  break;
1310               case 50:
1311                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1312                     jjAddStates(0, 2);
1313                  break;
1314               case 55:
1315                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1316                     jjCheckNAddTwoStates(55, 56);
1317                  break;
1318               case 57:
1319               case 58:
1320                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1321                     jjCheckNAddTwoStates(58, 56);
1322                  break;
1323               case 62:
1324                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1325                     jjCheckNAddTwoStates(62, 63);
1326                  break;
1327               case 64:
1328               case 65:
1329                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1330                     jjCheckNAddTwoStates(65, 63);
1331                  break;
1332               default : break;
1333            }
1334         } while(i != startsAt);
1335      }
1336      if (kind != 0x7fffffff)
1337      {
1338         jjmatchedKind = kind;
1339         jjmatchedPos = curPos;
1340         kind = 0x7fffffff;
1341      }
1342      ++curPos;
1343      if ((i = jjnewStateCnt) == (startsAt = 67 - (jjnewStateCnt = startsAt)))
1344         return curPos;
1345      try { curChar = input_stream.readChar(); }
1346      catch(java.io.IOException e) { return curPos; }
1347   }
1348}
1349static final int[] jjnextStates = {
1350   50, 51, 53, 30, 31, 36, 37, 40, 41, 8, 49, 60, 61, 19, 20, 22,
1351   10, 12, 45, 47, 2, 4, 5, 8, 19, 20, 24, 22, 32, 33, 8, 40,
1352   41, 8, 56, 57, 59, 63, 64, 66, 6, 7, 13, 14, 16, 21, 23, 25,
1353   34, 35, 38, 39, 42, 43,
1354};
1355private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
1356{
1357   switch(hiByte)
1358   {
1359      case 0:
1360         return ((jjbitVec2[i2] & l2) != 0L);
1361      default :
1362         if ((jjbitVec0[i1] & l1) != 0L)
1363            return true;
1364         return false;
1365   }
1366}
1367private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2)
1368{
1369   switch(hiByte)
1370   {
1371      case 0:
1372         return ((jjbitVec4[i2] & l2) != 0L);
1373      case 48:
1374         return ((jjbitVec5[i2] & l2) != 0L);
1375      case 49:
1376         return ((jjbitVec6[i2] & l2) != 0L);
1377      case 51:
1378         return ((jjbitVec7[i2] & l2) != 0L);
1379      case 61:
1380         return ((jjbitVec8[i2] & l2) != 0L);
1381      default :
1382         if ((jjbitVec3[i1] & l1) != 0L)
1383            return true;
1384         return false;
1385   }
1386}
1387
1388/** Token literal values. */
1389public static final String[] jjstrLiteralImages = {
1390"", null, null, null, null, null, null, null, null,
1391"\141\142\163\164\162\141\143\164", "\142\157\157\154\145\141\156", "\142\162\145\141\153", "\142\171\164\145",
1392"\143\141\163\145", "\143\141\164\143\150", "\143\150\141\162", "\143\154\141\163\163",
1393"\143\157\156\163\164", "\143\157\156\164\151\156\165\145", "\144\145\146\141\165\154\164",
1394"\144\157", "\144\157\165\142\154\145", "\145\154\163\145",
1395"\145\170\164\145\156\144\163", "\146\141\154\163\145", "\146\151\156\141\154",
1396"\146\151\156\141\154\154\171", "\146\154\157\141\164", "\146\157\162", "\147\157\164\157", "\151\146",
1397"\151\155\160\154\145\155\145\156\164\163", "\151\155\160\157\162\164", "\151\156\163\164\141\156\143\145\157\146",
1398"\151\156\164", "\151\156\164\145\162\146\141\143\145", "\154\157\156\147",
1399"\156\141\164\151\166\145", "\156\145\167", "\156\165\154\154", "\160\141\143\153\141\147\145",
1400"\160\162\151\166\141\164\145", "\160\162\157\164\145\143\164\145\144", "\160\165\142\154\151\143",
1401"\162\145\164\165\162\156", "\163\150\157\162\164", "\163\164\141\164\151\143", "\163\165\160\145\162",
1402"\163\167\151\164\143\150", "\163\171\156\143\150\162\157\156\151\172\145\144", "\164\150\151\163",
1403"\164\150\162\157\167", "\164\150\162\157\167\163", "\164\162\141\156\163\151\145\156\164",
1404"\164\162\165\145", "\164\162\171", "\166\157\151\144", "\166\157\154\141\164\151\154\145",
1405"\167\150\151\154\145", null, null, null, null, null, null, null, null, null, null, null, "\50",
1406"\51", "\173", "\175", "\133", "\135", "\73", "\54", "\56", "\75", "\76", "\74",
1407"\41", "\176", "\77", "\72", "\75\75", "\74\75", "\76\75", "\41\75", "\174\174",
1408"\46\46", "\53\53", "\55\55", "\53", "\55", "\52", "\57", "\46", "\174", "\136", "\45",
1409"\74\74", "\76\76", "\76\76\76", "\53\75", "\55\75", "\52\75", "\57\75", "\46\75",
1410"\174\75", "\136\75", "\45\75", "\74\74\75", "\76\76\75", "\76\76\76\75", };
1411
1412/** Lexer state names. */
1413public static final String[] lexStateNames = {
1414   "DEFAULT",
1415};
1416static final long[] jjtoToken = {
1417   0x8ffffffffffffe01L, 0xfffffffffffceL,
1418};
1419static final long[] jjtoSkip = {
1420   0x1feL, 0x0L,
1421};
1422static final long[] jjtoSpecial = {
1423   0x1c0L, 0x0L,
1424};
1425protected JavaCharStream input_stream;
1426private final int[] jjrounds = new int[67];
1427private final int[] jjstateSet = new int[134];
1428protected char curChar;
1429/** Constructor. */
1430public ExpressionParserTokenManager(JavaCharStream stream){
1431   if (JavaCharStream.staticFlag)
1432      throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
1433   input_stream = stream;
1434}
1435
1436/** Constructor. */
1437public ExpressionParserTokenManager(JavaCharStream stream, int lexState){
1438   this(stream);
1439   SwitchTo(lexState);
1440}
1441
1442/** Reinitialise parser. */
1443public void ReInit(JavaCharStream stream)
1444{
1445   jjmatchedPos = jjnewStateCnt = 0;
1446   curLexState = defaultLexState;
1447   input_stream = stream;
1448   ReInitRounds();
1449}
1450private void ReInitRounds()
1451{
1452   int i;
1453   jjround = 0x80000001;
1454   for (i = 67; i-- > 0;)
1455      jjrounds[i] = 0x80000000;
1456}
1457
1458/** Reinitialise parser. */
1459public void ReInit(JavaCharStream stream, int lexState)
1460{
1461   ReInit(stream);
1462   SwitchTo(lexState);
1463}
1464
1465/** Switch to specified lex state. */
1466public void SwitchTo(int lexState)
1467{
1468   if (lexState >= 1 || lexState < 0)
1469      throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
1470   else
1471      curLexState = lexState;
1472}
1473
1474protected Token jjFillToken()
1475{
1476   final Token t;
1477   final String curTokenImage;
1478   final int beginLine;
1479   final int endLine;
1480   final int beginColumn;
1481   final int endColumn;
1482   String im = jjstrLiteralImages[jjmatchedKind];
1483   curTokenImage = (im == null) ? input_stream.GetImage() : im;
1484   beginLine = input_stream.getBeginLine();
1485   beginColumn = input_stream.getBeginColumn();
1486   endLine = input_stream.getEndLine();
1487   endColumn = input_stream.getEndColumn();
1488   t = Token.newToken(jjmatchedKind, curTokenImage);
1489
1490   t.beginLine = beginLine;
1491   t.endLine = endLine;
1492   t.beginColumn = beginColumn;
1493   t.endColumn = endColumn;
1494
1495   return t;
1496}
1497
1498int curLexState = 0;
1499int defaultLexState = 0;
1500int jjnewStateCnt;
1501int jjround;
1502int jjmatchedPos;
1503int jjmatchedKind;
1504
1505/** Get the next Token. */
1506public Token getNextToken()
1507{
1508  Token specialToken = null;
1509  Token matchedToken;
1510  int curPos = 0;
1511
1512  EOFLoop :
1513  for (;;)
1514  {
1515   try
1516   {
1517      curChar = input_stream.BeginToken();
1518   }
1519   catch(java.io.IOException e)
1520   {
1521      jjmatchedKind = 0;
1522      matchedToken = jjFillToken();
1523      matchedToken.specialToken = specialToken;
1524      return matchedToken;
1525   }
1526
1527   try { input_stream.backup(0);
1528      while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L)
1529         curChar = input_stream.BeginToken();
1530   }
1531   catch (java.io.IOException e1) { continue EOFLoop; }
1532   jjmatchedKind = 0x7fffffff;
1533   jjmatchedPos = 0;
1534   curPos = jjMoveStringLiteralDfa0_0();
1535   if (jjmatchedKind != 0x7fffffff)
1536   {
1537      if (jjmatchedPos + 1 < curPos)
1538         input_stream.backup(curPos - jjmatchedPos - 1);
1539      if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1540      {
1541         matchedToken = jjFillToken();
1542         matchedToken.specialToken = specialToken;
1543         return matchedToken;
1544      }
1545      else
1546      {
1547         if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1548         {
1549            matchedToken = jjFillToken();
1550            if (specialToken == null)
1551               specialToken = matchedToken;
1552            else
1553            {
1554               matchedToken.specialToken = specialToken;
1555               specialToken = (specialToken.next = matchedToken);
1556            }
1557         }
1558         continue EOFLoop;
1559      }
1560   }
1561   int error_line = input_stream.getEndLine();
1562   int error_column = input_stream.getEndColumn();
1563   String error_after = null;
1564   boolean EOFSeen = false;
1565   try { input_stream.readChar(); input_stream.backup(1); }
1566   catch (java.io.IOException e1) {
1567      EOFSeen = true;
1568      error_after = curPos <= 1 ? "" : input_stream.GetImage();
1569      if (curChar == '\n' || curChar == '\r') {
1570         error_line++;
1571         error_column = 0;
1572      }
1573      else
1574         error_column++;
1575   }
1576   if (!EOFSeen) {
1577      input_stream.backup(1);
1578      error_after = curPos <= 1 ? "" : input_stream.GetImage();
1579   }
1580   throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
1581  }
1582}
1583
1584private void jjCheckNAdd(int state)
1585{
1586   if (jjrounds[state] != jjround)
1587   {
1588      jjstateSet[jjnewStateCnt++] = state;
1589      jjrounds[state] = jjround;
1590   }
1591}
1592private void jjAddStates(int start, int end)
1593{
1594   do {
1595      jjstateSet[jjnewStateCnt++] = jjnextStates[start];
1596   } while (start++ != end);
1597}
1598private void jjCheckNAddTwoStates(int state1, int state2)
1599{
1600   jjCheckNAdd(state1);
1601   jjCheckNAdd(state2);
1602}
1603
1604private void jjCheckNAddStates(int start, int end)
1605{
1606   do {
1607      jjCheckNAdd(jjnextStates[start]);
1608   } while (start++ != end);
1609}
1610
1611}
1612