001/* Generated By:JavaCC: Do not edit this line. CParserTokenManager.java */
002
003package jtb.cparser;
004
005import java.util.*;
006import jtb.cparser.syntaxtree.*;
007import java.util.Vector;
008
009public class CParserTokenManager implements CParserConstants
010{
011private static final int jjStopStringLiteralDfa_0(int pos, long active0, long active1)
012{
013   switch (pos)
014   {
015      case 0:
016         if ((active0 & 0x7fffffff8000L) != 0L)
017         {
018            jjmatchedKind = 47;
019            return 28;
020         }
021         if ((active0 & 0x2000000000000000L) != 0L || (active1 & 0x40000000L) != 0L)
022            return 4;
023         if ((active0 & 0x8000000000000000L) != 0L || (active1 & 0x1000000L) != 0L)
024            return 49;
025         return -1;
026      case 1:
027         if ((active0 & 0x600000200000L) != 0L)
028            return 28;
029         if ((active0 & 0x1fffffdf8000L) != 0L)
030         {
031            if (jjmatchedPos != 1)
032            {
033               jjmatchedKind = 47;
034               jjmatchedPos = 1;
035            }
036            return 28;
037         }
038         return -1;
039      case 2:
040         if ((active0 & 0x180000000000L) != 0L)
041            return 28;
042         if ((active0 & 0x7ffffff8000L) != 0L)
043         {
044            jjmatchedKind = 47;
045            jjmatchedPos = 2;
046            return 28;
047         }
048         return -1;
049      case 3:
050         if ((active0 & 0x7f800000000L) != 0L)
051            return 28;
052         if ((active0 & 0x7ffff8000L) != 0L)
053         {
054            jjmatchedKind = 47;
055            jjmatchedPos = 3;
056            return 28;
057         }
058         return -1;
059      case 4:
060         if ((active0 & 0x1fff8000L) != 0L)
061         {
062            jjmatchedKind = 47;
063            jjmatchedPos = 4;
064            return 28;
065         }
066         if ((active0 & 0x7e0000000L) != 0L)
067            return 28;
068         return -1;
069      case 5:
070         if ((active0 & 0x1fe00000L) != 0L)
071            return 28;
072         if ((active0 & 0x1f8000L) != 0L)
073         {
074            jjmatchedKind = 47;
075            jjmatchedPos = 5;
076            return 28;
077         }
078         return -1;
079      case 6:
080         if ((active0 & 0x180000L) != 0L)
081            return 28;
082         if ((active0 & 0x78000L) != 0L)
083         {
084            jjmatchedKind = 47;
085            jjmatchedPos = 6;
086            return 28;
087         }
088         return -1;
089      default :
090         return -1;
091   }
092}
093private static final int jjStartNfa_0(int pos, long active0, long active1)
094{
095   return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1);
096}
097static private final int jjStopAtPos(int pos, int kind)
098{
099   jjmatchedKind = kind;
100   jjmatchedPos = pos;
101   return pos + 1;
102}
103static private final int jjStartNfaWithStates_0(int pos, int kind, int state)
104{
105   jjmatchedKind = kind;
106   jjmatchedPos = pos;
107   try { curChar = ASCII_CharStream.readChar(); }
108   catch(java.io.IOException e) { return pos + 1; }
109   return jjMoveNfa_0(state, pos + 1);
110}
111static private final int jjMoveStringLiteralDfa0_0()
112{
113   switch(curChar)
114   {
115      case 33:
116         jjmatchedKind = 93;
117         return jjMoveStringLiteralDfa1_0(0x0L, 0x8000L);
118      case 37:
119         jjmatchedKind = 89;
120         return jjMoveStringLiteralDfa1_0(0x0L, 0x1L);
121      case 38:
122         jjmatchedKind = 77;
123         return jjMoveStringLiteralDfa1_0(0x0L, 0x420L);
124      case 40:
125         return jjStopAtPos(0, 56);
126      case 41:
127         return jjStopAtPos(0, 57);
128      case 42:
129         jjmatchedKind = 60;
130         return jjMoveStringLiteralDfa1_0(0x4000000000000000L, 0x0L);
131      case 43:
132         jjmatchedKind = 86;
133         return jjMoveStringLiteralDfa1_0(0x0L, 0x4000002L);
134      case 44:
135         return jjStopAtPos(0, 53);
136      case 45:
137         jjmatchedKind = 87;
138         return jjMoveStringLiteralDfa1_0(0x0L, 0x88000004L);
139      case 46:
140         jjmatchedKind = 94;
141         return jjMoveStringLiteralDfa1_0(0x2000000000000000L, 0x0L);
142      case 47:
143         jjmatchedKind = 88;
144         return jjMoveStringLiteralDfa1_0(0x8000000000000000L, 0x0L);
145      case 58:
146         return jjStopAtPos(0, 55);
147      case 59:
148         return jjStopAtPos(0, 50);
149      case 60:
150         jjmatchedKind = 80;
151         return jjMoveStringLiteralDfa1_0(0x0L, 0x140008L);
152      case 61:
153         jjmatchedKind = 54;
154         return jjMoveStringLiteralDfa1_0(0x0L, 0x4000L);
155      case 62:
156         jjmatchedKind = 81;
157         return jjMoveStringLiteralDfa1_0(0x0L, 0x280010L);
158      case 63:
159         return jjStopAtPos(0, 72);
160      case 91:
161         return jjStopAtPos(0, 58);
162      case 93:
163         return jjStopAtPos(0, 59);
164      case 94:
165         jjmatchedKind = 76;
166         return jjMoveStringLiteralDfa1_0(0x0L, 0x40L);
167      case 97:
168         return jjMoveStringLiteralDfa1_0(0x8000000000L, 0x0L);
169      case 98:
170         return jjMoveStringLiteralDfa1_0(0x40000000L, 0x0L);
171      case 99:
172         return jjMoveStringLiteralDfa1_0(0x21100008000L, 0x0L);
173      case 100:
174         return jjMoveStringLiteralDfa1_0(0x400000300000L, 0x0L);
175      case 101:
176         return jjMoveStringLiteralDfa1_0(0x4802000000L, 0x0L);
177      case 102:
178         return jjMoveStringLiteralDfa1_0(0x80200000000L, 0x0L);
179      case 103:
180         return jjMoveStringLiteralDfa1_0(0x40000000000L, 0x0L);
181      case 105:
182         return jjMoveStringLiteralDfa1_0(0x300000000000L, 0x0L);
183      case 108:
184         return jjMoveStringLiteralDfa1_0(0x2000000000L, 0x0L);
185      case 114:
186         return jjMoveStringLiteralDfa1_0(0x1020000L, 0x0L);
187      case 115:
188         return jjMoveStringLiteralDfa1_0(0x41cc00000L, 0x0L);
189      case 116:
190         return jjMoveStringLiteralDfa1_0(0x80000L, 0x0L);
191      case 117:
192         return jjMoveStringLiteralDfa1_0(0x80040000L, 0x0L);
193      case 118:
194         return jjMoveStringLiteralDfa1_0(0x10000010000L, 0x0L);
195      case 119:
196         return jjMoveStringLiteralDfa1_0(0x20000000L, 0x0L);
197      case 123:
198         return jjStopAtPos(0, 51);
199      case 124:
200         jjmatchedKind = 75;
201         return jjMoveStringLiteralDfa1_0(0x0L, 0x280L);
202      case 125:
203         return jjStopAtPos(0, 52);
204      case 126:
205         return jjStopAtPos(0, 92);
206      default :
207         return jjMoveNfa_0(0, 0);
208   }
209}
210static private final int jjMoveStringLiteralDfa1_0(long active0, long active1)
211{
212   try { curChar = ASCII_CharStream.readChar(); }
213   catch(java.io.IOException e) {
214      jjStopStringLiteralDfa_0(0, active0, active1);
215      return 1;
216   }
217   switch(curChar)
218   {
219      case 38:
220         if ((active1 & 0x400L) != 0L)
221            return jjStopAtPos(1, 74);
222         break;
223      case 43:
224         if ((active1 & 0x4000000L) != 0L)
225            return jjStopAtPos(1, 90);
226         break;
227      case 45:
228         if ((active1 & 0x8000000L) != 0L)
229            return jjStopAtPos(1, 91);
230         break;
231      case 46:
232         return jjMoveStringLiteralDfa2_0(active0, 0x2000000000000000L, active1, 0L);
233      case 60:
234         if ((active1 & 0x100000L) != 0L)
235         {
236            jjmatchedKind = 84;
237            jjmatchedPos = 1;
238         }
239         return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x8L);
240      case 61:
241         if ((active0 & 0x4000000000000000L) != 0L)
242            return jjStopAtPos(1, 62);
243         else if ((active0 & 0x8000000000000000L) != 0L)
244            return jjStopAtPos(1, 63);
245         else if ((active1 & 0x1L) != 0L)
246            return jjStopAtPos(1, 64);
247         else if ((active1 & 0x2L) != 0L)
248            return jjStopAtPos(1, 65);
249         else if ((active1 & 0x4L) != 0L)
250            return jjStopAtPos(1, 66);
251         else if ((active1 & 0x20L) != 0L)
252            return jjStopAtPos(1, 69);
253         else if ((active1 & 0x40L) != 0L)
254            return jjStopAtPos(1, 70);
255         else if ((active1 & 0x80L) != 0L)
256            return jjStopAtPos(1, 71);
257         else if ((active1 & 0x4000L) != 0L)
258            return jjStopAtPos(1, 78);
259         else if ((active1 & 0x8000L) != 0L)
260            return jjStopAtPos(1, 79);
261         else if ((active1 & 0x40000L) != 0L)
262            return jjStopAtPos(1, 82);
263         else if ((active1 & 0x80000L) != 0L)
264            return jjStopAtPos(1, 83);
265         break;
266      case 62:
267         if ((active1 & 0x200000L) != 0L)
268         {
269            jjmatchedKind = 85;
270            jjmatchedPos = 1;
271         }
272         else if ((active1 & 0x80000000L) != 0L)
273            return jjStopAtPos(1, 95);
274         return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x10L);
275      case 97:
276         return jjMoveStringLiteralDfa2_0(active0, 0x1000000000L, active1, 0L);
277      case 101:
278         return jjMoveStringLiteralDfa2_0(active0, 0x1120000L, active1, 0L);
279      case 102:
280         if ((active0 & 0x200000000000L) != 0L)
281            return jjStartNfaWithStates_0(1, 45, 28);
282         break;
283      case 104:
284         return jjMoveStringLiteralDfa2_0(active0, 0x20420000000L, active1, 0L);
285      case 105:
286         return jjMoveStringLiteralDfa2_0(active0, 0x10400000L, active1, 0L);
287      case 108:
288         return jjMoveStringLiteralDfa2_0(active0, 0xa00000000L, active1, 0L);
289      case 110:
290         return jjMoveStringLiteralDfa2_0(active0, 0x104080040000L, active1, 0L);
291      case 111:
292         if ((active0 & 0x400000000000L) != 0L)
293         {
294            jjmatchedKind = 46;
295            jjmatchedPos = 1;
296         }
297         return jjMoveStringLiteralDfa2_0(active0, 0xd2100218000L, active1, 0L);
298      case 114:
299         return jjMoveStringLiteralDfa2_0(active0, 0x40000000L, active1, 0L);
300      case 116:
301         return jjMoveStringLiteralDfa2_0(active0, 0xc000000L, active1, 0L);
302      case 117:
303         return jjMoveStringLiteralDfa2_0(active0, 0x8000000000L, active1, 0L);
304      case 119:
305         return jjMoveStringLiteralDfa2_0(active0, 0x800000L, active1, 0L);
306      case 120:
307         return jjMoveStringLiteralDfa2_0(active0, 0x2000000L, active1, 0L);
308      case 121:
309         return jjMoveStringLiteralDfa2_0(active0, 0x80000L, active1, 0L);
310      case 124:
311         if ((active1 & 0x200L) != 0L)
312            return jjStopAtPos(1, 73);
313         break;
314      default :
315         break;
316   }
317   return jjStartNfa_0(0, active0, active1);
318}
319static private final int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long active1)
320{
321   if (((active0 &= old0) | (active1 &= old1)) == 0L)
322      return jjStartNfa_0(0, old0, old1);
323   try { curChar = ASCII_CharStream.readChar(); }
324   catch(java.io.IOException e) {
325      jjStopStringLiteralDfa_0(1, active0, active1);
326      return 2;
327   }
328   switch(curChar)
329   {
330      case 46:
331         if ((active0 & 0x2000000000000000L) != 0L)
332            return jjStopAtPos(2, 61);
333         break;
334      case 61:
335         if ((active1 & 0x8L) != 0L)
336            return jjStopAtPos(2, 67);
337         else if ((active1 & 0x10L) != 0L)
338            return jjStopAtPos(2, 68);
339         break;
340      case 97:
341         return jjMoveStringLiteralDfa3_0(active0, 0x20008000000L, active1, 0L);
342      case 101:
343         return jjMoveStringLiteralDfa3_0(active0, 0x40000000L, active1, 0L);
344      case 102:
345         return jjMoveStringLiteralDfa3_0(active0, 0x100000L, active1, 0L);
346      case 103:
347         return jjMoveStringLiteralDfa3_0(active0, 0x10020000L, active1, 0L);
348      case 105:
349         return jjMoveStringLiteralDfa3_0(active0, 0x100a0800000L, active1, 0L);
350      case 108:
351         return jjMoveStringLiteralDfa3_0(active0, 0x10000L, active1, 0L);
352      case 110:
353         return jjMoveStringLiteralDfa3_0(active0, 0x2100008000L, active1, 0L);
354      case 111:
355         return jjMoveStringLiteralDfa3_0(active0, 0x600000000L, active1, 0L);
356      case 112:
357         return jjMoveStringLiteralDfa3_0(active0, 0x80000L, active1, 0L);
358      case 114:
359         if ((active0 & 0x80000000000L) != 0L)
360            return jjStartNfaWithStates_0(2, 43, 28);
361         return jjMoveStringLiteralDfa3_0(active0, 0x4000000L, active1, 0L);
362      case 115:
363         return jjMoveStringLiteralDfa3_0(active0, 0x1800040000L, active1, 0L);
364      case 116:
365         if ((active0 & 0x100000000000L) != 0L)
366            return jjStartNfaWithStates_0(2, 44, 28);
367         return jjMoveStringLiteralDfa3_0(active0, 0x48003000000L, active1, 0L);
368      case 117:
369         return jjMoveStringLiteralDfa3_0(active0, 0x4000200000L, active1, 0L);
370      case 122:
371         return jjMoveStringLiteralDfa3_0(active0, 0x400000L, active1, 0L);
372      default :
373         break;
374   }
375   return jjStartNfa_0(1, active0, active1);
376}
377static private final int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long active1)
378{
379   if (((active0 &= old0) | (active1 &= old1)) == 0L)
380      return jjStartNfa_0(1, old0, old1);
381   try { curChar = ASCII_CharStream.readChar(); }
382   catch(java.io.IOException e) {
383      jjStopStringLiteralDfa_0(2, active0, 0L);
384      return 3;
385   }
386   switch(curChar)
387   {
388      case 97:
389         return jjMoveStringLiteralDfa4_0(active0, 0x240110000L);
390      case 98:
391         return jjMoveStringLiteralDfa4_0(active0, 0x200000L);
392      case 100:
393         if ((active0 & 0x10000000000L) != 0L)
394            return jjStartNfaWithStates_0(3, 40, 28);
395         break;
396      case 101:
397         if ((active0 & 0x800000000L) != 0L)
398            return jjStartNfaWithStates_0(3, 35, 28);
399         else if ((active0 & 0x1000000000L) != 0L)
400            return jjStartNfaWithStates_0(3, 36, 28);
401         return jjMoveStringLiteralDfa4_0(active0, 0x2480000L);
402      case 103:
403         if ((active0 & 0x2000000000L) != 0L)
404            return jjStartNfaWithStates_0(3, 37, 28);
405         break;
406      case 105:
407         return jjMoveStringLiteralDfa4_0(active0, 0x60000L);
408      case 108:
409         return jjMoveStringLiteralDfa4_0(active0, 0x20000000L);
410      case 109:
411         if ((active0 & 0x4000000000L) != 0L)
412            return jjStartNfaWithStates_0(3, 38, 28);
413         break;
414      case 110:
415         return jjMoveStringLiteralDfa4_0(active0, 0x10000000L);
416      case 111:
417         if ((active0 & 0x8000000000L) != 0L)
418            return jjStartNfaWithStates_0(3, 39, 28);
419         else if ((active0 & 0x40000000000L) != 0L)
420            return jjStartNfaWithStates_0(3, 42, 28);
421         return jjMoveStringLiteralDfa4_0(active0, 0x80000000L);
422      case 114:
423         if ((active0 & 0x20000000000L) != 0L)
424            return jjStartNfaWithStates_0(3, 41, 28);
425         return jjMoveStringLiteralDfa4_0(active0, 0x400000000L);
426      case 115:
427         return jjMoveStringLiteralDfa4_0(active0, 0x100000000L);
428      case 116:
429         return jjMoveStringLiteralDfa4_0(active0, 0x8808000L);
430      case 117:
431         return jjMoveStringLiteralDfa4_0(active0, 0x5000000L);
432      default :
433         break;
434   }
435   return jjStartNfa_0(2, active0, 0L);
436}
437static private final int jjMoveStringLiteralDfa4_0(long old0, long active0)
438{
439   if (((active0 &= old0)) == 0L)
440      return jjStartNfa_0(2, old0, 0L);
441   try { curChar = ASCII_CharStream.readChar(); }
442   catch(java.io.IOException e) {
443      jjStopStringLiteralDfa_0(3, active0, 0L);
444      return 4;
445   }
446   switch(curChar)
447   {
448      case 99:
449         return jjMoveStringLiteralDfa5_0(active0, 0x4800000L);
450      case 100:
451         return jjMoveStringLiteralDfa5_0(active0, 0x80000L);
452      case 101:
453         if ((active0 & 0x20000000L) != 0L)
454            return jjStartNfaWithStates_0(4, 29, 28);
455         return jjMoveStringLiteralDfa5_0(active0, 0x10000000L);
456      case 103:
457         return jjMoveStringLiteralDfa5_0(active0, 0x40000L);
458      case 105:
459         return jjMoveStringLiteralDfa5_0(active0, 0x8008000L);
460      case 107:
461         if ((active0 & 0x40000000L) != 0L)
462            return jjStartNfaWithStates_0(4, 30, 28);
463         break;
464      case 108:
465         return jjMoveStringLiteralDfa5_0(active0, 0x200000L);
466      case 110:
467         if ((active0 & 0x80000000L) != 0L)
468            return jjStartNfaWithStates_0(4, 31, 28);
469         break;
470      case 111:
471         return jjMoveStringLiteralDfa5_0(active0, 0x400000L);
472      case 114:
473         return jjMoveStringLiteralDfa5_0(active0, 0x3000000L);
474      case 115:
475         return jjMoveStringLiteralDfa5_0(active0, 0x20000L);
476      case 116:
477         if ((active0 & 0x100000000L) != 0L)
478            return jjStartNfaWithStates_0(4, 32, 28);
479         else if ((active0 & 0x200000000L) != 0L)
480            return jjStartNfaWithStates_0(4, 33, 28);
481         else if ((active0 & 0x400000000L) != 0L)
482            return jjStartNfaWithStates_0(4, 34, 28);
483         return jjMoveStringLiteralDfa5_0(active0, 0x10000L);
484      case 117:
485         return jjMoveStringLiteralDfa5_0(active0, 0x100000L);
486      default :
487         break;
488   }
489   return jjStartNfa_0(3, active0, 0L);
490}
491static private final int jjMoveStringLiteralDfa5_0(long old0, long active0)
492{
493   if (((active0 &= old0)) == 0L)
494      return jjStartNfa_0(3, old0, 0L);
495   try { curChar = ASCII_CharStream.readChar(); }
496   catch(java.io.IOException e) {
497      jjStopStringLiteralDfa_0(4, active0, 0L);
498      return 5;
499   }
500   switch(curChar)
501   {
502      case 99:
503         if ((active0 & 0x8000000L) != 0L)
504            return jjStartNfaWithStates_0(5, 27, 28);
505         break;
506      case 100:
507         if ((active0 & 0x10000000L) != 0L)
508            return jjStartNfaWithStates_0(5, 28, 28);
509         break;
510      case 101:
511         if ((active0 & 0x200000L) != 0L)
512            return jjStartNfaWithStates_0(5, 21, 28);
513         return jjMoveStringLiteralDfa6_0(active0, 0x80000L);
514      case 102:
515         if ((active0 & 0x400000L) != 0L)
516            return jjStartNfaWithStates_0(5, 22, 28);
517         break;
518      case 104:
519         if ((active0 & 0x800000L) != 0L)
520            return jjStartNfaWithStates_0(5, 23, 28);
521         break;
522      case 105:
523         return jjMoveStringLiteralDfa6_0(active0, 0x10000L);
524      case 108:
525         return jjMoveStringLiteralDfa6_0(active0, 0x100000L);
526      case 110:
527         if ((active0 & 0x1000000L) != 0L)
528            return jjStartNfaWithStates_0(5, 24, 28);
529         else if ((active0 & 0x2000000L) != 0L)
530            return jjStartNfaWithStates_0(5, 25, 28);
531         return jjMoveStringLiteralDfa6_0(active0, 0x48000L);
532      case 116:
533         if ((active0 & 0x4000000L) != 0L)
534            return jjStartNfaWithStates_0(5, 26, 28);
535         return jjMoveStringLiteralDfa6_0(active0, 0x20000L);
536      default :
537         break;
538   }
539   return jjStartNfa_0(4, active0, 0L);
540}
541static private final int jjMoveStringLiteralDfa6_0(long old0, long active0)
542{
543   if (((active0 &= old0)) == 0L)
544      return jjStartNfa_0(4, old0, 0L);
545   try { curChar = ASCII_CharStream.readChar(); }
546   catch(java.io.IOException e) {
547      jjStopStringLiteralDfa_0(5, active0, 0L);
548      return 6;
549   }
550   switch(curChar)
551   {
552      case 101:
553         return jjMoveStringLiteralDfa7_0(active0, 0x60000L);
554      case 102:
555         if ((active0 & 0x80000L) != 0L)
556            return jjStartNfaWithStates_0(6, 19, 28);
557         break;
558      case 108:
559         return jjMoveStringLiteralDfa7_0(active0, 0x10000L);
560      case 116:
561         if ((active0 & 0x100000L) != 0L)
562            return jjStartNfaWithStates_0(6, 20, 28);
563         break;
564      case 117:
565         return jjMoveStringLiteralDfa7_0(active0, 0x8000L);
566      default :
567         break;
568   }
569   return jjStartNfa_0(5, active0, 0L);
570}
571static private final int jjMoveStringLiteralDfa7_0(long old0, long active0)
572{
573   if (((active0 &= old0)) == 0L)
574      return jjStartNfa_0(5, old0, 0L);
575   try { curChar = ASCII_CharStream.readChar(); }
576   catch(java.io.IOException e) {
577      jjStopStringLiteralDfa_0(6, active0, 0L);
578      return 7;
579   }
580   switch(curChar)
581   {
582      case 100:
583         if ((active0 & 0x40000L) != 0L)
584            return jjStartNfaWithStates_0(7, 18, 28);
585         break;
586      case 101:
587         if ((active0 & 0x8000L) != 0L)
588            return jjStartNfaWithStates_0(7, 15, 28);
589         else if ((active0 & 0x10000L) != 0L)
590            return jjStartNfaWithStates_0(7, 16, 28);
591         break;
592      case 114:
593         if ((active0 & 0x20000L) != 0L)
594            return jjStartNfaWithStates_0(7, 17, 28);
595         break;
596      default :
597         break;
598   }
599   return jjStartNfa_0(6, active0, 0L);
600}
601static private final void jjCheckNAdd(int state)
602{
603   if (jjrounds[state] != jjround)
604   {
605      jjstateSet[jjnewStateCnt++] = state;
606      jjrounds[state] = jjround;
607   }
608}
609static private final void jjAddStates(int start, int end)
610{
611   do {
612      jjstateSet[jjnewStateCnt++] = jjnextStates[start];
613   } while (start++ != end);
614}
615static private final void jjCheckNAddTwoStates(int state1, int state2)
616{
617   jjCheckNAdd(state1);
618   jjCheckNAdd(state2);
619}
620static private final void jjCheckNAddStates(int start, int end)
621{
622   do {
623      jjCheckNAdd(jjnextStates[start]);
624   } while (start++ != end);
625}
626static private final void jjCheckNAddStates(int start)
627{
628   jjCheckNAdd(jjnextStates[start]);
629   jjCheckNAdd(jjnextStates[start + 1]);
630}
631static final long[] jjbitVec0 = {
632   0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
633};
634static private final int jjMoveNfa_0(int startState, int curPos)
635{
636   int[] nextStates;
637   int startsAt = 0;
638   jjnewStateCnt = 60;
639   int i = 1;
640   jjstateSet[0] = startState;
641   int j, kind = 0x7fffffff;
642   for (;;)
643   {
644      if (++jjround == 0x7fffffff)
645         ReInitRounds();
646      if (curChar < 64)
647      {
648         long l = 1L << curChar;
649         MatchLoop: do
650         {
651            switch(jjstateSet[--i])
652            {
653               case 49:
654                  if (curChar == 42)
655                     jjCheckNAddTwoStates(55, 56);
656                  else if (curChar == 47)
657                     jjCheckNAddStates(0, 2);
658                  break;
659               case 0:
660                  if ((0x3ff000000000000L & l) != 0L)
661                     jjCheckNAddStates(3, 9);
662                  else if (curChar == 47)
663                     jjAddStates(10, 11);
664                  else if (curChar == 36)
665                  {
666                     if (kind > 47)
667                        kind = 47;
668                     jjCheckNAdd(28);
669                  }
670                  else if (curChar == 34)
671                     jjCheckNAddStates(12, 14);
672                  else if (curChar == 39)
673                     jjAddStates(15, 16);
674                  else if (curChar == 46)
675                     jjCheckNAdd(4);
676                  if ((0x3fe000000000000L & l) != 0L)
677                  {
678                     if (kind > 7)
679                        kind = 7;
680                     jjCheckNAddTwoStates(1, 2);
681                  }
682                  else if (curChar == 48)
683                  {
684                     if (kind > 7)
685                        kind = 7;
686                     jjCheckNAddStates(17, 19);
687                  }
688                  break;
689               case 1:
690                  if ((0x3ff000000000000L & l) == 0L)
691                     break;
692                  if (kind > 7)
693                     kind = 7;
694                  jjCheckNAddTwoStates(1, 2);
695                  break;
696               case 3:
697                  if (curChar == 46)
698                     jjCheckNAdd(4);
699                  break;
700               case 4:
701                  if ((0x3ff000000000000L & l) == 0L)
702                     break;
703                  if (kind > 11)
704                     kind = 11;
705                  jjCheckNAddStates(20, 22);
706                  break;
707               case 6:
708                  if ((0x280000000000L & l) != 0L)
709                     jjCheckNAdd(7);
710                  break;
711               case 7:
712                  if ((0x3ff000000000000L & l) == 0L)
713                     break;
714                  if (kind > 11)
715                     kind = 11;
716                  jjCheckNAddTwoStates(7, 8);
717                  break;
718               case 9:
719                  if (curChar == 39)
720                     jjAddStates(15, 16);
721                  break;
722               case 10:
723                  if ((0xffffff7fffffdbffL & l) != 0L)
724                     jjCheckNAdd(11);
725                  break;
726               case 11:
727                  if (curChar == 39 && kind > 13)
728                     kind = 13;
729                  break;
730               case 13:
731                  if ((0x8400000000L & l) != 0L)
732                     jjCheckNAdd(11);
733                  break;
734               case 14:
735                  if ((0xff000000000000L & l) != 0L)
736                     jjCheckNAddTwoStates(15, 11);
737                  break;
738               case 15:
739                  if ((0xff000000000000L & l) != 0L)
740                     jjCheckNAdd(11);
741                  break;
742               case 16:
743                  if ((0xf000000000000L & l) != 0L)
744                     jjstateSet[jjnewStateCnt++] = 17;
745                  break;
746               case 17:
747                  if ((0xff000000000000L & l) != 0L)
748                     jjCheckNAdd(15);
749                  break;
750               case 18:
751                  if (curChar == 34)
752                     jjCheckNAddStates(12, 14);
753                  break;
754               case 19:
755                  if ((0xfffffffbffffdbffL & l) != 0L)
756                     jjCheckNAddStates(12, 14);
757                  break;
758               case 21:
759                  if ((0x8400000000L & l) != 0L)
760                     jjCheckNAddStates(12, 14);
761                  break;
762               case 22:
763                  if (curChar == 34 && kind > 14)
764                     kind = 14;
765                  break;
766               case 23:
767                  if ((0xff000000000000L & l) != 0L)
768                     jjCheckNAddStates(23, 26);
769                  break;
770               case 24:
771                  if ((0xff000000000000L & l) != 0L)
772                     jjCheckNAddStates(12, 14);
773                  break;
774               case 25:
775                  if ((0xf000000000000L & l) != 0L)
776                     jjstateSet[jjnewStateCnt++] = 26;
777                  break;
778               case 26:
779                  if ((0xff000000000000L & l) != 0L)
780                     jjCheckNAdd(24);
781                  break;
782               case 27:
783                  if (curChar != 36)
784                     break;
785                  if (kind > 47)
786                     kind = 47;
787                  jjCheckNAdd(28);
788                  break;
789               case 28:
790                  if ((0x3ff001000000000L & l) == 0L)
791                     break;
792                  if (kind > 47)
793                     kind = 47;
794                  jjCheckNAdd(28);
795                  break;
796               case 29:
797                  if ((0x3ff000000000000L & l) != 0L)
798                     jjCheckNAddStates(3, 9);
799                  break;
800               case 30:
801                  if ((0x3ff000000000000L & l) != 0L)
802                     jjCheckNAddTwoStates(30, 31);
803                  break;
804               case 31:
805                  if (curChar != 46)
806                     break;
807                  if (kind > 11)
808                     kind = 11;
809                  jjCheckNAddStates(27, 29);
810                  break;
811               case 32:
812                  if ((0x3ff000000000000L & l) == 0L)
813                     break;
814                  if (kind > 11)
815                     kind = 11;
816                  jjCheckNAddStates(27, 29);
817                  break;
818               case 34:
819                  if ((0x280000000000L & l) != 0L)
820                     jjCheckNAdd(35);
821                  break;
822               case 35:
823                  if ((0x3ff000000000000L & l) == 0L)
824                     break;
825                  if (kind > 11)
826                     kind = 11;
827                  jjCheckNAddTwoStates(35, 8);
828                  break;
829               case 36:
830                  if ((0x3ff000000000000L & l) != 0L)
831                     jjCheckNAddTwoStates(36, 37);
832                  break;
833               case 38:
834                  if ((0x280000000000L & l) != 0L)
835                     jjCheckNAdd(39);
836                  break;
837               case 39:
838                  if ((0x3ff000000000000L & l) == 0L)
839                     break;
840                  if (kind > 11)
841                     kind = 11;
842                  jjCheckNAddTwoStates(39, 8);
843                  break;
844               case 40:
845                  if ((0x3ff000000000000L & l) != 0L)
846                     jjCheckNAddStates(30, 32);
847                  break;
848               case 42:
849                  if ((0x280000000000L & l) != 0L)
850                     jjCheckNAdd(43);
851                  break;
852               case 43:
853                  if ((0x3ff000000000000L & l) != 0L)
854                     jjCheckNAddTwoStates(43, 8);
855                  break;
856               case 44:
857                  if (curChar != 48)
858                     break;
859                  if (kind > 7)
860                     kind = 7;
861                  jjCheckNAddStates(17, 19);
862                  break;
863               case 46:
864                  if ((0x3ff000000000000L & l) == 0L)
865                     break;
866                  if (kind > 7)
867                     kind = 7;
868                  jjCheckNAddTwoStates(46, 2);
869                  break;
870               case 47:
871                  if ((0xff000000000000L & l) == 0L)
872                     break;
873                  if (kind > 7)
874                     kind = 7;
875                  jjCheckNAddTwoStates(47, 2);
876                  break;
877               case 48:
878                  if (curChar == 47)
879                     jjAddStates(10, 11);
880                  break;
881               case 50:
882                  if ((0xffffffffffffdbffL & l) != 0L)
883                     jjCheckNAddStates(0, 2);
884                  break;
885               case 51:
886                  if ((0x2400L & l) != 0L && kind > 5)
887                     kind = 5;
888                  break;
889               case 52:
890                  if (curChar == 10 && kind > 5)
891                     kind = 5;
892                  break;
893               case 53:
894                  if (curChar == 13)
895                     jjstateSet[jjnewStateCnt++] = 52;
896                  break;
897               case 54:
898                  if (curChar == 42)
899                     jjCheckNAddTwoStates(55, 56);
900                  break;
901               case 55:
902                  if ((0xfffffbffffffffffL & l) != 0L)
903                     jjCheckNAddTwoStates(55, 56);
904                  break;
905               case 56:
906                  if (curChar == 42)
907                     jjCheckNAddStates(33, 35);
908                  break;
909               case 57:
910                  if ((0xffff7bffffffffffL & l) != 0L)
911                     jjCheckNAddTwoStates(58, 56);
912                  break;
913               case 58:
914                  if ((0xfffffbffffffffffL & l) != 0L)
915                     jjCheckNAddTwoStates(58, 56);
916                  break;
917               case 59:
918                  if (curChar == 47 && kind > 6)
919                     kind = 6;
920                  break;
921               default : break;
922            }
923         } while(i != startsAt);
924      }
925      else if (curChar < 128)
926      {
927         long l = 1L << (curChar & 077);
928         MatchLoop: do
929         {
930            switch(jjstateSet[--i])
931            {
932               case 0:
933               case 28:
934                  if ((0x7fffffe87fffffeL & l) == 0L)
935                     break;
936                  if (kind > 47)
937                     kind = 47;
938                  jjCheckNAdd(28);
939                  break;
940               case 2:
941                  if ((0x100000001000L & l) != 0L && kind > 7)
942                     kind = 7;
943                  break;
944               case 5:
945                  if ((0x2000000020L & l) != 0L)
946                     jjAddStates(36, 37);
947                  break;
948               case 8:
949                  if ((0x5000000050L & l) != 0L && kind > 11)
950                     kind = 11;
951                  break;
952               case 10:
953                  if ((0xffffffffefffffffL & l) != 0L)
954                     jjCheckNAdd(11);
955                  break;
956               case 12:
957                  if (curChar == 92)
958                     jjAddStates(38, 40);
959                  break;
960               case 13:
961                  if ((0x14404410000000L & l) != 0L)
962                     jjCheckNAdd(11);
963                  break;
964               case 19:
965                  if ((0xffffffffefffffffL & l) != 0L)
966                     jjCheckNAddStates(12, 14);
967                  break;
968               case 20:
969                  if (curChar == 92)
970                     jjAddStates(41, 43);
971                  break;
972               case 21:
973                  if ((0x14404410000000L & l) != 0L)
974                     jjCheckNAddStates(12, 14);
975                  break;
976               case 33:
977                  if ((0x2000000020L & l) != 0L)
978                     jjAddStates(44, 45);
979                  break;
980               case 37:
981                  if ((0x2000000020L & l) != 0L)
982                     jjAddStates(46, 47);
983                  break;
984               case 41:
985                  if ((0x2000000020L & l) != 0L)
986                     jjAddStates(48, 49);
987                  break;
988               case 45:
989                  if ((0x100000001000000L & l) != 0L)
990                     jjCheckNAdd(46);
991                  break;
992               case 46:
993                  if ((0x7e0000007eL & l) == 0L)
994                     break;
995                  if (kind > 7)
996                     kind = 7;
997                  jjCheckNAddTwoStates(46, 2);
998                  break;
999               case 50:
1000                  jjAddStates(0, 2);
1001                  break;
1002               case 55:
1003                  jjCheckNAddTwoStates(55, 56);
1004                  break;
1005               case 57:
1006               case 58:
1007                  jjCheckNAddTwoStates(58, 56);
1008                  break;
1009               default : break;
1010            }
1011         } while(i != startsAt);
1012      }
1013      else
1014      {
1015         int i2 = (curChar & 0xff) >> 6;
1016         long l2 = 1L << (curChar & 077);
1017         MatchLoop: do
1018         {
1019            switch(jjstateSet[--i])
1020            {
1021               case 10:
1022                  if ((jjbitVec0[i2] & l2) != 0L)
1023                     jjstateSet[jjnewStateCnt++] = 11;
1024                  break;
1025               case 19:
1026                  if ((jjbitVec0[i2] & l2) != 0L)
1027                     jjAddStates(12, 14);
1028                  break;
1029               case 50:
1030                  if ((jjbitVec0[i2] & l2) != 0L)
1031                     jjAddStates(0, 2);
1032                  break;
1033               case 55:
1034                  if ((jjbitVec0[i2] & l2) != 0L)
1035                     jjCheckNAddTwoStates(55, 56);
1036                  break;
1037               case 57:
1038               case 58:
1039                  if ((jjbitVec0[i2] & l2) != 0L)
1040                     jjCheckNAddTwoStates(58, 56);
1041                  break;
1042               default : break;
1043            }
1044         } while(i != startsAt);
1045      }
1046      if (kind != 0x7fffffff)
1047      {
1048         jjmatchedKind = kind;
1049         jjmatchedPos = curPos;
1050         kind = 0x7fffffff;
1051      }
1052      ++curPos;
1053      if ((i = jjnewStateCnt) == (startsAt = 60 - (jjnewStateCnt = startsAt)))
1054         return curPos;
1055      try { curChar = ASCII_CharStream.readChar(); }
1056      catch(java.io.IOException e) { return curPos; }
1057   }
1058}
1059static final int[] jjnextStates = {
1060   50, 51, 53, 30, 31, 36, 37, 40, 41, 8, 49, 54, 19, 20, 22, 10,
1061   12, 45, 47, 2, 4, 5, 8, 19, 20, 24, 22, 32, 33, 8, 40, 41,
1062   8, 56, 57, 59, 6, 7, 13, 14, 16, 21, 23, 25, 34, 35, 38, 39,
1063   42, 43,
1064};
1065public static final String[] jjstrLiteralImages = {
1066"", null, null, null, null, null, null, null, null, null, null, null, null,
1067null, null, "\143\157\156\164\151\156\165\145", "\166\157\154\141\164\151\154\145",
1068"\162\145\147\151\163\164\145\162", "\165\156\163\151\147\156\145\144", "\164\171\160\145\144\145\146",
1069"\144\145\146\141\165\154\164", "\144\157\165\142\154\145", "\163\151\172\145\157\146",
1070"\163\167\151\164\143\150", "\162\145\164\165\162\156", "\145\170\164\145\162\156",
1071"\163\164\162\165\143\164", "\163\164\141\164\151\143", "\163\151\147\156\145\144",
1072"\167\150\151\154\145", "\142\162\145\141\153", "\165\156\151\157\156", "\143\157\156\163\164",
1073"\146\154\157\141\164", "\163\150\157\162\164", "\145\154\163\145", "\143\141\163\145",
1074"\154\157\156\147", "\145\156\165\155", "\141\165\164\157", "\166\157\151\144",
1075"\143\150\141\162", "\147\157\164\157", "\146\157\162", "\151\156\164", "\151\146", "\144\157",
1076null, null, null, "\73", "\173", "\175", "\54", "\75", "\72", "\50", "\51", "\133",
1077"\135", "\52", "\56\56\56", "\52\75", "\57\75", "\45\75", "\53\75", "\55\75",
1078"\74\74\75", "\76\76\75", "\46\75", "\136\75", "\174\75", "\77", "\174\174", "\46\46",
1079"\174", "\136", "\46", "\75\75", "\41\75", "\74", "\76", "\74\75", "\76\75", "\74\74",
1080"\76\76", "\53", "\55", "\57", "\45", "\53\53", "\55\55", "\176", "\41", "\56",
1081"\55\76", };
1082public static final String[] lexStateNames = {
1083   "DEFAULT",
1084};
1085static final long[] jjtoToken = {
1086   0xfffcffffffffe881L, 0xffffffffL,
1087};
1088static final long[] jjtoSkip = {
1089   0x7eL, 0x0L,
1090};
1091static private ASCII_CharStream input_stream;
1092static private final int[] jjrounds = new int[60];
1093static private final int[] jjstateSet = new int[120];
1094static protected char curChar;
1095public CParserTokenManager(ASCII_CharStream stream)
1096{
1097   if (input_stream != null)
1098      throw new TokenMgrError("ERROR: Second call to constructor of static lexer. You must use ReInit() to initialize the static variables.", TokenMgrError.STATIC_LEXER_ERROR);
1099   input_stream = stream;
1100}
1101public CParserTokenManager(ASCII_CharStream stream, int lexState)
1102{
1103   this(stream);
1104   SwitchTo(lexState);
1105}
1106static public void ReInit(ASCII_CharStream stream)
1107{
1108   jjmatchedPos = jjnewStateCnt = 0;
1109   curLexState = defaultLexState;
1110   input_stream = stream;
1111   ReInitRounds();
1112}
1113static private final void ReInitRounds()
1114{
1115   int i;
1116   jjround = 0x80000001;
1117   for (i = 60; i-- > 0;)
1118      jjrounds[i] = 0x80000000;
1119}
1120static public void ReInit(ASCII_CharStream stream, int lexState)
1121{
1122   ReInit(stream);
1123   SwitchTo(lexState);
1124}
1125static public void SwitchTo(int lexState)
1126{
1127   if (lexState >= 1 || lexState < 0)
1128      throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
1129   else
1130      curLexState = lexState;
1131}
1132
1133static private final Token jjFillToken()
1134{
1135   Token t = Token.newToken(jjmatchedKind);
1136   t.kind = jjmatchedKind;
1137   String im = jjstrLiteralImages[jjmatchedKind];
1138   t.image = (im == null) ? ASCII_CharStream.GetImage() : im;
1139   t.beginLine = ASCII_CharStream.getBeginLine();
1140   t.beginColumn = ASCII_CharStream.getBeginColumn();
1141   t.endLine = ASCII_CharStream.getEndLine();
1142   t.endColumn = ASCII_CharStream.getEndColumn();
1143   return t;
1144}
1145
1146static int curLexState = 0;
1147static int defaultLexState = 0;
1148static int jjnewStateCnt;
1149static int jjround;
1150static int jjmatchedPos;
1151static int jjmatchedKind;
1152
1153public static final Token getNextToken()
1154{
1155  int kind;
1156  Token specialToken = null;
1157  Token matchedToken;
1158  int curPos = 0;
1159
1160  EOFLoop :
1161  for (;;)
1162  {
1163   try
1164   {
1165      curChar = ASCII_CharStream.BeginToken();
1166   }
1167   catch(java.io.IOException e)
1168   {
1169      jjmatchedKind = 0;
1170      matchedToken = jjFillToken();
1171      return matchedToken;
1172   }
1173
1174   try { ASCII_CharStream.backup(0);
1175      while (curChar <= 32 && (0x100002600L & (1L << curChar)) != 0L)
1176         curChar = ASCII_CharStream.BeginToken();
1177   }
1178   catch (java.io.IOException e1) { continue EOFLoop; }
1179   jjmatchedKind = 0x7fffffff;
1180   jjmatchedPos = 0;
1181   curPos = jjMoveStringLiteralDfa0_0();
1182   if (jjmatchedKind != 0x7fffffff)
1183   {
1184      if (jjmatchedPos + 1 < curPos)
1185         ASCII_CharStream.backup(curPos - jjmatchedPos - 1);
1186      if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1187      {
1188         matchedToken = jjFillToken();
1189         return matchedToken;
1190      }
1191      else
1192      {
1193         continue EOFLoop;
1194      }
1195   }
1196   int error_line = ASCII_CharStream.getEndLine();
1197   int error_column = ASCII_CharStream.getEndColumn();
1198   String error_after = null;
1199   boolean EOFSeen = false;
1200   try { ASCII_CharStream.readChar(); ASCII_CharStream.backup(1); }
1201   catch (java.io.IOException e1) {
1202      EOFSeen = true;
1203      error_after = curPos <= 1 ? "" : ASCII_CharStream.GetImage();
1204      if (curChar == '\n' || curChar == '\r') {
1205         error_line++;
1206         error_column = 0;
1207      }
1208      else
1209         error_column++;
1210   }
1211   if (!EOFSeen) {
1212      ASCII_CharStream.backup(1);
1213      error_after = curPos <= 1 ? "" : ASCII_CharStream.GetImage();
1214   }
1215   throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
1216  }
1217}
1218
1219}