001/* Generated By:JavaCC: Do not edit this line. MdxParserImplTokenManager.java */
002package mondrian.parser;
003import java.util.*;
004import java.io.StringReader;
005import java.math.BigDecimal;
006import mondrian.olap.*;
007import mondrian.mdx.*;
008import mondrian.parser.*;
009import mondrian.resource.MondrianResource;
010import mondrian.server.Statement;
011
012/** Token Manager. */
013public class MdxParserImplTokenManager implements MdxParserImplConstants
014{
015
016  /** Debug output. */
017  public  java.io.PrintStream debugStream = System.out;
018  /** Set debug output. */
019  public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
020private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1)
021{
022   switch (pos)
023   {
024      case 0:
025         if ((active0 & 0x2800000000000L) != 0L || (active1 & 0x100L) != 0L)
026            return 2;
027         if ((active0 & 0x800000000000000L) != 0L)
028            return 44;
029         if ((active0 & 0x1fffffffffeL) != 0L)
030         {
031            jjmatchedKind = 80;
032            return 15;
033         }
034         return -1;
035      case 1:
036         if ((active0 & 0x2000000000000L) != 0L)
037            return 0;
038         if ((active0 & 0xc0c0004L) != 0L)
039            return 15;
040         if ((active0 & 0x1fff3f3fffaL) != 0L)
041         {
042            jjmatchedKind = 80;
043            jjmatchedPos = 1;
044            return 15;
045         }
046         return -1;
047      case 2:
048         if ((active0 & 0x177f272dff8L) != 0L)
049         {
050            jjmatchedKind = 80;
051            jjmatchedPos = 2;
052            return 15;
053         }
054         if ((active0 & 0x8801812002L) != 0L)
055            return 15;
056         return -1;
057      case 3:
058         if ((active0 & 0x46d070d780L) != 0L)
059         {
060            jjmatchedKind = 80;
061            jjmatchedPos = 3;
062            return 15;
063         }
064         if ((active0 & 0x13122020878L) != 0L)
065            return 15;
066         return -1;
067      case 4:
068         if ((active0 & 0x4010001000L) != 0L)
069            return 15;
070         if ((active0 & 0x6c070c780L) != 0L)
071         {
072            jjmatchedKind = 80;
073            jjmatchedPos = 4;
074            return 15;
075         }
076         return -1;
077      case 5:
078         if ((active0 & 0x24030c780L) != 0L)
079         {
080            jjmatchedKind = 80;
081            jjmatchedPos = 5;
082            return 15;
083         }
084         if ((active0 & 0x480400000L) != 0L)
085            return 15;
086         return -1;
087      case 6:
088         if ((active0 & 0x240008680L) != 0L)
089         {
090            jjmatchedKind = 80;
091            jjmatchedPos = 6;
092            return 15;
093         }
094         if ((active0 & 0x304100L) != 0L)
095            return 15;
096         return -1;
097      case 7:
098         if ((active0 & 0x40008600L) != 0L)
099         {
100            jjmatchedKind = 80;
101            jjmatchedPos = 7;
102            return 15;
103         }
104         if ((active0 & 0x200000080L) != 0L)
105            return 15;
106         return -1;
107      case 8:
108         if ((active0 & 0x200L) != 0L)
109            return 15;
110         if ((active0 & 0x40008400L) != 0L)
111         {
112            jjmatchedKind = 80;
113            jjmatchedPos = 8;
114            return 15;
115         }
116         return -1;
117      case 9:
118         if ((active0 & 0x8400L) != 0L)
119         {
120            jjmatchedKind = 80;
121            jjmatchedPos = 9;
122            return 15;
123         }
124         if ((active0 & 0x40000000L) != 0L)
125            return 15;
126         return -1;
127      case 10:
128         if ((active0 & 0x8000L) != 0L)
129            return 15;
130         if ((active0 & 0x400L) != 0L)
131         {
132            jjmatchedKind = 80;
133            jjmatchedPos = 10;
134            return 15;
135         }
136         return -1;
137      default :
138         return -1;
139   }
140}
141private final int jjStartNfa_0(int pos, long active0, long active1)
142{
143   return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1);
144}
145private int jjStopAtPos(int pos, int kind)
146{
147   jjmatchedKind = kind;
148   jjmatchedPos = pos;
149   return pos + 1;
150}
151private int jjMoveStringLiteralDfa0_0()
152{
153   switch(curChar)
154   {
155      case 33:
156         return jjStopAtPos(0, 55);
157      case 40:
158         return jjStopAtPos(0, 65);
159      case 41:
160         return jjStopAtPos(0, 71);
161      case 42:
162         return jjStopAtPos(0, 54);
163      case 43:
164         return jjStopAtPos(0, 69);
165      case 44:
166         return jjStopAtPos(0, 57);
167      case 45:
168         jjmatchedKind = 67;
169         return jjMoveStringLiteralDfa1_0(0x1000000000000L, 0x0L);
170      case 46:
171         return jjStartNfaWithStates_0(0, 59, 44);
172      case 47:
173         jjmatchedKind = 72;
174         return jjMoveStringLiteralDfa1_0(0x2800000000000L, 0x0L);
175      case 58:
176         return jjStopAtPos(0, 56);
177      case 60:
178         jjmatchedKind = 66;
179         return jjMoveStringLiteralDfa1_0(0x0L, 0x11L);
180      case 61:
181         return jjStopAtPos(0, 60);
182      case 62:
183         jjmatchedKind = 62;
184         return jjMoveStringLiteralDfa1_0(0x2000000000000000L, 0x0L);
185      case 65:
186      case 97:
187         return jjMoveStringLiteralDfa1_0(0xeL, 0x0L);
188      case 67:
189      case 99:
190         return jjMoveStringLiteralDfa1_0(0x1f0L, 0x0L);
191      case 68:
192      case 100:
193         return jjMoveStringLiteralDfa1_0(0x600L, 0x0L);
194      case 69:
195      case 101:
196         return jjMoveStringLiteralDfa1_0(0x7800L, 0x0L);
197      case 70:
198      case 102:
199         return jjMoveStringLiteralDfa1_0(0x38000L, 0x0L);
200      case 73:
201      case 105:
202         return jjMoveStringLiteralDfa1_0(0xc0000L, 0x0L);
203      case 77:
204      case 109:
205         return jjMoveStringLiteralDfa1_0(0x700000L, 0x0L);
206      case 78:
207      case 110:
208         return jjMoveStringLiteralDfa1_0(0x3800000L, 0x0L);
209      case 79:
210      case 111:
211         return jjMoveStringLiteralDfa1_0(0xc000000L, 0x0L);
212      case 80:
213      case 112:
214         return jjMoveStringLiteralDfa1_0(0x70000000L, 0x0L);
215      case 82:
216      case 114:
217         return jjMoveStringLiteralDfa1_0(0x180000000L, 0x0L);
218      case 83:
219      case 115:
220         return jjMoveStringLiteralDfa1_0(0xe00000000L, 0x0L);
221      case 84:
222      case 116:
223         return jjMoveStringLiteralDfa1_0(0x1000000000L, 0x0L);
224      case 87:
225      case 119:
226         return jjMoveStringLiteralDfa1_0(0x16000000000L, 0x0L);
227      case 88:
228      case 120:
229         return jjMoveStringLiteralDfa1_0(0x8000000000L, 0x0L);
230      case 123:
231         return jjStopAtPos(0, 63);
232      case 124:
233         return jjMoveStringLiteralDfa1_0(0x400000000000000L, 0x0L);
234      case 125:
235         return jjStopAtPos(0, 70);
236      default :
237         return jjMoveNfa_0(3, 0);
238   }
239}
240private int jjMoveStringLiteralDfa1_0(long active0, long active1)
241{
242   try { curChar = input_stream.readChar(); }
243   catch(java.io.IOException e) {
244      jjStopStringLiteralDfa_0(0, active0, active1);
245      return 1;
246   }
247   switch(curChar)
248   {
249      case 42:
250         if ((active0 & 0x2000000000000L) != 0L)
251            return jjStartNfaWithStates_0(1, 49, 0);
252         break;
253      case 45:
254         if ((active0 & 0x1000000000000L) != 0L)
255            return jjStopAtPos(1, 48);
256         break;
257      case 47:
258         if ((active0 & 0x800000000000L) != 0L)
259            return jjStopAtPos(1, 47);
260         break;
261      case 61:
262         if ((active0 & 0x2000000000000000L) != 0L)
263            return jjStopAtPos(1, 61);
264         else if ((active1 & 0x1L) != 0L)
265            return jjStopAtPos(1, 64);
266         break;
267      case 62:
268         if ((active1 & 0x10L) != 0L)
269            return jjStopAtPos(1, 68);
270         break;
271      case 65:
272      case 97:
273         return jjMoveStringLiteralDfa2_0(active0, 0x10300030L, active1, 0L);
274      case 69:
275      case 101:
276         return jjMoveStringLiteralDfa2_0(active0, 0xe80400040L, active1, 0L);
277      case 72:
278      case 104:
279         return jjMoveStringLiteralDfa2_0(active0, 0x7000000080L, active1, 0L);
280      case 73:
281      case 105:
282         return jjMoveStringLiteralDfa2_0(active0, 0x10000008200L, active1, 0L);
283      case 76:
284      case 108:
285         return jjMoveStringLiteralDfa2_0(active0, 0x20000800L, active1, 0L);
286      case 77:
287      case 109:
288         return jjMoveStringLiteralDfa2_0(active0, 0x1000L, active1, 0L);
289      case 78:
290      case 110:
291         if ((active0 & 0x40000L) != 0L)
292            return jjStartNfaWithStates_0(1, 18, 15);
293         else if ((active0 & 0x4000000L) != 0L)
294            return jjStartNfaWithStates_0(1, 26, 15);
295         return jjMoveStringLiteralDfa2_0(active0, 0x2002L, active1, 0L);
296      case 79:
297      case 111:
298         return jjMoveStringLiteralDfa2_0(active0, 0x8101810100L, active1, 0L);
299      case 82:
300      case 114:
301         if ((active0 & 0x8000000L) != 0L)
302            return jjStartNfaWithStates_0(1, 27, 15);
303         return jjMoveStringLiteralDfa2_0(active0, 0x40020400L, active1, 0L);
304      case 83:
305      case 115:
306         if ((active0 & 0x4L) != 0L)
307            return jjStartNfaWithStates_0(1, 2, 15);
308         else if ((active0 & 0x80000L) != 0L)
309            return jjStartNfaWithStates_0(1, 19, 15);
310         break;
311      case 85:
312      case 117:
313         return jjMoveStringLiteralDfa2_0(active0, 0x2000000L, active1, 0L);
314      case 88:
315      case 120:
316         return jjMoveStringLiteralDfa2_0(active0, 0x4008L, active1, 0L);
317      case 124:
318         if ((active0 & 0x400000000000000L) != 0L)
319            return jjStopAtPos(1, 58);
320         break;
321      default :
322         break;
323   }
324   return jjStartNfa_0(0, active0, active1);
325}
326private int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long active1)
327{
328   if (((active0 &= old0) | (active1 &= old1)) == 0L)
329      return jjStartNfa_0(0, old0, old1);
330   try { curChar = input_stream.readChar(); }
331   catch(java.io.IOException e) {
332      jjStopStringLiteralDfa_0(1, active0, 0L);
333      return 2;
334   }
335   switch(curChar)
336   {
337      case 65:
338      case 97:
339         return jjMoveStringLiteralDfa3_0(active0, 0x20000080L);
340      case 67:
341      case 99:
342         return jjMoveStringLiteralDfa3_0(active0, 0x200000000L);
343      case 68:
344      case 100:
345         if ((active0 & 0x2L) != 0L)
346            return jjStartNfaWithStates_0(2, 1, 15);
347         else if ((active0 & 0x2000L) != 0L)
348            return jjStartNfaWithStates_0(2, 13, 15);
349         break;
350      case 69:
351      case 101:
352         return jjMoveStringLiteralDfa3_0(active0, 0x7000000000L);
353      case 71:
354      case 103:
355         return jjMoveStringLiteralDfa3_0(active0, 0x10000000L);
356      case 73:
357      case 105:
358         return jjMoveStringLiteralDfa3_0(active0, 0x408L);
359      case 76:
360      case 108:
361         return jjMoveStringLiteralDfa3_0(active0, 0x402000140L);
362      case 77:
363      case 109:
364         return jjMoveStringLiteralDfa3_0(active0, 0x400200L);
365      case 78:
366      case 110:
367         if ((active0 & 0x800000L) != 0L)
368            return jjStartNfaWithStates_0(2, 23, 15);
369         break;
370      case 79:
371      case 111:
372         return jjMoveStringLiteralDfa3_0(active0, 0x40020000L);
373      case 80:
374      case 112:
375         return jjMoveStringLiteralDfa3_0(active0, 0x5000L);
376      case 82:
377      case 114:
378         if ((active0 & 0x10000L) != 0L)
379            return jjStartNfaWithStates_0(2, 16, 15);
380         else if ((active0 & 0x8000000000L) != 0L)
381            return jjStartNfaWithStates_0(2, 39, 15);
382         return jjMoveStringLiteralDfa3_0(active0, 0x8000L);
383      case 83:
384      case 115:
385         return jjMoveStringLiteralDfa3_0(active0, 0x830L);
386      case 84:
387      case 116:
388         if ((active0 & 0x1000000L) != 0L)
389            return jjStartNfaWithStates_0(2, 24, 15);
390         else if ((active0 & 0x800000000L) != 0L)
391            return jjStartNfaWithStates_0(2, 35, 15);
392         return jjMoveStringLiteralDfa3_0(active0, 0x10080100000L);
393      case 87:
394      case 119:
395         return jjMoveStringLiteralDfa3_0(active0, 0x100000000L);
396      case 88:
397      case 120:
398         return jjMoveStringLiteralDfa3_0(active0, 0x200000L);
399      default :
400         break;
401   }
402   return jjStartNfa_0(1, active0, 0L);
403}
404private int jjMoveStringLiteralDfa3_0(long old0, long active0)
405{
406   if (((active0 &= old0)) == 0L)
407      return jjStartNfa_0(1, old0, 0L);
408   try { curChar = input_stream.readChar(); }
409   catch(java.io.IOException e) {
410      jjStopStringLiteralDfa_0(2, active0, 0L);
411      return 3;
412   }
413   switch(curChar)
414   {
415      case 66:
416      case 98:
417         return jjMoveStringLiteralDfa4_0(active0, 0x400000L);
418      case 67:
419      case 99:
420         return jjMoveStringLiteralDfa4_0(active0, 0x100000L);
421      case 69:
422      case 101:
423         if ((active0 & 0x10L) != 0L)
424            return jjStartNfaWithStates_0(3, 4, 15);
425         else if ((active0 & 0x800L) != 0L)
426            return jjStartNfaWithStates_0(3, 11, 15);
427         return jjMoveStringLiteralDfa4_0(active0, 0x410000200L);
428      case 72:
429      case 104:
430         if ((active0 & 0x10000000000L) != 0L)
431            return jjStartNfaWithStates_0(3, 40, 15);
432         break;
433      case 76:
434      case 108:
435         if ((active0 & 0x40L) != 0L)
436            return jjStartNfaWithStates_0(3, 6, 15);
437         else if ((active0 & 0x2000000L) != 0L)
438            return jjStartNfaWithStates_0(3, 25, 15);
439         return jjMoveStringLiteralDfa4_0(active0, 0x4400L);
440      case 77:
441      case 109:
442         if ((active0 & 0x20000L) != 0L)
443            return jjStartNfaWithStates_0(3, 17, 15);
444         break;
445      case 78:
446      case 110:
447         if ((active0 & 0x20000000L) != 0L)
448            return jjStartNfaWithStates_0(3, 29, 15);
449         else if ((active0 & 0x1000000000L) != 0L)
450            return jjStartNfaWithStates_0(3, 36, 15);
451         else if ((active0 & 0x2000000000L) != 0L)
452            return jjStartNfaWithStates_0(3, 37, 15);
453         break;
454      case 80:
455      case 112:
456         return jjMoveStringLiteralDfa4_0(active0, 0x40000080L);
457      case 82:
458      case 114:
459         return jjMoveStringLiteralDfa4_0(active0, 0x4000200000L);
460      case 83:
461      case 115:
462         if ((active0 & 0x8L) != 0L)
463            return jjStartNfaWithStates_0(3, 3, 15);
464         else if ((active0 & 0x100000000L) != 0L)
465            return jjStartNfaWithStates_0(3, 32, 15);
466         return jjMoveStringLiteralDfa4_0(active0, 0x8000L);
467      case 84:
468      case 116:
469         if ((active0 & 0x20L) != 0L)
470            return jjStartNfaWithStates_0(3, 5, 15);
471         return jjMoveStringLiteralDfa4_0(active0, 0x200001000L);
472      case 85:
473      case 117:
474         return jjMoveStringLiteralDfa4_0(active0, 0x80000100L);
475      default :
476         break;
477   }
478   return jjStartNfa_0(2, active0, 0L);
479}
480private int jjMoveStringLiteralDfa4_0(long old0, long active0)
481{
482   if (((active0 &= old0)) == 0L)
483      return jjStartNfa_0(2, old0, 0L);
484   try { curChar = input_stream.readChar(); }
485   catch(java.io.IOException e) {
486      jjStopStringLiteralDfa_0(3, active0, 0L);
487      return 4;
488   }
489   switch(curChar)
490   {
491      case 65:
492      case 97:
493         return jjMoveStringLiteralDfa5_0(active0, 0x4000L);
494      case 67:
495      case 99:
496         return jjMoveStringLiteralDfa5_0(active0, 0x400000000L);
497      case 69:
498      case 101:
499         if ((active0 & 0x4000000000L) != 0L)
500            return jjStartNfaWithStates_0(4, 38, 15);
501         return jjMoveStringLiteralDfa5_0(active0, 0x40400000L);
502      case 72:
503      case 104:
504         return jjMoveStringLiteralDfa5_0(active0, 0x100000L);
505      case 73:
506      case 105:
507         return jjMoveStringLiteralDfa5_0(active0, 0x200000000L);
508      case 76:
509      case 108:
510         return jjMoveStringLiteralDfa5_0(active0, 0x400L);
511      case 77:
512      case 109:
513         return jjMoveStringLiteralDfa5_0(active0, 0x100L);
514      case 78:
515      case 110:
516         return jjMoveStringLiteralDfa5_0(active0, 0x200L);
517      case 79:
518      case 111:
519         return jjMoveStringLiteralDfa5_0(active0, 0x200000L);
520      case 82:
521      case 114:
522         return jjMoveStringLiteralDfa5_0(active0, 0x80000000L);
523      case 83:
524      case 115:
525         if ((active0 & 0x10000000L) != 0L)
526            return jjStartNfaWithStates_0(4, 28, 15);
527         break;
528      case 84:
529      case 116:
530         return jjMoveStringLiteralDfa5_0(active0, 0x8080L);
531      case 89:
532      case 121:
533         if ((active0 & 0x1000L) != 0L)
534            return jjStartNfaWithStates_0(4, 12, 15);
535         break;
536      default :
537         break;
538   }
539   return jjStartNfa_0(3, active0, 0L);
540}
541private int jjMoveStringLiteralDfa5_0(long old0, long active0)
542{
543   if (((active0 &= old0)) == 0L)
544      return jjStartNfa_0(3, old0, 0L);
545   try { curChar = input_stream.readChar(); }
546   catch(java.io.IOException e) {
547      jjStopStringLiteralDfa_0(4, active0, 0L);
548      return 5;
549   }
550   switch(curChar)
551   {
552      case 69:
553      case 101:
554         return jjMoveStringLiteralDfa6_0(active0, 0x100080L);
555      case 73:
556      case 105:
557         return jjMoveStringLiteralDfa6_0(active0, 0x4000L);
558      case 78:
559      case 110:
560         if ((active0 & 0x80000000L) != 0L)
561            return jjStartNfaWithStates_0(5, 31, 15);
562         return jjMoveStringLiteralDfa6_0(active0, 0x100L);
563      case 79:
564      case 111:
565         return jjMoveStringLiteralDfa6_0(active0, 0x200000000L);
566      case 82:
567      case 114:
568         if ((active0 & 0x400000L) != 0L)
569            return jjStartNfaWithStates_0(5, 22, 15);
570         return jjMoveStringLiteralDfa6_0(active0, 0x40008000L);
571      case 83:
572      case 115:
573         return jjMoveStringLiteralDfa6_0(active0, 0x200L);
574      case 84:
575      case 116:
576         if ((active0 & 0x400000000L) != 0L)
577            return jjStartNfaWithStates_0(5, 34, 15);
578         return jjMoveStringLiteralDfa6_0(active0, 0x400L);
579      case 87:
580      case 119:
581         return jjMoveStringLiteralDfa6_0(active0, 0x200000L);
582      default :
583         break;
584   }
585   return jjStartNfa_0(4, active0, 0L);
586}
587private int jjMoveStringLiteralDfa6_0(long old0, long active0)
588{
589   if (((active0 &= old0)) == 0L)
590      return jjStartNfa_0(4, old0, 0L);
591   try { curChar = input_stream.readChar(); }
592   catch(java.io.IOException e) {
593      jjStopStringLiteralDfa_0(5, active0, 0L);
594      return 6;
595   }
596   switch(curChar)
597   {
598      case 72:
599      case 104:
600         return jjMoveStringLiteralDfa7_0(active0, 0x400L);
601      case 73:
602      case 105:
603         return jjMoveStringLiteralDfa7_0(active0, 0x200L);
604      case 78:
605      case 110:
606         if ((active0 & 0x4000L) != 0L)
607            return jjStartNfaWithStates_0(6, 14, 15);
608         return jjMoveStringLiteralDfa7_0(active0, 0x200000000L);
609      case 79:
610      case 111:
611         return jjMoveStringLiteralDfa7_0(active0, 0x8000L);
612      case 82:
613      case 114:
614         return jjMoveStringLiteralDfa7_0(active0, 0x80L);
615      case 83:
616      case 115:
617         if ((active0 & 0x100L) != 0L)
618            return jjStartNfaWithStates_0(6, 8, 15);
619         else if ((active0 & 0x100000L) != 0L)
620            return jjStartNfaWithStates_0(6, 20, 15);
621         else if ((active0 & 0x200000L) != 0L)
622            return jjStartNfaWithStates_0(6, 21, 15);
623         break;
624      case 84:
625      case 116:
626         return jjMoveStringLiteralDfa7_0(active0, 0x40000000L);
627      default :
628         break;
629   }
630   return jjStartNfa_0(5, active0, 0L);
631}
632private int jjMoveStringLiteralDfa7_0(long old0, long active0)
633{
634   if (((active0 &= old0)) == 0L)
635      return jjStartNfa_0(5, old0, 0L);
636   try { curChar = input_stream.readChar(); }
637   catch(java.io.IOException e) {
638      jjStopStringLiteralDfa_0(6, active0, 0L);
639      return 7;
640   }
641   switch(curChar)
642   {
643      case 73:
644      case 105:
645         return jjMoveStringLiteralDfa8_0(active0, 0x40000000L);
646      case 79:
647      case 111:
648         return jjMoveStringLiteralDfa8_0(active0, 0x200L);
649      case 82:
650      case 114:
651         return jjMoveStringLiteralDfa8_0(active0, 0x400L);
652      case 83:
653      case 115:
654         if ((active0 & 0x80L) != 0L)
655            return jjStartNfaWithStates_0(7, 7, 15);
656         else if ((active0 & 0x200000000L) != 0L)
657            return jjStartNfaWithStates_0(7, 33, 15);
658         break;
659      case 87:
660      case 119:
661         return jjMoveStringLiteralDfa8_0(active0, 0x8000L);
662      default :
663         break;
664   }
665   return jjStartNfa_0(6, active0, 0L);
666}
667private int jjMoveStringLiteralDfa8_0(long old0, long active0)
668{
669   if (((active0 &= old0)) == 0L)
670      return jjStartNfa_0(6, old0, 0L);
671   try { curChar = input_stream.readChar(); }
672   catch(java.io.IOException e) {
673      jjStopStringLiteralDfa_0(7, active0, 0L);
674      return 8;
675   }
676   switch(curChar)
677   {
678      case 69:
679      case 101:
680         return jjMoveStringLiteralDfa9_0(active0, 0x40000000L);
681      case 78:
682      case 110:
683         if ((active0 & 0x200L) != 0L)
684            return jjStartNfaWithStates_0(8, 9, 15);
685         break;
686      case 79:
687      case 111:
688         return jjMoveStringLiteralDfa9_0(active0, 0x400L);
689      case 83:
690      case 115:
691         return jjMoveStringLiteralDfa9_0(active0, 0x8000L);
692      default :
693         break;
694   }
695   return jjStartNfa_0(7, active0, 0L);
696}
697private int jjMoveStringLiteralDfa9_0(long old0, long active0)
698{
699   if (((active0 &= old0)) == 0L)
700      return jjStartNfa_0(7, old0, 0L);
701   try { curChar = input_stream.readChar(); }
702   catch(java.io.IOException e) {
703      jjStopStringLiteralDfa_0(8, active0, 0L);
704      return 9;
705   }
706   switch(curChar)
707   {
708      case 69:
709      case 101:
710         return jjMoveStringLiteralDfa10_0(active0, 0x8000L);
711      case 83:
712      case 115:
713         if ((active0 & 0x40000000L) != 0L)
714            return jjStartNfaWithStates_0(9, 30, 15);
715         break;
716      case 85:
717      case 117:
718         return jjMoveStringLiteralDfa10_0(active0, 0x400L);
719      default :
720         break;
721   }
722   return jjStartNfa_0(8, active0, 0L);
723}
724private int jjMoveStringLiteralDfa10_0(long old0, long active0)
725{
726   if (((active0 &= old0)) == 0L)
727      return jjStartNfa_0(8, old0, 0L);
728   try { curChar = input_stream.readChar(); }
729   catch(java.io.IOException e) {
730      jjStopStringLiteralDfa_0(9, active0, 0L);
731      return 10;
732   }
733   switch(curChar)
734   {
735      case 71:
736      case 103:
737         return jjMoveStringLiteralDfa11_0(active0, 0x400L);
738      case 84:
739      case 116:
740         if ((active0 & 0x8000L) != 0L)
741            return jjStartNfaWithStates_0(10, 15, 15);
742         break;
743      default :
744         break;
745   }
746   return jjStartNfa_0(9, active0, 0L);
747}
748private int jjMoveStringLiteralDfa11_0(long old0, long active0)
749{
750   if (((active0 &= old0)) == 0L)
751      return jjStartNfa_0(9, old0, 0L);
752   try { curChar = input_stream.readChar(); }
753   catch(java.io.IOException e) {
754      jjStopStringLiteralDfa_0(10, active0, 0L);
755      return 11;
756   }
757   switch(curChar)
758   {
759      case 72:
760      case 104:
761         if ((active0 & 0x400L) != 0L)
762            return jjStartNfaWithStates_0(11, 10, 15);
763         break;
764      default :
765         break;
766   }
767   return jjStartNfa_0(10, active0, 0L);
768}
769private int jjStartNfaWithStates_0(int pos, int kind, int state)
770{
771   jjmatchedKind = kind;
772   jjmatchedPos = pos;
773   try { curChar = input_stream.readChar(); }
774   catch(java.io.IOException e) { return pos + 1; }
775   return jjMoveNfa_0(state, pos + 1);
776}
777static final long[] jjbitVec0 = {
778   0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
779};
780static final long[] jjbitVec2 = {
781   0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
782};
783static final long[] jjbitVec3 = {
784   0x1ff00000fffffffeL, 0xffffffffffffc000L, 0xffffffffL, 0x600000000000000L
785};
786static final long[] jjbitVec4 = {
787   0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL
788};
789static final long[] jjbitVec5 = {
790   0x3fffffffffL, 0x0L, 0x0L, 0x0L
791};
792static final long[] jjbitVec6 = {
793   0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
794};
795static final long[] jjbitVec7 = {
796   0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffL, 0x0L
797};
798static final long[] jjbitVec8 = {
799   0xffffffffffffffffL, 0xffffffffffffffffL, 0x0L, 0x0L
800};
801static final long[] jjbitVec9 = {
802   0x3fffffffffffL, 0x0L, 0x0L, 0x0L
803};
804private int jjMoveNfa_0(int startState, int curPos)
805{
806   int startsAt = 0;
807   jjnewStateCnt = 44;
808   int i = 1;
809   jjstateSet[0] = startState;
810   int kind = 0x7fffffff;
811   for (;;)
812   {
813      if (++jjround == 0x7fffffff)
814         ReInitRounds();
815      if (curChar < 64)
816      {
817         long l = 1L << curChar;
818         do
819         {
820            switch(jjstateSet[--i])
821            {
822               case 3:
823                  if ((0x3ff000000000000L & l) != 0L)
824                  {
825                     if (kind > 73)
826                        kind = 73;
827                     jjCheckNAddStates(0, 6);
828                  }
829                  else if (curChar == 38)
830                     jjAddStates(7, 8);
831                  else if (curChar == 46)
832                     jjCheckNAddTwoStates(34, 35);
833                  else if (curChar == 36)
834                  {
835                     if (kind > 80)
836                        kind = 80;
837                     jjCheckNAdd(15);
838                  }
839                  else if (curChar == 34)
840                     jjCheckNAddStates(9, 11);
841                  else if (curChar == 39)
842                     jjCheckNAddStates(12, 14);
843                  else if (curChar == 47)
844                     jjstateSet[jjnewStateCnt++] = 2;
845                  break;
846               case 44:
847                  if ((0x3ff000000000000L & l) != 0L)
848                  {
849                     if (kind > 75)
850                        kind = 75;
851                     jjCheckNAdd(35);
852                  }
853                  if ((0x3ff000000000000L & l) != 0L)
854                     jjCheckNAddTwoStates(34, 24);
855                  break;
856               case 0:
857                  if (curChar == 42)
858                     jjstateSet[jjnewStateCnt++] = 1;
859                  break;
860               case 1:
861                  if ((0xffff7fffffffffffL & l) != 0L && kind > 46)
862                     kind = 46;
863                  break;
864               case 2:
865                  if (curChar == 42)
866                     jjstateSet[jjnewStateCnt++] = 0;
867                  break;
868               case 4:
869               case 6:
870                  if (curChar == 39)
871                     jjCheckNAddStates(12, 14);
872                  break;
873               case 5:
874                  if ((0xffffff7fffffffffL & l) != 0L)
875                     jjCheckNAddStates(12, 14);
876                  break;
877               case 7:
878                  if (curChar == 39)
879                     jjstateSet[jjnewStateCnt++] = 6;
880                  break;
881               case 8:
882                  if (curChar == 39 && kind > 77)
883                     kind = 77;
884                  break;
885               case 9:
886               case 11:
887                  if (curChar == 34)
888                     jjCheckNAddStates(9, 11);
889                  break;
890               case 10:
891                  if ((0xfffffffbffffffffL & l) != 0L)
892                     jjCheckNAddStates(9, 11);
893                  break;
894               case 12:
895                  if (curChar == 34)
896                     jjstateSet[jjnewStateCnt++] = 11;
897                  break;
898               case 13:
899                  if (curChar == 34 && kind > 78)
900                     kind = 78;
901                  break;
902               case 14:
903                  if (curChar != 36)
904                     break;
905                  if (kind > 80)
906                     kind = 80;
907                  jjCheckNAdd(15);
908                  break;
909               case 15:
910                  if ((0x3ff001000000000L & l) == 0L)
911                     break;
912                  if (kind > 80)
913                     kind = 80;
914                  jjCheckNAdd(15);
915                  break;
916               case 17:
917                  if ((0xffffffffffffdbffL & l) != 0L)
918                     jjAddStates(15, 17);
919                  break;
920               case 21:
921                  if ((0x3ff000000000000L & l) == 0L)
922                     break;
923                  if (kind > 73)
924                     kind = 73;
925                  jjCheckNAddStates(0, 6);
926                  break;
927               case 22:
928                  if ((0x3ff000000000000L & l) == 0L)
929                     break;
930                  if (kind > 73)
931                     kind = 73;
932                  jjCheckNAdd(22);
933                  break;
934               case 23:
935                  if ((0x3ff000000000000L & l) != 0L)
936                     jjCheckNAddTwoStates(23, 24);
937                  break;
938               case 25:
939                  if ((0x280000000000L & l) != 0L)
940                     jjCheckNAdd(26);
941                  break;
942               case 26:
943                  if ((0x3ff000000000000L & l) == 0L)
944                     break;
945                  if (kind > 74)
946                     kind = 74;
947                  jjCheckNAdd(26);
948                  break;
949               case 27:
950                  if (curChar == 46)
951                     jjCheckNAddTwoStates(28, 24);
952                  break;
953               case 28:
954                  if ((0x3ff000000000000L & l) != 0L)
955                     jjCheckNAddTwoStates(28, 24);
956                  break;
957               case 29:
958                  if (curChar != 46)
959                     break;
960                  if (kind > 75)
961                     kind = 75;
962                  jjCheckNAdd(30);
963                  break;
964               case 30:
965                  if ((0x3ff000000000000L & l) == 0L)
966                     break;
967                  if (kind > 75)
968                     kind = 75;
969                  jjCheckNAdd(30);
970                  break;
971               case 31:
972                  if ((0x3ff000000000000L & l) == 0L)
973                     break;
974                  if (kind > 75)
975                     kind = 75;
976                  jjCheckNAddStates(18, 20);
977                  break;
978               case 32:
979                  if ((0x3ff000000000000L & l) != 0L)
980                     jjCheckNAddStates(21, 24);
981                  break;
982               case 33:
983                  if (curChar == 46)
984                     jjCheckNAddTwoStates(34, 35);
985                  break;
986               case 34:
987                  if ((0x3ff000000000000L & l) != 0L)
988                     jjCheckNAddTwoStates(34, 24);
989                  break;
990               case 35:
991                  if ((0x3ff000000000000L & l) == 0L)
992                     break;
993                  if (kind > 75)
994                     kind = 75;
995                  jjCheckNAdd(35);
996                  break;
997               case 36:
998                  if (curChar == 38)
999                     jjAddStates(7, 8);
1000                  break;
1001               case 38:
1002                  if ((0xffffffffffffdbffL & l) != 0L)
1003                     jjAddStates(25, 27);
1004                  break;
1005               case 43:
1006                  if ((0x3ff001000000000L & l) == 0L)
1007                     break;
1008                  if (kind > 83)
1009                     kind = 83;
1010                  jjstateSet[jjnewStateCnt++] = 43;
1011                  break;
1012               default : break;
1013            }
1014         } while(i != startsAt);
1015      }
1016      else if (curChar < 128)
1017      {
1018         long l = 1L << (curChar & 077);
1019         do
1020         {
1021            switch(jjstateSet[--i])
1022            {
1023               case 3:
1024                  if ((0x7fffffe87fffffeL & l) != 0L)
1025                  {
1026                     if (kind > 80)
1027                        kind = 80;
1028                     jjCheckNAdd(15);
1029                  }
1030                  else if (curChar == 91)
1031                     jjCheckNAddStates(15, 17);
1032                  break;
1033               case 1:
1034                  if (kind > 46)
1035                     kind = 46;
1036                  break;
1037               case 5:
1038                  jjAddStates(12, 14);
1039                  break;
1040               case 10:
1041                  jjAddStates(9, 11);
1042                  break;
1043               case 14:
1044               case 15:
1045                  if ((0x7fffffe87fffffeL & l) == 0L)
1046                     break;
1047                  if (kind > 80)
1048                     kind = 80;
1049                  jjCheckNAdd(15);
1050                  break;
1051               case 16:
1052                  if (curChar == 91)
1053                     jjCheckNAddStates(15, 17);
1054                  break;
1055               case 17:
1056                  if ((0xffffffffdfffffffL & l) != 0L)
1057                     jjCheckNAddStates(15, 17);
1058                  break;
1059               case 18:
1060                  if (curChar == 93)
1061                     jjCheckNAddStates(15, 17);
1062                  break;
1063               case 19:
1064                  if (curChar == 93)
1065                     jjstateSet[jjnewStateCnt++] = 18;
1066                  break;
1067               case 20:
1068                  if (curChar == 93 && kind > 81)
1069                     kind = 81;
1070                  break;
1071               case 24:
1072                  if ((0x2000000020L & l) != 0L)
1073                     jjAddStates(28, 29);
1074                  break;
1075               case 37:
1076                  if (curChar == 91)
1077                     jjCheckNAddStates(25, 27);
1078                  break;
1079               case 38:
1080                  if ((0xffffffffdfffffffL & l) != 0L)
1081                     jjCheckNAddStates(25, 27);
1082                  break;
1083               case 39:
1084                  if (curChar == 93)
1085                     jjCheckNAddStates(25, 27);
1086                  break;
1087               case 40:
1088                  if (curChar == 93)
1089                     jjstateSet[jjnewStateCnt++] = 39;
1090                  break;
1091               case 41:
1092                  if (curChar == 93 && kind > 82)
1093                     kind = 82;
1094                  break;
1095               case 42:
1096                  if ((0x7fffffe07fffffeL & l) == 0L)
1097                     break;
1098                  if (kind > 83)
1099                     kind = 83;
1100                  jjCheckNAdd(43);
1101                  break;
1102               case 43:
1103                  if ((0x7fffffe87fffffeL & l) == 0L)
1104                     break;
1105                  if (kind > 83)
1106                     kind = 83;
1107                  jjCheckNAdd(43);
1108                  break;
1109               default : break;
1110            }
1111         } while(i != startsAt);
1112      }
1113      else
1114      {
1115         int hiByte = (int)(curChar >> 8);
1116         int i1 = hiByte >> 6;
1117         long l1 = 1L << (hiByte & 077);
1118         int i2 = (curChar & 0xff) >> 6;
1119         long l2 = 1L << (curChar & 077);
1120         do
1121         {
1122            switch(jjstateSet[--i])
1123            {
1124               case 3:
1125               case 15:
1126                  if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1127                     break;
1128                  if (kind > 80)
1129                     kind = 80;
1130                  jjCheckNAdd(15);
1131                  break;
1132               case 1:
1133                  if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 46)
1134                     kind = 46;
1135                  break;
1136               case 5:
1137                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1138                     jjAddStates(12, 14);
1139                  break;
1140               case 10:
1141                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1142                     jjAddStates(9, 11);
1143                  break;
1144               case 17:
1145                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1146                     jjAddStates(15, 17);
1147                  break;
1148               case 38:
1149                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1150                     jjAddStates(25, 27);
1151                  break;
1152               case 43:
1153                  if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1154                     break;
1155                  if (kind > 83)
1156                     kind = 83;
1157                  jjstateSet[jjnewStateCnt++] = 43;
1158                  break;
1159               default : break;
1160            }
1161         } while(i != startsAt);
1162      }
1163      if (kind != 0x7fffffff)
1164      {
1165         jjmatchedKind = kind;
1166         jjmatchedPos = curPos;
1167         kind = 0x7fffffff;
1168      }
1169      ++curPos;
1170      if ((i = jjnewStateCnt) == (startsAt = 44 - (jjnewStateCnt = startsAt)))
1171         return curPos;
1172      try { curChar = input_stream.readChar(); }
1173      catch(java.io.IOException e) { return curPos; }
1174   }
1175}
1176private int jjMoveStringLiteralDfa0_3()
1177{
1178   switch(curChar)
1179   {
1180      case 42:
1181         return jjMoveStringLiteralDfa1_3(0x10000000000000L);
1182      default :
1183         return 1;
1184   }
1185}
1186private int jjMoveStringLiteralDfa1_3(long active0)
1187{
1188   try { curChar = input_stream.readChar(); }
1189   catch(java.io.IOException e) {
1190      return 1;
1191   }
1192   switch(curChar)
1193   {
1194      case 47:
1195         if ((active0 & 0x10000000000000L) != 0L)
1196            return jjStopAtPos(1, 52);
1197         break;
1198      default :
1199         return 2;
1200   }
1201   return 2;
1202}
1203private int jjMoveStringLiteralDfa0_1()
1204{
1205   return jjMoveNfa_1(0, 0);
1206}
1207private int jjMoveNfa_1(int startState, int curPos)
1208{
1209   int startsAt = 0;
1210   jjnewStateCnt = 3;
1211   int i = 1;
1212   jjstateSet[0] = startState;
1213   int kind = 0x7fffffff;
1214   for (;;)
1215   {
1216      if (++jjround == 0x7fffffff)
1217         ReInitRounds();
1218      if (curChar < 64)
1219      {
1220         long l = 1L << curChar;
1221         do
1222         {
1223            switch(jjstateSet[--i])
1224            {
1225               case 0:
1226                  if ((0x2400L & l) != 0L)
1227                  {
1228                     if (kind > 50)
1229                        kind = 50;
1230                  }
1231                  if (curChar == 13)
1232                     jjstateSet[jjnewStateCnt++] = 1;
1233                  break;
1234               case 1:
1235                  if (curChar == 10 && kind > 50)
1236                     kind = 50;
1237                  break;
1238               case 2:
1239                  if (curChar == 13)
1240                     jjstateSet[jjnewStateCnt++] = 1;
1241                  break;
1242               default : break;
1243            }
1244         } while(i != startsAt);
1245      }
1246      else if (curChar < 128)
1247      {
1248         long l = 1L << (curChar & 077);
1249         do
1250         {
1251            switch(jjstateSet[--i])
1252            {
1253               default : break;
1254            }
1255         } while(i != startsAt);
1256      }
1257      else
1258      {
1259         int hiByte = (int)(curChar >> 8);
1260         int i1 = hiByte >> 6;
1261         long l1 = 1L << (hiByte & 077);
1262         int i2 = (curChar & 0xff) >> 6;
1263         long l2 = 1L << (curChar & 077);
1264         do
1265         {
1266            switch(jjstateSet[--i])
1267            {
1268               default : break;
1269            }
1270         } while(i != startsAt);
1271      }
1272      if (kind != 0x7fffffff)
1273      {
1274         jjmatchedKind = kind;
1275         jjmatchedPos = curPos;
1276         kind = 0x7fffffff;
1277      }
1278      ++curPos;
1279      if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
1280         return curPos;
1281      try { curChar = input_stream.readChar(); }
1282      catch(java.io.IOException e) { return curPos; }
1283   }
1284}
1285private int jjMoveStringLiteralDfa0_2()
1286{
1287   switch(curChar)
1288   {
1289      case 42:
1290         return jjMoveStringLiteralDfa1_2(0x8000000000000L);
1291      default :
1292         return 1;
1293   }
1294}
1295private int jjMoveStringLiteralDfa1_2(long active0)
1296{
1297   try { curChar = input_stream.readChar(); }
1298   catch(java.io.IOException e) {
1299      return 1;
1300   }
1301   switch(curChar)
1302   {
1303      case 47:
1304         if ((active0 & 0x8000000000000L) != 0L)
1305            return jjStopAtPos(1, 51);
1306         break;
1307      default :
1308         return 2;
1309   }
1310   return 2;
1311}
1312static final int[] jjnextStates = {
1313   22, 23, 27, 24, 29, 31, 32, 37, 42, 10, 12, 13, 5, 7, 8, 17, 
1314   19, 20, 29, 30, 31, 27, 28, 24, 32, 38, 40, 41, 25, 26, 
1315};
1316private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
1317{
1318   switch(hiByte)
1319   {
1320      case 0:
1321         return ((jjbitVec2[i2] & l2) != 0L);
1322      default :
1323         if ((jjbitVec0[i1] & l1) != 0L)
1324            return true;
1325         return false;
1326   }
1327}
1328private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2)
1329{
1330   switch(hiByte)
1331   {
1332      case 0:
1333         return ((jjbitVec4[i2] & l2) != 0L);
1334      case 45:
1335         return ((jjbitVec5[i2] & l2) != 0L);
1336      case 48:
1337         return ((jjbitVec6[i2] & l2) != 0L);
1338      case 49:
1339         return ((jjbitVec7[i2] & l2) != 0L);
1340      case 51:
1341         return ((jjbitVec8[i2] & l2) != 0L);
1342      case 61:
1343         return ((jjbitVec9[i2] & l2) != 0L);
1344      default :
1345         if ((jjbitVec3[i1] & l1) != 0L)
1346            return true;
1347         return false;
1348   }
1349}
1350
1351/** Token literal values. */
1352public static final String[] jjstrLiteralImages = {
1353"", null, null, null, null, null, null, null, null, null, null, null, null, 
1354null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
1355null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
1356null, null, null, null, null, null, null, null, null, null, null, null, null, "\52", 
1357"\41", "\72", "\54", "\174\174", "\56", "\75", "\76\75", "\76", "\173", "\74\75", 
1358"\50", "\74", "\55", "\74\76", "\53", "\175", "\51", "\57", null, null, null, null, 
1359null, null, null, null, null, null, null, null, null, };
1360
1361/** Lexer state names. */
1362public static final String[] lexStateNames = {
1363   "DEFAULT",
1364   "IN_SINGLE_LINE_COMMENT",
1365   "IN_FORMAL_COMMENT",
1366   "IN_MULTI_LINE_COMMENT",
1367};
1368
1369/** Lex State array. */
1370public static final int[] jjnewLexState = {
1371   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
1372   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2, 1, 1, 3, 
1373   0, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
1374   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
1375};
1376static final long[] jjtoToken = {
1377   0xffc001ffffffffffL, 0xf6fffL, 
1378};
1379static final long[] jjtoSkip = {
1380   0x1c3e0000000000L, 0x0L, 
1381};
1382static final long[] jjtoSpecial = {
1383   0x1c000000000000L, 0x0L, 
1384};
1385static final long[] jjtoMore = {
1386   0x23c00000000000L, 0x0L, 
1387};
1388protected SimpleCharStream input_stream;
1389private final int[] jjrounds = new int[44];
1390private final int[] jjstateSet = new int[88];
1391private final StringBuilder jjimage = new StringBuilder();
1392private StringBuilder image = jjimage;
1393private int jjimageLen;
1394private int lengthOfMatch;
1395protected char curChar;
1396/** Constructor. */
1397public MdxParserImplTokenManager(SimpleCharStream stream){
1398   if (SimpleCharStream.staticFlag)
1399      throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
1400   input_stream = stream;
1401}
1402
1403/** Constructor. */
1404public MdxParserImplTokenManager(SimpleCharStream stream, int lexState){
1405   this(stream);
1406   SwitchTo(lexState);
1407}
1408
1409/** Reinitialise parser. */
1410public void ReInit(SimpleCharStream stream)
1411{
1412   jjmatchedPos = jjnewStateCnt = 0;
1413   curLexState = defaultLexState;
1414   input_stream = stream;
1415   ReInitRounds();
1416}
1417private void ReInitRounds()
1418{
1419   int i;
1420   jjround = 0x80000001;
1421   for (i = 44; i-- > 0;)
1422      jjrounds[i] = 0x80000000;
1423}
1424
1425/** Reinitialise parser. */
1426public void ReInit(SimpleCharStream stream, int lexState)
1427{
1428   ReInit(stream);
1429   SwitchTo(lexState);
1430}
1431
1432/** Switch to specified lex state. */
1433public void SwitchTo(int lexState)
1434{
1435   if (lexState >= 4 || lexState < 0)
1436      throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
1437   else
1438      curLexState = lexState;
1439}
1440
1441protected Token jjFillToken()
1442{
1443   final Token t;
1444   final String curTokenImage;
1445   final int beginLine;
1446   final int endLine;
1447   final int beginColumn;
1448   final int endColumn;
1449   String im = jjstrLiteralImages[jjmatchedKind];
1450   curTokenImage = (im == null) ? input_stream.GetImage() : im;
1451   beginLine = input_stream.getBeginLine();
1452   beginColumn = input_stream.getBeginColumn();
1453   endLine = input_stream.getEndLine();
1454   endColumn = input_stream.getEndColumn();
1455   t = Token.newToken(jjmatchedKind, curTokenImage);
1456
1457   t.beginLine = beginLine;
1458   t.endLine = endLine;
1459   t.beginColumn = beginColumn;
1460   t.endColumn = endColumn;
1461
1462   return t;
1463}
1464
1465int curLexState = 0;
1466int defaultLexState = 0;
1467int jjnewStateCnt;
1468int jjround;
1469int jjmatchedPos;
1470int jjmatchedKind;
1471
1472/** Get the next Token. */
1473public Token getNextToken() 
1474{
1475  Token specialToken = null;
1476  Token matchedToken;
1477  int curPos = 0;
1478
1479  EOFLoop :
1480  for (;;)
1481  {
1482   try
1483   {
1484      curChar = input_stream.BeginToken();
1485   }
1486   catch(java.io.IOException e)
1487   {
1488      jjmatchedKind = 0;
1489      matchedToken = jjFillToken();
1490      matchedToken.specialToken = specialToken;
1491      return matchedToken;
1492   }
1493   image = jjimage;
1494   image.setLength(0);
1495   jjimageLen = 0;
1496
1497   for (;;)
1498   {
1499     switch(curLexState)
1500     {
1501       case 0:
1502         try { input_stream.backup(0);
1503            while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L)
1504               curChar = input_stream.BeginToken();
1505         }
1506         catch (java.io.IOException e1) { continue EOFLoop; }
1507         jjmatchedKind = 0x7fffffff;
1508         jjmatchedPos = 0;
1509         curPos = jjMoveStringLiteralDfa0_0();
1510         break;
1511       case 1:
1512         jjmatchedKind = 0x7fffffff;
1513         jjmatchedPos = 0;
1514         curPos = jjMoveStringLiteralDfa0_1();
1515         if (jjmatchedPos == 0 && jjmatchedKind > 53)
1516         {
1517            jjmatchedKind = 53;
1518         }
1519         break;
1520       case 2:
1521         jjmatchedKind = 0x7fffffff;
1522         jjmatchedPos = 0;
1523         curPos = jjMoveStringLiteralDfa0_2();
1524         if (jjmatchedPos == 0 && jjmatchedKind > 53)
1525         {
1526            jjmatchedKind = 53;
1527         }
1528         break;
1529       case 3:
1530         jjmatchedKind = 0x7fffffff;
1531         jjmatchedPos = 0;
1532         curPos = jjMoveStringLiteralDfa0_3();
1533         if (jjmatchedPos == 0 && jjmatchedKind > 53)
1534         {
1535            jjmatchedKind = 53;
1536         }
1537         break;
1538     }
1539     if (jjmatchedKind != 0x7fffffff)
1540     {
1541        if (jjmatchedPos + 1 < curPos)
1542           input_stream.backup(curPos - jjmatchedPos - 1);
1543        if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1544        {
1545           matchedToken = jjFillToken();
1546           matchedToken.specialToken = specialToken;
1547       if (jjnewLexState[jjmatchedKind] != -1)
1548         curLexState = jjnewLexState[jjmatchedKind];
1549           return matchedToken;
1550        }
1551        else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1552        {
1553           if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1554           {
1555              matchedToken = jjFillToken();
1556              if (specialToken == null)
1557                 specialToken = matchedToken;
1558              else
1559              {
1560                 matchedToken.specialToken = specialToken;
1561                 specialToken = (specialToken.next = matchedToken);
1562              }
1563              SkipLexicalActions(matchedToken);
1564           }
1565           else
1566              SkipLexicalActions(null);
1567         if (jjnewLexState[jjmatchedKind] != -1)
1568           curLexState = jjnewLexState[jjmatchedKind];
1569           continue EOFLoop;
1570        }
1571        jjimageLen += jjmatchedPos + 1;
1572      if (jjnewLexState[jjmatchedKind] != -1)
1573        curLexState = jjnewLexState[jjmatchedKind];
1574        curPos = 0;
1575        jjmatchedKind = 0x7fffffff;
1576        try {
1577           curChar = input_stream.readChar();
1578           continue;
1579        }
1580        catch (java.io.IOException e1) { }
1581     }
1582     int error_line = input_stream.getEndLine();
1583     int error_column = input_stream.getEndColumn();
1584     String error_after = null;
1585     boolean EOFSeen = false;
1586     try { input_stream.readChar(); input_stream.backup(1); }
1587     catch (java.io.IOException e1) {
1588        EOFSeen = true;
1589        error_after = curPos <= 1 ? "" : input_stream.GetImage();
1590        if (curChar == '\n' || curChar == '\r') {
1591           error_line++;
1592           error_column = 0;
1593        }
1594        else
1595           error_column++;
1596     }
1597     if (!EOFSeen) {
1598        input_stream.backup(1);
1599        error_after = curPos <= 1 ? "" : input_stream.GetImage();
1600     }
1601     throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
1602   }
1603  }
1604}
1605
1606void SkipLexicalActions(Token matchedToken)
1607{
1608   switch(jjmatchedKind)
1609   {
1610      default :
1611         break;
1612   }
1613}
1614private void jjCheckNAdd(int state)
1615{
1616   if (jjrounds[state] != jjround)
1617   {
1618      jjstateSet[jjnewStateCnt++] = state;
1619      jjrounds[state] = jjround;
1620   }
1621}
1622private void jjAddStates(int start, int end)
1623{
1624   do {
1625      jjstateSet[jjnewStateCnt++] = jjnextStates[start];
1626   } while (start++ != end);
1627}
1628private void jjCheckNAddTwoStates(int state1, int state2)
1629{
1630   jjCheckNAdd(state1);
1631   jjCheckNAdd(state2);
1632}
1633
1634private void jjCheckNAddStates(int start, int end)
1635{
1636   do {
1637      jjCheckNAdd(jjnextStates[start]);
1638   } while (start++ != end);
1639}
1640
1641}