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