001/* JmriServerParserTokenManager.java */
002/* Generated By:JJTree&JavaCC: Do not edit this line. JmriServerParserTokenManager.java */
003package jmri.jmris.simpleserver.parser;
004import org.slf4j.Logger;
005import org.slf4j.LoggerFactory;
006
007/* Token Manager. */
008public class JmriServerParserTokenManager implements JmriServerParserConstants {
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, long active1){
015   switch (pos)
016   {
017      default :
018         return -1;
019   }
020}
021private final int jjStartNfa_0(int pos, long active0, long active1){
022   return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), 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, 5);
035      case 44:
036         return jjStopAtPos(0, 38);
037      case 61:
038         return jjStopAtPos(0, 68);
039      case 92:
040         return jjMoveStringLiteralDfa1_0(0x4L);
041      default :
042         return jjMoveNfa_0(0, 0);
043   }
044}
045private int jjMoveStringLiteralDfa1_0(long active0){
046   try { curChar = input_stream.readChar(); }
047   catch(java.io.IOException e) {
048      jjStopStringLiteralDfa_0(0, active0, 0L);
049      return 1;
050   }
051   switch(curChar)
052   {
053      case 10:
054         if ((active0 & 0x4L) != 0L)
055            return jjStopAtPos(1, 2);
056         break;
057      default :
058         break;
059   }
060   return jjStartNfa_0(0, active0, 0L);
061}
062private int jjMoveNfa_0(int startState, int curPos)
063{
064   int startsAt = 0;
065   jjnewStateCnt = 175;
066   int i = 1;
067   jjstateSet[0] = startState;
068   int kind = 0x7fffffff;
069   for (;;)
070   {
071      if (++jjround == 0x7fffffff)
072         ReInitRounds();
073      if (curChar < 64)
074      {
075         long l = 1L << curChar;
076         do
077         {
078            switch(jjstateSet[--i])
079            {
080               case 0:
081                  if ((0x3ff000000000000L & l) != 0L)
082                  {
083                     if (kind > 39)
084                        kind = 39;
085                     { jjCheckNAddTwoStates(39, 37); }
086                  }
087                  else if (curChar == 45)
088                     { jjCheckNAdd(37); }
089                  if ((0x3fe000000000000L & l) != 0L)
090                     jjstateSet[jjnewStateCnt++] = 26;
091                  if ((0x3f000000000000L & l) != 0L)
092                     jjstateSet[jjnewStateCnt++] = 35;
093                  if ((0x7000000000000L & l) != 0L)
094                     jjstateSet[jjnewStateCnt++] = 33;
095                  break;
096               case 25:
097                  if ((0x3fe000000000000L & l) != 0L)
098                     jjstateSet[jjnewStateCnt++] = 26;
099                  break;
100               case 26:
101                  if ((0x3fe000000000000L & l) != 0L)
102                     { jjCheckNAddTwoStates(27, 30); }
103                  break;
104               case 27:
105                  if ((0xf000000000000L & l) != 0L)
106                     jjstateSet[jjnewStateCnt++] = 28;
107                  break;
108               case 28:
109                  if ((0x3ff000000000000L & l) != 0L)
110                     jjstateSet[jjnewStateCnt++] = 29;
111                  break;
112               case 29:
113                  if ((0x3ff000000000000L & l) != 0L && kind > 53)
114                     kind = 53;
115                  break;
116               case 30:
117                  if ((0x3fe000000000000L & l) != 0L)
118                     { jjCheckNAddTwoStates(31, 27); }
119                  break;
120               case 31:
121                  if ((0x3fe000000000000L & l) != 0L)
122                     { jjCheckNAdd(27); }
123                  break;
124               case 32:
125                  if ((0x7000000000000L & l) != 0L)
126                     jjstateSet[jjnewStateCnt++] = 33;
127                  break;
128               case 33:
129                  if ((0x3ff000000000000L & l) != 0L && kind > 54)
130                     kind = 54;
131                  break;
132               case 34:
133                  if ((0x3f000000000000L & l) != 0L)
134                     jjstateSet[jjnewStateCnt++] = 35;
135                  break;
136               case 35:
137                  if ((0x3ff000000000000L & l) != 0L && kind > 55)
138                     kind = 55;
139                  break;
140               case 36:
141                  if (curChar == 45)
142                     { jjCheckNAdd(37); }
143                  break;
144               case 37:
145                  if ((0x3ff000000000000L & l) == 0L)
146                     break;
147                  if (kind > 56)
148                     kind = 56;
149                  { jjCheckNAdd(37); }
150                  break;
151               case 38:
152                  if ((0x3ff000000000000L & l) == 0L)
153                     break;
154                  if (kind > 39)
155                     kind = 39;
156                  { jjCheckNAddTwoStates(39, 37); }
157                  break;
158               case 39:
159                  if ((0x3ff000000000000L & l) == 0L)
160                     break;
161                  if (kind > 39)
162                     kind = 39;
163                  { jjCheckNAdd(39); }
164                  break;
165               default : break;
166            }
167         } while(i != startsAt);
168      }
169      else if (curChar < 128)
170      {
171         long l = 1L << (curChar & 077);
172         do
173         {
174            switch(jjstateSet[--i])
175            {
176               case 0:
177                  if ((0x800000008000L & l) != 0L)
178                     { jjAddStates(0, 2); }
179                  else if ((0x100000001000L & l) != 0L)
180                     { jjAddStates(3, 4); }
181                  else if ((0x10000000100000L & l) != 0L)
182                     { jjAddStates(5, 17); }
183                  else if ((0x800000008L & l) != 0L)
184                     jjstateSet[jjnewStateCnt++] = 20;
185                  else if ((0x8000000080000L & l) != 0L)
186                     jjstateSet[jjnewStateCnt++] = 14;
187                  else if ((0x4000000040000L & l) != 0L)
188                     jjstateSet[jjnewStateCnt++] = 6;
189                  else if ((0x1000000010000L & l) != 0L)
190                     jjstateSet[jjnewStateCnt++] = 1;
191                  break;
192               case 1:
193                  if ((0x800000008000L & l) != 0L)
194                     jjstateSet[jjnewStateCnt++] = 2;
195                  break;
196               case 2:
197                  if ((0x80000000800000L & l) != 0L)
198                     jjstateSet[jjnewStateCnt++] = 3;
199                  break;
200               case 3:
201                  if ((0x2000000020L & l) != 0L)
202                     jjstateSet[jjnewStateCnt++] = 4;
203                  break;
204               case 4:
205                  if ((0x4000000040000L & l) != 0L && kind > 40)
206                     kind = 40;
207                  break;
208               case 5:
209                  if ((0x4000000040000L & l) != 0L)
210                     jjstateSet[jjnewStateCnt++] = 6;
211                  break;
212               case 6:
213                  if ((0x2000000020L & l) != 0L)
214                     jjstateSet[jjnewStateCnt++] = 7;
215                  break;
216               case 7:
217                  if ((0x1000000010000L & l) != 0L)
218                     jjstateSet[jjnewStateCnt++] = 8;
219                  break;
220               case 8:
221                  if ((0x800000008000L & l) != 0L)
222                     jjstateSet[jjnewStateCnt++] = 9;
223                  break;
224               case 9:
225                  if ((0x4000000040000L & l) != 0L)
226                     jjstateSet[jjnewStateCnt++] = 10;
227                  break;
228               case 10:
229                  if ((0x10000000100000L & l) != 0L)
230                     jjstateSet[jjnewStateCnt++] = 11;
231                  break;
232               case 11:
233                  if ((0x2000000020L & l) != 0L)
234                     jjstateSet[jjnewStateCnt++] = 12;
235                  break;
236               case 12:
237                  if ((0x4000000040000L & l) != 0L && kind > 41)
238                     kind = 41;
239                  break;
240               case 13:
241                  if ((0x8000000080000L & l) != 0L)
242                     jjstateSet[jjnewStateCnt++] = 14;
243                  break;
244               case 14:
245                  if ((0x2000000020L & l) != 0L)
246                     jjstateSet[jjnewStateCnt++] = 15;
247                  break;
248               case 15:
249                  if ((0x400000004000L & l) != 0L)
250                     jjstateSet[jjnewStateCnt++] = 16;
251                  break;
252               case 16:
253                  if ((0x8000000080000L & l) != 0L)
254                     jjstateSet[jjnewStateCnt++] = 17;
255                  break;
256               case 17:
257                  if ((0x800000008000L & l) != 0L)
258                     jjstateSet[jjnewStateCnt++] = 18;
259                  break;
260               case 18:
261                  if ((0x4000000040000L & l) != 0L && kind > 44)
262                     kind = 44;
263                  break;
264               case 19:
265                  if ((0x800000008L & l) != 0L)
266                     jjstateSet[jjnewStateCnt++] = 20;
267                  break;
268               case 20:
269                  if ((0x100000001000L & l) != 0L)
270                     jjstateSet[jjnewStateCnt++] = 21;
271                  break;
272               case 21:
273                  if ((0x800000008000L & l) != 0L)
274                     jjstateSet[jjnewStateCnt++] = 22;
275                  break;
276               case 22:
277                  if ((0x8000000080000L & l) != 0L)
278                     jjstateSet[jjnewStateCnt++] = 23;
279                  break;
280               case 23:
281                  if ((0x2000000020L & l) != 0L)
282                     jjstateSet[jjnewStateCnt++] = 24;
283                  break;
284               case 24:
285                  if ((0x1000000010L & l) != 0L && kind > 50)
286                     kind = 50;
287                  break;
288               case 40:
289                  if ((0x10000000100000L & l) != 0L)
290                     { jjAddStates(5, 17); }
291                  break;
292               case 41:
293                  if ((0x20000000200000L & l) != 0L)
294                     jjstateSet[jjnewStateCnt++] = 42;
295                  break;
296               case 42:
297                  if ((0x4000000040000L & l) != 0L)
298                     jjstateSet[jjnewStateCnt++] = 43;
299                  break;
300               case 43:
301                  if ((0x400000004000L & l) != 0L)
302                     jjstateSet[jjnewStateCnt++] = 44;
303                  break;
304               case 44:
305                  if ((0x800000008000L & l) != 0L)
306                     jjstateSet[jjnewStateCnt++] = 45;
307                  break;
308               case 45:
309                  if ((0x20000000200000L & l) != 0L)
310                     jjstateSet[jjnewStateCnt++] = 46;
311                  break;
312               case 46:
313                  if ((0x10000000100000L & l) != 0L && kind > 42)
314                     kind = 42;
315                  break;
316               case 47:
317                  if ((0x10000000100L & l) != 0L)
318                     jjstateSet[jjnewStateCnt++] = 48;
319                  break;
320               case 48:
321                  if ((0x4000000040000L & l) != 0L)
322                     jjstateSet[jjnewStateCnt++] = 49;
323                  break;
324               case 49:
325                  if ((0x800000008000L & l) != 0L)
326                     jjstateSet[jjnewStateCnt++] = 50;
327                  break;
328               case 50:
329                  if ((0x10000000100000L & l) != 0L)
330                     jjstateSet[jjnewStateCnt++] = 51;
331                  break;
332               case 51:
333                  if ((0x10000000100000L & l) != 0L)
334                     jjstateSet[jjnewStateCnt++] = 52;
335                  break;
336               case 52:
337                  if ((0x100000001000L & l) != 0L)
338                     jjstateSet[jjnewStateCnt++] = 53;
339                  break;
340               case 53:
341                  if ((0x2000000020L & l) != 0L && kind > 45)
342                     kind = 45;
343                  break;
344               case 54:
345                  if ((0x10000000100L & l) != 0L)
346                     jjstateSet[jjnewStateCnt++] = 55;
347                  break;
348               case 55:
349                  if ((0x4000000040000L & l) != 0L)
350                     jjstateSet[jjnewStateCnt++] = 56;
351                  break;
352               case 56:
353                  if ((0x800000008000L & l) != 0L)
354                     jjstateSet[jjnewStateCnt++] = 57;
355                  break;
356               case 57:
357                  if ((0x80000000800000L & l) != 0L)
358                     jjstateSet[jjnewStateCnt++] = 58;
359                  break;
360               case 58:
361                  if ((0x400000004000L & l) != 0L && kind > 50)
362                     kind = 50;
363                  break;
364               case 59:
365                  if ((0x4000000040000L & l) != 0L)
366                     jjstateSet[jjnewStateCnt++] = 60;
367                  break;
368               case 60:
369                  if ((0x200000002L & l) != 0L)
370                     jjstateSet[jjnewStateCnt++] = 61;
371                  break;
372               case 61:
373                  if ((0x20000000200L & l) != 0L)
374                     jjstateSet[jjnewStateCnt++] = 62;
375                  break;
376               case 62:
377                  if ((0x400000004000L & l) != 0L && kind > 57)
378                     kind = 57;
379                  break;
380               case 63:
381                  if ((0x4000000040000L & l) != 0L)
382                     jjstateSet[jjnewStateCnt++] = 64;
383                  break;
384               case 64:
385                  if ((0x200000002L & l) != 0L)
386                     jjstateSet[jjnewStateCnt++] = 65;
387                  break;
388               case 65:
389                  if ((0x20000000200L & l) != 0L)
390                     jjstateSet[jjnewStateCnt++] = 66;
391                  break;
392               case 66:
393                  if ((0x400000004000L & l) != 0L)
394                     jjstateSet[jjnewStateCnt++] = 67;
395                  break;
396               case 67:
397                  if ((0x8000000080000L & l) != 0L && kind > 58)
398                     kind = 58;
399                  break;
400               case 68:
401                  if ((0x4000000040000L & l) != 0L)
402                     jjstateSet[jjnewStateCnt++] = 69;
403                  break;
404               case 69:
405                  if ((0x200000002L & l) != 0L)
406                     jjstateSet[jjnewStateCnt++] = 70;
407                  break;
408               case 70:
409                  if ((0x20000000200L & l) != 0L)
410                     jjstateSet[jjnewStateCnt++] = 71;
411                  break;
412               case 71:
413                  if ((0x400000004000L & l) != 0L)
414                     jjstateSet[jjnewStateCnt++] = 72;
415                  break;
416               case 72:
417                  if ((0x80000000800000L & l) != 0L)
418                     jjstateSet[jjnewStateCnt++] = 73;
419                  break;
420               case 73:
421                  if ((0x2000000020L & l) != 0L)
422                     jjstateSet[jjnewStateCnt++] = 74;
423                  break;
424               case 74:
425                  if ((0x20000000200L & l) != 0L)
426                     jjstateSet[jjnewStateCnt++] = 75;
427                  break;
428               case 75:
429                  if ((0x8000000080L & l) != 0L)
430                     jjstateSet[jjnewStateCnt++] = 76;
431                  break;
432               case 76:
433                  if ((0x10000000100L & l) != 0L)
434                     jjstateSet[jjnewStateCnt++] = 77;
435                  break;
436               case 77:
437                  if ((0x10000000100000L & l) != 0L && kind > 60)
438                     kind = 60;
439                  break;
440               case 78:
441                  if ((0x4000000040000L & l) != 0L)
442                     jjstateSet[jjnewStateCnt++] = 79;
443                  break;
444               case 79:
445                  if ((0x200000002L & l) != 0L)
446                     jjstateSet[jjnewStateCnt++] = 80;
447                  break;
448               case 80:
449                  if ((0x20000000200L & l) != 0L)
450                     jjstateSet[jjnewStateCnt++] = 81;
451                  break;
452               case 81:
453                  if ((0x400000004000L & l) != 0L)
454                     jjstateSet[jjnewStateCnt++] = 82;
455                  break;
456               case 82:
457                  if ((0x100000001000L & l) != 0L)
458                     jjstateSet[jjnewStateCnt++] = 83;
459                  break;
460               case 83:
461                  if ((0x2000000020L & l) != 0L)
462                     jjstateSet[jjnewStateCnt++] = 84;
463                  break;
464               case 84:
465                  if ((0x400000004000L & l) != 0L)
466                     jjstateSet[jjnewStateCnt++] = 85;
467                  break;
468               case 85:
469                  if ((0x8000000080L & l) != 0L)
470                     jjstateSet[jjnewStateCnt++] = 86;
471                  break;
472               case 86:
473                  if ((0x10000000100000L & l) != 0L)
474                     jjstateSet[jjnewStateCnt++] = 87;
475                  break;
476               case 87:
477                  if ((0x10000000100000L & l) != 0L && kind > 61)
478                     kind = 61;
479                  break;
480               case 88:
481                  if ((0x4000000040000L & l) != 0L)
482                     jjstateSet[jjnewStateCnt++] = 89;
483                  break;
484               case 89:
485                  if ((0x200000002L & l) != 0L)
486                     jjstateSet[jjnewStateCnt++] = 90;
487                  break;
488               case 90:
489                  if ((0x20000000200L & l) != 0L)
490                     jjstateSet[jjnewStateCnt++] = 91;
491                  break;
492               case 91:
493                  if ((0x400000004000L & l) != 0L)
494                     jjstateSet[jjnewStateCnt++] = 92;
495                  break;
496               case 92:
497                  if ((0x800000008L & l) != 0L)
498                     jjstateSet[jjnewStateCnt++] = 93;
499                  break;
500               case 93:
501                  if ((0x200000002L & l) != 0L)
502                     jjstateSet[jjnewStateCnt++] = 94;
503                  break;
504               case 94:
505                  if ((0x4000000040000L & l) != 0L)
506                     jjstateSet[jjnewStateCnt++] = 95;
507                  break;
508               case 95:
509                  if ((0x8000000080000L & l) != 0L && kind > 62)
510                     kind = 62;
511                  break;
512               case 96:
513                  if ((0x4000000040000L & l) != 0L)
514                     jjstateSet[jjnewStateCnt++] = 97;
515                  break;
516               case 97:
517                  if ((0x200000002L & l) != 0L)
518                     jjstateSet[jjnewStateCnt++] = 98;
519                  break;
520               case 98:
521                  if ((0x20000000200L & l) != 0L)
522                     jjstateSet[jjnewStateCnt++] = 99;
523                  break;
524               case 99:
525                  if ((0x400000004000L & l) != 0L)
526                     jjstateSet[jjnewStateCnt++] = 100;
527                  break;
528               case 100:
529                  if ((0x100000001000L & l) != 0L)
530                     jjstateSet[jjnewStateCnt++] = 101;
531                  break;
532               case 101:
533                  if ((0x2000000020L & l) != 0L)
534                     jjstateSet[jjnewStateCnt++] = 102;
535                  break;
536               case 102:
537                  if ((0x200000002L & l) != 0L)
538                     jjstateSet[jjnewStateCnt++] = 103;
539                  break;
540               case 103:
541                  if ((0x1000000010L & l) != 0L)
542                     jjstateSet[jjnewStateCnt++] = 104;
543                  break;
544               case 104:
545                  if ((0x100000001000L & l) != 0L)
546                     jjstateSet[jjnewStateCnt++] = 105;
547                  break;
548               case 105:
549                  if ((0x800000008000L & l) != 0L)
550                     jjstateSet[jjnewStateCnt++] = 106;
551                  break;
552               case 106:
553                  if ((0x800000008L & l) != 0L)
554                     jjstateSet[jjnewStateCnt++] = 107;
555                  break;
556               case 107:
557                  if ((0x800000008000L & l) != 0L && kind > 63)
558                     kind = 63;
559                  break;
560               case 108:
561                  if ((0x4000000040000L & l) != 0L)
562                     jjstateSet[jjnewStateCnt++] = 109;
563                  break;
564               case 109:
565                  if ((0x200000002L & l) != 0L)
566                     jjstateSet[jjnewStateCnt++] = 110;
567                  break;
568               case 110:
569                  if ((0x20000000200L & l) != 0L)
570                     jjstateSet[jjnewStateCnt++] = 111;
571                  break;
572               case 111:
573                  if ((0x400000004000L & l) != 0L)
574                     jjstateSet[jjnewStateCnt++] = 112;
575                  break;
576               case 112:
577                  if ((0x800000008L & l) != 0L)
578                     jjstateSet[jjnewStateCnt++] = 113;
579                  break;
580               case 113:
581                  if ((0x200000002L & l) != 0L)
582                     jjstateSet[jjnewStateCnt++] = 114;
583                  break;
584               case 114:
585                  if ((0x400000004L & l) != 0L)
586                     jjstateSet[jjnewStateCnt++] = 115;
587                  break;
588               case 115:
589                  if ((0x800000008000L & l) != 0L)
590                     jjstateSet[jjnewStateCnt++] = 116;
591                  break;
592               case 116:
593                  if ((0x800000008000L & l) != 0L)
594                     jjstateSet[jjnewStateCnt++] = 117;
595                  break;
596               case 117:
597                  if ((0x8000000080000L & l) != 0L)
598                     jjstateSet[jjnewStateCnt++] = 118;
599                  break;
600               case 118:
601                  if ((0x2000000020L & l) != 0L && kind > 64)
602                     kind = 64;
603                  break;
604               case 119:
605                  if ((0x4000000040000L & l) != 0L)
606                     jjstateSet[jjnewStateCnt++] = 120;
607                  break;
608               case 120:
609                  if ((0x200000002L & l) != 0L)
610                     jjstateSet[jjnewStateCnt++] = 121;
611                  break;
612               case 121:
613                  if ((0x20000000200L & l) != 0L)
614                     jjstateSet[jjnewStateCnt++] = 122;
615                  break;
616               case 122:
617                  if ((0x400000004000L & l) != 0L)
618                     jjstateSet[jjnewStateCnt++] = 123;
619                  break;
620               case 123:
621                  if ((0x8000000080000L & l) != 0L)
622                     jjstateSet[jjnewStateCnt++] = 124;
623                  break;
624               case 124:
625                  if ((0x10000000100000L & l) != 0L)
626                     jjstateSet[jjnewStateCnt++] = 125;
627                  break;
628               case 125:
629                  if ((0x200000002L & l) != 0L)
630                     jjstateSet[jjnewStateCnt++] = 126;
631                  break;
632               case 126:
633                  if ((0x10000000100000L & l) != 0L)
634                     jjstateSet[jjnewStateCnt++] = 127;
635                  break;
636               case 127:
637                  if ((0x20000000200000L & l) != 0L)
638                     jjstateSet[jjnewStateCnt++] = 128;
639                  break;
640               case 128:
641                  if ((0x8000000080000L & l) != 0L && kind > 65)
642                     kind = 65;
643                  break;
644               case 129:
645                  if ((0x4000000040000L & l) != 0L)
646                     jjstateSet[jjnewStateCnt++] = 130;
647                  break;
648               case 130:
649                  if ((0x200000002L & l) != 0L)
650                     jjstateSet[jjnewStateCnt++] = 131;
651                  break;
652               case 131:
653                  if ((0x20000000200L & l) != 0L)
654                     jjstateSet[jjnewStateCnt++] = 132;
655                  break;
656               case 132:
657                  if ((0x400000004000L & l) != 0L)
658                     jjstateSet[jjnewStateCnt++] = 133;
659                  break;
660               case 133:
661                  if ((0x100000001000L & l) != 0L)
662                     jjstateSet[jjnewStateCnt++] = 134;
663                  break;
664               case 134:
665                  if ((0x800000008000L & l) != 0L)
666                     jjstateSet[jjnewStateCnt++] = 135;
667                  break;
668               case 135:
669                  if ((0x800000008L & l) != 0L)
670                     jjstateSet[jjnewStateCnt++] = 136;
671                  break;
672               case 136:
673                  if ((0x200000002L & l) != 0L)
674                     jjstateSet[jjnewStateCnt++] = 137;
675                  break;
676               case 137:
677                  if ((0x10000000100000L & l) != 0L)
678                     jjstateSet[jjnewStateCnt++] = 138;
679                  break;
680               case 138:
681                  if ((0x20000000200L & l) != 0L)
682                     jjstateSet[jjnewStateCnt++] = 139;
683                  break;
684               case 139:
685                  if ((0x800000008000L & l) != 0L)
686                     jjstateSet[jjnewStateCnt++] = 140;
687                  break;
688               case 140:
689                  if ((0x400000004000L & l) != 0L && kind > 66)
690                     kind = 66;
691                  break;
692               case 141:
693                  if ((0x2000000020L & l) != 0L)
694                     jjstateSet[jjnewStateCnt++] = 142;
695                  break;
696               case 142:
697                  if ((0x4000000040000L & l) != 0L)
698                     jjstateSet[jjnewStateCnt++] = 143;
699                  break;
700               case 143:
701                  if ((0x200000002000L & l) != 0L)
702                     jjstateSet[jjnewStateCnt++] = 144;
703                  break;
704               case 144:
705                  if ((0x20000000200L & l) != 0L)
706                     jjstateSet[jjnewStateCnt++] = 145;
707                  break;
708               case 145:
709                  if ((0x400000004000L & l) != 0L)
710                     jjstateSet[jjnewStateCnt++] = 146;
711                  break;
712               case 146:
713                  if ((0x200000002L & l) != 0L)
714                     jjstateSet[jjnewStateCnt++] = 147;
715                  break;
716               case 147:
717                  if ((0x10000000100000L & l) != 0L)
718                     jjstateSet[jjnewStateCnt++] = 148;
719                  break;
720               case 148:
721                  if ((0x2000000020L & l) != 0L && kind > 67)
722                     kind = 67;
723                  break;
724               case 149:
725                  if ((0x100000001000L & l) != 0L)
726                     { jjAddStates(3, 4); }
727                  break;
728               case 150:
729                  if ((0x20000000200L & l) != 0L)
730                     jjstateSet[jjnewStateCnt++] = 151;
731                  break;
732               case 151:
733                  if ((0x8000000080L & l) != 0L)
734                     jjstateSet[jjnewStateCnt++] = 152;
735                  break;
736               case 152:
737                  if ((0x10000000100L & l) != 0L)
738                     jjstateSet[jjnewStateCnt++] = 153;
739                  break;
740               case 153:
741                  if ((0x10000000100000L & l) != 0L && kind > 43)
742                     kind = 43;
743                  break;
744               case 154:
745                  if ((0x800000008000L & l) != 0L)
746                     jjstateSet[jjnewStateCnt++] = 155;
747                  break;
748               case 155:
749                  if ((0x800000008L & l) != 0L)
750                     jjstateSet[jjnewStateCnt++] = 156;
751                  break;
752               case 156:
753                  if ((0x200000002L & l) != 0L)
754                     jjstateSet[jjnewStateCnt++] = 157;
755                  break;
756               case 157:
757                  if ((0x10000000100000L & l) != 0L)
758                     jjstateSet[jjnewStateCnt++] = 158;
759                  break;
760               case 158:
761                  if ((0x20000000200L & l) != 0L)
762                     jjstateSet[jjnewStateCnt++] = 159;
763                  break;
764               case 159:
765                  if ((0x800000008000L & l) != 0L)
766                     jjstateSet[jjnewStateCnt++] = 160;
767                  break;
768               case 160:
769                  if ((0x400000004000L & l) != 0L)
770                     jjstateSet[jjnewStateCnt++] = 161;
771                  break;
772               case 161:
773                  if ((0x8000000080000L & l) != 0L && kind > 59)
774                     kind = 59;
775                  break;
776               case 162:
777                  if ((0x800000008000L & l) != 0L)
778                     { jjAddStates(0, 2); }
779                  break;
780               case 163:
781                  if ((0x1000000010000L & l) != 0L)
782                     jjstateSet[jjnewStateCnt++] = 164;
783                  break;
784               case 164:
785                  if ((0x2000000020L & l) != 0L)
786                     jjstateSet[jjnewStateCnt++] = 165;
787                  break;
788               case 165:
789                  if ((0x4000000040000L & l) != 0L)
790                     jjstateSet[jjnewStateCnt++] = 166;
791                  break;
792               case 166:
793                  if ((0x200000002L & l) != 0L)
794                     jjstateSet[jjnewStateCnt++] = 167;
795                  break;
796               case 167:
797                  if ((0x10000000100000L & l) != 0L)
798                     jjstateSet[jjnewStateCnt++] = 168;
799                  break;
800               case 168:
801                  if ((0x20000000200L & l) != 0L)
802                     jjstateSet[jjnewStateCnt++] = 169;
803                  break;
804               case 169:
805                  if ((0x800000008000L & l) != 0L)
806                     jjstateSet[jjnewStateCnt++] = 170;
807                  break;
808               case 170:
809                  if ((0x400000004000L & l) != 0L)
810                     jjstateSet[jjnewStateCnt++] = 171;
811                  break;
812               case 171:
813                  if ((0x8000000080000L & l) != 0L && kind > 46)
814                     kind = 46;
815                  break;
816               case 172:
817                  if ((0x400000004000L & l) != 0L && kind > 47)
818                     kind = 47;
819                  break;
820               case 173:
821                  if ((0x4000000040L & l) != 0L)
822                     jjstateSet[jjnewStateCnt++] = 174;
823                  break;
824               case 174:
825                  if ((0x4000000040L & l) != 0L && kind > 47)
826                     kind = 47;
827                  break;
828               default : break;
829            }
830         } while(i != startsAt);
831      }
832      else
833      {
834         int i2 = (curChar & 0xff) >> 6;
835         long l2 = 1L << (curChar & 077);
836         do
837         {
838            switch(jjstateSet[--i])
839            {
840               default : break;
841            }
842         } while(i != startsAt);
843      }
844      if (kind != 0x7fffffff)
845      {
846         jjmatchedKind = kind;
847         jjmatchedPos = curPos;
848         kind = 0x7fffffff;
849      }
850      ++curPos;
851      if ((i = jjnewStateCnt) == (startsAt = 175 - (jjnewStateCnt = startsAt)))
852         return curPos;
853      try { curChar = input_stream.readChar(); }
854      catch(java.io.IOException e) { return curPos; }
855   }
856}
857private final int jjStopStringLiteralDfa_2(int pos, long active0){
858   switch (pos)
859   {
860      default :
861         return -1;
862   }
863}
864private final int jjStartNfa_2(int pos, long active0){
865   return jjMoveNfa_2(jjStopStringLiteralDfa_2(pos, active0), pos + 1);
866}
867private int jjMoveStringLiteralDfa0_2(){
868   switch(curChar)
869   {
870      case 10:
871         return jjStopAtPos(0, 5);
872      case 44:
873         return jjStopAtPos(0, 38);
874      default :
875         return jjMoveNfa_2(0, 0);
876   }
877}
878static final long[] jjbitVec0 = {
879   0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
880};
881private int jjMoveNfa_2(int startState, int curPos)
882{
883   int startsAt = 0;
884   jjnewStateCnt = 1;
885   int i = 1;
886   jjstateSet[0] = startState;
887   int kind = 0x7fffffff;
888   for (;;)
889   {
890      if (++jjround == 0x7fffffff)
891         ReInitRounds();
892      if (curChar < 64)
893      {
894         long l = 1L << curChar;
895         do
896         {
897            switch(jjstateSet[--i])
898            {
899               case 0:
900                  if ((0xffffefffffffdbffL & l) != 0L)
901                     kind = 37;
902                  break;
903               default : break;
904            }
905         } while(i != startsAt);
906      }
907      else if (curChar < 128)
908      {
909         long l = 1L << (curChar & 077);
910         do
911         {
912            switch(jjstateSet[--i])
913            {
914               case 0:
915                  kind = 37;
916                  break;
917               default : break;
918            }
919         } while(i != startsAt);
920      }
921      else
922      {
923         int i2 = (curChar & 0xff) >> 6;
924         long l2 = 1L << (curChar & 077);
925         do
926         {
927            switch(jjstateSet[--i])
928            {
929               case 0:
930                  if ((jjbitVec0[i2] & l2) != 0L && kind > 37)
931                     kind = 37;
932                  break;
933               default : break;
934            }
935         } while(i != startsAt);
936      }
937      if (kind != 0x7fffffff)
938      {
939         jjmatchedKind = kind;
940         jjmatchedPos = curPos;
941         kind = 0x7fffffff;
942      }
943      ++curPos;
944      if ((i = jjnewStateCnt) == (startsAt = 1 - (jjnewStateCnt = startsAt)))
945         return curPos;
946      try { curChar = input_stream.readChar(); }
947      catch(java.io.IOException e) { return curPos; }
948   }
949}
950private final int jjStopStringLiteralDfa_1(int pos, long active0){
951   switch (pos)
952   {
953      default :
954         return -1;
955   }
956}
957private final int jjStartNfa_1(int pos, long active0){
958   return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0), pos + 1);
959}
960private int jjMoveStringLiteralDfa0_1(){
961   switch(curChar)
962   {
963      case 10:
964         return jjStopAtPos(0, 5);
965      default :
966         return jjMoveNfa_1(0, 0);
967   }
968}
969private int jjMoveNfa_1(int startState, int curPos)
970{
971   int startsAt = 0;
972   jjnewStateCnt = 8;
973   int i = 1;
974   jjstateSet[0] = startState;
975   int kind = 0x7fffffff;
976   for (;;)
977   {
978      if (++jjround == 0x7fffffff)
979         ReInitRounds();
980      if (curChar < 64)
981      {
982         long l = 1L << curChar;
983         do
984         {
985            switch(jjstateSet[--i])
986            {
987               case 1:
988                  if ((0x3ff000000000000L & l) == 0L)
989                     break;
990                  if (kind > 33)
991                     kind = 33;
992                  jjstateSet[jjnewStateCnt++] = 1;
993                  break;
994               case 3:
995                  if ((0x3ff000000000000L & l) == 0L)
996                     break;
997                  if (kind > 34)
998                     kind = 34;
999                  jjstateSet[jjnewStateCnt++] = 3;
1000                  break;
1001               case 5:
1002                  if ((0x3ff000000000000L & l) == 0L)
1003                     break;
1004                  if (kind > 35)
1005                     kind = 35;
1006                  jjstateSet[jjnewStateCnt++] = 5;
1007                  break;
1008               case 7:
1009                  if ((0x3ff000000000000L & l) == 0L)
1010                     break;
1011                  if (kind > 36)
1012                     kind = 36;
1013                  jjstateSet[jjnewStateCnt++] = 7;
1014                  break;
1015               default : break;
1016            }
1017         } while(i != startsAt);
1018      }
1019      else if (curChar < 128)
1020      {
1021         long l = 1L << (curChar & 077);
1022         do
1023         {
1024            switch(jjstateSet[--i])
1025            {
1026               case 0:
1027                  if ((0x4000000040000L & l) != 0L)
1028                     jjstateSet[jjnewStateCnt++] = 7;
1029                  else if ((0x100000001000L & l) != 0L)
1030                     jjstateSet[jjnewStateCnt++] = 5;
1031                  else if ((0x8000000080000L & l) != 0L)
1032                     jjstateSet[jjnewStateCnt++] = 3;
1033                  else if ((0x10000000100000L & l) != 0L)
1034                     jjstateSet[jjnewStateCnt++] = 1;
1035                  break;
1036               case 2:
1037                  if ((0x8000000080000L & l) != 0L)
1038                     jjstateSet[jjnewStateCnt++] = 3;
1039                  break;
1040               case 4:
1041                  if ((0x100000001000L & l) != 0L)
1042                     jjstateSet[jjnewStateCnt++] = 5;
1043                  break;
1044               case 6:
1045                  if ((0x4000000040000L & l) != 0L)
1046                     jjstateSet[jjnewStateCnt++] = 7;
1047                  break;
1048               default : break;
1049            }
1050         } while(i != startsAt);
1051      }
1052      else
1053      {
1054         int i2 = (curChar & 0xff) >> 6;
1055         long l2 = 1L << (curChar & 077);
1056         do
1057         {
1058            switch(jjstateSet[--i])
1059            {
1060               default : break;
1061            }
1062         } while(i != startsAt);
1063      }
1064      if (kind != 0x7fffffff)
1065      {
1066         jjmatchedKind = kind;
1067         jjmatchedPos = curPos;
1068         kind = 0x7fffffff;
1069      }
1070      ++curPos;
1071      if ((i = jjnewStateCnt) == (startsAt = 8 - (jjnewStateCnt = startsAt)))
1072         return curPos;
1073      try { curChar = input_stream.readChar(); }
1074      catch(java.io.IOException e) { return curPos; }
1075   }
1076}
1077
1078/* Token literal values. */
1079public static final String[] jjstrLiteralImages = {
1080"", null, null, null, null, null, null, null, null, null, null, null, null, 
1081null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
1082null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
1083null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
1084null, null, null, null, null, null, null, null, null, null, null, null, null, "\75", };
1085protected Token jjFillToken()
1086{
1087   final Token t;
1088   final String curTokenImage;
1089   final int beginLine;
1090   final int endLine;
1091   final int beginColumn;
1092   final int endColumn;
1093   String im = jjstrLiteralImages[jjmatchedKind];
1094   curTokenImage = (im == null) ? input_stream.GetImage() : im;
1095   beginLine = input_stream.getBeginLine();
1096   beginColumn = input_stream.getBeginColumn();
1097   endLine = input_stream.getEndLine();
1098   endColumn = input_stream.getEndColumn();
1099   t = Token.newToken(jjmatchedKind);
1100   t.kind = jjmatchedKind;
1101   t.image = curTokenImage;
1102
1103   t.beginLine = beginLine;
1104   t.endLine = endLine;
1105   t.beginColumn = beginColumn;
1106   t.endColumn = endColumn;
1107
1108   return t;
1109}
1110static final int[] jjnextStates = {
1111   163, 172, 173, 150, 154, 41, 47, 54, 59, 63, 68, 78, 88, 96, 108, 119, 
1112   129, 141, 
1113};
1114
1115int curLexState = 0;
1116int defaultLexState = 0;
1117int jjnewStateCnt;
1118int jjround;
1119int jjmatchedPos;
1120int jjmatchedKind;
1121
1122/* Get the next Token. */
1123public Token getNextToken() 
1124{
1125  Token matchedToken;
1126  int curPos = 0;
1127
1128  EOFLoop :
1129  for (;;)
1130  {
1131   try
1132   {
1133      curChar = input_stream.BeginToken();
1134   }
1135   catch(Exception e)
1136   {
1137      jjmatchedKind = 0;
1138      jjmatchedPos = -1;
1139      matchedToken = jjFillToken();
1140      return matchedToken;
1141   }
1142
1143   for (;;)
1144   {
1145     switch(curLexState)
1146     {
1147       case 0:
1148         try { input_stream.backup(0);
1149            while (curChar <= 32 && (0x100002200L & (1L << curChar)) != 0L)
1150               curChar = input_stream.BeginToken();
1151         }
1152         catch (java.io.IOException e1) { continue EOFLoop; }
1153         jjmatchedKind = 0x7fffffff;
1154         jjmatchedPos = 0;
1155         curPos = jjMoveStringLiteralDfa0_0();
1156         break;
1157       case 1:
1158         jjmatchedKind = 0x7fffffff;
1159         jjmatchedPos = 0;
1160         curPos = jjMoveStringLiteralDfa0_1();
1161         if (jjmatchedPos == 0 && jjmatchedKind > 32)
1162         {
1163            jjmatchedKind = 32;
1164         }
1165         break;
1166       case 2:
1167         jjmatchedKind = 0x7fffffff;
1168         jjmatchedPos = 0;
1169         curPos = jjMoveStringLiteralDfa0_2();
1170         break;
1171     }
1172     if (jjmatchedKind != 0x7fffffff)
1173     {
1174        if (jjmatchedPos + 1 < curPos)
1175           input_stream.backup(curPos - jjmatchedPos - 1);
1176        if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1177        {
1178           matchedToken = jjFillToken();
1179       if (jjnewLexState[jjmatchedKind] != -1)
1180         curLexState = jjnewLexState[jjmatchedKind];
1181           return matchedToken;
1182        }
1183        else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1184        {
1185         if (jjnewLexState[jjmatchedKind] != -1)
1186           curLexState = jjnewLexState[jjmatchedKind];
1187           continue EOFLoop;
1188        }
1189      if (jjnewLexState[jjmatchedKind] != -1)
1190        curLexState = jjnewLexState[jjmatchedKind];
1191        curPos = 0;
1192        jjmatchedKind = 0x7fffffff;
1193        try {
1194           curChar = input_stream.readChar();
1195           continue;
1196        }
1197        catch (java.io.IOException e1) { }
1198     }
1199     int error_line = input_stream.getEndLine();
1200     int error_column = input_stream.getEndColumn();
1201     String error_after = null;
1202     boolean EOFSeen = false;
1203     try { input_stream.readChar(); input_stream.backup(1); }
1204     catch (java.io.IOException e1) {
1205        EOFSeen = true;
1206        error_after = curPos <= 1 ? "" : input_stream.GetImage();
1207        if (curChar == '\n' || curChar == '\r') {
1208           error_line++;
1209           error_column = 0;
1210        }
1211        else
1212           error_column++;
1213     }
1214     if (!EOFSeen) {
1215        input_stream.backup(1);
1216        error_after = curPos <= 1 ? "" : input_stream.GetImage();
1217     }
1218     throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
1219   }
1220  }
1221}
1222
1223void SkipLexicalActions(Token matchedToken)
1224{
1225   switch(jjmatchedKind)
1226   {
1227      default :
1228         break;
1229   }
1230}
1231void MoreLexicalActions()
1232{
1233   jjimageLen += (lengthOfMatch = jjmatchedPos + 1);
1234   switch(jjmatchedKind)
1235   {
1236      default :
1237         break;
1238   }
1239}
1240void TokenLexicalActions(Token matchedToken)
1241{
1242   switch(jjmatchedKind)
1243   {
1244      default :
1245         break;
1246   }
1247}
1248private void jjCheckNAdd(int state)
1249{
1250   if (jjrounds[state] != jjround)
1251   {
1252      jjstateSet[jjnewStateCnt++] = state;
1253      jjrounds[state] = jjround;
1254   }
1255}
1256private void jjAddStates(int start, int end)
1257{
1258   do {
1259      jjstateSet[jjnewStateCnt++] = jjnextStates[start];
1260   } while (start++ != end);
1261}
1262private void jjCheckNAddTwoStates(int state1, int state2)
1263{
1264   jjCheckNAdd(state1);
1265   jjCheckNAdd(state2);
1266}
1267
1268    /* Constructor. */
1269    public JmriServerParserTokenManager(SimpleCharStream stream){
1270
1271      if (SimpleCharStream.staticFlag)
1272            throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
1273
1274    input_stream = stream;
1275  }
1276
1277  /* Constructor. */
1278  public JmriServerParserTokenManager (SimpleCharStream stream, int lexState){
1279    ReInit(stream);
1280    SwitchTo(lexState);
1281  }
1282
1283  /* Reinitialise parser. */
1284  
1285  public void ReInit(SimpleCharStream stream)
1286  {
1287
1288
1289    jjmatchedPos =
1290    jjnewStateCnt =
1291    0;
1292    curLexState = defaultLexState;
1293    input_stream = stream;
1294    ReInitRounds();
1295  }
1296
1297  private void ReInitRounds()
1298  {
1299    int i;
1300    jjround = 0x80000001;
1301    for (i = 175; i-- > 0;)
1302      jjrounds[i] = 0x80000000;
1303  }
1304
1305  /* Reinitialise parser. */
1306  public void ReInit(SimpleCharStream stream, int lexState)
1307  
1308  {
1309    ReInit(stream);
1310    SwitchTo(lexState);
1311  }
1312
1313  /* Switch to specified lex state. */
1314  public void SwitchTo(int lexState)
1315  {
1316    if (lexState >= 3 || lexState < 0)
1317      throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
1318    else
1319      curLexState = lexState;
1320  }
1321
1322
1323/* Lexer state names. */
1324public static final String[] lexStateNames = {
1325   "DEFAULT",
1326   "DEVICENAME",
1327   "VALUE",
1328};
1329
1330/* Lex State array. */
1331public static final int[] jjnewLexState = {
1332   -1, -1, -1, -1, -1, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
1333   -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, -1, 0, -1, -1, 1, 1, 1, 1, -1, -1, -1, -1, -1, 
1334   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2, 
1335};
1336static final long[] jjtoToken = {
1337   0xffe4ffde00000021L, 0x1fL, 
1338};
1339static final long[] jjtoSkip = {
1340   0x1eL, 0x0L, 
1341};
1342static final long[] jjtoSpecial = {
1343   0x0L, 0x0L, 
1344};
1345static final long[] jjtoMore = {
1346   0x2100000000L, 0x0L, 
1347};
1348    protected SimpleCharStream  input_stream;
1349
1350    private final int[] jjrounds = new int[175];
1351    private final int[] jjstateSet = new int[2 * 175];
1352    private final StringBuilder jjimage = new StringBuilder();
1353    private StringBuilder image = jjimage;
1354    private int jjimageLen;
1355    private int lengthOfMatch;
1356    protected int curChar;
1357}