KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > codehaus > aspectwerkz > expression > ast > ExpressionParserTokenManager


1 /* Generated By:JJTree&JavaCC: Do not edit this line. ExpressionParserTokenManager.java */
2 /**************************************************************************************
3  * Copyright (c) Jonas Bonér, Alexandre Vasseur. All rights reserved. *
4  * http://aspectwerkz.codehaus.org *
5  * ---------------------------------------------------------------------------------- *
6  * The software in this package is published under the terms of the LGPL license *
7  * a copy of which has been included with this distribution in the license.txt file. *
8  **************************************************************************************/

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