Source code

001/* SRCPParser.java */
002/* Generated By:JJTree&JavaCC: Do not edit this line. SRCPParser.java */
003package jmri.jmris.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.
011 *
012 * @author Paul Bender Copyright (C) 2010
013 */
014
015// This is generated code.  DO NOT ATTEMPT TO FIX ANY FINDBUGS WARNINGS
016@edu.umd.cs.findbugs.annotations.SuppressFBWarnings({"NM_METHOD_NAMING_CONVENTION",
017    "NM_CONFUSING","RCN_REDUNDANT_NULLCHECK_OF_NONNULL_VALUE","SLF4J_FORMAT_SHOULD_BE_CONST"})
018
019public class SRCPParser/*@bgen(jjtree)*/implements SRCPParserTreeConstants, SRCPParserConstants {/*@bgen(jjtree)*/
020  protected JJTSRCPParserState jjtree = new JJTSRCPParserState();
021   private final static Logger log = LoggerFactory.getLogger(SRCPParser.class);
022
023// Lexical specifications begin here
024  final public 
025SimpleNode handshakecommand() throws ParseException {/*@bgen(jjtree) handshakecommand */
026  ASThandshakecommand jjtn000 = new ASThandshakecommand(JJTHANDSHAKECOMMAND);
027  boolean jjtc000 = true;
028  jjtree.openNodeScope(jjtn000);
029    try {
030      if (jj_2_1(2)) {
031        go();
032      } else {
033        switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
034        case SET:{
035          handshake_set();
036          break;
037          }
038        default:
039          jj_la1[0] = jj_gen;
040          jj_consume_token(-1);
041          throw new ParseException();
042        }
043      }
044      jj_consume_token(EOL);
045jjtree.closeNodeScope(jjtn000, true);
046    jjtc000 = false;
047log.debug("Handshake Command Production");
048    {if ("" != null) return jjtn000;}
049    } catch (Throwable jjte000) {
050if (jjtc000) {
051      jjtree.clearNodeScope(jjtn000);
052      jjtc000 = false;
053    } else {
054      jjtree.popNode();
055    }
056    if (jjte000 instanceof RuntimeException) {
057      {if (true) throw (RuntimeException)jjte000;}
058    }
059    if (jjte000 instanceof ParseException) {
060      {if (true) throw (ParseException)jjte000;}
061    }
062    {if (true) throw (Error)jjte000;}
063    } finally {
064if (jjtc000) {
065      jjtree.closeNodeScope(jjtn000, true);
066    }
067    }
068    throw new Error("Missing return statement in function");
069}
070
071  final public SimpleNode command() throws ParseException {/*@bgen(jjtree) command */
072  ASTcommand jjtn000 = new ASTcommand(JJTCOMMAND);
073  boolean jjtc000 = true;
074  jjtree.openNodeScope(jjtn000);
075    try {
076      if (jj_2_2(4)) {
077        get();
078      } else {
079        switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
080        case SET:{
081          set();
082          break;
083          }
084        case CHECK:{
085          check();
086          break;
087          }
088        case WAIT:{
089          wait_cmd();
090          break;
091          }
092        case INIT:{
093          init();
094          break;
095          }
096        case TERM:{
097          term();
098          break;
099          }
100        case RESET:{
101          reset();
102          break;
103          }
104        case VERIFY:{
105          verify();
106          break;
107          }
108        default:
109          jj_la1[1] = jj_gen;
110          jj_consume_token(-1);
111          throw new ParseException();
112        }
113      }
114      jj_consume_token(EOL);
115jjtree.closeNodeScope(jjtn000, true);
116    jjtc000 = false;
117log.debug("Command Production");
118    {if ("" != null) return jjtn000;}
119    } catch (Throwable jjte000) {
120if (jjtc000) {
121      jjtree.clearNodeScope(jjtn000);
122      jjtc000 = false;
123    } else {
124      jjtree.popNode();
125    }
126    if (jjte000 instanceof RuntimeException) {
127      {if (true) throw (RuntimeException)jjte000;}
128    }
129    if (jjte000 instanceof ParseException) {
130      {if (true) throw (ParseException)jjte000;}
131    }
132    {if (true) throw (Error)jjte000;}
133    } finally {
134if (jjtc000) {
135      jjtree.closeNodeScope(jjtn000, true);
136    }
137    }
138    throw new Error("Missing return statement in function");
139}
140
141  final public SimpleNode serviceversion() throws ParseException {/*@bgen(jjtree) serviceversion */
142                             ASTserviceversion jjtn000 = new ASTserviceversion(JJTSERVICEVERSION);
143                             boolean jjtc000 = true;
144                             jjtree.openNodeScope(jjtn000);Token t;
145    try {
146      jj_consume_token(SRCP);
147      t = jj_consume_token(VERSION);
148jjtree.closeNodeScope(jjtn000, true);
149    jjtc000 = false;
150log.debug("Service Version Production");
151    jjtn000.jjtSetValue(t.image);
152    {if ("" != null) return jjtn000;}
153    } finally {
154if (jjtc000) {
155      jjtree.closeNodeScope(jjtn000, true);
156    }
157    }
158    throw new Error("Missing return statement in function");
159}
160
161  final public SimpleNode connectionmode() throws ParseException {/*@bgen(jjtree) connectionmode */
162                             ASTconnectionmode jjtn000 = new ASTconnectionmode(JJTCONNECTIONMODE);
163                             boolean jjtc000 = true;
164                             jjtree.openNodeScope(jjtn000);Token t;
165    try {
166      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
167      case COMMAND:{
168        t = jj_consume_token(COMMAND);
169        break;
170        }
171      case INFO:{
172        t = jj_consume_token(INFO);
173        break;
174        }
175      default:
176        jj_la1[2] = jj_gen;
177        jj_consume_token(-1);
178        throw new ParseException();
179      }
180jjtree.closeNodeScope(jjtn000, true);
181    jjtc000 = false;
182log.debug("Connection Mode Production");
183    jjtn000.jjtSetValue(t.image);
184    {if ("" != null) return jjtn000;}
185    } finally {
186if (jjtc000) {
187      jjtree.closeNodeScope(jjtn000, true);
188    }
189    }
190    throw new Error("Missing return statement in function");
191}
192
193  final public SimpleNode bus() throws ParseException {/*@bgen(jjtree) bus */
194                  ASTbus jjtn000 = new ASTbus(JJTBUS);
195                  boolean jjtc000 = true;
196                  jjtree.openNodeScope(jjtn000);SimpleNode s;
197    try {
198      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
199      case ZEROADDR:{
200        s = zeroaddress();
201        break;
202        }
203      case NONZEROADDR:{
204        s = nonzeroaddress();
205        break;
206        }
207      default:
208        jj_la1[3] = jj_gen;
209        jj_consume_token(-1);
210        throw new ParseException();
211      }
212jjtree.closeNodeScope(jjtn000, true);
213    jjtc000 = false;
214log.debug("BUS Production "+ s.jjtGetValue());
215    jjtn000.jjtSetValue(s.jjtGetValue());
216    {if ("" != null) return jjtn000;}
217    } catch (Throwable jjte000) {
218if (jjtc000) {
219      jjtree.clearNodeScope(jjtn000);
220      jjtc000 = false;
221    } else {
222      jjtree.popNode();
223    }
224    if (jjte000 instanceof RuntimeException) {
225      {if (true) throw (RuntimeException)jjte000;}
226    }
227    if (jjte000 instanceof ParseException) {
228      {if (true) throw (ParseException)jjte000;}
229    }
230    {if (true) throw (Error)jjte000;}
231    } finally {
232if (jjtc000) {
233      jjtree.closeNodeScope(jjtn000, true);
234    }
235    }
236    throw new Error("Missing return statement in function");
237}
238
239  final public SimpleNode address() throws ParseException {/*@bgen(jjtree) address */
240                      ASTaddress jjtn000 = new ASTaddress(JJTADDRESS);
241                      boolean jjtc000 = true;
242                      jjtree.openNodeScope(jjtn000);SimpleNode s;
243    try {
244      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
245      case ZEROADDR:{
246        s = zeroaddress();
247        break;
248        }
249      case NONZEROADDR:{
250        s = nonzeroaddress();
251        break;
252        }
253      default:
254        jj_la1[4] = jj_gen;
255        jj_consume_token(-1);
256        throw new ParseException();
257      }
258jjtree.closeNodeScope(jjtn000, true);
259    jjtc000 = false;
260log.debug("Address Production "+ s.jjtGetValue());
261    jjtn000.jjtSetValue(s.jjtGetValue());
262    {if ("" != null) return jjtn000;}
263    } catch (Throwable jjte000) {
264if (jjtc000) {
265      jjtree.clearNodeScope(jjtn000);
266      jjtc000 = false;
267    } else {
268      jjtree.popNode();
269    }
270    if (jjte000 instanceof RuntimeException) {
271      {if (true) throw (RuntimeException)jjte000;}
272    }
273    if (jjte000 instanceof ParseException) {
274      {if (true) throw (ParseException)jjte000;}
275    }
276    {if (true) throw (Error)jjte000;}
277    } finally {
278if (jjtc000) {
279      jjtree.closeNodeScope(jjtn000, true);
280    }
281    }
282    throw new Error("Missing return statement in function");
283}
284
285  final public SimpleNode value() throws ParseException {/*@bgen(jjtree) value */
286                    ASTvalue jjtn000 = new ASTvalue(JJTVALUE);
287                    boolean jjtc000 = true;
288                    jjtree.openNodeScope(jjtn000);SimpleNode s;
289    try {
290      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
291      case ZEROADDR:{
292        s = zeroaddress();
293        break;
294        }
295      case NONZEROADDR:{
296        s = nonzeroaddress();
297        break;
298        }
299      default:
300        jj_la1[5] = jj_gen;
301        jj_consume_token(-1);
302        throw new ParseException();
303      }
304jjtree.closeNodeScope(jjtn000, true);
305    jjtc000 = false;
306log.debug("Value Production "+ s.jjtGetValue());
307    jjtn000.jjtSetValue(s.jjtGetValue());
308    {if ("" != null) return jjtn000;}
309    } catch (Throwable jjte000) {
310if (jjtc000) {
311      jjtree.clearNodeScope(jjtn000);
312      jjtc000 = false;
313    } else {
314      jjtree.popNode();
315    }
316    if (jjte000 instanceof RuntimeException) {
317      {if (true) throw (RuntimeException)jjte000;}
318    }
319    if (jjte000 instanceof ParseException) {
320      {if (true) throw (ParseException)jjte000;}
321    }
322    {if (true) throw (Error)jjte000;}
323    } finally {
324if (jjtc000) {
325      jjtree.closeNodeScope(jjtn000, true);
326    }
327    }
328    throw new Error("Missing return statement in function");
329}
330
331  final public SimpleNode cvno() throws ParseException {/*@bgen(jjtree) cvno */
332                   ASTcvno jjtn000 = new ASTcvno(JJTCVNO);
333                   boolean jjtc000 = true;
334                   jjtree.openNodeScope(jjtn000);SimpleNode s;
335    try {
336      s = nonzeroaddress();
337jjtree.closeNodeScope(jjtn000, true);
338    jjtc000 = false;
339log.debug("CV Number Production "+ s.jjtGetValue());
340    jjtn000.jjtSetValue(s.jjtGetValue());
341    {if ("" != null) return jjtn000;}
342    } catch (Throwable jjte000) {
343if (jjtc000) {
344      jjtree.clearNodeScope(jjtn000);
345      jjtc000 = false;
346    } else {
347      jjtree.popNode();
348    }
349    if (jjte000 instanceof RuntimeException) {
350      {if (true) throw (RuntimeException)jjte000;}
351    }
352    if (jjte000 instanceof ParseException) {
353      {if (true) throw (ParseException)jjte000;}
354    }
355    {if (true) throw (Error)jjte000;}
356    } finally {
357if (jjtc000) {
358      jjtree.closeNodeScope(jjtn000, true);
359    }
360    }
361    throw new Error("Missing return statement in function");
362}
363
364  final public SimpleNode zeroaddress() throws ParseException {/*@bgen(jjtree) zeroaddress */
365                          ASTzeroaddress jjtn000 = new ASTzeroaddress(JJTZEROADDRESS);
366                          boolean jjtc000 = true;
367                          jjtree.openNodeScope(jjtn000);Token t;
368    try {
369      t = jj_consume_token(ZEROADDR);
370jjtree.closeNodeScope(jjtn000, true);
371    jjtc000 = false;
372//Zero Address allows a leading zero
373    log.debug("ZeroAddress Production "+ t.image);
374    jjtn000.jjtSetValue(t.image);
375    {if ("" != null) return jjtn000;}
376    } finally {
377if (jjtc000) {
378      jjtree.closeNodeScope(jjtn000, true);
379    }
380    }
381    throw new Error("Missing return statement in function");
382}
383
384  final public SimpleNode nonzeroaddress() throws ParseException {/*@bgen(jjtree) nonzeroaddress */
385                             ASTnonzeroaddress jjtn000 = new ASTnonzeroaddress(JJTNONZEROADDRESS);
386                             boolean jjtc000 = true;
387                             jjtree.openNodeScope(jjtn000);Token t;
388    try {
389      t = jj_consume_token(NONZEROADDR);
390jjtree.closeNodeScope(jjtn000, true);
391    jjtc000 = false;
392//NonZero Address requires a value  >=1, without
393    //a leading zero
394    log.debug("NonZeroAddress Production "+ t.image);
395    jjtn000.jjtSetValue(t.image);
396    {if ("" != null) return jjtn000;}
397    } finally {
398if (jjtc000) {
399      jjtree.closeNodeScope(jjtn000, true);
400    }
401    }
402    throw new Error("Missing return statement in function");
403}
404
405  final public SimpleNode port() throws ParseException {/*@bgen(jjtree) port */
406                   ASTport jjtn000 = new ASTport(JJTPORT);
407                   boolean jjtc000 = true;
408                   jjtree.openNodeScope(jjtn000);SimpleNode s;
409    try {
410      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
411      case ZEROADDR:{
412        s = zeroaddress();
413        break;
414        }
415      case NONZEROADDR:{
416        s = nonzeroaddress();
417        break;
418        }
419      default:
420        jj_la1[6] = jj_gen;
421        jj_consume_token(-1);
422        throw new ParseException();
423      }
424jjtree.closeNodeScope(jjtn000, true);
425    jjtc000 = false;
426log.debug("PORT Production "+ s.jjtGetValue());
427    jjtn000.jjtSetValue(s.jjtGetValue());
428    {if ("" != null) return jjtn000;}
429    } catch (Throwable jjte000) {
430if (jjtc000) {
431      jjtree.clearNodeScope(jjtn000);
432      jjtc000 = false;
433    } else {
434      jjtree.popNode();
435    }
436    if (jjte000 instanceof RuntimeException) {
437      {if (true) throw (RuntimeException)jjte000;}
438    }
439    if (jjte000 instanceof ParseException) {
440      {if (true) throw (ParseException)jjte000;}
441    }
442    {if (true) throw (Error)jjte000;}
443    } finally {
444if (jjtc000) {
445      jjtree.closeNodeScope(jjtn000, true);
446    }
447    }
448    throw new Error("Missing return statement in function");
449}
450
451  final public SimpleNode devicegroup() throws ParseException {/*@bgen(jjtree) devicegroup */
452                          ASTdevicegroup jjtn000 = new ASTdevicegroup(JJTDEVICEGROUP);
453                          boolean jjtc000 = true;
454                          jjtree.openNodeScope(jjtn000);Token t;
455    try {
456      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
457      case FB:{
458        t = jj_consume_token(FB);
459        break;
460        }
461      case GA:{
462        t = jj_consume_token(GA);
463        break;
464        }
465      case GL:{
466        t = jj_consume_token(GL);
467        break;
468        }
469      case SM:{
470        t = jj_consume_token(SM);
471        break;
472        }
473      case TIME:{
474        t = jj_consume_token(TIME);
475        break;
476        }
477      case SESSION:{
478        t = jj_consume_token(SESSION);
479        break;
480        }
481      case SERVER:{
482        t = jj_consume_token(SERVER);
483        break;
484        }
485      case LOCK:{
486        t = jj_consume_token(LOCK);
487        break;
488        }
489      case DESCRIPTION:{
490        t = jj_consume_token(DESCRIPTION);
491        break;
492        }
493      case POWER:{
494        t = jj_consume_token(POWER);
495        break;
496        }
497      default:
498        jj_la1[7] = jj_gen;
499        jj_consume_token(-1);
500        throw new ParseException();
501      }
502jjtree.closeNodeScope(jjtn000, true);
503    jjtc000 = false;
504log.debug("DeviceGroup Production");
505    jjtn000.jjtSetValue(t.image);
506    {if ("" != null) return jjtn000;}
507    } finally {
508if (jjtc000) {
509      jjtree.closeNodeScope(jjtn000, true);
510    }
511    }
512    throw new Error("Missing return statement in function");
513}
514
515  final public SimpleNode go() throws ParseException {/*@bgen(jjtree) go */
516  ASTgo jjtn000 = new ASTgo(JJTGO);
517  boolean jjtc000 = true;
518  jjtree.openNodeScope(jjtn000);
519    try {
520      jj_consume_token(GO);
521jjtree.closeNodeScope(jjtn000, true);
522    jjtc000 = false;
523log.debug("GO Production");
524     {if ("" != null) return jjtn000;}
525    } finally {
526if (jjtc000) {
527      jjtree.closeNodeScope(jjtn000, true);
528    }
529    }
530    throw new Error("Missing return statement in function");
531}
532
533  final public SimpleNode get() throws ParseException {/*@bgen(jjtree) get */
534  ASTget jjtn000 = new ASTget(JJTGET);
535  boolean jjtc000 = true;
536  jjtree.openNodeScope(jjtn000);
537    try {
538      jj_consume_token(GET);
539      bus();
540      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
541      case FB:{
542        fb();
543        address();
544        break;
545        }
546      case GA:{
547        ga();
548        address();
549        port();
550        break;
551        }
552      case GL:{
553        gl();
554        address();
555        break;
556        }
557      case SM:{
558        sm();
559        address();
560        progmode();
561        cvno();
562        label_1:
563        while (true) {
564          switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
565          case ZEROADDR:
566          case NONZEROADDR:{
567            ;
568            break;
569            }
570          default:
571            jj_la1[8] = jj_gen;
572            break label_1;
573          }
574          value();
575        }
576        break;
577        }
578      case TIME:{
579        time();
580        break;
581        }
582      case POWER:{
583        power();
584        break;
585        }
586      case SERVER:{
587        server();
588        break;
589        }
590      case SESSION:{
591        session();
592        address();
593        break;
594        }
595      case LOCK:{
596        lock();
597        break;
598        }
599      case DESCRIPTION:{
600        description();
601        break;
602        }
603      default:
604        jj_la1[9] = jj_gen;
605        jj_consume_token(-1);
606        throw new ParseException();
607      }
608jjtree.closeNodeScope(jjtn000, true);
609    jjtc000 = false;
610log.debug("GET Production");
611     {if ("" != null) return jjtn000;}
612    } catch (Throwable jjte000) {
613if (jjtc000) {
614      jjtree.clearNodeScope(jjtn000);
615      jjtc000 = false;
616    } else {
617      jjtree.popNode();
618    }
619    if (jjte000 instanceof RuntimeException) {
620      {if (true) throw (RuntimeException)jjte000;}
621    }
622    if (jjte000 instanceof ParseException) {
623      {if (true) throw (ParseException)jjte000;}
624    }
625    {if (true) throw (Error)jjte000;}
626    } finally {
627if (jjtc000) {
628      jjtree.closeNodeScope(jjtn000, true);
629    }
630    }
631    throw new Error("Missing return statement in function");
632}
633
634  final public SimpleNode handshake_set() throws ParseException {/*@bgen(jjtree) handshake_set */
635  ASThandshake_set jjtn000 = new ASThandshake_set(JJTHANDSHAKE_SET);
636  boolean jjtc000 = true;
637  jjtree.openNodeScope(jjtn000);
638    try {
639      jj_consume_token(SET);
640      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
641      case PROTOCOLLITTERAL:{
642        protocollitteral();
643        serviceversion();
644        break;
645        }
646      case CONNECTIONMODELITTERAL:{
647        connectionlitteral();
648        jj_consume_token(SRCP);
649        connectionmode();
650        break;
651        }
652      default:
653        jj_la1[10] = jj_gen;
654        jj_consume_token(-1);
655        throw new ParseException();
656      }
657jjtree.closeNodeScope(jjtn000, true);
658    jjtc000 = false;
659log.debug("Handshake Mode SET Production");
660    {if ("" != null) return jjtn000;}
661    } catch (Throwable jjte000) {
662if (jjtc000) {
663            jjtree.clearNodeScope(jjtn000);
664            jjtc000 = false;
665          } else {
666            jjtree.popNode();
667          }
668          if (jjte000 instanceof RuntimeException) {
669            {if (true) throw (RuntimeException)jjte000;}
670          }
671          if (jjte000 instanceof ParseException) {
672            {if (true) throw (ParseException)jjte000;}
673          }
674          {if (true) throw (Error)jjte000;}
675    } finally {
676if (jjtc000) {
677            jjtree.closeNodeScope(jjtn000, true);
678          }
679    }
680    throw new Error("Missing return statement in function");
681}
682
683  final public SimpleNode protocollitteral() throws ParseException {/*@bgen(jjtree) protocollitteral */
684  ASTprotocollitteral jjtn000 = new ASTprotocollitteral(JJTPROTOCOLLITTERAL);
685  boolean jjtc000 = true;
686  jjtree.openNodeScope(jjtn000);
687    try {
688      jj_consume_token(PROTOCOLLITTERAL);
689jjtree.closeNodeScope(jjtn000, true);
690     jjtc000 = false;
691log.debug("Protocol Litteral production");
692       {if ("" != null) return jjtn000;}
693    } finally {
694if (jjtc000) {
695       jjtree.closeNodeScope(jjtn000, true);
696     }
697    }
698    throw new Error("Missing return statement in function");
699}
700
701  final public SimpleNode connectionlitteral() throws ParseException {/*@bgen(jjtree) connectionlitteral */
702  ASTconnectionlitteral jjtn000 = new ASTconnectionlitteral(JJTCONNECTIONLITTERAL);
703  boolean jjtc000 = true;
704  jjtree.openNodeScope(jjtn000);
705    try {
706      jj_consume_token(CONNECTIONMODELITTERAL);
707jjtree.closeNodeScope(jjtn000, true);
708     jjtc000 = false;
709log.debug("Connection Litteral production");
710       {if ("" != null) return jjtn000;}
711    } finally {
712if (jjtc000) {
713       jjtree.closeNodeScope(jjtn000, true);
714     }
715    }
716    throw new Error("Missing return statement in function");
717}
718
719  final public SimpleNode set() throws ParseException {/*@bgen(jjtree) set */
720  ASTset jjtn000 = new ASTset(JJTSET);
721  boolean jjtc000 = true;
722  jjtree.openNodeScope(jjtn000);
723    try {
724      jj_consume_token(SET);
725      bus();
726      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
727      case GL:{
728        gl();
729        address();
730        drivemode();
731        address();
732        address();
733        label_2:
734        while (true) {
735          switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
736          case ZEROADDR:
737          case NONZEROADDR:
738          case DRIVEMODE:
739          case FUNCTIONMODE:{
740            ;
741            break;
742            }
743          default:
744            jj_la1[11] = jj_gen;
745            break label_2;
746          }
747          functionmode();
748        }
749        break;
750        }
751      case SM:{
752        sm();
753        address();
754        progmode();
755        cvno();
756        label_3:
757        while (true) {
758          value();
759          switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
760          case ZEROADDR:
761          case NONZEROADDR:{
762            ;
763            break;
764            }
765          default:
766            jj_la1[12] = jj_gen;
767            break label_3;
768          }
769        }
770        break;
771        }
772      case GA:{
773        ga();
774        address();
775        port();
776        zeroone();
777        switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
778        case DELAY:{
779          delay();
780          break;
781          }
782        case ZEROADDR:
783        case NONZEROADDR:{
784          timeout();
785          break;
786          }
787        default:
788          jj_la1[13] = jj_gen;
789          jj_consume_token(-1);
790          throw new ParseException();
791        }
792        break;
793        }
794      case FB:{
795        fb();
796        address();
797        zeroone();
798        break;
799        }
800      case TIME:{
801        time();
802        address();
803        address();
804        address();
805        address();
806        break;
807        }
808      case POWER:{
809        power();
810        onoff();
811        break;
812        }
813      case LOCK:{
814        lock();
815        break;
816        }
817      default:
818        jj_la1[14] = jj_gen;
819        jj_consume_token(-1);
820        throw new ParseException();
821      }
822jjtree.closeNodeScope(jjtn000, true);
823    jjtc000 = false;
824log.debug("SET Production");
825    {if ("" != null) return jjtn000;}
826    } catch (Throwable jjte000) {
827if (jjtc000) {
828      jjtree.clearNodeScope(jjtn000);
829      jjtc000 = false;
830    } else {
831      jjtree.popNode();
832    }
833    if (jjte000 instanceof RuntimeException) {
834      {if (true) throw (RuntimeException)jjte000;}
835    }
836    if (jjte000 instanceof ParseException) {
837      {if (true) throw (ParseException)jjte000;}
838    }
839    {if (true) throw (Error)jjte000;}
840    } finally {
841if (jjtc000) {
842      jjtree.closeNodeScope(jjtn000, true);
843    }
844    }
845    throw new Error("Missing return statement in function");
846}
847
848  final public SimpleNode term() throws ParseException {/*@bgen(jjtree) term */
849  ASTterm jjtn000 = new ASTterm(JJTTERM);
850  boolean jjtc000 = true;
851  jjtree.openNodeScope(jjtn000);
852    try {
853      jj_consume_token(TERM);
854      bus();
855      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
856      case FB:{
857        fb();
858        break;
859        }
860      case GL:{
861        gl();
862        address();
863        break;
864        }
865      case SM:{
866        sm();
867        break;
868        }
869      case POWER:{
870        power();
871        break;
872        }
873      case SERVER:{
874        server();
875        break;
876        }
877      case LOCK:{
878        lock();
879        break;
880        }
881      case TIME:{
882        time();
883        break;
884        }
885      case SESSION:{
886        session();
887        switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
888        case ZEROADDR:
889        case NONZEROADDR:{
890          address();
891          break;
892          }
893        default:
894          jj_la1[15] = jj_gen;
895          ;
896        }
897        break;
898        }
899      default:
900        jj_la1[16] = jj_gen;
901        jj_consume_token(-1);
902        throw new ParseException();
903      }
904jjtree.closeNodeScope(jjtn000, true);
905    jjtc000 = false;
906{if ("" != null) return jjtn000;}
907    } catch (Throwable jjte000) {
908if (jjtc000) {
909      jjtree.clearNodeScope(jjtn000);
910      jjtc000 = false;
911    } else {
912      jjtree.popNode();
913    }
914    if (jjte000 instanceof RuntimeException) {
915      {if (true) throw (RuntimeException)jjte000;}
916    }
917    if (jjte000 instanceof ParseException) {
918      {if (true) throw (ParseException)jjte000;}
919    }
920    {if (true) throw (Error)jjte000;}
921    } finally {
922if (jjtc000) {
923      jjtree.closeNodeScope(jjtn000, true);
924    }
925    }
926    throw new Error("Missing return statement in function");
927}
928
929  final public SimpleNode check() throws ParseException {/*@bgen(jjtree) check */
930  ASTcheck jjtn000 = new ASTcheck(JJTCHECK);
931  boolean jjtc000 = true;
932  jjtree.openNodeScope(jjtn000);
933    try {
934      jj_consume_token(CHECK);
935      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
936      case ZEROADDR:
937      case NONZEROADDR:{
938        bus();
939        switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
940        case GL:{
941          gl();
942          break;
943          }
944        case SM:{
945          sm();
946          break;
947          }
948        case GA:{
949          ga();
950          address();
951          port();
952          zeroone();
953          switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
954          case DELAY:{
955            delay();
956            break;
957            }
958          case ZEROADDR:
959          case NONZEROADDR:{
960            timeout();
961            break;
962            }
963          default:
964            jj_la1[17] = jj_gen;
965            jj_consume_token(-1);
966            throw new ParseException();
967          }
968          break;
969          }
970        case FB:{
971          fb();
972          address();
973          zeroone();
974          break;
975          }
976        case TIME:{
977          time();
978          break;
979          }
980        case POWER:{
981          power();
982          onoff();
983          break;
984          }
985        case LOCK:{
986          lock();
987          break;
988          }
989        default:
990          jj_la1[18] = jj_gen;
991          jj_consume_token(-1);
992          throw new ParseException();
993        }
994        break;
995        }
996      case PROTOCOLLITTERAL:{
997        jj_consume_token(PROTOCOLLITTERAL);
998        serviceversion();
999        break;
1000        }
1001      case CONNECTIONMODELITTERAL:{
1002        jj_consume_token(CONNECTIONMODELITTERAL);
1003        connectionmode();
1004        break;
1005        }
1006      default:
1007        jj_la1[19] = jj_gen;
1008        jj_consume_token(-1);
1009        throw new ParseException();
1010      }
1011jjtree.closeNodeScope(jjtn000, true);
1012    jjtc000 = false;
1013log.debug("Check Production");
1014    {if ("" != null) return jjtn000;}
1015    } catch (Throwable jjte000) {
1016if (jjtc000) {
1017      jjtree.clearNodeScope(jjtn000);
1018      jjtc000 = false;
1019    } else {
1020      jjtree.popNode();
1021    }
1022    if (jjte000 instanceof RuntimeException) {
1023      {if (true) throw (RuntimeException)jjte000;}
1024    }
1025    if (jjte000 instanceof ParseException) {
1026      {if (true) throw (ParseException)jjte000;}
1027    }
1028    {if (true) throw (Error)jjte000;}
1029    } finally {
1030if (jjtc000) {
1031      jjtree.closeNodeScope(jjtn000, true);
1032    }
1033    }
1034    throw new Error("Missing return statement in function");
1035}
1036
1037  final public SimpleNode wait_cmd() throws ParseException {/*@bgen(jjtree) wait_cmd */
1038  ASTwait_cmd jjtn000 = new ASTwait_cmd(JJTWAIT_CMD);
1039  boolean jjtc000 = true;
1040  jjtree.openNodeScope(jjtn000);
1041    try {
1042      jj_consume_token(WAIT);
1043      bus();
1044      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1045      case FB:{
1046        fb();
1047        address();
1048        zeroone();
1049        timeout();
1050        break;
1051        }
1052      case TIME:{
1053        time();
1054        address();
1055        address();
1056        address();
1057        address();
1058        break;
1059        }
1060      default:
1061        jj_la1[20] = jj_gen;
1062        jj_consume_token(-1);
1063        throw new ParseException();
1064      }
1065jjtree.closeNodeScope(jjtn000, true);
1066    jjtc000 = false;
1067log.debug("WAIT Production");
1068     {if ("" != null) return jjtn000;}
1069    } catch (Throwable jjte000) {
1070if (jjtc000) {
1071      jjtree.clearNodeScope(jjtn000);
1072      jjtc000 = false;
1073    } else {
1074      jjtree.popNode();
1075    }
1076    if (jjte000 instanceof RuntimeException) {
1077      {if (true) throw (RuntimeException)jjte000;}
1078    }
1079    if (jjte000 instanceof ParseException) {
1080      {if (true) throw (ParseException)jjte000;}
1081    }
1082    {if (true) throw (Error)jjte000;}
1083    } finally {
1084if (jjtc000) {
1085      jjtree.closeNodeScope(jjtn000, true);
1086    }
1087    }
1088    throw new Error("Missing return statement in function");
1089}
1090
1091  final public SimpleNode init() throws ParseException {/*@bgen(jjtree) init */
1092  ASTinit jjtn000 = new ASTinit(JJTINIT);
1093  boolean jjtc000 = true;
1094  jjtree.openNodeScope(jjtn000);
1095    try {
1096      jj_consume_token(INIT);
1097      bus();
1098      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1099      case FB:{
1100        fb();
1101        break;
1102        }
1103      case GA:{
1104        ga();
1105        address();
1106        protocol();
1107        break;
1108        }
1109      case GL:{
1110        gl();
1111        address();
1112        protocol();
1113        break;
1114        }
1115      case SM:{
1116        sm();
1117        jj_consume_token(NMRA);
1118        break;
1119        }
1120      case TIME:{
1121        time();
1122        nonzeroaddress();
1123        nonzeroaddress();
1124        break;
1125        }
1126      case POWER:{
1127        power();
1128        break;
1129        }
1130      default:
1131        jj_la1[21] = jj_gen;
1132        jj_consume_token(-1);
1133        throw new ParseException();
1134      }
1135jjtree.closeNodeScope(jjtn000, true);
1136    jjtc000 = false;
1137log.debug("INIT Production");
1138     {if ("" != null) return jjtn000;}
1139    } catch (Throwable jjte000) {
1140if (jjtc000) {
1141      jjtree.clearNodeScope(jjtn000);
1142      jjtc000 = false;
1143    } else {
1144      jjtree.popNode();
1145    }
1146    if (jjte000 instanceof RuntimeException) {
1147      {if (true) throw (RuntimeException)jjte000;}
1148    }
1149    if (jjte000 instanceof ParseException) {
1150      {if (true) throw (ParseException)jjte000;}
1151    }
1152    {if (true) throw (Error)jjte000;}
1153    } finally {
1154if (jjtc000) {
1155      jjtree.closeNodeScope(jjtn000, true);
1156    }
1157    }
1158    throw new Error("Missing return statement in function");
1159}
1160
1161  final public SimpleNode reset() throws ParseException {/*@bgen(jjtree) reset */
1162  ASTreset jjtn000 = new ASTreset(JJTRESET);
1163  boolean jjtc000 = true;
1164  jjtree.openNodeScope(jjtn000);
1165    try {
1166      jj_consume_token(RESET);
1167      bus();
1168      server();
1169jjtree.closeNodeScope(jjtn000, true);
1170    jjtc000 = false;
1171log.debug("RESET Production");
1172     {if ("" != null) return jjtn000;}
1173    } catch (Throwable jjte000) {
1174if (jjtc000) {
1175      jjtree.clearNodeScope(jjtn000);
1176      jjtc000 = false;
1177    } else {
1178      jjtree.popNode();
1179    }
1180    if (jjte000 instanceof RuntimeException) {
1181      {if (true) throw (RuntimeException)jjte000;}
1182    }
1183    if (jjte000 instanceof ParseException) {
1184      {if (true) throw (ParseException)jjte000;}
1185    }
1186    {if (true) throw (Error)jjte000;}
1187    } finally {
1188if (jjtc000) {
1189      jjtree.closeNodeScope(jjtn000, true);
1190    }
1191    }
1192    throw new Error("Missing return statement in function");
1193}
1194
1195  final public SimpleNode verify() throws ParseException {/*@bgen(jjtree) verify */
1196  ASTverify jjtn000 = new ASTverify(JJTVERIFY);
1197  boolean jjtc000 = true;
1198  jjtree.openNodeScope(jjtn000);
1199    try {
1200      jj_consume_token(VERIFY);
1201      bus();
1202      sm();
1203      address();
1204      progmode();
1205      cvno();
1206      label_4:
1207      while (true) {
1208        value();
1209        switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1210        case ZEROADDR:
1211        case NONZEROADDR:{
1212          ;
1213          break;
1214          }
1215        default:
1216          jj_la1[22] = jj_gen;
1217          break label_4;
1218        }
1219      }
1220jjtree.closeNodeScope(jjtn000, true);
1221    jjtc000 = false;
1222log.debug("RESET Production");
1223     {if ("" != null) return jjtn000;}
1224    } catch (Throwable jjte000) {
1225if (jjtc000) {
1226      jjtree.clearNodeScope(jjtn000);
1227      jjtc000 = false;
1228    } else {
1229      jjtree.popNode();
1230    }
1231    if (jjte000 instanceof RuntimeException) {
1232      {if (true) throw (RuntimeException)jjte000;}
1233    }
1234    if (jjte000 instanceof ParseException) {
1235      {if (true) throw (ParseException)jjte000;}
1236    }
1237    {if (true) throw (Error)jjte000;}
1238    } finally {
1239if (jjtc000) {
1240      jjtree.closeNodeScope(jjtn000, true);
1241    }
1242    }
1243    throw new Error("Missing return statement in function");
1244}
1245
1246  final public SimpleNode gl() throws ParseException {/*@bgen(jjtree) gl */
1247                 ASTgl jjtn000 = new ASTgl(JJTGL);
1248                 boolean jjtc000 = true;
1249                 jjtree.openNodeScope(jjtn000);Token t;
1250    try {
1251      t = jj_consume_token(GL);
1252jjtree.closeNodeScope(jjtn000, true);
1253    jjtc000 = false;
1254jjtn000.jjtSetValue(t.image);
1255     {if ("" != null) return jjtn000;}
1256    } finally {
1257if (jjtc000) {
1258      jjtree.closeNodeScope(jjtn000, true);
1259    }
1260    }
1261    throw new Error("Missing return statement in function");
1262}
1263
1264  final public SimpleNode sm() throws ParseException {/*@bgen(jjtree) sm */
1265                 ASTsm jjtn000 = new ASTsm(JJTSM);
1266                 boolean jjtc000 = true;
1267                 jjtree.openNodeScope(jjtn000);Token t;
1268    try {
1269      t = jj_consume_token(SM);
1270jjtree.closeNodeScope(jjtn000, true);
1271    jjtc000 = false;
1272jjtn000.jjtSetValue(t.image);
1273     {if ("" != null) return jjtn000;}
1274    } finally {
1275if (jjtc000) {
1276      jjtree.closeNodeScope(jjtn000, true);
1277    }
1278    }
1279    throw new Error("Missing return statement in function");
1280}
1281
1282  final public SimpleNode ga() throws ParseException {/*@bgen(jjtree) ga */
1283                 ASTga jjtn000 = new ASTga(JJTGA);
1284                 boolean jjtc000 = true;
1285                 jjtree.openNodeScope(jjtn000);Token t;
1286    try {
1287      t = jj_consume_token(GA);
1288jjtree.closeNodeScope(jjtn000, true);
1289    jjtc000 = false;
1290jjtn000.jjtSetValue(t.image);
1291    {if ("" != null) return jjtn000;}
1292    } finally {
1293if (jjtc000) {
1294      jjtree.closeNodeScope(jjtn000, true);
1295    }
1296    }
1297    throw new Error("Missing return statement in function");
1298}
1299
1300  final public SimpleNode fb() throws ParseException {/*@bgen(jjtree) fb */
1301                 ASTfb jjtn000 = new ASTfb(JJTFB);
1302                 boolean jjtc000 = true;
1303                 jjtree.openNodeScope(jjtn000);Token t;
1304    try {
1305      t = jj_consume_token(FB);
1306jjtree.closeNodeScope(jjtn000, true);
1307    jjtc000 = false;
1308jjtn000.jjtSetValue(t.image);
1309    {if ("" != null) return jjtn000;}
1310    } finally {
1311if (jjtc000) {
1312      jjtree.closeNodeScope(jjtn000, true);
1313    }
1314    }
1315    throw new Error("Missing return statement in function");
1316}
1317
1318  final public SimpleNode time() throws ParseException {/*@bgen(jjtree) time */
1319                   ASTtime jjtn000 = new ASTtime(JJTTIME);
1320                   boolean jjtc000 = true;
1321                   jjtree.openNodeScope(jjtn000);Token t;
1322    try {
1323      t = jj_consume_token(TIME);
1324jjtree.closeNodeScope(jjtn000, true);
1325    jjtc000 = false;
1326jjtn000.jjtSetValue(t.image);
1327    {if ("" != null) return jjtn000;}
1328    } finally {
1329if (jjtc000) {
1330      jjtree.closeNodeScope(jjtn000, true);
1331    }
1332    }
1333    throw new Error("Missing return statement in function");
1334}
1335
1336  final public SimpleNode power() throws ParseException {/*@bgen(jjtree) power */
1337                    ASTpower jjtn000 = new ASTpower(JJTPOWER);
1338                    boolean jjtc000 = true;
1339                    jjtree.openNodeScope(jjtn000);Token t;
1340    try {
1341      t = jj_consume_token(POWER);
1342jjtree.closeNodeScope(jjtn000, true);
1343    jjtc000 = false;
1344jjtn000.jjtSetValue(t.image);
1345    {if ("" != null) return jjtn000;}
1346    } finally {
1347if (jjtc000) {
1348      jjtree.closeNodeScope(jjtn000, true);
1349    }
1350    }
1351    throw new Error("Missing return statement in function");
1352}
1353
1354  final public SimpleNode server() throws ParseException {/*@bgen(jjtree) server */
1355                     ASTserver jjtn000 = new ASTserver(JJTSERVER);
1356                     boolean jjtc000 = true;
1357                     jjtree.openNodeScope(jjtn000);Token t;
1358    try {
1359      t = jj_consume_token(SERVER);
1360jjtree.closeNodeScope(jjtn000, true);
1361    jjtc000 = false;
1362jjtn000.jjtSetValue(t.image);
1363    {if ("" != null) return jjtn000;}
1364    } finally {
1365if (jjtc000) {
1366      jjtree.closeNodeScope(jjtn000, true);
1367    }
1368    }
1369    throw new Error("Missing return statement in function");
1370}
1371
1372  final public SimpleNode session() throws ParseException {/*@bgen(jjtree) session */
1373                      ASTsession jjtn000 = new ASTsession(JJTSESSION);
1374                      boolean jjtc000 = true;
1375                      jjtree.openNodeScope(jjtn000);Token t;
1376    try {
1377      t = jj_consume_token(SESSION);
1378jjtree.closeNodeScope(jjtn000, true);
1379    jjtc000 = false;
1380jjtn000.jjtSetValue(t.image);
1381    {if ("" != null) return jjtn000;}
1382    } finally {
1383if (jjtc000) {
1384      jjtree.closeNodeScope(jjtn000, true);
1385    }
1386    }
1387    throw new Error("Missing return statement in function");
1388}
1389
1390  final public SimpleNode lock() throws ParseException {/*@bgen(jjtree) lock */
1391                   ASTlock jjtn000 = new ASTlock(JJTLOCK);
1392                   boolean jjtc000 = true;
1393                   jjtree.openNodeScope(jjtn000);Token t;
1394    try {
1395      t = jj_consume_token(LOCK);
1396      devicegroup();
1397      address();
1398      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1399      case ZEROADDR:
1400      case NONZEROADDR:{
1401        address();
1402        break;
1403        }
1404      default:
1405        jj_la1[23] = jj_gen;
1406        ;
1407      }
1408jjtree.closeNodeScope(jjtn000, true);
1409    jjtc000 = false;
1410jjtn000.jjtSetValue(t.image);
1411    {if ("" != null) return jjtn000;}
1412    } catch (Throwable jjte000) {
1413if (jjtc000) {
1414      jjtree.clearNodeScope(jjtn000);
1415      jjtc000 = false;
1416    } else {
1417      jjtree.popNode();
1418    }
1419    if (jjte000 instanceof RuntimeException) {
1420      {if (true) throw (RuntimeException)jjte000;}
1421    }
1422    if (jjte000 instanceof ParseException) {
1423      {if (true) throw (ParseException)jjte000;}
1424    }
1425    {if (true) throw (Error)jjte000;}
1426    } finally {
1427if (jjtc000) {
1428      jjtree.closeNodeScope(jjtn000, true);
1429    }
1430    }
1431    throw new Error("Missing return statement in function");
1432}
1433
1434  final public SimpleNode description() throws ParseException {/*@bgen(jjtree) description */
1435                          ASTdescription jjtn000 = new ASTdescription(JJTDESCRIPTION);
1436                          boolean jjtc000 = true;
1437                          jjtree.openNodeScope(jjtn000);Token t; SimpleNode s; SimpleNode r;
1438    try {
1439      t = jj_consume_token(DESCRIPTION);
1440      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1441      case FB:
1442      case GA:
1443      case GL:
1444      case SM:
1445      case LOCK:
1446      case TIME:
1447      case POWER:
1448      case SESSION:
1449      case DESCRIPTION:
1450      case SERVER:{
1451        devicegroup();
1452        switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1453        case ZEROADDR:
1454        case NONZEROADDR:{
1455          address();
1456          break;
1457          }
1458        default:
1459          jj_la1[24] = jj_gen;
1460          ;
1461        }
1462        break;
1463        }
1464      default:
1465        jj_la1[25] = jj_gen;
1466        ;
1467      }
1468jjtree.closeNodeScope(jjtn000, true);
1469    jjtc000 = false;
1470jjtn000.jjtSetValue(t.image);
1471    {if ("" != null) return jjtn000;}
1472    } catch (Throwable jjte000) {
1473if (jjtc000) {
1474      jjtree.clearNodeScope(jjtn000);
1475      jjtc000 = false;
1476    } else {
1477      jjtree.popNode();
1478    }
1479    if (jjte000 instanceof RuntimeException) {
1480      {if (true) throw (RuntimeException)jjte000;}
1481    }
1482    if (jjte000 instanceof ParseException) {
1483      {if (true) throw (ParseException)jjte000;}
1484    }
1485    {if (true) throw (Error)jjte000;}
1486    } finally {
1487if (jjtc000) {
1488      jjtree.closeNodeScope(jjtn000, true);
1489    }
1490    }
1491    throw new Error("Missing return statement in function");
1492}
1493
1494  final public SimpleNode onoff() throws ParseException {/*@bgen(jjtree) onoff */
1495                    ASTonoff jjtn000 = new ASTonoff(JJTONOFF);
1496                    boolean jjtc000 = true;
1497                    jjtree.openNodeScope(jjtn000);Token t;
1498    try {
1499      t = jj_consume_token(ONOFF);
1500jjtree.closeNodeScope(jjtn000, true);
1501    jjtc000 = false;
1502log.debug("OnOff Production " +t.image);
1503     jjtn000.jjtSetValue(t.image);
1504     {if ("" != null) return jjtn000;}
1505    } finally {
1506if (jjtc000) {
1507      jjtree.closeNodeScope(jjtn000, true);
1508    }
1509    }
1510    throw new Error("Missing return statement in function");
1511}
1512
1513  final public SimpleNode zeroone() throws ParseException {/*@bgen(jjtree) zeroone */
1514                      ASTzeroone jjtn000 = new ASTzeroone(JJTZEROONE);
1515                      boolean jjtc000 = true;
1516                      jjtree.openNodeScope(jjtn000);SimpleNode s;
1517    try {
1518      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1519      case ZEROADDR:{
1520        s = zeroaddress();
1521        break;
1522        }
1523      case NONZEROADDR:{
1524        s = nonzeroaddress();
1525        break;
1526        }
1527      default:
1528        jj_la1[26] = jj_gen;
1529        jj_consume_token(-1);
1530        throw new ParseException();
1531      }
1532jjtree.closeNodeScope(jjtn000, true);
1533    jjtc000 = false;
1534log.debug("ZeroOne Production ");
1535     jjtn000.jjtSetValue(s.jjtGetValue());
1536     {if ("" != null) return jjtn000;}
1537    } catch (Throwable jjte000) {
1538if (jjtc000) {
1539      jjtree.clearNodeScope(jjtn000);
1540      jjtc000 = false;
1541    } else {
1542      jjtree.popNode();
1543    }
1544    if (jjte000 instanceof RuntimeException) {
1545      {if (true) throw (RuntimeException)jjte000;}
1546    }
1547    if (jjte000 instanceof ParseException) {
1548      {if (true) throw (ParseException)jjte000;}
1549    }
1550    {if (true) throw (Error)jjte000;}
1551    } finally {
1552if (jjtc000) {
1553      jjtree.closeNodeScope(jjtn000, true);
1554    }
1555    }
1556    throw new Error("Missing return statement in function");
1557}
1558
1559  final public SimpleNode delay() throws ParseException {/*@bgen(jjtree) delay */
1560                    ASTdelay jjtn000 = new ASTdelay(JJTDELAY);
1561                    boolean jjtc000 = true;
1562                    jjtree.openNodeScope(jjtn000);Token t;
1563    try {
1564      // time timeout is a non-zero integer.  It may be negative.
1565        t = jj_consume_token(DELAY);
1566jjtree.closeNodeScope(jjtn000, true);
1567    jjtc000 = false;
1568log.debug("Delay Production " +t.image);
1569     {if ("" != null) return jjtn000;}
1570    } finally {
1571if (jjtc000) {
1572      jjtree.closeNodeScope(jjtn000, true);
1573    }
1574    }
1575    throw new Error("Missing return statement in function");
1576}
1577
1578  final public SimpleNode timeout() throws ParseException {/*@bgen(jjtree) timeout */
1579                      ASTtimeout jjtn000 = new ASTtimeout(JJTTIMEOUT);
1580                      boolean jjtc000 = true;
1581                      jjtree.openNodeScope(jjtn000);Token t;
1582    try {
1583      address();
1584jjtree.closeNodeScope(jjtn000, true);
1585    jjtc000 = false;
1586log.debug("Timeout Production ");
1587     {if ("" != null) return jjtn000;}
1588    } catch (Throwable jjte000) {
1589if (jjtc000) {
1590      jjtree.clearNodeScope(jjtn000);
1591      jjtc000 = false;
1592    } else {
1593      jjtree.popNode();
1594    }
1595    if (jjte000 instanceof RuntimeException) {
1596      {if (true) throw (RuntimeException)jjte000;}
1597    }
1598    if (jjte000 instanceof ParseException) {
1599      {if (true) throw (ParseException)jjte000;}
1600    }
1601    {if (true) throw (Error)jjte000;}
1602    } finally {
1603if (jjtc000) {
1604      jjtree.closeNodeScope(jjtn000, true);
1605    }
1606    }
1607    throw new Error("Missing return statement in function");
1608}
1609
1610// service mode programming modes
1611  final public 
1612SimpleNode progmode() throws ParseException {/*@bgen(jjtree) progmode */
1613                       ASTprogmode jjtn000 = new ASTprogmode(JJTPROGMODE);
1614                       boolean jjtc000 = true;
1615                       jjtree.openNodeScope(jjtn000);SimpleNode s;
1616    try {
1617      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1618      case CVBIT:{
1619        s = cvbit();
1620        break;
1621        }
1622      case CV:{
1623        s = cv();
1624        break;
1625        }
1626      case REG:{
1627        s = reg();
1628        break;
1629        }
1630      default:
1631        jj_la1[27] = jj_gen;
1632        jj_consume_token(-1);
1633        throw new ParseException();
1634      }
1635jjtree.closeNodeScope(jjtn000, true);
1636    jjtc000 = false;
1637log.debug("Programming Mode Production ");
1638     {if ("" != null) return jjtn000;}
1639    } catch (Throwable jjte000) {
1640if (jjtc000) {
1641      jjtree.clearNodeScope(jjtn000);
1642      jjtc000 = false;
1643    } else {
1644      jjtree.popNode();
1645    }
1646    if (jjte000 instanceof RuntimeException) {
1647      {if (true) throw (RuntimeException)jjte000;}
1648    }
1649    if (jjte000 instanceof ParseException) {
1650      {if (true) throw (ParseException)jjte000;}
1651    }
1652    {if (true) throw (Error)jjte000;}
1653    } finally {
1654if (jjtc000) {
1655      jjtree.closeNodeScope(jjtn000, true);
1656    }
1657    }
1658    throw new Error("Missing return statement in function");
1659}
1660
1661  final public SimpleNode cv() throws ParseException {/*@bgen(jjtree) cv */
1662  ASTcv jjtn000 = new ASTcv(JJTCV);
1663  boolean jjtc000 = true;
1664  jjtree.openNodeScope(jjtn000);
1665    try {
1666      jj_consume_token(CV);
1667jjtree.closeNodeScope(jjtn000, true);
1668    jjtc000 = false;
1669{if ("" != null) return jjtn000;}
1670    } finally {
1671if (jjtc000) {
1672      jjtree.closeNodeScope(jjtn000, true);
1673    }
1674    }
1675    throw new Error("Missing return statement in function");
1676}
1677
1678  final public SimpleNode cvbit() throws ParseException {/*@bgen(jjtree) cvbit */
1679  ASTcvbit jjtn000 = new ASTcvbit(JJTCVBIT);
1680  boolean jjtc000 = true;
1681  jjtree.openNodeScope(jjtn000);
1682    try {
1683      jj_consume_token(CVBIT);
1684jjtree.closeNodeScope(jjtn000, true);
1685    jjtc000 = false;
1686{if ("" != null) return jjtn000;}
1687    } finally {
1688if (jjtc000) {
1689      jjtree.closeNodeScope(jjtn000, true);
1690    }
1691    }
1692    throw new Error("Missing return statement in function");
1693}
1694
1695  final public SimpleNode reg() throws ParseException {/*@bgen(jjtree) reg */
1696  ASTreg jjtn000 = new ASTreg(JJTREG);
1697  boolean jjtc000 = true;
1698  jjtree.openNodeScope(jjtn000);
1699    try {
1700      jj_consume_token(REG);
1701jjtree.closeNodeScope(jjtn000, true);
1702    jjtc000 = false;
1703{if ("" != null) return jjtn000;}
1704    } finally {
1705if (jjtc000) {
1706      jjtree.closeNodeScope(jjtn000, true);
1707    }
1708    }
1709    throw new Error("Missing return statement in function");
1710}
1711
1712  final public SimpleNode protocol() throws ParseException {/*@bgen(jjtree) protocol */
1713                       ASTprotocol jjtn000 = new ASTprotocol(JJTPROTOCOL);
1714                       boolean jjtc000 = true;
1715                       jjtree.openNodeScope(jjtn000);Token t;
1716    try {
1717      t = jj_consume_token(PROTOCOL);
1718      label_5:
1719      while (true) {
1720        switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1721        case ZEROADDR:
1722        case NONZEROADDR:{
1723          ;
1724          break;
1725          }
1726        default:
1727          jj_la1[28] = jj_gen;
1728          break label_5;
1729        }
1730        address();
1731      }
1732jjtree.closeNodeScope(jjtn000, true);
1733    jjtc000 = false;
1734log.debug("Protocol Production "+ t.image);
1735    jjtn000.jjtSetValue(t.image);
1736    {if ("" != null) return jjtn000;}
1737    } catch (Throwable jjte000) {
1738if (jjtc000) {
1739      jjtree.clearNodeScope(jjtn000);
1740      jjtc000 = false;
1741    } else {
1742      jjtree.popNode();
1743    }
1744    if (jjte000 instanceof RuntimeException) {
1745      {if (true) throw (RuntimeException)jjte000;}
1746    }
1747    if (jjte000 instanceof ParseException) {
1748      {if (true) throw (ParseException)jjte000;}
1749    }
1750    {if (true) throw (Error)jjte000;}
1751    } finally {
1752if (jjtc000) {
1753      jjtree.closeNodeScope(jjtn000, true);
1754    }
1755    }
1756    throw new Error("Missing return statement in function");
1757}
1758
1759  final public SimpleNode drivemode() throws ParseException {/*@bgen(jjtree) drivemode */
1760                        ASTdrivemode jjtn000 = new ASTdrivemode(JJTDRIVEMODE);
1761                        boolean jjtc000 = true;
1762                        jjtree.openNodeScope(jjtn000);Token t;
1763    try {
1764      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1765      case DRIVEMODE:{
1766        t = jj_consume_token(DRIVEMODE);
1767        break;
1768        }
1769      case ZEROADDR:{
1770        t = jj_consume_token(ZEROADDR);
1771        break;
1772        }
1773      case NONZEROADDR:{
1774        t = jj_consume_token(NONZEROADDR);
1775        break;
1776        }
1777      default:
1778        jj_la1[29] = jj_gen;
1779        jj_consume_token(-1);
1780        throw new ParseException();
1781      }
1782jjtree.closeNodeScope(jjtn000, true);
1783     jjtc000 = false;
1784log.debug("Drivemode Production "+ t.image);
1785    jjtn000.jjtSetValue(t.image);
1786    {if ("" != null) return jjtn000;}
1787    } finally {
1788if (jjtc000) {
1789       jjtree.closeNodeScope(jjtn000, true);
1790     }
1791    }
1792    throw new Error("Missing return statement in function");
1793}
1794
1795  final public SimpleNode functionmode() throws ParseException {/*@bgen(jjtree) functionmode */
1796                           ASTfunctionmode jjtn000 = new ASTfunctionmode(JJTFUNCTIONMODE);
1797                           boolean jjtc000 = true;
1798                           jjtree.openNodeScope(jjtn000);Token t;
1799    try {
1800      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1801      case FUNCTIONMODE:{
1802        t = jj_consume_token(FUNCTIONMODE);
1803        break;
1804        }
1805      case ZEROADDR:{
1806        t = jj_consume_token(ZEROADDR);
1807        break;
1808        }
1809      case NONZEROADDR:{
1810        t = jj_consume_token(NONZEROADDR);
1811        break;
1812        }
1813      case DRIVEMODE:{
1814        t = jj_consume_token(DRIVEMODE);
1815        break;
1816        }
1817      default:
1818        jj_la1[30] = jj_gen;
1819        jj_consume_token(-1);
1820        throw new ParseException();
1821      }
1822jjtree.closeNodeScope(jjtn000, true);
1823     jjtc000 = false;
1824log.debug("Functionmode Production "+ t.image);
1825    jjtn000.jjtSetValue(t.image);
1826    {if ("" != null) return jjtn000;}
1827    } finally {
1828if (jjtc000) {
1829       jjtree.closeNodeScope(jjtn000, true);
1830     }
1831    }
1832    throw new Error("Missing return statement in function");
1833}
1834
1835  private boolean jj_2_1(int xla)
1836 {
1837    jj_la = xla; jj_lastpos = jj_scanpos = token;
1838    try { return (!jj_3_1()); }
1839    catch(LookaheadSuccess ls) { return true; }
1840    finally { jj_save(0, xla); }
1841  }
1842
1843  private boolean jj_2_2(int xla)
1844 {
1845    jj_la = xla; jj_lastpos = jj_scanpos = token;
1846    try { return (!jj_3_2()); }
1847    catch(LookaheadSuccess ls) { return true; }
1848    finally { jj_save(1, xla); }
1849  }
1850
1851  private boolean jj_3R_26()
1852 {
1853    if (jj_scan_token(TIME)) return true;
1854    return false;
1855  }
1856
1857  private boolean jj_3R_31()
1858 {
1859    if (jj_scan_token(DESCRIPTION)) return true;
1860    Token xsp;
1861    xsp = jj_scanpos;
1862    if (jj_3R_37()) jj_scanpos = xsp;
1863    return false;
1864  }
1865
1866  private boolean jj_3R_35()
1867 {
1868    if (jj_3R_33()) return true;
1869    return false;
1870  }
1871
1872  private boolean jj_3R_36()
1873 {
1874    Token xsp;
1875    xsp = jj_scanpos;
1876    if (jj_scan_token(19)) {
1877    jj_scanpos = xsp;
1878    if (jj_scan_token(20)) {
1879    jj_scanpos = xsp;
1880    if (jj_scan_token(21)) {
1881    jj_scanpos = xsp;
1882    if (jj_scan_token(23)) {
1883    jj_scanpos = xsp;
1884    if (jj_scan_token(25)) {
1885    jj_scanpos = xsp;
1886    if (jj_scan_token(27)) {
1887    jj_scanpos = xsp;
1888    if (jj_scan_token(29)) {
1889    jj_scanpos = xsp;
1890    if (jj_scan_token(24)) {
1891    jj_scanpos = xsp;
1892    if (jj_scan_token(28)) {
1893    jj_scanpos = xsp;
1894    if (jj_scan_token(26)) return true;
1895    }
1896    }
1897    }
1898    }
1899    }
1900    }
1901    }
1902    }
1903    }
1904    return false;
1905  }
1906
1907  private boolean jj_3R_21()
1908 {
1909    if (jj_scan_token(FB)) return true;
1910    return false;
1911  }
1912
1913  private boolean jj_3R_18()
1914 {
1915    if (jj_3R_31()) return true;
1916    return false;
1917  }
1918
1919  private boolean jj_3R_17()
1920 {
1921    if (jj_3R_30()) return true;
1922    return false;
1923  }
1924
1925  private boolean jj_3R_30()
1926 {
1927    if (jj_scan_token(LOCK)) return true;
1928    if (jj_3R_36()) return true;
1929    return false;
1930  }
1931
1932  private boolean jj_3R_16()
1933 {
1934    if (jj_3R_29()) return true;
1935    if (jj_3R_22()) return true;
1936    return false;
1937  }
1938
1939  private boolean jj_3R_15()
1940 {
1941    if (jj_3R_28()) return true;
1942    return false;
1943  }
1944
1945  private boolean jj_3_2()
1946 {
1947    if (jj_3R_7()) return true;
1948    return false;
1949  }
1950
1951  private boolean jj_3R_20()
1952 {
1953    if (jj_3R_33()) return true;
1954    return false;
1955  }
1956
1957  private boolean jj_3R_14()
1958 {
1959    if (jj_3R_27()) return true;
1960    return false;
1961  }
1962
1963  private boolean jj_3R_13()
1964 {
1965    if (jj_3R_26()) return true;
1966    return false;
1967  }
1968
1969  private boolean jj_3R_12()
1970 {
1971    if (jj_3R_25()) return true;
1972    if (jj_3R_22()) return true;
1973    return false;
1974  }
1975
1976  private boolean jj_3R_11()
1977 {
1978    if (jj_3R_24()) return true;
1979    if (jj_3R_22()) return true;
1980    return false;
1981  }
1982
1983  private boolean jj_3R_10()
1984 {
1985    if (jj_3R_23()) return true;
1986    if (jj_3R_22()) return true;
1987    return false;
1988  }
1989
1990  private boolean jj_3R_23()
1991 {
1992    if (jj_scan_token(GA)) return true;
1993    return false;
1994  }
1995
1996  private boolean jj_3R_9()
1997 {
1998    if (jj_3R_21()) return true;
1999    if (jj_3R_22()) return true;
2000    return false;
2001  }
2002
2003  private boolean jj_3R_29()
2004 {
2005    if (jj_scan_token(SESSION)) return true;
2006    return false;
2007  }
2008
2009  private boolean jj_3R_34()
2010 {
2011    if (jj_3R_32()) return true;
2012    return false;
2013  }
2014
2015  private boolean jj_3R_22()
2016 {
2017    Token xsp;
2018    xsp = jj_scanpos;
2019    if (jj_3R_34()) {
2020    jj_scanpos = xsp;
2021    if (jj_3R_35()) return true;
2022    }
2023    return false;
2024  }
2025
2026  private boolean jj_3_1()
2027 {
2028    if (jj_3R_6()) return true;
2029    return false;
2030  }
2031
2032  private boolean jj_3R_25()
2033 {
2034    if (jj_scan_token(SM)) return true;
2035    return false;
2036  }
2037
2038  private boolean jj_3R_33()
2039 {
2040    if (jj_scan_token(NONZEROADDR)) return true;
2041    return false;
2042  }
2043
2044  private boolean jj_3R_37()
2045 {
2046    if (jj_3R_36()) return true;
2047    return false;
2048  }
2049
2050  private boolean jj_3R_28()
2051 {
2052    if (jj_scan_token(SERVER)) return true;
2053    return false;
2054  }
2055
2056  private boolean jj_3R_19()
2057 {
2058    if (jj_3R_32()) return true;
2059    return false;
2060  }
2061
2062  private boolean jj_3R_8()
2063 {
2064    Token xsp;
2065    xsp = jj_scanpos;
2066    if (jj_3R_19()) {
2067    jj_scanpos = xsp;
2068    if (jj_3R_20()) return true;
2069    }
2070    return false;
2071  }
2072
2073  private boolean jj_3R_7()
2074 {
2075    if (jj_scan_token(GET)) return true;
2076    if (jj_3R_8()) return true;
2077    Token xsp;
2078    xsp = jj_scanpos;
2079    if (jj_3R_9()) {
2080    jj_scanpos = xsp;
2081    if (jj_3R_10()) {
2082    jj_scanpos = xsp;
2083    if (jj_3R_11()) {
2084    jj_scanpos = xsp;
2085    if (jj_3R_12()) {
2086    jj_scanpos = xsp;
2087    if (jj_3R_13()) {
2088    jj_scanpos = xsp;
2089    if (jj_3R_14()) {
2090    jj_scanpos = xsp;
2091    if (jj_3R_15()) {
2092    jj_scanpos = xsp;
2093    if (jj_3R_16()) {
2094    jj_scanpos = xsp;
2095    if (jj_3R_17()) {
2096    jj_scanpos = xsp;
2097    if (jj_3R_18()) return true;
2098    }
2099    }
2100    }
2101    }
2102    }
2103    }
2104    }
2105    }
2106    }
2107    return false;
2108  }
2109
2110  private boolean jj_3R_24()
2111 {
2112    if (jj_scan_token(GL)) return true;
2113    return false;
2114  }
2115
2116  private boolean jj_3R_27()
2117 {
2118    if (jj_scan_token(POWER)) return true;
2119    return false;
2120  }
2121
2122  private boolean jj_3R_32()
2123 {
2124    if (jj_scan_token(ZEROADDR)) return true;
2125    return false;
2126  }
2127
2128  private boolean jj_3R_6()
2129 {
2130    if (jj_scan_token(GO)) return true;
2131    return false;
2132  }
2133
2134  /* Generated Token Manager. */
2135  public SRCPParserTokenManager token_source;
2136  SimpleCharStream jj_input_stream;
2137  /* Current token. */
2138  public Token token;
2139  /* Next token. */
2140  public Token jj_nt;
2141  private int jj_ntk;
2142  private Token jj_scanpos, jj_lastpos;
2143  private int jj_la;
2144  private int jj_gen;
2145  final private int[] jj_la1 = new int[31];
2146  static private int[] jj_la1_0;
2147  static private int[] jj_la1_1;
2148  static private int[] jj_la1_2;
2149  static {
2150           jj_la1_init_0();
2151           jj_la1_init_1();
2152           jj_la1_init_2();
2153        }
2154        private static void jj_la1_init_0() {
2155           jj_la1_0 = new int[] {0x0,0x0,0x0,0xc0,0xc0,0xc0,0xc0,0x3fb80000,0xc0,0x3fb80000,0x0,0x180c0,0xc0,0x200c0,0x7b80000,0xc0,0x2fa80000,0x200c0,0x7b80000,0xc0,0x2080000,0x6b80000,0xc0,0xc0,0xc0,0x3fb80000,0xc0,0x0,0xc0,0x80c0,0x180c0,};
2156        }
2157        private static void jj_la1_init_1() {
2158           jj_la1_1 = new int[] {0x200,0xfe00,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xe0,0x0,0x0,0x0,};
2159        }
2160        private static void jj_la1_init_2() {
2161           jj_la1_2 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
2162        }
2163  final private JJCalls[] jj_2_rtns = new JJCalls[2];
2164  private boolean jj_rescan = false;
2165  private int jj_gc = 0;
2166
2167  /* Constructor with InputStream. */
2168  public SRCPParser(java.io.InputStream stream) {
2169          this(stream, null);
2170  }
2171  /* Constructor with InputStream and supplied encoding */
2172  public SRCPParser(java.io.InputStream stream, String encoding) {
2173         try { jj_input_stream = new SimpleCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
2174         token_source = new SRCPParserTokenManager(jj_input_stream);
2175         token = new Token();
2176         jj_ntk = -1;
2177         jj_gen = 0;
2178         for (int i = 0; i < 31; i++) jj_la1[i] = -1;
2179         for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
2180  }
2181
2182  /* Reinitialise. */
2183  public void ReInit(java.io.InputStream stream) {
2184          ReInit(stream, null);
2185  }
2186  /* Reinitialise. */
2187  public void ReInit(java.io.InputStream stream, String encoding) {
2188         try { jj_input_stream.ReInit(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
2189         token_source.ReInit(jj_input_stream);
2190         token = new Token();
2191         jj_ntk = -1;
2192         jjtree.reset();
2193         jj_gen = 0;
2194         for (int i = 0; i < 31; i++) jj_la1[i] = -1;
2195         for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
2196  }
2197
2198  /* Constructor. */
2199  public SRCPParser(java.io.Reader stream) {
2200         jj_input_stream = new SimpleCharStream(stream, 1, 1);
2201         token_source = new SRCPParserTokenManager(jj_input_stream);
2202         token = new Token();
2203         jj_ntk = -1;
2204         jj_gen = 0;
2205         for (int i = 0; i < 31; i++) jj_la1[i] = -1;
2206         for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
2207  }
2208
2209  /* Reinitialise. */
2210  public void ReInit(java.io.Reader stream) {
2211        if (jj_input_stream == null) {
2212           jj_input_stream = new SimpleCharStream(stream, 1, 1);
2213        } else {
2214           jj_input_stream.ReInit(stream, 1, 1);
2215        }
2216        if (token_source == null) {
2217 token_source = new SRCPParserTokenManager(jj_input_stream);
2218        }
2219
2220         token_source.ReInit(jj_input_stream);
2221         token = new Token();
2222         jj_ntk = -1;
2223         jjtree.reset();
2224         jj_gen = 0;
2225         for (int i = 0; i < 31; i++) jj_la1[i] = -1;
2226         for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
2227  }
2228
2229  /* Constructor with generated Token Manager. */
2230  public SRCPParser(SRCPParserTokenManager tm) {
2231         token_source = tm;
2232         token = new Token();
2233         jj_ntk = -1;
2234         jj_gen = 0;
2235         for (int i = 0; i < 31; i++) jj_la1[i] = -1;
2236         for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
2237  }
2238
2239  /* Reinitialise. */
2240  public void ReInit(SRCPParserTokenManager tm) {
2241         token_source = tm;
2242         token = new Token();
2243         jj_ntk = -1;
2244         jjtree.reset();
2245         jj_gen = 0;
2246         for (int i = 0; i < 31; i++) jj_la1[i] = -1;
2247         for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
2248  }
2249
2250  private Token jj_consume_token(int kind) throws ParseException {
2251         Token oldToken;
2252         if ((oldToken = token).next != null) token = token.next;
2253         else token = token.next = token_source.getNextToken();
2254         jj_ntk = -1;
2255         if (token.kind == kind) {
2256           jj_gen++;
2257           if (++jj_gc > 100) {
2258                 jj_gc = 0;
2259                 for (int i = 0; i < jj_2_rtns.length; i++) {
2260                   JJCalls c = jj_2_rtns[i];
2261                   while (c != null) {
2262                         if (c.gen < jj_gen) c.first = null;
2263                         c = c.next;
2264                   }
2265                 }
2266           }
2267           return token;
2268         }
2269         token = oldToken;
2270         jj_kind = kind;
2271         throw generateParseException();
2272  }
2273
2274  @SuppressWarnings("serial")
2275  static private final class LookaheadSuccess extends java.lang.Error { }
2276  final private LookaheadSuccess jj_ls = new LookaheadSuccess();
2277  private boolean jj_scan_token(int kind) {
2278         if (jj_scanpos == jj_lastpos) {
2279           jj_la--;
2280           if (jj_scanpos.next == null) {
2281                 jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
2282           } else {
2283                 jj_lastpos = jj_scanpos = jj_scanpos.next;
2284           }
2285         } else {
2286           jj_scanpos = jj_scanpos.next;
2287         }
2288         if (jj_rescan) {
2289           int i = 0; Token tok = token;
2290           while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
2291           if (tok != null) jj_add_error_token(kind, i);
2292         }
2293         if (jj_scanpos.kind != kind) return true;
2294         if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
2295         return false;
2296  }
2297
2298
2299/* Get the next Token. */
2300  final public Token getNextToken() {
2301         if (token.next != null) token = token.next;
2302         else token = token.next = token_source.getNextToken();
2303         jj_ntk = -1;
2304         jj_gen++;
2305         return token;
2306  }
2307
2308/* Get the specific Token. */
2309  final public Token getToken(int index) {
2310         Token t = token;
2311         for (int i = 0; i < index; i++) {
2312           if (t.next != null) t = t.next;
2313           else t = t.next = token_source.getNextToken();
2314         }
2315         return t;
2316  }
2317
2318  private int jj_ntk_f() {
2319         if ((jj_nt=token.next) == null)
2320           return (jj_ntk = (token.next=token_source.getNextToken()).kind);
2321         else
2322           return (jj_ntk = jj_nt.kind);
2323  }
2324
2325  private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>();
2326  private int[] jj_expentry;
2327  private int jj_kind = -1;
2328  private int[] jj_lasttokens = new int[100];
2329  private int jj_endpos;
2330
2331  private void jj_add_error_token(int kind, int pos) {
2332         if (pos >= 100) {
2333                return;
2334         }
2335
2336         if (pos == jj_endpos + 1) {
2337           jj_lasttokens[jj_endpos++] = kind;
2338         } else if (jj_endpos != 0) {
2339           jj_expentry = new int[jj_endpos];
2340
2341           for (int i = 0; i < jj_endpos; i++) {
2342                 jj_expentry[i] = jj_lasttokens[i];
2343           }
2344
2345           for (int[] oldentry : jj_expentries) {
2346                 if (oldentry.length == jj_expentry.length) {
2347                   boolean isMatched = true;
2348
2349                   for (int i = 0; i < jj_expentry.length; i++) {
2350                         if (oldentry[i] != jj_expentry[i]) {
2351                           isMatched = false;
2352                           break;
2353                         }
2354
2355                   }
2356                   if (isMatched) {
2357                         jj_expentries.add(jj_expentry);
2358                         break;
2359                   }
2360                 }
2361           }
2362
2363           if (pos != 0) {
2364                 jj_lasttokens[(jj_endpos = pos) - 1] = kind;
2365           }
2366         }
2367  }
2368
2369  /* Generate ParseException. */
2370  public ParseException generateParseException() {
2371         jj_expentries.clear();
2372         boolean[] la1tokens = new boolean[74];
2373         if (jj_kind >= 0) {
2374           la1tokens[jj_kind] = true;
2375           jj_kind = -1;
2376         }
2377         for (int i = 0; i < 31; i++) {
2378           if (jj_la1[i] == jj_gen) {
2379                 for (int j = 0; j < 32; j++) {
2380                   if ((jj_la1_0[i] & (1<<j)) != 0) {
2381                         la1tokens[j] = true;
2382                   }
2383                   if ((jj_la1_1[i] & (1<<j)) != 0) {
2384                         la1tokens[32+j] = true;
2385                   }
2386                   if ((jj_la1_2[i] & (1<<j)) != 0) {
2387                         la1tokens[64+j] = true;
2388                   }
2389                 }
2390           }
2391         }
2392         for (int i = 0; i < 74; i++) {
2393           if (la1tokens[i]) {
2394                 jj_expentry = new int[1];
2395                 jj_expentry[0] = i;
2396                 jj_expentries.add(jj_expentry);
2397           }
2398         }
2399         jj_endpos = 0;
2400         jj_rescan_token();
2401         jj_add_error_token(0, 0);
2402         int[][] exptokseq = new int[jj_expentries.size()][];
2403         for (int i = 0; i < jj_expentries.size(); i++) {
2404           exptokseq[i] = jj_expentries.get(i);
2405         }
2406         return new ParseException(token, exptokseq, tokenImage);
2407  }
2408
2409  private int trace_indent = 0;
2410  private boolean trace_enabled;
2411
2412/* Trace enabled. */
2413  final public boolean trace_enabled() {
2414         return trace_enabled;
2415  }
2416
2417  /* Enable tracing. */
2418  final public void enable_tracing() {
2419  }
2420
2421  /* Disable tracing. */
2422  final public void disable_tracing() {
2423  }
2424
2425  private void jj_rescan_token() {
2426         jj_rescan = true;
2427         for (int i = 0; i < 2; i++) {
2428           try {
2429                 JJCalls p = jj_2_rtns[i];
2430
2431                 do {
2432                   if (p.gen > jj_gen) {
2433                         jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
2434                         switch (i) {
2435                           case 0: jj_3_1(); break;
2436                           case 1: jj_3_2(); break;
2437                         }
2438                   }
2439                   p = p.next;
2440                 } while (p != null);
2441
2442                 } catch(LookaheadSuccess ls) { }
2443         }
2444         jj_rescan = false;
2445  }
2446
2447  private void jj_save(int index, int xla) {
2448         JJCalls p = jj_2_rtns[index];
2449         while (p.gen > jj_gen) {
2450           if (p.next == null) { p = p.next = new JJCalls(); break; }
2451           p = p.next;
2452         }
2453
2454         p.gen = jj_gen + xla - jj_la; 
2455         p.first = token;
2456         p.arg = xla;
2457  }
2458
2459  static final class JJCalls {
2460         int gen;
2461         Token first;
2462         int arg;
2463         JJCalls next;
2464  }
2465
2466  }