001/* SRCPParserTokenManager.java */
002/* Generated By:JJTree&JavaCC: Do not edit this line. SRCPParserTokenManager.java */
003package jmri.jmris.srcp.parser;
004import org.slf4j.Logger;
005import org.slf4j.LoggerFactory;
006
007/* Token Manager. */
008public class SRCPParserTokenManager implements SRCPParserConstants {
009
010  /* Debug output. */
011  public  java.io.PrintStream debugStream = System.out;
012  /* Set debug output. */
013  public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
014private final int jjStopStringLiteralDfa_0(int pos, long active0){
015   switch (pos)
016   {
017      default :
018         return -1;
019   }
020}
021private final int jjStartNfa_0(int pos, long active0){
022   return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
023}
024private int jjStopAtPos(int pos, int kind)
025{
026   jjmatchedKind = kind;
027   jjmatchedPos = pos;
028   return pos + 1;
029}
030private int jjMoveStringLiteralDfa0_0(){
031   switch(curChar)
032   {
033      case 10:
034         return jjStopAtPos(0, 1);
035      case 92:
036         return jjMoveStringLiteralDfa1_0(0x8L);
037      default :
038         return jjMoveNfa_0(0, 0);
039   }
040}
041private int jjMoveStringLiteralDfa1_0(long active0){
042   try { curChar = input_stream.readChar(); }
043   catch(java.io.IOException e) {
044      jjStopStringLiteralDfa_0(0, active0);
045      return 1;
046   }
047   switch(curChar)
048   {
049      case 10:
050         if ((active0 & 0x8L) != 0L)
051            return jjStopAtPos(1, 3);
052         break;
053      default :
054         break;
055   }
056   return jjStartNfa_0(0, active0);
057}
058private int jjMoveNfa_0(int startState, int curPos)
059{
060   int startsAt = 0;
061   jjnewStateCnt = 144;
062   int i = 1;
063   jjstateSet[0] = startState;
064   int kind = 0x7fffffff;
065   for (;;)
066   {
067      if (++jjround == 0x7fffffff)
068         ReInitRounds();
069      if (curChar < 64)
070      {
071         long l = 1L << curChar;
072         do
073         {
074            switch(jjstateSet[--i])
075            {
076               case 0:
077                  if ((0x3ff000000000000L & l) != 0L)
078                  {
079                     if (kind > 17)
080                        kind = 17;
081                     { jjCheckNAddStates(0, 2); }
082                  }
083                  else if (curChar == 45)
084                     { jjCheckNAdd(8); }
085                  if ((0x3fe000000000000L & l) != 0L)
086                  {
087                     if (kind > 7)
088                        kind = 7;
089                     { jjCheckNAdd(3); }
090                  }
091                  else if (curChar == 48)
092                  {
093                     if (kind > 6)
094                        kind = 6;
095                     { jjCheckNAdd(1); }
096                  }
097                  if ((0x2007000000000000L & l) != 0L)
098                  {
099                     if (kind > 15)
100                        kind = 15;
101                  }
102                  if ((0x2003000000000000L & l) != 0L)
103                  {
104                     if (kind > 16)
105                        kind = 16;
106                  }
107                  break;
108               case 1:
109                  if ((0x3ff000000000000L & l) == 0L)
110                     break;
111                  if (kind > 6)
112                     kind = 6;
113                  { jjCheckNAdd(1); }
114                  break;
115               case 2:
116                  if ((0x3fe000000000000L & l) == 0L)
117                     break;
118                  if (kind > 7)
119                     kind = 7;
120                  { jjCheckNAdd(3); }
121                  break;
122               case 3:
123                  if ((0x3ff000000000000L & l) == 0L)
124                     break;
125                  if (kind > 7)
126                     kind = 7;
127                  { jjCheckNAdd(3); }
128                  break;
129               case 5:
130                  if ((0x2007000000000000L & l) != 0L && kind > 15)
131                     kind = 15;
132                  break;
133               case 6:
134                  if ((0x2003000000000000L & l) != 0L && kind > 16)
135                     kind = 16;
136                  break;
137               case 7:
138                  if (curChar == 45)
139                     { jjCheckNAdd(8); }
140                  break;
141               case 8:
142                  if ((0x3ff000000000000L & l) == 0L)
143                     break;
144                  if (kind > 17)
145                     kind = 17;
146                  { jjCheckNAdd(8); }
147                  break;
148               case 46:
149                  if ((0x3ff000000000000L & l) == 0L)
150                     break;
151                  if (kind > 8)
152                     kind = 8;
153                  jjstateSet[jjnewStateCnt++] = 46;
154                  break;
155               case 48:
156                  if ((0x3ff000000000000L & l) == 0L)
157                     break;
158                  if (kind > 9)
159                     kind = 9;
160                  jjstateSet[jjnewStateCnt++] = 48;
161                  break;
162               case 50:
163                  if ((0x3ff000000000000L & l) == 0L)
164                     break;
165                  if (kind > 10)
166                     kind = 10;
167                  jjstateSet[jjnewStateCnt++] = 50;
168                  break;
169               case 51:
170                  if ((0x3ff000000000000L & l) == 0L)
171                     break;
172                  if (kind > 17)
173                     kind = 17;
174                  { jjCheckNAddStates(0, 2); }
175                  break;
176               case 52:
177                  if ((0x3ff000000000000L & l) != 0L)
178                     { jjCheckNAddTwoStates(52, 53); }
179                  break;
180               case 53:
181                  if (curChar == 46)
182                     { jjCheckNAdd(54); }
183                  break;
184               case 54:
185                  if ((0x3ff000000000000L & l) != 0L)
186                     { jjCheckNAddTwoStates(54, 55); }
187                  break;
188               case 55:
189                  if (curChar == 46)
190                     { jjCheckNAdd(56); }
191                  break;
192               case 56:
193                  if ((0x3ff000000000000L & l) == 0L)
194                     break;
195                  if (kind > 32)
196                     kind = 32;
197                  { jjCheckNAdd(56); }
198                  break;
199               default : break;
200            }
201         } while(i != startsAt);
202      }
203      else if (curChar < 128)
204      {
205         long l = 1L << (curChar & 077);
206         do
207         {
208            switch(jjstateSet[--i])
209            {
210               case 0:
211                  if ((0x7fffffe07fffffeL & l) != 0L)
212                     { jjAddStates(3, 5); }
213                  if ((0x409704204097042L & l) != 0L)
214                  {
215                     if (kind > 14)
216                        kind = 14;
217                  }
218                  else if ((0x4000000040000L & l) != 0L)
219                     { jjAddStates(6, 7); }
220                  else if ((0x20000000200L & l) != 0L)
221                     { jjAddStates(8, 9); }
222                  else if ((0x800000008L & l) != 0L)
223                     { jjAddStates(10, 14); }
224                  else if ((0x10000000100000L & l) != 0L)
225                     { jjAddStates(15, 16); }
226                  else if ((0x8000000080L & l) != 0L)
227                     { jjAddStates(17, 21); }
228                  else if ((0x800000008000L & l) != 0L)
229                     { jjAddStates(22, 23); }
230                  else if ((0x40000000400000L & l) != 0L)
231                     jjstateSet[jjnewStateCnt++] = 35;
232                  else if ((0x80000000800000L & l) != 0L)
233                     jjstateSet[jjnewStateCnt++] = 31;
234                  else if ((0x1000000010L & l) != 0L)
235                     jjstateSet[jjnewStateCnt++] = 20;
236                  if ((0x1000000010000L & l) != 0L)
237                     { jjAddStates(24, 25); }
238                  else if ((0x8000000080000L & l) != 0L)
239                     { jjAddStates(26, 30); }
240                  else if ((0x100000001000L & l) != 0L)
241                     jjstateSet[jjnewStateCnt++] = 16;
242                  else if ((0x4000000040L & l) != 0L)
243                     jjstateSet[jjnewStateCnt++] = 14;
244                  else if ((0x400000004000L & l) != 0L)
245                     jjstateSet[jjnewStateCnt++] = 10;
246                  break;
247               case 4:
248                  if ((0x409704204097042L & l) != 0L && kind > 14)
249                     kind = 14;
250                  break;
251               case 9:
252                  if ((0x400000004000L & l) != 0L)
253                     jjstateSet[jjnewStateCnt++] = 10;
254                  break;
255               case 10:
256                  if ((0x200000002000L & l) != 0L)
257                     jjstateSet[jjnewStateCnt++] = 11;
258                  break;
259               case 11:
260                  if ((0x4000000040000L & l) != 0L)
261                     jjstateSet[jjnewStateCnt++] = 12;
262                  break;
263               case 12:
264                  if ((0x200000002L & l) != 0L && kind > 18)
265                     kind = 18;
266                  break;
267               case 13:
268                  if ((0x4000000040L & l) != 0L)
269                     jjstateSet[jjnewStateCnt++] = 14;
270                  break;
271               case 14:
272                  if ((0x400000004L & l) != 0L && kind > 19)
273                     kind = 19;
274                  break;
275               case 15:
276                  if ((0x100000001000L & l) != 0L)
277                     jjstateSet[jjnewStateCnt++] = 16;
278                  break;
279               case 16:
280                  if ((0x800000008000L & l) != 0L)
281                     jjstateSet[jjnewStateCnt++] = 17;
282                  break;
283               case 17:
284                  if ((0x800000008L & l) != 0L)
285                     jjstateSet[jjnewStateCnt++] = 18;
286                  break;
287               case 18:
288                  if ((0x80000000800L & l) != 0L && kind > 24)
289                     kind = 24;
290                  break;
291               case 19:
292                  if ((0x1000000010L & l) != 0L)
293                     jjstateSet[jjnewStateCnt++] = 20;
294                  break;
295               case 20:
296                  if ((0x2000000020L & l) != 0L)
297                     jjstateSet[jjnewStateCnt++] = 21;
298                  break;
299               case 21:
300                  if ((0x8000000080000L & l) != 0L)
301                     jjstateSet[jjnewStateCnt++] = 22;
302                  break;
303               case 22:
304                  if ((0x800000008L & l) != 0L)
305                     jjstateSet[jjnewStateCnt++] = 23;
306                  break;
307               case 23:
308                  if ((0x4000000040000L & l) != 0L)
309                     jjstateSet[jjnewStateCnt++] = 24;
310                  break;
311               case 24:
312                  if ((0x20000000200L & l) != 0L)
313                     jjstateSet[jjnewStateCnt++] = 25;
314                  break;
315               case 25:
316                  if ((0x1000000010000L & l) != 0L)
317                     jjstateSet[jjnewStateCnt++] = 26;
318                  break;
319               case 26:
320                  if ((0x10000000100000L & l) != 0L)
321                     jjstateSet[jjnewStateCnt++] = 27;
322                  break;
323               case 27:
324                  if ((0x20000000200L & l) != 0L)
325                     jjstateSet[jjnewStateCnt++] = 28;
326                  break;
327               case 28:
328                  if ((0x800000008000L & l) != 0L)
329                     jjstateSet[jjnewStateCnt++] = 29;
330                  break;
331               case 29:
332                  if ((0x400000004000L & l) != 0L && kind > 28)
333                     kind = 28;
334                  break;
335               case 30:
336                  if ((0x80000000800000L & l) != 0L)
337                     jjstateSet[jjnewStateCnt++] = 31;
338                  break;
339               case 31:
340                  if ((0x200000002L & l) != 0L)
341                     jjstateSet[jjnewStateCnt++] = 32;
342                  break;
343               case 32:
344                  if ((0x20000000200L & l) != 0L)
345                     jjstateSet[jjnewStateCnt++] = 33;
346                  break;
347               case 33:
348                  if ((0x10000000100000L & l) != 0L && kind > 45)
349                     kind = 45;
350                  break;
351               case 34:
352                  if ((0x40000000400000L & l) != 0L)
353                     jjstateSet[jjnewStateCnt++] = 35;
354                  break;
355               case 35:
356                  if ((0x2000000020L & l) != 0L)
357                     jjstateSet[jjnewStateCnt++] = 36;
358                  break;
359               case 36:
360                  if ((0x4000000040000L & l) != 0L)
361                     jjstateSet[jjnewStateCnt++] = 37;
362                  break;
363               case 37:
364                  if ((0x20000000200L & l) != 0L)
365                     jjstateSet[jjnewStateCnt++] = 38;
366                  break;
367               case 38:
368                  if ((0x4000000040L & l) != 0L)
369                     jjstateSet[jjnewStateCnt++] = 39;
370                  break;
371               case 39:
372                  if ((0x200000002000000L & l) != 0L && kind > 46)
373                     kind = 46;
374                  break;
375               case 40:
376                  if ((0x800000008000L & l) != 0L)
377                     { jjAddStates(22, 23); }
378                  break;
379               case 41:
380                  if ((0x400000004000L & l) != 0L && kind > 11)
381                     kind = 11;
382                  break;
383               case 42:
384                  if ((0x4000000040L & l) != 0L)
385                     jjstateSet[jjnewStateCnt++] = 43;
386                  break;
387               case 43:
388                  if ((0x4000000040L & l) != 0L && kind > 11)
389                     kind = 11;
390                  break;
391               case 44:
392                  if ((0x7fffffe07fffffeL & l) != 0L)
393                     { jjAddStates(3, 5); }
394                  break;
395               case 45:
396                  if (curChar == 84)
397                     jjstateSet[jjnewStateCnt++] = 46;
398                  break;
399               case 47:
400                  if (curChar == 83)
401                     jjstateSet[jjnewStateCnt++] = 48;
402                  break;
403               case 49:
404                  if (curChar == 76)
405                     jjstateSet[jjnewStateCnt++] = 50;
406                  break;
407               case 57:
408                  if ((0x8000000080L & l) != 0L)
409                     { jjAddStates(17, 21); }
410                  break;
411               case 58:
412                  if ((0x200000002L & l) != 0L && kind > 20)
413                     kind = 20;
414                  break;
415               case 59:
416                  if ((0x100000001000L & l) != 0L && kind > 21)
417                     kind = 21;
418                  break;
419               case 60:
420                  if ((0x200000002000L & l) != 0L && kind > 22)
421                     kind = 22;
422                  break;
423               case 61:
424                  if ((0x800000008000L & l) != 0L && kind > 31)
425                     kind = 31;
426                  break;
427               case 62:
428                  if ((0x2000000020L & l) != 0L)
429                     jjstateSet[jjnewStateCnt++] = 63;
430                  break;
431               case 63:
432                  if ((0x10000000100000L & l) != 0L && kind > 40)
433                     kind = 40;
434                  break;
435               case 64:
436                  if ((0x8000000080000L & l) != 0L)
437                     { jjAddStates(26, 30); }
438                  break;
439               case 65:
440                  if ((0x200000002000L & l) != 0L && kind > 23)
441                     kind = 23;
442                  break;
443               case 66:
444                  if ((0x2000000020L & l) != 0L)
445                     jjstateSet[jjnewStateCnt++] = 67;
446                  break;
447               case 67:
448                  if ((0x8000000080000L & l) != 0L)
449                     jjstateSet[jjnewStateCnt++] = 68;
450                  break;
451               case 68:
452                  if ((0x8000000080000L & l) != 0L)
453                     jjstateSet[jjnewStateCnt++] = 69;
454                  break;
455               case 69:
456                  if ((0x20000000200L & l) != 0L)
457                     jjstateSet[jjnewStateCnt++] = 70;
458                  break;
459               case 70:
460                  if ((0x800000008000L & l) != 0L)
461                     jjstateSet[jjnewStateCnt++] = 71;
462                  break;
463               case 71:
464                  if ((0x400000004000L & l) != 0L && kind > 27)
465                     kind = 27;
466                  break;
467               case 72:
468                  if ((0x2000000020L & l) != 0L)
469                     jjstateSet[jjnewStateCnt++] = 73;
470                  break;
471               case 73:
472                  if ((0x4000000040000L & l) != 0L)
473                     jjstateSet[jjnewStateCnt++] = 74;
474                  break;
475               case 74:
476                  if ((0x40000000400000L & l) != 0L)
477                     jjstateSet[jjnewStateCnt++] = 75;
478                  break;
479               case 75:
480                  if ((0x2000000020L & l) != 0L)
481                     jjstateSet[jjnewStateCnt++] = 76;
482                  break;
483               case 76:
484                  if ((0x4000000040000L & l) != 0L && kind > 29)
485                     kind = 29;
486                  break;
487               case 77:
488                  if ((0x4000000040000L & l) != 0L)
489                     jjstateSet[jjnewStateCnt++] = 78;
490                  break;
491               case 78:
492                  if ((0x800000008L & l) != 0L)
493                     jjstateSet[jjnewStateCnt++] = 79;
494                  break;
495               case 79:
496                  if ((0x1000000010000L & l) != 0L && kind > 30)
497                     kind = 30;
498                  break;
499               case 80:
500                  if ((0x2000000020L & l) != 0L)
501                     jjstateSet[jjnewStateCnt++] = 81;
502                  break;
503               case 81:
504                  if ((0x10000000100000L & l) != 0L && kind > 41)
505                     kind = 41;
506                  break;
507               case 82:
508                  if ((0x10000000100000L & l) != 0L)
509                     { jjAddStates(15, 16); }
510                  break;
511               case 83:
512                  if ((0x20000000200L & l) != 0L)
513                     jjstateSet[jjnewStateCnt++] = 84;
514                  break;
515               case 84:
516                  if ((0x200000002000L & l) != 0L)
517                     jjstateSet[jjnewStateCnt++] = 85;
518                  break;
519               case 85:
520                  if ((0x2000000020L & l) != 0L && kind > 25)
521                     kind = 25;
522                  break;
523               case 86:
524                  if ((0x2000000020L & l) != 0L)
525                     jjstateSet[jjnewStateCnt++] = 87;
526                  break;
527               case 87:
528                  if ((0x4000000040000L & l) != 0L)
529                     jjstateSet[jjnewStateCnt++] = 88;
530                  break;
531               case 88:
532                  if ((0x200000002000L & l) != 0L && kind > 44)
533                     kind = 44;
534                  break;
535               case 89:
536                  if ((0x1000000010000L & l) != 0L)
537                     { jjAddStates(24, 25); }
538                  break;
539               case 90:
540                  if ((0x800000008000L & l) != 0L)
541                     jjstateSet[jjnewStateCnt++] = 91;
542                  break;
543               case 91:
544                  if ((0x80000000800000L & l) != 0L)
545                     jjstateSet[jjnewStateCnt++] = 92;
546                  break;
547               case 92:
548                  if ((0x2000000020L & l) != 0L)
549                     jjstateSet[jjnewStateCnt++] = 93;
550                  break;
551               case 93:
552                  if ((0x4000000040000L & l) != 0L && kind > 26)
553                     kind = 26;
554                  break;
555               case 94:
556                  if ((0x4000000040000L & l) != 0L)
557                     jjstateSet[jjnewStateCnt++] = 95;
558                  break;
559               case 95:
560                  if ((0x800000008000L & l) != 0L)
561                     jjstateSet[jjnewStateCnt++] = 96;
562                  break;
563               case 96:
564                  if ((0x10000000100000L & l) != 0L)
565                     jjstateSet[jjnewStateCnt++] = 97;
566                  break;
567               case 97:
568                  if ((0x800000008000L & l) != 0L)
569                     jjstateSet[jjnewStateCnt++] = 98;
570                  break;
571               case 98:
572                  if ((0x800000008L & l) != 0L)
573                     jjstateSet[jjnewStateCnt++] = 99;
574                  break;
575               case 99:
576                  if ((0x800000008000L & l) != 0L)
577                     jjstateSet[jjnewStateCnt++] = 100;
578                  break;
579               case 100:
580                  if ((0x100000001000L & l) != 0L && kind > 33)
581                     kind = 33;
582                  break;
583               case 101:
584                  if ((0x800000008L & l) != 0L)
585                     { jjAddStates(10, 14); }
586                  break;
587               case 102:
588                  if ((0x800000008000L & l) != 0L)
589                     jjstateSet[jjnewStateCnt++] = 103;
590                  break;
591               case 103:
592                  if ((0x400000004000L & l) != 0L)
593                     jjstateSet[jjnewStateCnt++] = 104;
594                  break;
595               case 104:
596                  if ((0x400000004000L & l) != 0L)
597                     jjstateSet[jjnewStateCnt++] = 105;
598                  break;
599               case 105:
600                  if ((0x2000000020L & l) != 0L)
601                     jjstateSet[jjnewStateCnt++] = 106;
602                  break;
603               case 106:
604                  if ((0x800000008L & l) != 0L)
605                     jjstateSet[jjnewStateCnt++] = 107;
606                  break;
607               case 107:
608                  if ((0x10000000100000L & l) != 0L)
609                     jjstateSet[jjnewStateCnt++] = 108;
610                  break;
611               case 108:
612                  if ((0x20000000200L & l) != 0L)
613                     jjstateSet[jjnewStateCnt++] = 109;
614                  break;
615               case 109:
616                  if ((0x800000008000L & l) != 0L)
617                     jjstateSet[jjnewStateCnt++] = 110;
618                  break;
619               case 110:
620                  if ((0x400000004000L & l) != 0L)
621                     jjstateSet[jjnewStateCnt++] = 111;
622                  break;
623               case 111:
624                  if ((0x200000002000L & l) != 0L)
625                     jjstateSet[jjnewStateCnt++] = 112;
626                  break;
627               case 112:
628                  if ((0x800000008000L & l) != 0L)
629                     jjstateSet[jjnewStateCnt++] = 113;
630                  break;
631               case 113:
632                  if ((0x1000000010L & l) != 0L)
633                     jjstateSet[jjnewStateCnt++] = 114;
634                  break;
635               case 114:
636                  if ((0x2000000020L & l) != 0L && kind > 34)
637                     kind = 34;
638                  break;
639               case 115:
640                  if ((0x800000008000L & l) != 0L)
641                     jjstateSet[jjnewStateCnt++] = 116;
642                  break;
643               case 116:
644                  if ((0x200000002000L & l) != 0L)
645                     jjstateSet[jjnewStateCnt++] = 117;
646                  break;
647               case 117:
648                  if ((0x200000002000L & l) != 0L)
649                     jjstateSet[jjnewStateCnt++] = 118;
650                  break;
651               case 118:
652                  if ((0x200000002L & l) != 0L)
653                     jjstateSet[jjnewStateCnt++] = 119;
654                  break;
655               case 119:
656                  if ((0x400000004000L & l) != 0L)
657                     jjstateSet[jjnewStateCnt++] = 120;
658                  break;
659               case 120:
660                  if ((0x1000000010L & l) != 0L && kind > 36)
661                     kind = 36;
662                  break;
663               case 121:
664                  if ((0x40000000400000L & l) != 0L)
665                     jjstateSet[jjnewStateCnt++] = 122;
666                  break;
667               case 122:
668                  if ((0x400000004L & l) != 0L)
669                     jjstateSet[jjnewStateCnt++] = 123;
670                  break;
671               case 123:
672                  if ((0x20000000200L & l) != 0L)
673                     jjstateSet[jjnewStateCnt++] = 124;
674                  break;
675               case 124:
676                  if ((0x10000000100000L & l) != 0L && kind > 37)
677                     kind = 37;
678                  break;
679               case 125:
680                  if ((0x40000000400000L & l) != 0L && kind > 38)
681                     kind = 38;
682                  break;
683               case 126:
684                  if ((0x10000000100L & l) != 0L)
685                     jjstateSet[jjnewStateCnt++] = 127;
686                  break;
687               case 127:
688                  if ((0x2000000020L & l) != 0L)
689                     jjstateSet[jjnewStateCnt++] = 128;
690                  break;
691               case 128:
692                  if ((0x800000008L & l) != 0L)
693                     jjstateSet[jjnewStateCnt++] = 129;
694                  break;
695               case 129:
696                  if ((0x80000000800L & l) != 0L && kind > 42)
697                     kind = 42;
698                  break;
699               case 130:
700                  if ((0x20000000200L & l) != 0L)
701                     { jjAddStates(8, 9); }
702                  break;
703               case 131:
704                  if ((0x400000004000L & l) != 0L)
705                     jjstateSet[jjnewStateCnt++] = 132;
706                  break;
707               case 132:
708                  if ((0x4000000040L & l) != 0L)
709                     jjstateSet[jjnewStateCnt++] = 133;
710                  break;
711               case 133:
712                  if ((0x800000008000L & l) != 0L && kind > 35)
713                     kind = 35;
714                  break;
715               case 134:
716                  if ((0x400000004000L & l) != 0L)
717                     jjstateSet[jjnewStateCnt++] = 135;
718                  break;
719               case 135:
720                  if ((0x20000000200L & l) != 0L)
721                     jjstateSet[jjnewStateCnt++] = 136;
722                  break;
723               case 136:
724                  if ((0x10000000100000L & l) != 0L && kind > 43)
725                     kind = 43;
726                  break;
727               case 137:
728                  if ((0x4000000040000L & l) != 0L)
729                     { jjAddStates(6, 7); }
730                  break;
731               case 138:
732                  if ((0x2000000020L & l) != 0L)
733                     jjstateSet[jjnewStateCnt++] = 139;
734                  break;
735               case 139:
736                  if ((0x8000000080L & l) != 0L && kind > 39)
737                     kind = 39;
738                  break;
739               case 140:
740                  if ((0x2000000020L & l) != 0L)
741                     jjstateSet[jjnewStateCnt++] = 141;
742                  break;
743               case 141:
744                  if ((0x8000000080000L & l) != 0L)
745                     jjstateSet[jjnewStateCnt++] = 142;
746                  break;
747               case 142:
748                  if ((0x2000000020L & l) != 0L)
749                     jjstateSet[jjnewStateCnt++] = 143;
750                  break;
751               case 143:
752                  if ((0x10000000100000L & l) != 0L && kind > 47)
753                     kind = 47;
754                  break;
755               default : break;
756            }
757         } while(i != startsAt);
758      }
759      else
760      {
761         int i2 = (curChar & 0xff) >> 6;
762         long l2 = 1L << (curChar & 077);
763         do
764         {
765            switch(jjstateSet[--i])
766            {
767               default : break;
768            }
769         } while(i != startsAt);
770      }
771      if (kind != 0x7fffffff)
772      {
773         jjmatchedKind = kind;
774         jjmatchedPos = curPos;
775         kind = 0x7fffffff;
776      }
777      ++curPos;
778      if ((i = jjnewStateCnt) == (startsAt = 144 - (jjnewStateCnt = startsAt)))
779         return curPos;
780      try { curChar = input_stream.readChar(); }
781      catch(java.io.IOException e) { return curPos; }
782   }
783}
784private int jjMoveStringLiteralDfa0_1(){
785   switch(curChar)
786   {
787      case 10:
788         return jjStopAtPos(0, 1);
789      default :
790         return 1;
791   }
792}
793
794/* Token literal values. */
795public static final String[] jjstrLiteralImages = {
796"", "\12", null, null, null, null, null, null, null, null, null, null, null, 
797null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
798null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
799null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
800null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
801null, null, null, null, null, };
802protected Token jjFillToken()
803{
804   final Token t;
805   final String curTokenImage;
806   final int beginLine;
807   final int endLine;
808   final int beginColumn;
809   final int endColumn;
810   String im = jjstrLiteralImages[jjmatchedKind];
811   curTokenImage = (im == null) ? input_stream.GetImage() : im;
812   beginLine = input_stream.getBeginLine();
813   beginColumn = input_stream.getBeginColumn();
814   endLine = input_stream.getEndLine();
815   endColumn = input_stream.getEndColumn();
816   t = Token.newToken(jjmatchedKind);
817   t.kind = jjmatchedKind;
818   t.image = curTokenImage;
819
820   t.beginLine = beginLine;
821   t.endLine = endLine;
822   t.beginColumn = beginColumn;
823   t.endColumn = endColumn;
824
825   return t;
826}
827static final int[] jjnextStates = {
828   8, 52, 53, 45, 47, 49, 138, 140, 131, 134, 102, 115, 121, 125, 126, 83, 
829   86, 58, 59, 60, 61, 62, 41, 42, 90, 94, 65, 66, 72, 77, 80, 
830};
831
832int curLexState = 0;
833int defaultLexState = 0;
834int jjnewStateCnt;
835int jjround;
836int jjmatchedPos;
837int jjmatchedKind;
838
839/* Get the next Token. */
840public Token getNextToken() 
841{
842  Token matchedToken;
843  int curPos = 0;
844
845  EOFLoop :
846  for (;;)
847  {
848   try
849   {
850      curChar = input_stream.BeginToken();
851   }
852   catch(Exception e)
853   {
854      jjmatchedKind = 0;
855      jjmatchedPos = -1;
856      matchedToken = jjFillToken();
857      return matchedToken;
858   }
859
860   switch(curLexState)
861   {
862     case 0:
863       try { input_stream.backup(0);
864          while (curChar <= 32 && (0x100002200L & (1L << curChar)) != 0L)
865             curChar = input_stream.BeginToken();
866       }
867       catch (java.io.IOException e1) { continue EOFLoop; }
868       jjmatchedKind = 0x7fffffff;
869       jjmatchedPos = 0;
870       curPos = jjMoveStringLiteralDfa0_0();
871       break;
872     case 1:
873       jjmatchedKind = 0x7fffffff;
874       jjmatchedPos = 0;
875       curPos = jjMoveStringLiteralDfa0_1();
876       break;
877   }
878     if (jjmatchedKind != 0x7fffffff)
879     {
880        if (jjmatchedPos + 1 < curPos)
881           input_stream.backup(curPos - jjmatchedPos - 1);
882        if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
883        {
884           matchedToken = jjFillToken();
885       if (jjnewLexState[jjmatchedKind] != -1)
886         curLexState = jjnewLexState[jjmatchedKind];
887           return matchedToken;
888        }
889        else
890        {
891         if (jjnewLexState[jjmatchedKind] != -1)
892           curLexState = jjnewLexState[jjmatchedKind];
893           continue EOFLoop;
894        }
895     }
896     int error_line = input_stream.getEndLine();
897     int error_column = input_stream.getEndColumn();
898     String error_after = null;
899     boolean EOFSeen = false;
900     try { input_stream.readChar(); input_stream.backup(1); }
901     catch (java.io.IOException e1) {
902        EOFSeen = true;
903        error_after = curPos <= 1 ? "" : input_stream.GetImage();
904        if (curChar == '\n' || curChar == '\r') {
905           error_line++;
906           error_column = 0;
907        }
908        else
909           error_column++;
910     }
911     if (!EOFSeen) {
912        input_stream.backup(1);
913        error_after = curPos <= 1 ? "" : input_stream.GetImage();
914     }
915     throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
916  }
917}
918
919void SkipLexicalActions(Token matchedToken)
920{
921   switch(jjmatchedKind)
922   {
923      default :
924         break;
925   }
926}
927void MoreLexicalActions()
928{
929   jjimageLen += (lengthOfMatch = jjmatchedPos + 1);
930   switch(jjmatchedKind)
931   {
932      default :
933         break;
934   }
935}
936void TokenLexicalActions(Token matchedToken)
937{
938   switch(jjmatchedKind)
939   {
940      default :
941         break;
942   }
943}
944private void jjCheckNAdd(int state)
945{
946   if (jjrounds[state] != jjround)
947   {
948      jjstateSet[jjnewStateCnt++] = state;
949      jjrounds[state] = jjround;
950   }
951}
952private void jjAddStates(int start, int end)
953{
954   do {
955      jjstateSet[jjnewStateCnt++] = jjnextStates[start];
956   } while (start++ != end);
957}
958private void jjCheckNAddTwoStates(int state1, int state2)
959{
960   jjCheckNAdd(state1);
961   jjCheckNAdd(state2);
962}
963
964private void jjCheckNAddStates(int start, int end)
965{
966   do {
967      jjCheckNAdd(jjnextStates[start]);
968   } while (start++ != end);
969}
970
971    /* Constructor. */
972    public SRCPParserTokenManager(SimpleCharStream stream){
973
974      if (SimpleCharStream.staticFlag)
975            throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
976
977    input_stream = stream;
978  }
979
980  /* Constructor. */
981  public SRCPParserTokenManager (SimpleCharStream stream, int lexState){
982    ReInit(stream);
983    SwitchTo(lexState);
984  }
985
986  /* Reinitialise parser. */
987  
988  public void ReInit(SimpleCharStream stream)
989  {
990
991
992    jjmatchedPos =
993    jjnewStateCnt =
994    0;
995    curLexState = defaultLexState;
996    input_stream = stream;
997    ReInitRounds();
998  }
999
1000  private void ReInitRounds()
1001  {
1002    int i;
1003    jjround = 0x80000001;
1004    for (i = 144; i-- > 0;)
1005      jjrounds[i] = 0x80000000;
1006  }
1007
1008  /* Reinitialise parser. */
1009  public void ReInit(SimpleCharStream stream, int lexState)
1010  
1011  {
1012    ReInit(stream);
1013    SwitchTo(lexState);
1014  }
1015
1016  /* Switch to specified lex state. */
1017  public void SwitchTo(int lexState)
1018  {
1019    if (lexState >= 2 || lexState < 0)
1020      throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
1021    else
1022      curLexState = lexState;
1023  }
1024
1025
1026/* Lexer state names. */
1027public static final String[] lexStateNames = {
1028   "DEFAULT",
1029   "IN_TIME",
1030};
1031
1032/* Lex State array. */
1033public static final int[] jjnewLexState = {
1034   -1, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
1035   -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, 
1036   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
1037};
1038static final long[] jjtoToken = {
1039   0xffffffffcfc3L, 0x0L, 
1040};
1041static final long[] jjtoSkip = {
1042   0x3cL, 0x0L, 
1043};
1044static final long[] jjtoSpecial = {
1045   0x0L, 0x0L, 
1046};
1047static final long[] jjtoMore = {
1048   0x0L, 0x0L, 
1049};
1050    protected SimpleCharStream  input_stream;
1051
1052    private final int[] jjrounds = new int[144];
1053    private final int[] jjstateSet = new int[2 * 144];
1054    private final StringBuilder jjimage = new StringBuilder();
1055    private StringBuilder image = jjimage;
1056    private int jjimageLen;
1057    private int lengthOfMatch;
1058    protected int curChar;
1059}