Source code

001/* SRCPClientParser.java */
002/* Generated By:JJTree&JavaCC: Do not edit this line. SRCPClientParser.java */
003package jmri.jmrix.srcp.parser;
004
005import org.slf4j.Logger;
006import org.slf4j.LoggerFactory;
007
008/*
009 * This file defines a JavaTree/JavaCC parser implementation for
010 * the SRCP protocol responses to the client.
011 *
012 * @author Paul Bender Copyright (C) 2011
013 */
014
015// This is generated code.  DO NOT ATTEMPT TO FIX ANY FINDBUGS WARNINGS
016@edu.umd.cs.findbugs.annotations.SuppressFBWarnings({
017    "NM_METHOD_NAMING_CONVENTION","RCN_REDUNDANT_NULLCHECK_OF_NONNULL_VALUE",
018    "SLF4J_FORMAT_SHOULD_BE_CONST","THROWS_METHOD_THROWS_RUNTIMEEXCEPTION"})
019
020public class SRCPClientParser/*@bgen(jjtree)*/implements SRCPClientParserTreeConstants, SRCPClientParserConstants {/*@bgen(jjtree)*/
021  protected JJTSRCPClientParserState jjtree = new JJTSRCPClientParserState();
022   private final static Logger log = LoggerFactory.getLogger(SRCPClientParser.class.getName());
023
024// Lexical specifications begin here
025  final public 
026SimpleNode handshakeresponse() throws ParseException {/*@bgen(jjtree) handshakeresponse */
027                                ASThandshakeresponse jjtn000 = new ASThandshakeresponse(JJTHANDSHAKERESPONSE);
028                                boolean jjtc000 = true;
029                                jjtree.openNodeScope(jjtn000);
030                                jjtn000.jjtSetFirstToken(getToken(1));SimpleNode t; SimpleNode s;
031    try {
032      // this should match any valid response to the client in handshake
033        // mode.
034        t = timestamp();
035      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
036      case SRCP:{
037        s = serviceversion();
038        break;
039        }
040      case ZEROADDR:
041      case NONZEROADDR:{
042        s = inforesponse();
043        break;
044        }
045      default:
046        jj_la1[0] = jj_gen;
047        jj_consume_token(-1);
048        throw new ParseException();
049      }
050jjtree.closeNodeScope(jjtn000, true);
051    jjtc000 = false;
052    jjtn000.jjtSetLastToken(getToken(0));
053jjtn000.jjtSetValue(s.jjtGetValue());
054    log.debug("Handshake Response Production: "+jjtn000.jjtGetValue());
055    {if ("" != null) return jjtn000;}
056    } catch (Throwable jjte000) {
057if (jjtc000) {
058      jjtree.clearNodeScope(jjtn000);
059      jjtc000 = false;
060    } else {
061      jjtree.popNode();
062    }
063    if (jjte000 instanceof RuntimeException) {
064      {if (true) throw (RuntimeException)jjte000;}
065    }
066    if (jjte000 instanceof ParseException) {
067      {if (true) throw (ParseException)jjte000;}
068    }
069    {if (true) throw (Error)jjte000;}
070    } finally {
071if (jjtc000) {
072      jjtree.closeNodeScope(jjtn000, true);
073      jjtn000.jjtSetLastToken(getToken(0));
074    }
075    }
076    throw new Error("Missing return statement in function");
077}
078
079  final public SimpleNode timestamp() throws ParseException {/*@bgen(jjtree) timestamp */
080                         ASTtimestamp jjtn000 = new ASTtimestamp(JJTTIMESTAMP);
081                         boolean jjtc000 = true;
082                         jjtree.openNodeScope(jjtn000);
083                         jjtn000.jjtSetFirstToken(getToken(1));Token t;
084    try {
085      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
086      case TIMESTAMP:{
087        t = jj_consume_token(TIMESTAMP);
088        break;
089        }
090      case NONZEROADDR:{
091        t = jj_consume_token(NONZEROADDR);
092        break;
093        }
094      case ZEROADDR:{
095        t = jj_consume_token(ZEROADDR);
096        break;
097        }
098      default:
099        jj_la1[1] = jj_gen;
100        jj_consume_token(-1);
101        throw new ParseException();
102      }
103jjtree.closeNodeScope(jjtn000, true);
104    jjtc000 = false;
105    jjtn000.jjtSetLastToken(getToken(0));
106jjtn000.jjtSetValue(t.image);
107    log.debug("Timestamp Production: "+jjtn000.jjtGetValue());
108    {if ("" != null) return jjtn000;}
109    } finally {
110if (jjtc000) {
111       jjtree.closeNodeScope(jjtn000, true);
112       jjtn000.jjtSetLastToken(getToken(0));
113     }
114    }
115    throw new Error("Missing return statement in function");
116}
117
118  final public SimpleNode serviceversion() throws ParseException {/*@bgen(jjtree) serviceversion */
119                             ASTserviceversion jjtn000 = new ASTserviceversion(JJTSERVICEVERSION);
120                             boolean jjtc000 = true;
121                             jjtree.openNodeScope(jjtn000);
122                             jjtn000.jjtSetFirstToken(getToken(1));Token t; Token s;
123    try {
124      t = jj_consume_token(SRCP);
125      s = jj_consume_token(VERSION);
126      jj_consume_token(EOL);
127jjtree.closeNodeScope(jjtn000, true);
128    jjtc000 = false;
129    jjtn000.jjtSetLastToken(getToken(0));
130log.debug("Service Version Production");
131    jjtn000.jjtSetValue(t.image +" " + s.image);
132    {if ("" != null) return jjtn000;}
133    } finally {
134if (jjtc000) {
135      jjtree.closeNodeScope(jjtn000, true);
136      jjtn000.jjtSetLastToken(getToken(0));
137    }
138    }
139    throw new Error("Missing return statement in function");
140}
141
142  final public SimpleNode inforesponse() throws ParseException {/*@bgen(jjtree) inforesponse */
143                            ASTinforesponse jjtn000 = new ASTinforesponse(JJTINFORESPONSE);
144                            boolean jjtc000 = true;
145                            jjtree.openNodeScope(jjtn000);
146                            jjtn000.jjtSetFirstToken(getToken(1));SimpleNode t; SimpleNode s;
147    try {
148      address();
149      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
150      case INFO:{
151        s = info();
152        break;
153        }
154      case OK:{
155        s = ok();
156        break;
157        }
158      case ERROR:{
159        s = error();
160        break;
161        }
162      default:
163        jj_la1[2] = jj_gen;
164        jj_consume_token(-1);
165        throw new ParseException();
166      }
167jjtree.closeNodeScope(jjtn000, true);
168    jjtc000 = false;
169    jjtn000.jjtSetLastToken(getToken(0));
170jjtn000.jjtSetValue("");
171    log.debug("Information Response Production: " + jjtn000.jjtGetValue() );
172    {if ("" != null) return jjtn000;}
173    } catch (Throwable jjte000) {
174if (jjtc000) {
175      jjtree.clearNodeScope(jjtn000);
176      jjtc000 = false;
177    } else {
178      jjtree.popNode();
179    }
180    if (jjte000 instanceof RuntimeException) {
181      {if (true) throw (RuntimeException)jjte000;}
182    }
183    if (jjte000 instanceof ParseException) {
184      {if (true) throw (ParseException)jjte000;}
185    }
186    {if (true) throw (Error)jjte000;}
187    } finally {
188if (jjtc000) {
189      jjtree.closeNodeScope(jjtn000, true);
190      jjtn000.jjtSetLastToken(getToken(0));
191    }
192    }
193    throw new Error("Missing return statement in function");
194}
195
196  final public SimpleNode info() throws ParseException {/*@bgen(jjtree) info */
197                   ASTinfo jjtn000 = new ASTinfo(JJTINFO);
198                   boolean jjtc000 = true;
199                   jjtree.openNodeScope(jjtn000);
200                   jjtn000.jjtSetFirstToken(getToken(1));Token t;SimpleNode s; SimpleNode r;
201    try {
202      t = jj_consume_token(INFO);
203      bus();
204      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
205      case FB:{
206        fb();
207        jj_consume_token(EOL);
208        break;
209        }
210      case GA:{
211        ga();
212        jj_consume_token(EOL);
213        break;
214        }
215      case GL:{
216        gl();
217        jj_consume_token(EOL);
218        break;
219        }
220      case SM:{
221        sm();
222        break;
223        }
224      case TIME:{
225        time();
226        break;
227        }
228      case POWER:{
229        power();
230        break;
231        }
232      case SESSION:{
233        session();
234        break;
235        }
236      case SERVER:{
237        server();
238        break;
239        }
240      case DESCRIPTION:{
241        description();
242        break;
243        }
244      case LOCK:{
245        lock();
246        break;
247        }
248      default:
249        jj_la1[3] = jj_gen;
250        jj_consume_token(-1);
251        throw new ParseException();
252      }
253jjtree.closeNodeScope(jjtn000, true);
254    jjtc000 = false;
255    jjtn000.jjtSetLastToken(getToken(0));
256jjtn000.jjtSetValue(t.image );
257    log.debug("Information Response Production: " + jjtn000.jjtGetValue() );
258    {if ("" != null) return jjtn000;}
259    } catch (Throwable jjte000) {
260if (jjtc000) {
261       jjtree.clearNodeScope(jjtn000);
262       jjtc000 = false;
263     } else {
264       jjtree.popNode();
265     }
266     if (jjte000 instanceof RuntimeException) {
267       {if (true) throw (RuntimeException)jjte000;}
268     }
269     if (jjte000 instanceof ParseException) {
270       {if (true) throw (ParseException)jjte000;}
271     }
272     {if (true) throw (Error)jjte000;}
273    } finally {
274if (jjtc000) {
275       jjtree.closeNodeScope(jjtn000, true);
276       jjtn000.jjtSetLastToken(getToken(0));
277     }
278    }
279    throw new Error("Missing return statement in function");
280}
281
282  final public SimpleNode error() throws ParseException {/*@bgen(jjtree) error */
283                    ASTerror jjtn000 = new ASTerror(JJTERROR);
284                    boolean jjtc000 = true;
285                    jjtree.openNodeScope(jjtn000);
286                    jjtn000.jjtSetFirstToken(getToken(1));Token t;Token r;
287    try {
288      t = jj_consume_token(ERROR);
289      r = jj_consume_token(EOL);
290jjtree.closeNodeScope(jjtn000, true);
291    jjtc000 = false;
292    jjtn000.jjtSetLastToken(getToken(0));
293jjtn000.jjtSetValue(t.image + r.image);
294    //jjtThis.jjtSetValue(r.image);
295    log.debug("Error Response Production: " + jjtn000.jjtGetValue() );
296    {if ("" != null) return jjtn000;}
297    } finally {
298if (jjtc000) {
299       jjtree.closeNodeScope(jjtn000, true);
300       jjtn000.jjtSetLastToken(getToken(0));
301     }
302    }
303    throw new Error("Missing return statement in function");
304}
305
306  final public SimpleNode ok() throws ParseException {/*@bgen(jjtree) ok */
307                 ASTok jjtn000 = new ASTok(JJTOK);
308                 boolean jjtc000 = true;
309                 jjtree.openNodeScope(jjtn000);
310                 jjtn000.jjtSetFirstToken(getToken(1));Token t;Token r;
311    try {
312      t = jj_consume_token(OK);
313      r = jj_consume_token(EOL);
314jjtree.closeNodeScope(jjtn000, true);
315    jjtc000 = false;
316    jjtn000.jjtSetLastToken(getToken(0));
317jjtn000.jjtSetValue(t.image + " " + r.image);
318    log.debug("OK Response Production: " + jjtn000.jjtGetValue() );
319    {if ("" != null) return jjtn000;}
320    } finally {
321if (jjtc000) {
322      jjtree.closeNodeScope(jjtn000, true);
323      jjtn000.jjtSetLastToken(getToken(0));
324    }
325    }
326    throw new Error("Missing return statement in function");
327}
328
329  final public SimpleNode commandresponse() throws ParseException {/*@bgen(jjtree) commandresponse */
330                              ASTcommandresponse jjtn000 = new ASTcommandresponse(JJTCOMMANDRESPONSE);
331                              boolean jjtc000 = true;
332                              jjtree.openNodeScope(jjtn000);
333                              jjtn000.jjtSetFirstToken(getToken(1));SimpleNode t; SimpleNode s;
334    try {
335      // this should match any valid response to the client in
336        // either command mode or info mode.
337        t = timestamp();
338      s = inforesponse();
339jjtree.closeNodeScope(jjtn000, true);
340    jjtc000 = false;
341    jjtn000.jjtSetLastToken(getToken(0));
342log.debug("Command Mode Response Production");
343    jjtn000.jjtSetValue(s.jjtGetValue() );
344
345    {if ("" != null) return jjtn000;}
346    } catch (Throwable jjte000) {
347if (jjtc000) {
348      jjtree.clearNodeScope(jjtn000);
349      jjtc000 = false;
350    } else {
351      jjtree.popNode();
352    }
353    if (jjte000 instanceof RuntimeException) {
354      {if (true) throw (RuntimeException)jjte000;}
355    }
356    if (jjte000 instanceof ParseException) {
357      {if (true) throw (ParseException)jjte000;}
358    }
359    {if (true) throw (Error)jjte000;}
360    } finally {
361if (jjtc000) {
362      jjtree.closeNodeScope(jjtn000, true);
363      jjtn000.jjtSetLastToken(getToken(0));
364    }
365    }
366    throw new Error("Missing return statement in function");
367}
368
369  final public SimpleNode bus() throws ParseException {/*@bgen(jjtree) bus */
370                  ASTbus jjtn000 = new ASTbus(JJTBUS);
371                  boolean jjtc000 = true;
372                  jjtree.openNodeScope(jjtn000);
373                  jjtn000.jjtSetFirstToken(getToken(1));SimpleNode s;
374    try {
375      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
376      case ZEROADDR:{
377        s = zeroaddress();
378        break;
379        }
380      case NONZEROADDR:{
381        s = nonzeroaddress();
382        break;
383        }
384      default:
385        jj_la1[4] = jj_gen;
386        jj_consume_token(-1);
387        throw new ParseException();
388      }
389jjtree.closeNodeScope(jjtn000, true);
390    jjtc000 = false;
391    jjtn000.jjtSetLastToken(getToken(0));
392log.debug("BUS Production "+ s.jjtGetValue());
393    jjtn000.jjtSetValue(s.jjtGetValue());
394    {if ("" != null) return jjtn000;}
395    } catch (Throwable jjte000) {
396if (jjtc000) {
397      jjtree.clearNodeScope(jjtn000);
398      jjtc000 = false;
399    } else {
400      jjtree.popNode();
401    }
402    if (jjte000 instanceof RuntimeException) {
403      {if (true) throw (RuntimeException)jjte000;}
404    }
405    if (jjte000 instanceof ParseException) {
406      {if (true) throw (ParseException)jjte000;}
407    }
408    {if (true) throw (Error)jjte000;}
409    } finally {
410if (jjtc000) {
411      jjtree.closeNodeScope(jjtn000, true);
412      jjtn000.jjtSetLastToken(getToken(0));
413    }
414    }
415    throw new Error("Missing return statement in function");
416}
417
418  final public SimpleNode power() throws ParseException {/*@bgen(jjtree) power */
419                    ASTpower jjtn000 = new ASTpower(JJTPOWER);
420                    boolean jjtc000 = true;
421                    jjtree.openNodeScope(jjtn000);
422                    jjtn000.jjtSetFirstToken(getToken(1));Token t; SimpleNode r;
423    try {
424      t = jj_consume_token(POWER);
425      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
426      case ONOFF:{
427        r = onoff();
428        break;
429        }
430      case EOL:{
431        jj_consume_token(EOL);
432        break;
433        }
434      default:
435        jj_la1[5] = jj_gen;
436        jj_consume_token(-1);
437        throw new ParseException();
438      }
439jjtree.closeNodeScope(jjtn000, true);
440    jjtc000 = false;
441    jjtn000.jjtSetLastToken(getToken(0));
442log.debug("POWER Production "+ t.image);
443    //jjtThis.jjtSetValue(t.image + " " + r.jjtGetValue() );
444    jjtn000.jjtSetValue(t.image );
445    {if ("" != null) return jjtn000;}
446    } catch (Throwable jjte000) {
447if (jjtc000) {
448      jjtree.clearNodeScope(jjtn000);
449      jjtc000 = false;
450    } else {
451      jjtree.popNode();
452    }
453    if (jjte000 instanceof RuntimeException) {
454      {if (true) throw (RuntimeException)jjte000;}
455    }
456    if (jjte000 instanceof ParseException) {
457      {if (true) throw (ParseException)jjte000;}
458    }
459    {if (true) throw (Error)jjte000;}
460    } finally {
461if (jjtc000) {
462      jjtree.closeNodeScope(jjtn000, true);
463      jjtn000.jjtSetLastToken(getToken(0));
464    }
465    }
466    throw new Error("Missing return statement in function");
467}
468
469  final public void address() throws ParseException {SimpleNode s;
470    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
471    case ZEROADDR:{
472      s = zeroaddress();
473      break;
474      }
475    case NONZEROADDR:{
476      s = nonzeroaddress();
477      break;
478      }
479    default:
480      jj_la1[6] = jj_gen;
481      jj_consume_token(-1);
482      throw new ParseException();
483    }
484log.debug("Address Production "+ s.jjtGetValue());
485    //jjtThis.jjtSetValue(s.jjtGetValue());
486    //return jjtThis;
487
488}
489
490  final public SimpleNode zeroaddress() throws ParseException {/*@bgen(jjtree) zeroaddress */
491                          ASTzeroaddress jjtn000 = new ASTzeroaddress(JJTZEROADDRESS);
492                          boolean jjtc000 = true;
493                          jjtree.openNodeScope(jjtn000);
494                          jjtn000.jjtSetFirstToken(getToken(1));Token t;
495    try {
496      t = jj_consume_token(ZEROADDR);
497jjtree.closeNodeScope(jjtn000, true);
498    jjtc000 = false;
499    jjtn000.jjtSetLastToken(getToken(0));
500//Zero Address allows a leading zero
501    log.debug("ZeroAddress Production "+ t.image);
502    jjtn000.jjtSetValue(t.image);
503    {if ("" != null) return jjtn000;}
504    } finally {
505if (jjtc000) {
506      jjtree.closeNodeScope(jjtn000, true);
507      jjtn000.jjtSetLastToken(getToken(0));
508    }
509    }
510    throw new Error("Missing return statement in function");
511}
512
513  final public SimpleNode nonzeroaddress() throws ParseException {/*@bgen(jjtree) nonzeroaddress */
514                             ASTnonzeroaddress jjtn000 = new ASTnonzeroaddress(JJTNONZEROADDRESS);
515                             boolean jjtc000 = true;
516                             jjtree.openNodeScope(jjtn000);
517                             jjtn000.jjtSetFirstToken(getToken(1));Token t;
518    try {
519      t = jj_consume_token(NONZEROADDR);
520jjtree.closeNodeScope(jjtn000, true);
521    jjtc000 = false;
522    jjtn000.jjtSetLastToken(getToken(0));
523//NonZero Address requires a value  >=1, without
524    //a leading zero
525    log.debug("NonZeroAddress Production "+ t.image);
526    jjtn000.jjtSetValue(t.image);
527    {if ("" != null) return jjtn000;}
528    } finally {
529if (jjtc000) {
530      jjtree.closeNodeScope(jjtn000, true);
531      jjtn000.jjtSetLastToken(getToken(0));
532    }
533    }
534    throw new Error("Missing return statement in function");
535}
536
537  final public SimpleNode port() throws ParseException {/*@bgen(jjtree) port */
538                   ASTport jjtn000 = new ASTport(JJTPORT);
539                   boolean jjtc000 = true;
540                   jjtree.openNodeScope(jjtn000);
541                   jjtn000.jjtSetFirstToken(getToken(1));SimpleNode s;
542    try {
543      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
544      case ZEROADDR:{
545        s = zeroaddress();
546        break;
547        }
548      case NONZEROADDR:{
549        s = nonzeroaddress();
550        break;
551        }
552      default:
553        jj_la1[7] = jj_gen;
554        jj_consume_token(-1);
555        throw new ParseException();
556      }
557jjtree.closeNodeScope(jjtn000, true);
558    jjtc000 = false;
559    jjtn000.jjtSetLastToken(getToken(0));
560log.debug("PORT Production "+ s.jjtGetValue());
561    jjtn000.jjtSetValue(s.jjtGetValue());
562    {if ("" != null) return jjtn000;}
563    } catch (Throwable jjte000) {
564if (jjtc000) {
565      jjtree.clearNodeScope(jjtn000);
566      jjtc000 = false;
567    } else {
568      jjtree.popNode();
569    }
570    if (jjte000 instanceof RuntimeException) {
571      {if (true) throw (RuntimeException)jjte000;}
572    }
573    if (jjte000 instanceof ParseException) {
574      {if (true) throw (ParseException)jjte000;}
575    }
576    {if (true) throw (Error)jjte000;}
577    } finally {
578if (jjtc000) {
579      jjtree.closeNodeScope(jjtn000, true);
580      jjtn000.jjtSetLastToken(getToken(0));
581    }
582    }
583    throw new Error("Missing return statement in function");
584}
585
586  final public SimpleNode devicegroup() throws ParseException {/*@bgen(jjtree) devicegroup */
587                          ASTdevicegroup jjtn000 = new ASTdevicegroup(JJTDEVICEGROUP);
588                          boolean jjtc000 = true;
589                          jjtree.openNodeScope(jjtn000);
590                          jjtn000.jjtSetFirstToken(getToken(1));Token t;
591    try {
592      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
593      case FB:{
594        t = jj_consume_token(FB);
595        break;
596        }
597      case GA:{
598        t = jj_consume_token(GA);
599        break;
600        }
601      case GL:{
602        t = jj_consume_token(GL);
603        break;
604        }
605      case SM:{
606        t = jj_consume_token(SM);
607        break;
608        }
609      case TIME:{
610        t = jj_consume_token(TIME);
611        break;
612        }
613      case SESSION:{
614        t = jj_consume_token(SESSION);
615        break;
616        }
617      case SERVER:{
618        t = jj_consume_token(SERVER);
619        break;
620        }
621      case LOCK:{
622        t = jj_consume_token(LOCK);
623        break;
624        }
625      case POWER:{
626        t = jj_consume_token(POWER);
627        break;
628        }
629      case DESCRIPTION:{
630        t = jj_consume_token(DESCRIPTION);
631        break;
632        }
633      default:
634        jj_la1[8] = jj_gen;
635        jj_consume_token(-1);
636        throw new ParseException();
637      }
638jjtree.closeNodeScope(jjtn000, true);
639    jjtc000 = false;
640    jjtn000.jjtSetLastToken(getToken(0));
641log.debug("DeviceGroup Production");
642    jjtn000.jjtSetValue(t.image);
643    {if ("" != null) return jjtn000;}
644    } finally {
645if (jjtc000) {
646      jjtree.closeNodeScope(jjtn000, true);
647      jjtn000.jjtSetLastToken(getToken(0));
648    }
649    }
650    throw new Error("Missing return statement in function");
651}
652
653  final public SimpleNode gl() throws ParseException {/*@bgen(jjtree) gl */
654                 ASTgl jjtn000 = new ASTgl(JJTGL);
655                 boolean jjtc000 = true;
656                 jjtree.openNodeScope(jjtn000);
657                 jjtn000.jjtSetFirstToken(getToken(1));Token t;
658    try {
659      t = jj_consume_token(GL);
660      address();
661      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
662      case ZEROADDR:
663      case NONZEROADDR:
664      case DRIVEMODE:
665      case PROTOCOL:{
666        switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
667        case ZEROADDR:
668        case NONZEROADDR:
669        case DRIVEMODE:{
670          switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
671          case DRIVEMODE:{
672            jj_consume_token(DRIVEMODE);
673            break;
674            }
675          case ZEROADDR:
676          case NONZEROADDR:{
677            address();
678            break;
679            }
680          default:
681            jj_la1[9] = jj_gen;
682            jj_consume_token(-1);
683            throw new ParseException();
684          }
685          label_1:
686          while (true) {
687            address();
688            switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
689            case ZEROADDR:
690            case NONZEROADDR:{
691              ;
692              break;
693              }
694            default:
695              jj_la1[10] = jj_gen;
696              break label_1;
697            }
698          }
699          break;
700          }
701        case PROTOCOL:{
702          jj_consume_token(PROTOCOL);
703          switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
704          case ZEROADDR:
705          case NONZEROADDR:{
706            address();
707            address();
708            break;
709            }
710          default:
711            jj_la1[11] = jj_gen;
712            ;
713          }
714          break;
715          }
716        default:
717          jj_la1[12] = jj_gen;
718          jj_consume_token(-1);
719          throw new ParseException();
720        }
721        break;
722        }
723      default:
724        jj_la1[13] = jj_gen;
725        ;
726      }
727jjtree.closeNodeScope(jjtn000, true);
728    jjtc000 = false;
729    jjtn000.jjtSetLastToken(getToken(0));
730jjtn000.jjtSetValue(t.image);
731    {if ("" != null) return jjtn000;}
732    } catch (Throwable jjte000) {
733if (jjtc000) {
734      jjtree.clearNodeScope(jjtn000);
735      jjtc000 = false;
736    } else {
737      jjtree.popNode();
738    }
739    if (jjte000 instanceof RuntimeException) {
740      {if (true) throw (RuntimeException)jjte000;}
741    }
742    if (jjte000 instanceof ParseException) {
743      {if (true) throw (ParseException)jjte000;}
744    }
745    {if (true) throw (Error)jjte000;}
746    } finally {
747if (jjtc000) {
748      jjtree.closeNodeScope(jjtn000, true);
749      jjtn000.jjtSetLastToken(getToken(0));
750    }
751    }
752    throw new Error("Missing return statement in function");
753}
754
755  final public SimpleNode sm() throws ParseException {/*@bgen(jjtree) sm */
756                 ASTsm jjtn000 = new ASTsm(JJTSM);
757                 boolean jjtc000 = true;
758                 jjtree.openNodeScope(jjtn000);
759                 jjtn000.jjtSetFirstToken(getToken(1));Token t;
760    try {
761      t = jj_consume_token(SM);
762jjtree.closeNodeScope(jjtn000, true);
763    jjtc000 = false;
764    jjtn000.jjtSetLastToken(getToken(0));
765jjtn000.jjtSetValue(t.image);
766    {if ("" != null) return jjtn000;}
767    } finally {
768if (jjtc000) {
769      jjtree.closeNodeScope(jjtn000, true);
770      jjtn000.jjtSetLastToken(getToken(0));
771    }
772    }
773    throw new Error("Missing return statement in function");
774}
775
776  final public SimpleNode ga() throws ParseException {/*@bgen(jjtree) ga */
777                 ASTga jjtn000 = new ASTga(JJTGA);
778                 boolean jjtc000 = true;
779                 jjtree.openNodeScope(jjtn000);
780                 jjtn000.jjtSetFirstToken(getToken(1));Token t;
781    try {
782      t = jj_consume_token(GA);
783      address();
784      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
785      case ZEROADDR:
786      case NONZEROADDR:
787      case PROTOCOL:{
788        switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
789        case PROTOCOL:{
790          jj_consume_token(PROTOCOL);
791          break;
792          }
793        case ZEROADDR:
794        case NONZEROADDR:{
795          port();
796          zeroone();
797          break;
798          }
799        default:
800          jj_la1[14] = jj_gen;
801          jj_consume_token(-1);
802          throw new ParseException();
803        }
804        break;
805        }
806      default:
807        jj_la1[15] = jj_gen;
808        ;
809      }
810jjtree.closeNodeScope(jjtn000, true);
811    jjtc000 = false;
812    jjtn000.jjtSetLastToken(getToken(0));
813jjtn000.jjtSetValue(t.image);
814    {if ("" != null) return jjtn000;}
815    } catch (Throwable jjte000) {
816if (jjtc000) {
817      jjtree.clearNodeScope(jjtn000);
818      jjtc000 = false;
819    } else {
820      jjtree.popNode();
821    }
822    if (jjte000 instanceof RuntimeException) {
823      {if (true) throw (RuntimeException)jjte000;}
824    }
825    if (jjte000 instanceof ParseException) {
826      {if (true) throw (ParseException)jjte000;}
827    }
828    {if (true) throw (Error)jjte000;}
829    } finally {
830if (jjtc000) {
831      jjtree.closeNodeScope(jjtn000, true);
832      jjtn000.jjtSetLastToken(getToken(0));
833    }
834    }
835    throw new Error("Missing return statement in function");
836}
837
838  final public SimpleNode fb() throws ParseException {/*@bgen(jjtree) fb */
839                 ASTfb jjtn000 = new ASTfb(JJTFB);
840                 boolean jjtc000 = true;
841                 jjtree.openNodeScope(jjtn000);
842                 jjtn000.jjtSetFirstToken(getToken(1));Token t;
843    try {
844      t = jj_consume_token(FB);
845      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
846      case ZEROADDR:
847      case NONZEROADDR:{
848        address();
849        zeroone();
850        break;
851        }
852      default:
853        jj_la1[16] = jj_gen;
854        ;
855      }
856jjtree.closeNodeScope(jjtn000, true);
857    jjtc000 = false;
858    jjtn000.jjtSetLastToken(getToken(0));
859jjtn000.jjtSetValue(t.image);
860    {if ("" != null) return jjtn000;}
861    } catch (Throwable jjte000) {
862if (jjtc000) {
863      jjtree.clearNodeScope(jjtn000);
864      jjtc000 = false;
865    } else {
866      jjtree.popNode();
867    }
868    if (jjte000 instanceof RuntimeException) {
869      {if (true) throw (RuntimeException)jjte000;}
870    }
871    if (jjte000 instanceof ParseException) {
872      {if (true) throw (ParseException)jjte000;}
873    }
874    {if (true) throw (Error)jjte000;}
875    } finally {
876if (jjtc000) {
877      jjtree.closeNodeScope(jjtn000, true);
878      jjtn000.jjtSetLastToken(getToken(0));
879    }
880    }
881    throw new Error("Missing return statement in function");
882}
883
884  final public SimpleNode time() throws ParseException {/*@bgen(jjtree) time */
885                   ASTtime jjtn000 = new ASTtime(JJTTIME);
886                   boolean jjtc000 = true;
887                   jjtree.openNodeScope(jjtn000);
888                   jjtn000.jjtSetFirstToken(getToken(1));Token t;
889    try {
890      t = jj_consume_token(TIME);
891jjtree.closeNodeScope(jjtn000, true);
892    jjtc000 = false;
893    jjtn000.jjtSetLastToken(getToken(0));
894jjtn000.jjtSetValue(t.image);
895    {if ("" != null) return jjtn000;}
896    } finally {
897if (jjtc000) {
898      jjtree.closeNodeScope(jjtn000, true);
899      jjtn000.jjtSetLastToken(getToken(0));
900    }
901    }
902    throw new Error("Missing return statement in function");
903}
904
905  final public SimpleNode server() throws ParseException {/*@bgen(jjtree) server */
906                     ASTserver jjtn000 = new ASTserver(JJTSERVER);
907                     boolean jjtc000 = true;
908                     jjtree.openNodeScope(jjtn000);
909                     jjtn000.jjtSetFirstToken(getToken(1));Token t;Token r;
910    try {
911      t = jj_consume_token(SERVER);
912      r = jj_consume_token(EOL);
913jjtree.closeNodeScope(jjtn000, true);
914    jjtc000 = false;
915    jjtn000.jjtSetLastToken(getToken(0));
916jjtn000.jjtSetValue(t.image + " " + r.image);
917    {if ("" != null) return jjtn000;}
918    } finally {
919if (jjtc000) {
920      jjtree.closeNodeScope(jjtn000, true);
921      jjtn000.jjtSetLastToken(getToken(0));
922    }
923    }
924    throw new Error("Missing return statement in function");
925}
926
927  final public SimpleNode session() throws ParseException {/*@bgen(jjtree) session */
928                      ASTsession jjtn000 = new ASTsession(JJTSESSION);
929                      boolean jjtc000 = true;
930                      jjtree.openNodeScope(jjtn000);
931                      jjtn000.jjtSetFirstToken(getToken(1));Token t;
932    try {
933      t = jj_consume_token(SESSION);
934      address();
935      jj_consume_token(EOL);
936jjtree.closeNodeScope(jjtn000, true);
937    jjtc000 = false;
938    jjtn000.jjtSetLastToken(getToken(0));
939jjtn000.jjtSetValue(t.image);
940    {if ("" != null) return jjtn000;}
941    } catch (Throwable jjte000) {
942if (jjtc000) {
943      jjtree.clearNodeScope(jjtn000);
944      jjtc000 = false;
945    } else {
946      jjtree.popNode();
947    }
948    if (jjte000 instanceof RuntimeException) {
949      {if (true) throw (RuntimeException)jjte000;}
950    }
951    if (jjte000 instanceof ParseException) {
952      {if (true) throw (ParseException)jjte000;}
953    }
954    {if (true) throw (Error)jjte000;}
955    } finally {
956if (jjtc000) {
957      jjtree.closeNodeScope(jjtn000, true);
958      jjtn000.jjtSetLastToken(getToken(0));
959    }
960    }
961    throw new Error("Missing return statement in function");
962}
963
964  final public SimpleNode lock() throws ParseException {/*@bgen(jjtree) lock */
965                   ASTlock jjtn000 = new ASTlock(JJTLOCK);
966                   boolean jjtc000 = true;
967                   jjtree.openNodeScope(jjtn000);
968                   jjtn000.jjtSetFirstToken(getToken(1));Token t;
969    try {
970      t = jj_consume_token(LOCK);
971      devicegroup();
972      label_2:
973      while (true) {
974        address();
975        switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
976        case ZEROADDR:
977        case NONZEROADDR:{
978          ;
979          break;
980          }
981        default:
982          jj_la1[17] = jj_gen;
983          break label_2;
984        }
985      }
986      jj_consume_token(EOL);
987jjtree.closeNodeScope(jjtn000, true);
988    jjtc000 = false;
989    jjtn000.jjtSetLastToken(getToken(0));
990jjtn000.jjtSetValue(t.image);
991    {if ("" != null) return jjtn000;}
992    } catch (Throwable jjte000) {
993if (jjtc000) {
994      jjtree.clearNodeScope(jjtn000);
995      jjtc000 = false;
996    } else {
997      jjtree.popNode();
998    }
999    if (jjte000 instanceof RuntimeException) {
1000      {if (true) throw (RuntimeException)jjte000;}
1001    }
1002    if (jjte000 instanceof ParseException) {
1003      {if (true) throw (ParseException)jjte000;}
1004    }
1005    {if (true) throw (Error)jjte000;}
1006    } finally {
1007if (jjtc000) {
1008      jjtree.closeNodeScope(jjtn000, true);
1009      jjtn000.jjtSetLastToken(getToken(0));
1010    }
1011    }
1012    throw new Error("Missing return statement in function");
1013}
1014
1015  final public SimpleNode description() throws ParseException {/*@bgen(jjtree) description */
1016                          ASTdescription jjtn000 = new ASTdescription(JJTDESCRIPTION);
1017                          boolean jjtc000 = true;
1018                          jjtree.openNodeScope(jjtn000);
1019                          jjtn000.jjtSetFirstToken(getToken(1));Token t;
1020    try {
1021      t = jj_consume_token(DESCRIPTION);
1022      if (jj_2_1(3)) {
1023        label_3:
1024        while (true) {
1025          devicegroup();
1026          switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1027          case FB:
1028          case GA:
1029          case GL:
1030          case SM:
1031          case LOCK:
1032          case TIME:
1033          case POWER:
1034          case SESSION:
1035          case DESCRIPTION:
1036          case SERVER:{
1037            ;
1038            break;
1039            }
1040          default:
1041            jj_la1[18] = jj_gen;
1042            break label_3;
1043          }
1044        }
1045        jj_consume_token(EOL);
1046      } else {
1047        switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1048        case FB:
1049        case GA:
1050        case GL:
1051        case SM:
1052        case LOCK:
1053        case TIME:
1054        case POWER:
1055        case SESSION:
1056        case SERVER:{
1057          switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1058          case FB:{
1059            fb();
1060            jj_consume_token(EOL);
1061            break;
1062            }
1063          case GA:{
1064            ga();
1065            jj_consume_token(EOL);
1066            break;
1067            }
1068          case GL:{
1069            gl();
1070            jj_consume_token(EOL);
1071            break;
1072            }
1073          case SM:{
1074            sm();
1075            break;
1076            }
1077          case TIME:{
1078            time();
1079            break;
1080            }
1081          case POWER:{
1082            power();
1083            break;
1084            }
1085          case SESSION:{
1086            session();
1087            break;
1088            }
1089          case SERVER:{
1090            server();
1091            break;
1092            }
1093          case LOCK:{
1094            lock();
1095            break;
1096            }
1097          default:
1098            jj_la1[19] = jj_gen;
1099            jj_consume_token(-1);
1100            throw new ParseException();
1101          }
1102          break;
1103          }
1104        default:
1105          jj_la1[20] = jj_gen;
1106          jj_consume_token(-1);
1107          throw new ParseException();
1108        }
1109      }
1110jjtree.closeNodeScope(jjtn000, true);
1111    jjtc000 = false;
1112    jjtn000.jjtSetLastToken(getToken(0));
1113jjtn000.jjtSetValue(t.image);
1114    {if ("" != null) return jjtn000;}
1115    } catch (Throwable jjte000) {
1116if (jjtc000) {
1117     jjtree.clearNodeScope(jjtn000);
1118     jjtc000 = false;
1119   } else {
1120     jjtree.popNode();
1121   }
1122   if (jjte000 instanceof RuntimeException) {
1123     {if (true) throw (RuntimeException)jjte000;}
1124   }
1125   if (jjte000 instanceof ParseException) {
1126     {if (true) throw (ParseException)jjte000;}
1127   }
1128   {if (true) throw (Error)jjte000;}
1129    } finally {
1130if (jjtc000) {
1131     jjtree.closeNodeScope(jjtn000, true);
1132     jjtn000.jjtSetLastToken(getToken(0));
1133   }
1134    }
1135    throw new Error("Missing return statement in function");
1136}
1137
1138  final public SimpleNode onoff() throws ParseException {/*@bgen(jjtree) onoff */
1139                    ASTonoff jjtn000 = new ASTonoff(JJTONOFF);
1140                    boolean jjtc000 = true;
1141                    jjtree.openNodeScope(jjtn000);
1142                    jjtn000.jjtSetFirstToken(getToken(1));Token t; Token r;
1143    try {
1144      t = jj_consume_token(ONOFF);
1145      r = jj_consume_token(EOL);
1146jjtree.closeNodeScope(jjtn000, true);
1147    jjtc000 = false;
1148    jjtn000.jjtSetLastToken(getToken(0));
1149log.debug("OnOff Production " +t.image + " " + r.image);
1150     jjtn000.jjtSetValue(t.image);
1151     {if ("" != null) return jjtn000;}
1152    } finally {
1153if (jjtc000) {
1154      jjtree.closeNodeScope(jjtn000, true);
1155      jjtn000.jjtSetLastToken(getToken(0));
1156    }
1157    }
1158    throw new Error("Missing return statement in function");
1159}
1160
1161  final public void zeroone() throws ParseException {SimpleNode s;
1162    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1163    case ZEROADDR:{
1164      s = zeroaddress();
1165      break;
1166      }
1167    case NONZEROADDR:{
1168      s = nonzeroaddress();
1169      break;
1170      }
1171    default:
1172      jj_la1[21] = jj_gen;
1173      jj_consume_token(-1);
1174      throw new ParseException();
1175    }
1176log.debug("ZeroOne Production ");
1177     //return jjtThis;
1178
1179}
1180
1181  private boolean jj_2_1(int xla)
1182 {
1183    jj_la = xla; jj_lastpos = jj_scanpos = token;
1184    try { return (!jj_3_1()); }
1185    catch(LookaheadSuccess ls) { return true; }
1186    finally { jj_save(0, xla); }
1187  }
1188
1189  private boolean jj_3R_4()
1190 {
1191    if (jj_3R_5()) return true;
1192    return false;
1193  }
1194
1195  private boolean jj_3R_5()
1196 {
1197    Token xsp;
1198    xsp = jj_scanpos;
1199    if (jj_scan_token(17)) {
1200    jj_scanpos = xsp;
1201    if (jj_scan_token(18)) {
1202    jj_scanpos = xsp;
1203    if (jj_scan_token(19)) {
1204    jj_scanpos = xsp;
1205    if (jj_scan_token(21)) {
1206    jj_scanpos = xsp;
1207    if (jj_scan_token(23)) {
1208    jj_scanpos = xsp;
1209    if (jj_scan_token(25)) {
1210    jj_scanpos = xsp;
1211    if (jj_scan_token(27)) {
1212    jj_scanpos = xsp;
1213    if (jj_scan_token(22)) {
1214    jj_scanpos = xsp;
1215    if (jj_scan_token(24)) {
1216    jj_scanpos = xsp;
1217    if (jj_scan_token(26)) return true;
1218    }
1219    }
1220    }
1221    }
1222    }
1223    }
1224    }
1225    }
1226    }
1227    return false;
1228  }
1229
1230  private boolean jj_3_1()
1231 {
1232    Token xsp;
1233    if (jj_3R_4()) return true;
1234    while (true) {
1235      xsp = jj_scanpos;
1236      if (jj_3R_4()) { jj_scanpos = xsp; break; }
1237    }
1238    if (jj_scan_token(EOL)) return true;
1239    return false;
1240  }
1241
1242  /* Generated Token Manager. */
1243  public SRCPClientParserTokenManager token_source;
1244  SimpleCharStream jj_input_stream;
1245  /* Current token. */
1246  public Token token;
1247  /* Next token. */
1248  public Token jj_nt;
1249  private int jj_ntk;
1250  private Token jj_scanpos, jj_lastpos;
1251  private int jj_la;
1252  private int jj_gen;
1253  final private int[] jj_la1 = new int[22];
1254  static private int[] jj_la1_0;
1255  static private int[] jj_la1_1;
1256  static {
1257           jj_la1_init_0();
1258           jj_la1_init_1();
1259        }
1260        private static void jj_la1_init_0() {
1261           jj_la1_0 = new int[] {0x100000c0,0x10c0,0xc0000000,0xfee0000,0xc0,0x2004,0xc0,0xc0,0xfee0000,0x1c0,0xc0,0xc0,0x101c0,0x101c0,0x100c0,0x100c0,0xc0,0xc0,0xfee0000,0xbee0000,0xbee0000,0xc0,};
1262        }
1263        private static void jj_la1_init_1() {
1264           jj_la1_1 = new int[] {0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
1265        }
1266  final private JJCalls[] jj_2_rtns = new JJCalls[1];
1267  private boolean jj_rescan = false;
1268  private int jj_gc = 0;
1269
1270  /* Constructor with InputStream. */
1271  public SRCPClientParser(java.io.InputStream stream) {
1272          this(stream, null);
1273  }
1274  /* Constructor with InputStream and supplied encoding */
1275  public SRCPClientParser(java.io.InputStream stream, String encoding) {
1276         try { jj_input_stream = new SimpleCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
1277         token_source = new SRCPClientParserTokenManager(jj_input_stream);
1278         token = new Token();
1279         jj_ntk = -1;
1280         jj_gen = 0;
1281         for (int i = 0; i < 22; i++) jj_la1[i] = -1;
1282         for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1283  }
1284
1285  /* Reinitialise. */
1286  public void ReInit(java.io.InputStream stream) {
1287          ReInit(stream, null);
1288  }
1289  /* Reinitialise. */
1290  public void ReInit(java.io.InputStream stream, String encoding) {
1291         try { jj_input_stream.ReInit(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
1292         token_source.ReInit(jj_input_stream);
1293         token = new Token();
1294         jj_ntk = -1;
1295         jjtree.reset();
1296         jj_gen = 0;
1297         for (int i = 0; i < 22; i++) jj_la1[i] = -1;
1298         for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1299  }
1300
1301  /* Constructor. */
1302  public SRCPClientParser(java.io.Reader stream) {
1303         jj_input_stream = new SimpleCharStream(stream, 1, 1);
1304         token_source = new SRCPClientParserTokenManager(jj_input_stream);
1305         token = new Token();
1306         jj_ntk = -1;
1307         jj_gen = 0;
1308         for (int i = 0; i < 22; i++) jj_la1[i] = -1;
1309         for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1310  }
1311
1312  /* Reinitialise. */
1313  public void ReInit(java.io.Reader stream) {
1314        if (jj_input_stream == null) {
1315           jj_input_stream = new SimpleCharStream(stream, 1, 1);
1316        } else {
1317           jj_input_stream.ReInit(stream, 1, 1);
1318        }
1319        if (token_source == null) {
1320 token_source = new SRCPClientParserTokenManager(jj_input_stream);
1321        }
1322
1323         token_source.ReInit(jj_input_stream);
1324         token = new Token();
1325         jj_ntk = -1;
1326         jjtree.reset();
1327         jj_gen = 0;
1328         for (int i = 0; i < 22; i++) jj_la1[i] = -1;
1329         for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1330  }
1331
1332  /* Constructor with generated Token Manager. */
1333  public SRCPClientParser(SRCPClientParserTokenManager tm) {
1334         token_source = tm;
1335         token = new Token();
1336         jj_ntk = -1;
1337         jj_gen = 0;
1338         for (int i = 0; i < 22; i++) jj_la1[i] = -1;
1339         for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1340  }
1341
1342  /* Reinitialise. */
1343  public void ReInit(SRCPClientParserTokenManager tm) {
1344         token_source = tm;
1345         token = new Token();
1346         jj_ntk = -1;
1347         jjtree.reset();
1348         jj_gen = 0;
1349         for (int i = 0; i < 22; i++) jj_la1[i] = -1;
1350         for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1351  }
1352
1353  private Token jj_consume_token(int kind) throws ParseException {
1354         Token oldToken;
1355         if ((oldToken = token).next != null) token = token.next;
1356         else token = token.next = token_source.getNextToken();
1357         jj_ntk = -1;
1358         if (token.kind == kind) {
1359           jj_gen++;
1360           if (++jj_gc > 100) {
1361                 jj_gc = 0;
1362                 for (int i = 0; i < jj_2_rtns.length; i++) {
1363                   JJCalls c = jj_2_rtns[i];
1364                   while (c != null) {
1365                         if (c.gen < jj_gen) c.first = null;
1366                         c = c.next;
1367                   }
1368                 }
1369           }
1370           return token;
1371         }
1372         token = oldToken;
1373         jj_kind = kind;
1374         throw generateParseException();
1375  }
1376
1377  @SuppressWarnings("serial")
1378  static private final class LookaheadSuccess extends java.lang.Error { }
1379  final private LookaheadSuccess jj_ls = new LookaheadSuccess();
1380  private boolean jj_scan_token(int kind) {
1381         if (jj_scanpos == jj_lastpos) {
1382           jj_la--;
1383           if (jj_scanpos.next == null) {
1384                 jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
1385           } else {
1386                 jj_lastpos = jj_scanpos = jj_scanpos.next;
1387           }
1388         } else {
1389           jj_scanpos = jj_scanpos.next;
1390         }
1391         if (jj_rescan) {
1392           int i = 0; Token tok = token;
1393           while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
1394           if (tok != null) jj_add_error_token(kind, i);
1395         }
1396         if (jj_scanpos.kind != kind) return true;
1397         if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
1398         return false;
1399  }
1400
1401
1402/* Get the next Token. */
1403  final public Token getNextToken() {
1404         if (token.next != null) token = token.next;
1405         else token = token.next = token_source.getNextToken();
1406         jj_ntk = -1;
1407         jj_gen++;
1408         return token;
1409  }
1410
1411/* Get the specific Token. */
1412  final public Token getToken(int index) {
1413         Token t = token;
1414         for (int i = 0; i < index; i++) {
1415           if (t.next != null) t = t.next;
1416           else t = t.next = token_source.getNextToken();
1417         }
1418         return t;
1419  }
1420
1421  private int jj_ntk_f() {
1422         if ((jj_nt=token.next) == null)
1423           return (jj_ntk = (token.next=token_source.getNextToken()).kind);
1424         else
1425           return (jj_ntk = jj_nt.kind);
1426  }
1427
1428  private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>();
1429  private int[] jj_expentry;
1430  private int jj_kind = -1;
1431  private int[] jj_lasttokens = new int[100];
1432  private int jj_endpos;
1433
1434  private void jj_add_error_token(int kind, int pos) {
1435         if (pos >= 100) {
1436                return;
1437         }
1438
1439         if (pos == jj_endpos + 1) {
1440           jj_lasttokens[jj_endpos++] = kind;
1441         } else if (jj_endpos != 0) {
1442           jj_expentry = new int[jj_endpos];
1443
1444           for (int i = 0; i < jj_endpos; i++) {
1445                 jj_expentry[i] = jj_lasttokens[i];
1446           }
1447
1448           for (int[] oldentry : jj_expentries) {
1449                 if (oldentry.length == jj_expentry.length) {
1450                   boolean isMatched = true;
1451
1452                   for (int i = 0; i < jj_expentry.length; i++) {
1453                         if (oldentry[i] != jj_expentry[i]) {
1454                           isMatched = false;
1455                           break;
1456                         }
1457
1458                   }
1459                   if (isMatched) {
1460                         jj_expentries.add(jj_expentry);
1461                         break;
1462                   }
1463                 }
1464           }
1465
1466           if (pos != 0) {
1467                 jj_lasttokens[(jj_endpos = pos) - 1] = kind;
1468           }
1469         }
1470  }
1471
1472  /* Generate ParseException. */
1473  public ParseException generateParseException() {
1474         jj_expentries.clear();
1475         boolean[] la1tokens = new boolean[63];
1476         if (jj_kind >= 0) {
1477           la1tokens[jj_kind] = true;
1478           jj_kind = -1;
1479         }
1480         for (int i = 0; i < 22; i++) {
1481           if (jj_la1[i] == jj_gen) {
1482                 for (int j = 0; j < 32; j++) {
1483                   if ((jj_la1_0[i] & (1<<j)) != 0) {
1484                         la1tokens[j] = true;
1485                   }
1486                   if ((jj_la1_1[i] & (1<<j)) != 0) {
1487                         la1tokens[32+j] = true;
1488                   }
1489                 }
1490           }
1491         }
1492         for (int i = 0; i < 63; i++) {
1493           if (la1tokens[i]) {
1494                 jj_expentry = new int[1];
1495                 jj_expentry[0] = i;
1496                 jj_expentries.add(jj_expentry);
1497           }
1498         }
1499         jj_endpos = 0;
1500         jj_rescan_token();
1501         jj_add_error_token(0, 0);
1502         int[][] exptokseq = new int[jj_expentries.size()][];
1503         for (int i = 0; i < jj_expentries.size(); i++) {
1504           exptokseq[i] = jj_expentries.get(i);
1505         }
1506         return new ParseException(token, exptokseq, tokenImage);
1507  }
1508
1509  private int trace_indent = 0;
1510  private boolean trace_enabled;
1511
1512/* Trace enabled. */
1513  final public boolean trace_enabled() {
1514         return trace_enabled;
1515  }
1516
1517  /* Enable tracing. */
1518  final public void enable_tracing() {
1519  }
1520
1521  /* Disable tracing. */
1522  final public void disable_tracing() {
1523  }
1524
1525  private void jj_rescan_token() {
1526         jj_rescan = true;
1527         for (int i = 0; i < 1; i++) {
1528           try {
1529                 JJCalls p = jj_2_rtns[i];
1530
1531                 do {
1532                   if (p.gen > jj_gen) {
1533                         jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
1534                         switch (i) {
1535                           case 0: jj_3_1(); break;
1536                         }
1537                   }
1538                   p = p.next;
1539                 } while (p != null);
1540
1541                 } catch(LookaheadSuccess ls) { }
1542         }
1543         jj_rescan = false;
1544  }
1545
1546  private void jj_save(int index, int xla) {
1547         JJCalls p = jj_2_rtns[index];
1548         while (p.gen > jj_gen) {
1549           if (p.next == null) { p = p.next = new JJCalls(); break; }
1550           p = p.next;
1551         }
1552
1553         p.gen = jj_gen + xla - jj_la; 
1554         p.first = token;
1555         p.arg = xla;
1556  }
1557
1558  static final class JJCalls {
1559         int gen;
1560         Token first;
1561         int arg;
1562         JJCalls next;
1563  }
1564
1565  }