All Downloads are FREE. Search and download functionalities are using the official Maven repository.

net.sourceforge.pmd.lang.modelica.ast.ModelicaParserImpl Maven / Gradle / Ivy

The newest version!
/* Generated By:JJTree&JavaCC: Do not edit this line. ModelicaParserImpl.java */
package net.sourceforge.pmd.lang.modelica.ast;

import static net.sourceforge.pmd.lang.modelica.ast.ModelicaTokenKinds.*;

class ModelicaParserImpl/*@bgen(jjtree)*/implements ModelicaParserImplTreeConstants {/*@bgen(jjtree)*/
  protected net.sourceforge.pmd.lang.ast.impl.javacc.JjtreeBuilder jjtree = new net.sourceforge.pmd.lang.ast.impl.javacc.JjtreeBuilder();

  final public ASTStoredDefinition StoredDefinition() throws net.sourceforge.pmd.lang.ast.ParseException {
                                         /*@bgen(jjtree) StoredDefinition */
  ASTStoredDefinition jjtn000 = new ASTStoredDefinition(JJTSTOREDDEFINITION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      switch (jj_nt.kind) {
      case BOM:
        jj_consume_token(BOM);
            jjtn000.markHasBOM();
        break;
      default:
        jj_la1[0] = jj_gen;
        ;
      }
      label_1:
      while (true) {
        switch (jj_nt.kind) {
        case WITHIN:
          ;
          break;
        default:
          jj_la1[1] = jj_gen;
          break label_1;
        }
       ASTWithinClause jjtn001 = new ASTWithinClause(JJTWITHINCLAUSE);
       boolean jjtc001 = true;
       jjtree.openNodeScope(jjtn001, getToken(1));
        try {
          jj_consume_token(WITHIN);
          switch (jj_nt.kind) {
          case DOT:
          case IDENT:
            Name();
            break;
          default:
            jj_la1[2] = jj_gen;
            ;
          }
          jj_consume_token(SC);
        } catch (Throwable jjte001) {
       if (jjtc001) {
         jjtree.clearNodeScope(jjtn001);
         jjtc001 = false;
       } else {
         jjtree.popNode();
       }
       if (jjte001 instanceof RuntimeException) {
         {if (true) throw (RuntimeException)jjte001;}
       }
       if (jjte001 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
         {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte001;}
       }
       {if (true) throw (Error)jjte001;}
        } finally {
       if (jjtc001) {
         jjtree.closeNodeScope(jjtn001, true, getToken(0));
       }
        }
      }
      label_2:
      while (true) {
        switch (jj_nt.kind) {
        case ENCAPSULATED:
        case PARTIAL:
        case FINAL:
        case CLASS:
        case MODEL:
        case OPERATOR:
        case RECORD:
        case BLOCK:
        case EXPANDABLE:
        case CONNECTOR:
        case TYPE:
        case PACKAGE:
        case PURE:
        case IMPURE:
        case FUNCTION:
          ;
          break;
        default:
          jj_la1[3] = jj_gen;
          break label_2;
        }
        switch (jj_nt.kind) {
        case FINAL:
          jj_consume_token(FINAL);
          break;
        default:
          jj_la1[4] = jj_gen;
          ;
        }
        ClassDefinition();
        jj_consume_token(SC);
      }
      jj_consume_token(0);
      jjtree.closeNodeScope(jjtn000, true, getToken(0));
      jjtc000 = false;
      {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public void ClassDefinition() throws net.sourceforge.pmd.lang.ast.ParseException {
                         /*@bgen(jjtree) ClassDefinition */
  ASTClassDefinition jjtn000 = new ASTClassDefinition(JJTCLASSDEFINITION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      switch (jj_nt.kind) {
      case ENCAPSULATED:
       ASTEncapsulatedClause jjtn001 = new ASTEncapsulatedClause(JJTENCAPSULATEDCLAUSE);
       boolean jjtc001 = true;
       jjtree.openNodeScope(jjtn001, getToken(1));
        try {
          jj_consume_token(ENCAPSULATED);
        } finally {
       if (jjtc001) {
         jjtree.closeNodeScope(jjtn001, true, getToken(0));
       }
        }
        break;
      default:
        jj_la1[5] = jj_gen;
        ;
      }
      ClassPrefixes();
      ClassSpecifier();
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void ClassSpecifier() throws net.sourceforge.pmd.lang.ast.ParseException {
                        /*@bgen(jjtree) ClassSpecifier */
  ASTClassSpecifier jjtn000 = new ASTClassSpecifier(JJTCLASSSPECIFIER);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      if (jj_2_1(2)) {
        LongClassSpecifier();
      } else if (jj_2_2(3)) {
        DerClassSpecifier();
      } else {
        switch (jj_nt.kind) {
        case IDENT:
          ShortClassSpecifier();
          break;
        default:
          jj_la1[6] = jj_gen;
          jj_consume_token(-1);
          throw net.sourceforge.pmd.util.AssertionUtil.shouldNotReachHere("consumetoken(-1) should have thrown");
        }
      }
    } catch (Throwable jjte000) {
        if (jjtc000) {
          jjtree.clearNodeScope(jjtn000);
          jjtc000 = false;
        } else {
          jjtree.popNode();
        }
        if (jjte000 instanceof RuntimeException) {
          {if (true) throw (RuntimeException)jjte000;}
        }
        if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
          {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
        }
        {if (true) throw (Error)jjte000;}
    } finally {
        if (jjtc000) {
          jjtree.closeNodeScope(jjtn000, true, getToken(0));
        }
    }
  }

  final public void ClassPrefixes() throws net.sourceforge.pmd.lang.ast.ParseException {
                       /*@bgen(jjtree) ClassPrefixes */
  ASTClassPrefixes jjtn000 = new ASTClassPrefixes(JJTCLASSPREFIXES);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      switch (jj_nt.kind) {
      case PARTIAL:
       ASTPartialClause jjtn001 = new ASTPartialClause(JJTPARTIALCLAUSE);
       boolean jjtc001 = true;
       jjtree.openNodeScope(jjtn001, getToken(1));
        try {
          jj_consume_token(PARTIAL);
        } finally {
       if (jjtc001) {
         jjtree.closeNodeScope(jjtn001, true, getToken(0));
       }
        }
        break;
      default:
        jj_la1[7] = jj_gen;
        ;
      }
      switch (jj_nt.kind) {
      case CLASS:
            ASTClassClause jjtn002 = new ASTClassClause(JJTCLASSCLAUSE);
            boolean jjtc002 = true;
            jjtree.openNodeScope(jjtn002, getToken(1));
        try {
          jj_consume_token(CLASS);
        } finally {
            if (jjtc002) {
              jjtree.closeNodeScope(jjtn002, true, getToken(0));
            }
        }
        break;
      case MODEL:
            ASTModelClause jjtn003 = new ASTModelClause(JJTMODELCLAUSE);
            boolean jjtc003 = true;
            jjtree.openNodeScope(jjtn003, getToken(1));
        try {
          jj_consume_token(MODEL);
        } finally {
            if (jjtc003) {
              jjtree.closeNodeScope(jjtn003, true, getToken(0));
            }
        }
        break;
      case RECORD:
            ASTRecordClause jjtn004 = new ASTRecordClause(JJTRECORDCLAUSE);
            boolean jjtc004 = true;
            jjtree.openNodeScope(jjtn004, getToken(1));
        try {
          jj_consume_token(RECORD);
        } finally {
            if (jjtc004) {
              jjtree.closeNodeScope(jjtn004, true, getToken(0));
            }
        }
        break;
      default:
        jj_la1[11] = jj_gen;
        if (jj_2_3(2)) {
          jj_consume_token(OPERATOR);
                                     ASTOperatorRecordClause jjtn005 = new ASTOperatorRecordClause(JJTOPERATORRECORDCLAUSE);
                                     boolean jjtc005 = true;
                                     jjtree.openNodeScope(jjtn005, getToken(1));
          try {
            jj_consume_token(RECORD);
          } finally {
                                     if (jjtc005) {
                                       jjtree.closeNodeScope(jjtn005, true, getToken(0));
                                     }
          }
        } else {
          switch (jj_nt.kind) {
          case BLOCK:
            ASTBlockClause jjtn006 = new ASTBlockClause(JJTBLOCKCLAUSE);
            boolean jjtc006 = true;
            jjtree.openNodeScope(jjtn006, getToken(1));
            try {
              jj_consume_token(BLOCK);
            } finally {
            if (jjtc006) {
              jjtree.closeNodeScope(jjtn006, true, getToken(0));
            }
            }
            break;
          default:
            jj_la1[12] = jj_gen;
            if (jj_2_4(2)) {
              jj_consume_token(EXPANDABLE);
                                       ASTExpandableConnectorClause jjtn007 = new ASTExpandableConnectorClause(JJTEXPANDABLECONNECTORCLAUSE);
                                       boolean jjtc007 = true;
                                       jjtree.openNodeScope(jjtn007, getToken(1));
              try {
                jj_consume_token(CONNECTOR);
              } finally {
                                       if (jjtc007) {
                                         jjtree.closeNodeScope(jjtn007, true, getToken(0));
                                       }
              }
            } else {
              switch (jj_nt.kind) {
              case CONNECTOR:
            ASTConnectorClause jjtn008 = new ASTConnectorClause(JJTCONNECTORCLAUSE);
            boolean jjtc008 = true;
            jjtree.openNodeScope(jjtn008, getToken(1));
                try {
                  jj_consume_token(CONNECTOR);
                } finally {
            if (jjtc008) {
              jjtree.closeNodeScope(jjtn008, true, getToken(0));
            }
                }
                break;
              case TYPE:
            ASTTypeClause jjtn009 = new ASTTypeClause(JJTTYPECLAUSE);
            boolean jjtc009 = true;
            jjtree.openNodeScope(jjtn009, getToken(1));
                try {
                  jj_consume_token(TYPE);
                } finally {
            if (jjtc009) {
              jjtree.closeNodeScope(jjtn009, true, getToken(0));
            }
                }
                break;
              case PACKAGE:
            ASTPackageClause jjtn010 = new ASTPackageClause(JJTPACKAGECLAUSE);
            boolean jjtc010 = true;
            jjtree.openNodeScope(jjtn010, getToken(1));
                try {
                  jj_consume_token(PACKAGE);
                } finally {
            if (jjtc010) {
              jjtree.closeNodeScope(jjtn010, true, getToken(0));
            }
                }
                break;
              default:
                jj_la1[13] = jj_gen;
                if (jj_2_5(3)) {
                         ASTFunctionClause jjtn014 = new ASTFunctionClause(JJTFUNCTIONCLAUSE);
                         boolean jjtc014 = true;
                         jjtree.openNodeScope(jjtn014, getToken(1));
                  try {
                    switch (jj_nt.kind) {
                    case PURE:
                    case IMPURE:
                      switch (jj_nt.kind) {
                      case PURE:
                           ASTPureClause jjtn011 = new ASTPureClause(JJTPURECLAUSE);
                           boolean jjtc011 = true;
                           jjtree.openNodeScope(jjtn011, getToken(1));
                        try {
                          jj_consume_token(PURE);
                        } finally {
                           if (jjtc011) {
                             jjtree.closeNodeScope(jjtn011, true, getToken(0));
                           }
                        }
                        break;
                      case IMPURE:
                                                ASTImpureClause jjtn012 = new ASTImpureClause(JJTIMPURECLAUSE);
                                                boolean jjtc012 = true;
                                                jjtree.openNodeScope(jjtn012, getToken(1));
                        try {
                          jj_consume_token(IMPURE);
                        } finally {
                                                if (jjtc012) {
                                                  jjtree.closeNodeScope(jjtn012, true, getToken(0));
                                                }
                        }
                        break;
                      default:
                        jj_la1[8] = jj_gen;
                        jj_consume_token(-1);
                        throw net.sourceforge.pmd.util.AssertionUtil.shouldNotReachHere("consumetoken(-1) should have thrown");
                      }
                      break;
                    default:
                      jj_la1[9] = jj_gen;
                      ;
                    }
                    switch (jj_nt.kind) {
                    case OPERATOR:
                                                                          ASTOperatorClause jjtn013 = new ASTOperatorClause(JJTOPERATORCLAUSE);
                                                                          boolean jjtc013 = true;
                                                                          jjtree.openNodeScope(jjtn013, getToken(1));
                      try {
                        jj_consume_token(OPERATOR);
                      } finally {
                                                                          if (jjtc013) {
                                                                            jjtree.closeNodeScope(jjtn013, true, getToken(0));
                                                                          }
                      }
                      break;
                    default:
                      jj_la1[10] = jj_gen;
                      ;
                    }
                    jj_consume_token(FUNCTION);
                  } finally {
                         if (jjtc014) {
                           jjtree.closeNodeScope(jjtn014, true, getToken(0));
                         }
                  }
                } else {
                  switch (jj_nt.kind) {
                  case OPERATOR:
            ASTOperator jjtn015 = new ASTOperator(JJTOPERATOR);
            boolean jjtc015 = true;
            jjtree.openNodeScope(jjtn015, getToken(1));
                    try {
                      jj_consume_token(OPERATOR);
                    } finally {
            if (jjtc015) {
              jjtree.closeNodeScope(jjtn015, true, getToken(0));
            }
                    }
                    break;
                  default:
                    jj_la1[14] = jj_gen;
                    jj_consume_token(-1);
                    throw net.sourceforge.pmd.util.AssertionUtil.shouldNotReachHere("consumetoken(-1) should have thrown");
                  }
                }
              }
            }
          }
        }
      }
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void LongClassSpecifier() throws net.sourceforge.pmd.lang.ast.ParseException {
    switch (jj_nt.kind) {
    case IDENT:
      ASTSimpleLongClassSpecifier jjtn001 = new ASTSimpleLongClassSpecifier(JJTSIMPLELONGCLASSSPECIFIER);
      boolean jjtc001 = true;
      jjtree.openNodeScope(jjtn001, getToken(1));
      try {
        SimpleName();
        StringComment();
        Composition();
        jj_consume_token(END);
        SimpleName();
      } catch (Throwable jjte001) {
      if (jjtc001) {
        jjtree.clearNodeScope(jjtn001);
        jjtc001 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte001 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte001;}
      }
      if (jjte001 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte001;}
      }
      {if (true) throw (Error)jjte001;}
      } finally {
      if (jjtc001) {
        jjtree.closeNodeScope(jjtn001, true, getToken(0));
      }
      }
      break;
    case EXTENDS:
        ASTExtendingLongClassSpecifier jjtn002 = new ASTExtendingLongClassSpecifier(JJTEXTENDINGLONGCLASSSPECIFIER);
        boolean jjtc002 = true;
        jjtree.openNodeScope(jjtn002, getToken(1));
      try {
        jj_consume_token(EXTENDS);
        SimpleName();
        switch (jj_nt.kind) {
        case LPAREN:
          ClassModification();
          break;
        default:
          jj_la1[15] = jj_gen;
          ;
        }
        StringComment();
        Composition();
        jj_consume_token(END);
        SimpleName();
      } catch (Throwable jjte002) {
        if (jjtc002) {
          jjtree.clearNodeScope(jjtn002);
          jjtc002 = false;
        } else {
          jjtree.popNode();
        }
        if (jjte002 instanceof RuntimeException) {
          {if (true) throw (RuntimeException)jjte002;}
        }
        if (jjte002 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
          {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte002;}
        }
        {if (true) throw (Error)jjte002;}
      } finally {
        if (jjtc002) {
          jjtree.closeNodeScope(jjtn002, true, getToken(0));
        }
      }
      break;
    default:
      jj_la1[16] = jj_gen;
      jj_consume_token(-1);
      throw net.sourceforge.pmd.util.AssertionUtil.shouldNotReachHere("consumetoken(-1) should have thrown");
    }
  }

  final public void ShortClassSpecifier() throws net.sourceforge.pmd.lang.ast.ParseException {
    if (jj_2_6(3)) {
                   ASTSimpleShortClassSpecifier jjtn001 = new ASTSimpleShortClassSpecifier(JJTSIMPLESHORTCLASSSPECIFIER);
                   boolean jjtc001 = true;
                   jjtree.openNodeScope(jjtn001, getToken(1));
      try {
        SimpleName();
        jj_consume_token(EQ_SIGN);
        BasePrefix();
        Name();
        switch (jj_nt.kind) {
        case LSQUARE:
          ArraySubscripts();
          break;
        default:
          jj_la1[17] = jj_gen;
          ;
        }
        switch (jj_nt.kind) {
        case LPAREN:
          ClassModification();
          break;
        default:
          jj_la1[18] = jj_gen;
          ;
        }
        Comment();
      } catch (Throwable jjte001) {
                   if (jjtc001) {
                     jjtree.clearNodeScope(jjtn001);
                     jjtc001 = false;
                   } else {
                     jjtree.popNode();
                   }
                   if (jjte001 instanceof RuntimeException) {
                     {if (true) throw (RuntimeException)jjte001;}
                   }
                   if (jjte001 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
                     {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte001;}
                   }
                   {if (true) throw (Error)jjte001;}
      } finally {
                   if (jjtc001) {
                     jjtree.closeNodeScope(jjtn001, true, getToken(0));
                   }
      }
    } else {
      switch (jj_nt.kind) {
      case IDENT:
        ASTEnumerationShortClassSpecifier jjtn002 = new ASTEnumerationShortClassSpecifier(JJTENUMERATIONSHORTCLASSSPECIFIER);
        boolean jjtc002 = true;
        jjtree.openNodeScope(jjtn002, getToken(1));
        try {
          SimpleName();
          jj_consume_token(EQ_SIGN);
          jj_consume_token(ENUMERATION);
          jj_consume_token(LPAREN);
          switch (jj_nt.kind) {
          case COLON:
            jj_consume_token(COLON);
            break;
          default:
            jj_la1[20] = jj_gen;
            switch (jj_nt.kind) {
            case IDENT:
              EnumList();
              break;
            default:
              jj_la1[19] = jj_gen;
              ;
            }
          }
          jj_consume_token(RPAREN);
          Comment();
        } catch (Throwable jjte002) {
        if (jjtc002) {
          jjtree.clearNodeScope(jjtn002);
          jjtc002 = false;
        } else {
          jjtree.popNode();
        }
        if (jjte002 instanceof RuntimeException) {
          {if (true) throw (RuntimeException)jjte002;}
        }
        if (jjte002 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
          {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte002;}
        }
        {if (true) throw (Error)jjte002;}
        } finally {
        if (jjtc002) {
          jjtree.closeNodeScope(jjtn002, true, getToken(0));
        }
        }
        break;
      default:
        jj_la1[21] = jj_gen;
        jj_consume_token(-1);
        throw net.sourceforge.pmd.util.AssertionUtil.shouldNotReachHere("consumetoken(-1) should have thrown");
      }
    }
  }

  final public void DerClassSpecifier() throws net.sourceforge.pmd.lang.ast.ParseException {
                           /*@bgen(jjtree) DerClassSpecifier */
  ASTDerClassSpecifier jjtn000 = new ASTDerClassSpecifier(JJTDERCLASSSPECIFIER);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      SimpleName();
      jj_consume_token(EQ_SIGN);
      jj_consume_token(DER);
      ASTDerClause jjtn001 = new ASTDerClause(JJTDERCLAUSE);
      boolean jjtc001 = true;
      jjtree.openNodeScope(jjtn001, getToken(1));
      try {
        jj_consume_token(LPAREN);
        Name();
        jj_consume_token(COMMA);
        jj_consume_token(IDENT);
        label_3:
        while (true) {
          switch (jj_nt.kind) {
          case COMMA:
            ;
            break;
          default:
            jj_la1[22] = jj_gen;
            break label_3;
          }
          jj_consume_token(COMMA);
          SimpleName();
        }
        jj_consume_token(RPAREN);
      } catch (Throwable jjte001) {
      if (jjtc001) {
        jjtree.clearNodeScope(jjtn001);
        jjtc001 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte001 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte001;}
      }
      if (jjte001 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte001;}
      }
      {if (true) throw (Error)jjte001;}
      } finally {
      if (jjtc001) {
        jjtree.closeNodeScope(jjtn001, true, getToken(0));
      }
      }
      Comment();
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void BasePrefix() throws net.sourceforge.pmd.lang.ast.ParseException {
                    /*@bgen(jjtree) BasePrefix */
  ASTBasePrefix jjtn000 = new ASTBasePrefix(JJTBASEPREFIX);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      TypePrefix();
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void EnumList() throws net.sourceforge.pmd.lang.ast.ParseException {
                  /*@bgen(jjtree) EnumList */
  ASTEnumList jjtn000 = new ASTEnumList(JJTENUMLIST);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      EnumerationLiteral();
      label_4:
      while (true) {
        switch (jj_nt.kind) {
        case COMMA:
          ;
          break;
        default:
          jj_la1[23] = jj_gen;
          break label_4;
        }
        jj_consume_token(COMMA);
        EnumerationLiteral();
      }
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void EnumerationLiteral() throws net.sourceforge.pmd.lang.ast.ParseException {
                            /*@bgen(jjtree) EnumerationLiteral */
  ASTEnumerationLiteral jjtn000 = new ASTEnumerationLiteral(JJTENUMERATIONLITERAL);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      SimpleName();
      Comment();
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void Composition() throws net.sourceforge.pmd.lang.ast.ParseException {
                     /*@bgen(jjtree) Composition */
  ASTComposition jjtn000 = new ASTComposition(JJTCOMPOSITION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      ElementList(Visibility.UNSPEC);
      label_5:
      while (true) {
        switch (jj_nt.kind) {
        case PUBLIC:
        case PROTECTED:
        case INITIAL:
        case EQUATION:
        case ALGORITHM:
          ;
          break;
        default:
          jj_la1[24] = jj_gen;
          break label_5;
        }
        switch (jj_nt.kind) {
        case PUBLIC:
          jj_consume_token(PUBLIC);
          ElementList(Visibility.PUBLIC);
          break;
        case PROTECTED:
          jj_consume_token(PROTECTED);
          ElementList(Visibility.PROTECTED);
          break;
        default:
          jj_la1[25] = jj_gen;
          if (jj_2_7(2)) {
            EquationSection();
          } else if (jj_2_8(2)) {
            AlgorithmSection();
          } else {
            jj_consume_token(-1);
            throw net.sourceforge.pmd.util.AssertionUtil.shouldNotReachHere("consumetoken(-1) should have thrown");
          }
        }
      }
      switch (jj_nt.kind) {
      case EXTERNAL:
       ASTExternalClause jjtn001 = new ASTExternalClause(JJTEXTERNALCLAUSE);
       boolean jjtc001 = true;
       jjtree.openNodeScope(jjtn001, getToken(1));
        try {
          jj_consume_token(EXTERNAL);
          switch (jj_nt.kind) {
          case STRING:
            LanguageSpecification();
            break;
          default:
            jj_la1[26] = jj_gen;
            ;
          }
          switch (jj_nt.kind) {
          case DOT:
          case IDENT:
            ExternalFunctionCall();
            break;
          default:
            jj_la1[27] = jj_gen;
            ;
          }
          switch (jj_nt.kind) {
          case ANNOTATION:
            Annotation();
            break;
          default:
            jj_la1[28] = jj_gen;
            ;
          }
          jj_consume_token(SC);
        } catch (Throwable jjte001) {
       if (jjtc001) {
         jjtree.clearNodeScope(jjtn001);
         jjtc001 = false;
       } else {
         jjtree.popNode();
       }
       if (jjte001 instanceof RuntimeException) {
         {if (true) throw (RuntimeException)jjte001;}
       }
       if (jjte001 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
         {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte001;}
       }
       {if (true) throw (Error)jjte001;}
        } finally {
       if (jjtc001) {
         jjtree.closeNodeScope(jjtn001, true, getToken(0));
       }
        }
        break;
      default:
        jj_la1[29] = jj_gen;
        ;
      }
      switch (jj_nt.kind) {
      case ANNOTATION:
        Annotation();
        jj_consume_token(SC);
        break;
      default:
        jj_la1[30] = jj_gen;
        ;
      }
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void LanguageSpecification() throws net.sourceforge.pmd.lang.ast.ParseException {
 /*@bgen(jjtree) LanguageSpecification */
    ASTLanguageSpecification jjtn000 = new ASTLanguageSpecification(JJTLANGUAGESPECIFICATION);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000, getToken(1));net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken t;
    try {
      t = jj_consume_token(STRING);
      jjtree.closeNodeScope(jjtn000, true, getToken(0));
      jjtc000 = false;
      jjtn000.setExternalLanguage(t.getImage());
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void ExternalFunctionCall() throws net.sourceforge.pmd.lang.ast.ParseException {
                              /*@bgen(jjtree) ExternalFunctionCall */
  ASTExternalFunctionCall jjtn000 = new ASTExternalFunctionCall(JJTEXTERNALFUNCTIONCALL);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      if (jj_2_9(2)) {
        ComponentReference();
        jj_consume_token(EQ_SIGN);
      } else {
        ;
      }
      SimpleName();
      jj_consume_token(LPAREN);
      switch (jj_nt.kind) {
      case LPAREN:
      case LCURL:
      case LSQUARE:
      case DOT:
      case END:
      case DER:
      case IF:
      case INITIAL:
      case NOT:
      case TRUE:
      case FALSE:
      case PLUS:
      case MINUS:
      case DOT_PLUS:
      case DOT_MINUS:
      case IDENT:
      case STRING:
      case UNSIGNED_NUMBER:
        ExpressionList();
        break;
      default:
        jj_la1[31] = jj_gen;
        ;
      }
      jj_consume_token(RPAREN);
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void ElementList(Visibility v) throws net.sourceforge.pmd.lang.ast.ParseException {
                                 /*@bgen(jjtree) ElementList */
  ASTElementList jjtn000 = new ASTElementList(JJTELEMENTLIST);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      jjtn000.setVisibility(v);
      label_6:
      while (true) {
        switch (jj_nt.kind) {
        case DOT:
        case IMPORT:
        case ENCAPSULATED:
        case PARTIAL:
        case FINAL:
        case CLASS:
        case MODEL:
        case OPERATOR:
        case RECORD:
        case BLOCK:
        case EXPANDABLE:
        case CONNECTOR:
        case TYPE:
        case PACKAGE:
        case PURE:
        case IMPURE:
        case FUNCTION:
        case EXTENDS:
        case REDECLARE:
        case INNER:
        case OUTER:
        case REPLACEABLE:
        case FLOW:
        case STREAM:
        case DISCRETE:
        case PARAMETER:
        case CONSTANT:
        case INPUT:
        case OUTPUT:
        case IDENT:
          ;
          break;
        default:
          jj_la1[32] = jj_gen;
          break label_6;
        }
        Element();
        jj_consume_token(SC);
      }
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void Element() throws net.sourceforge.pmd.lang.ast.ParseException {
    switch (jj_nt.kind) {
    case IMPORT:
      ImportClause();
      break;
    case EXTENDS:
      ExtendsClause();
      break;
    case DOT:
    case ENCAPSULATED:
    case PARTIAL:
    case FINAL:
    case CLASS:
    case MODEL:
    case OPERATOR:
    case RECORD:
    case BLOCK:
    case EXPANDABLE:
    case CONNECTOR:
    case TYPE:
    case PACKAGE:
    case PURE:
    case IMPURE:
    case FUNCTION:
    case REDECLARE:
    case INNER:
    case OUTER:
    case REPLACEABLE:
    case FLOW:
    case STREAM:
    case DISCRETE:
    case PARAMETER:
    case CONSTANT:
    case INPUT:
    case OUTPUT:
    case IDENT:
        ASTRegularElement jjtn006 = new ASTRegularElement(JJTREGULARELEMENT);
        boolean jjtc006 = true;
        jjtree.openNodeScope(jjtn006, getToken(1));
      try {
        switch (jj_nt.kind) {
        case REDECLARE:
         ASTRedeclareClause jjtn001 = new ASTRedeclareClause(JJTREDECLARECLAUSE);
         boolean jjtc001 = true;
         jjtree.openNodeScope(jjtn001, getToken(1));
          try {
            jj_consume_token(REDECLARE);
          } finally {
         if (jjtc001) {
           jjtree.closeNodeScope(jjtn001, true, getToken(0));
         }
          }
          break;
        default:
          jj_la1[33] = jj_gen;
          ;
        }
        switch (jj_nt.kind) {
        case FINAL:
         ASTFinalClause jjtn002 = new ASTFinalClause(JJTFINALCLAUSE);
         boolean jjtc002 = true;
         jjtree.openNodeScope(jjtn002, getToken(1));
          try {
            jj_consume_token(FINAL);
          } finally {
         if (jjtc002) {
           jjtree.closeNodeScope(jjtn002, true, getToken(0));
         }
          }
          break;
        default:
          jj_la1[34] = jj_gen;
          ;
        }
        switch (jj_nt.kind) {
        case INNER:
         ASTInnerClause jjtn003 = new ASTInnerClause(JJTINNERCLAUSE);
         boolean jjtc003 = true;
         jjtree.openNodeScope(jjtn003, getToken(1));
          try {
            jj_consume_token(INNER);
          } finally {
         if (jjtc003) {
           jjtree.closeNodeScope(jjtn003, true, getToken(0));
         }
          }
          break;
        default:
          jj_la1[35] = jj_gen;
          ;
        }
        switch (jj_nt.kind) {
        case OUTER:
         ASTOuterClause jjtn004 = new ASTOuterClause(JJTOUTERCLAUSE);
         boolean jjtc004 = true;
         jjtree.openNodeScope(jjtn004, getToken(1));
          try {
            jj_consume_token(OUTER);
          } finally {
         if (jjtc004) {
           jjtree.closeNodeScope(jjtn004, true, getToken(0));
         }
          }
          break;
        default:
          jj_la1[36] = jj_gen;
          ;
        }
        switch (jj_nt.kind) {
        case DOT:
        case ENCAPSULATED:
        case PARTIAL:
        case CLASS:
        case MODEL:
        case OPERATOR:
        case RECORD:
        case BLOCK:
        case EXPANDABLE:
        case CONNECTOR:
        case TYPE:
        case PACKAGE:
        case PURE:
        case IMPURE:
        case FUNCTION:
        case FLOW:
        case STREAM:
        case DISCRETE:
        case PARAMETER:
        case CONSTANT:
        case INPUT:
        case OUTPUT:
        case IDENT:
          switch (jj_nt.kind) {
          case ENCAPSULATED:
          case PARTIAL:
          case CLASS:
          case MODEL:
          case OPERATOR:
          case RECORD:
          case BLOCK:
          case EXPANDABLE:
          case CONNECTOR:
          case TYPE:
          case PACKAGE:
          case PURE:
          case IMPURE:
          case FUNCTION:
            ClassDefinition();
            break;
          case DOT:
          case FLOW:
          case STREAM:
          case DISCRETE:
          case PARAMETER:
          case CONSTANT:
          case INPUT:
          case OUTPUT:
          case IDENT:
            ComponentClause();
            break;
          default:
            jj_la1[37] = jj_gen;
            jj_consume_token(-1);
            throw net.sourceforge.pmd.util.AssertionUtil.shouldNotReachHere("consumetoken(-1) should have thrown");
          }
          break;
        case REPLACEABLE:
              ASTReplaceableClause jjtn005 = new ASTReplaceableClause(JJTREPLACEABLECLAUSE);
              boolean jjtc005 = true;
              jjtree.openNodeScope(jjtn005, getToken(1));
          try {
            jj_consume_token(REPLACEABLE);
            switch (jj_nt.kind) {
            case ENCAPSULATED:
            case PARTIAL:
            case CLASS:
            case MODEL:
            case OPERATOR:
            case RECORD:
            case BLOCK:
            case EXPANDABLE:
            case CONNECTOR:
            case TYPE:
            case PACKAGE:
            case PURE:
            case IMPURE:
            case FUNCTION:
              ClassDefinition();
              break;
            case DOT:
            case FLOW:
            case STREAM:
            case DISCRETE:
            case PARAMETER:
            case CONSTANT:
            case INPUT:
            case OUTPUT:
            case IDENT:
              ComponentClause();
              break;
            default:
              jj_la1[38] = jj_gen;
              jj_consume_token(-1);
              throw net.sourceforge.pmd.util.AssertionUtil.shouldNotReachHere("consumetoken(-1) should have thrown");
            }
            switch (jj_nt.kind) {
            case CONSTRAINEDBY:
              ConstrainingClause();
              Comment();
              break;
            default:
              jj_la1[39] = jj_gen;
              ;
            }
          } catch (Throwable jjte005) {
              if (jjtc005) {
                jjtree.clearNodeScope(jjtn005);
                jjtc005 = false;
              } else {
                jjtree.popNode();
              }
              if (jjte005 instanceof RuntimeException) {
                {if (true) throw (RuntimeException)jjte005;}
              }
              if (jjte005 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
                {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte005;}
              }
              {if (true) throw (Error)jjte005;}
          } finally {
              if (jjtc005) {
                jjtree.closeNodeScope(jjtn005, true, getToken(0));
              }
          }
          break;
        default:
          jj_la1[40] = jj_gen;
          jj_consume_token(-1);
          throw net.sourceforge.pmd.util.AssertionUtil.shouldNotReachHere("consumetoken(-1) should have thrown");
        }
      } catch (Throwable jjte006) {
        if (jjtc006) {
          jjtree.clearNodeScope(jjtn006);
          jjtc006 = false;
        } else {
          jjtree.popNode();
        }
        if (jjte006 instanceof RuntimeException) {
          {if (true) throw (RuntimeException)jjte006;}
        }
        if (jjte006 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
          {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte006;}
        }
        {if (true) throw (Error)jjte006;}
      } finally {
        if (jjtc006) {
          jjtree.closeNodeScope(jjtn006, true, getToken(0));
        }
      }
      break;
    default:
      jj_la1[41] = jj_gen;
      jj_consume_token(-1);
      throw net.sourceforge.pmd.util.AssertionUtil.shouldNotReachHere("consumetoken(-1) should have thrown");
    }
  }

  final public void ImportClause() throws net.sourceforge.pmd.lang.ast.ParseException {
                      /*@bgen(jjtree) ImportClause */
  ASTImportClause jjtn000 = new ASTImportClause(JJTIMPORTCLAUSE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      jj_consume_token(IMPORT);
      if (jj_2_10(2)) {
                         ASTRenamingImportClause jjtn001 = new ASTRenamingImportClause(JJTRENAMINGIMPORTCLAUSE);
                         boolean jjtc001 = true;
                         jjtree.openNodeScope(jjtn001, getToken(1));
        try {
          SimpleName();
          jj_consume_token(EQ_SIGN);
          Name();
        } catch (Throwable jjte001) {
                         if (jjtc001) {
                           jjtree.clearNodeScope(jjtn001);
                           jjtc001 = false;
                         } else {
                           jjtree.popNode();
                         }
                         if (jjte001 instanceof RuntimeException) {
                           {if (true) throw (RuntimeException)jjte001;}
                         }
                         if (jjte001 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
                           {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte001;}
                         }
                         {if (true) throw (Error)jjte001;}
        } finally {
                         if (jjtc001) {
                           jjtree.closeNodeScope(jjtn001, true, getToken(0));
                         }
        }
      } else if (jj_2_11(2147483647)) {
                                                                    ASTUnqualifiedImportClause jjtn002 = new ASTUnqualifiedImportClause(JJTUNQUALIFIEDIMPORTCLAUSE);
                                                                    boolean jjtc002 = true;
                                                                    jjtree.openNodeScope(jjtn002, getToken(1));
        try {
          Name();
          switch (jj_nt.kind) {
          case DOT:
            jj_consume_token(DOT);
            jj_consume_token(ASTERISK);
            break;
          case DOT_ASTERISK:
            jj_consume_token(DOT_ASTERISK);
            break;
          default:
            jj_la1[42] = jj_gen;
            jj_consume_token(-1);
            throw net.sourceforge.pmd.util.AssertionUtil.shouldNotReachHere("consumetoken(-1) should have thrown");
          }
        } catch (Throwable jjte002) {
                                                                    if (jjtc002) {
                                                                      jjtree.clearNodeScope(jjtn002);
                                                                      jjtc002 = false;
                                                                    } else {
                                                                      jjtree.popNode();
                                                                    }
                                                                    if (jjte002 instanceof RuntimeException) {
                                                                      {if (true) throw (RuntimeException)jjte002;}
                                                                    }
                                                                    if (jjte002 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
                                                                      {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte002;}
                                                                    }
                                                                    {if (true) throw (Error)jjte002;}
        } finally {
                                                                    if (jjtc002) {
                                                                      jjtree.closeNodeScope(jjtn002, true, getToken(0));
                                                                    }
        }
      } else if (jj_2_12(2147483647)) {
                                               ASTMultipleDefinitionImportClause jjtn003 = new ASTMultipleDefinitionImportClause(JJTMULTIPLEDEFINITIONIMPORTCLAUSE);
                                               boolean jjtc003 = true;
                                               jjtree.openNodeScope(jjtn003, getToken(1));
        try {
          Name();
          jj_consume_token(DOT);
          jj_consume_token(LCURL);
          ImportList();
          jj_consume_token(RCURL);
        } catch (Throwable jjte003) {
                                               if (jjtc003) {
                                                 jjtree.clearNodeScope(jjtn003);
                                                 jjtc003 = false;
                                               } else {
                                                 jjtree.popNode();
                                               }
                                               if (jjte003 instanceof RuntimeException) {
                                                 {if (true) throw (RuntimeException)jjte003;}
                                               }
                                               if (jjte003 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
                                                 {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte003;}
                                               }
                                               {if (true) throw (Error)jjte003;}
        } finally {
                                               if (jjtc003) {
                                                 jjtree.closeNodeScope(jjtn003, true, getToken(0));
                                               }
        }
      } else {
        switch (jj_nt.kind) {
        case DOT:
        case IDENT:
            ASTSingleDefinitionImportClause jjtn004 = new ASTSingleDefinitionImportClause(JJTSINGLEDEFINITIONIMPORTCLAUSE);
            boolean jjtc004 = true;
            jjtree.openNodeScope(jjtn004, getToken(1));
          try {
            Name();
          } catch (Throwable jjte004) {
            if (jjtc004) {
              jjtree.clearNodeScope(jjtn004);
              jjtc004 = false;
            } else {
              jjtree.popNode();
            }
            if (jjte004 instanceof RuntimeException) {
              {if (true) throw (RuntimeException)jjte004;}
            }
            if (jjte004 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
              {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte004;}
            }
            {if (true) throw (Error)jjte004;}
          } finally {
            if (jjtc004) {
              jjtree.closeNodeScope(jjtn004, true, getToken(0));
            }
          }
          break;
        default:
          jj_la1[43] = jj_gen;
          jj_consume_token(-1);
          throw net.sourceforge.pmd.util.AssertionUtil.shouldNotReachHere("consumetoken(-1) should have thrown");
        }
      }
      Comment();
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void ImportList() throws net.sourceforge.pmd.lang.ast.ParseException {
                    /*@bgen(jjtree) ImportList */
  ASTImportList jjtn000 = new ASTImportList(JJTIMPORTLIST);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      SimpleName();
      label_7:
      while (true) {
        switch (jj_nt.kind) {
        case COMMA:
          ;
          break;
        default:
          jj_la1[44] = jj_gen;
          break label_7;
        }
        jj_consume_token(COMMA);
        SimpleName();
      }
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void ExtendsClause() throws net.sourceforge.pmd.lang.ast.ParseException {
                       /*@bgen(jjtree) ExtendsClause */
  ASTExtendsClause jjtn000 = new ASTExtendsClause(JJTEXTENDSCLAUSE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      jj_consume_token(EXTENDS);
      Name();
      switch (jj_nt.kind) {
      case LPAREN:
        ClassModification();
        break;
      default:
        jj_la1[45] = jj_gen;
        ;
      }
      switch (jj_nt.kind) {
      case ANNOTATION:
        Annotation();
        break;
      default:
        jj_la1[46] = jj_gen;
        ;
      }
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void ConstrainingClause() throws net.sourceforge.pmd.lang.ast.ParseException {
                            /*@bgen(jjtree) ConstrainingClause */
  ASTConstrainingClause jjtn000 = new ASTConstrainingClause(JJTCONSTRAININGCLAUSE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      jj_consume_token(CONSTRAINEDBY);
      Name();
      switch (jj_nt.kind) {
      case LPAREN:
        ClassModification();
        break;
      default:
        jj_la1[47] = jj_gen;
        ;
      }
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void ComponentClause() throws net.sourceforge.pmd.lang.ast.ParseException {
                         /*@bgen(jjtree) ComponentClause */
  ASTComponentClause jjtn000 = new ASTComponentClause(JJTCOMPONENTCLAUSE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      TypePrefix();
      TypeSpecifier();
      switch (jj_nt.kind) {
      case LSQUARE:
        ArraySubscripts();
        break;
      default:
        jj_la1[48] = jj_gen;
        ;
      }
      ComponentList();
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void TypePrefix() throws net.sourceforge.pmd.lang.ast.ParseException {
                    /*@bgen(jjtree) TypePrefix */
  ASTTypePrefix jjtn000 = new ASTTypePrefix(JJTTYPEPREFIX);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      switch (jj_nt.kind) {
      case FLOW:
      case STREAM:
        switch (jj_nt.kind) {
        case FLOW:
       ASTFlowClause jjtn001 = new ASTFlowClause(JJTFLOWCLAUSE);
       boolean jjtc001 = true;
       jjtree.openNodeScope(jjtn001, getToken(1));
          try {
            jj_consume_token(FLOW);
          } finally {
       if (jjtc001) {
         jjtree.closeNodeScope(jjtn001, true, getToken(0));
       }
          }
          break;
        case STREAM:
                            ASTStreamClause jjtn002 = new ASTStreamClause(JJTSTREAMCLAUSE);
                            boolean jjtc002 = true;
                            jjtree.openNodeScope(jjtn002, getToken(1));
          try {
            jj_consume_token(STREAM);
          } finally {
                            if (jjtc002) {
                              jjtree.closeNodeScope(jjtn002, true, getToken(0));
                            }
          }
          break;
        default:
          jj_la1[49] = jj_gen;
          jj_consume_token(-1);
          throw net.sourceforge.pmd.util.AssertionUtil.shouldNotReachHere("consumetoken(-1) should have thrown");
        }
        break;
      default:
        jj_la1[50] = jj_gen;
        ;
      }
      switch (jj_nt.kind) {
      case DISCRETE:
      case PARAMETER:
      case CONSTANT:
        switch (jj_nt.kind) {
        case DISCRETE:
       ASTDiscreteClause jjtn003 = new ASTDiscreteClause(JJTDISCRETECLAUSE);
       boolean jjtc003 = true;
       jjtree.openNodeScope(jjtn003, getToken(1));
          try {
            jj_consume_token(DISCRETE);
          } finally {
       if (jjtc003) {
         jjtree.closeNodeScope(jjtn003, true, getToken(0));
       }
          }
          break;
        case PARAMETER:
                                    ASTParameterClause jjtn004 = new ASTParameterClause(JJTPARAMETERCLAUSE);
                                    boolean jjtc004 = true;
                                    jjtree.openNodeScope(jjtn004, getToken(1));
          try {
            jj_consume_token(PARAMETER);
          } finally {
                                    if (jjtc004) {
                                      jjtree.closeNodeScope(jjtn004, true, getToken(0));
                                    }
          }
          break;
        case CONSTANT:
                                                                   ASTConstantClause jjtn005 = new ASTConstantClause(JJTCONSTANTCLAUSE);
                                                                   boolean jjtc005 = true;
                                                                   jjtree.openNodeScope(jjtn005, getToken(1));
          try {
            jj_consume_token(CONSTANT);
          } finally {
                                                                   if (jjtc005) {
                                                                     jjtree.closeNodeScope(jjtn005, true, getToken(0));
                                                                   }
          }
          break;
        default:
          jj_la1[51] = jj_gen;
          jj_consume_token(-1);
          throw net.sourceforge.pmd.util.AssertionUtil.shouldNotReachHere("consumetoken(-1) should have thrown");
        }
        break;
      default:
        jj_la1[52] = jj_gen;
        ;
      }
      switch (jj_nt.kind) {
      case INPUT:
      case OUTPUT:
        switch (jj_nt.kind) {
        case INPUT:
       ASTInputClause jjtn006 = new ASTInputClause(JJTINPUTCLAUSE);
       boolean jjtc006 = true;
       jjtree.openNodeScope(jjtn006, getToken(1));
          try {
            jj_consume_token(INPUT);
          } finally {
       if (jjtc006) {
         jjtree.closeNodeScope(jjtn006, true, getToken(0));
       }
          }
          break;
        case OUTPUT:
                              ASTOutputClause jjtn007 = new ASTOutputClause(JJTOUTPUTCLAUSE);
                              boolean jjtc007 = true;
                              jjtree.openNodeScope(jjtn007, getToken(1));
          try {
            jj_consume_token(OUTPUT);
          } finally {
                              if (jjtc007) {
                                jjtree.closeNodeScope(jjtn007, true, getToken(0));
                              }
          }
          break;
        default:
          jj_la1[53] = jj_gen;
          jj_consume_token(-1);
          throw net.sourceforge.pmd.util.AssertionUtil.shouldNotReachHere("consumetoken(-1) should have thrown");
        }
        break;
      default:
        jj_la1[54] = jj_gen;
        ;
      }
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void TypeSpecifier() throws net.sourceforge.pmd.lang.ast.ParseException {
                       /*@bgen(jjtree) TypeSpecifier */
  ASTTypeSpecifier jjtn000 = new ASTTypeSpecifier(JJTTYPESPECIFIER);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      Name();
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void ComponentList() throws net.sourceforge.pmd.lang.ast.ParseException {
                       /*@bgen(jjtree) ComponentList */
  ASTComponentList jjtn000 = new ASTComponentList(JJTCOMPONENTLIST);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      ComponentDeclaration();
      label_8:
      while (true) {
        switch (jj_nt.kind) {
        case COMMA:
          ;
          break;
        default:
          jj_la1[55] = jj_gen;
          break label_8;
        }
        jj_consume_token(COMMA);
        ComponentDeclaration();
      }
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void ComponentDeclaration() throws net.sourceforge.pmd.lang.ast.ParseException {
                              /*@bgen(jjtree) ComponentDeclaration */
  ASTComponentDeclaration jjtn000 = new ASTComponentDeclaration(JJTCOMPONENTDECLARATION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      Declaration();
      switch (jj_nt.kind) {
      case IF:
        ConditionAttribute();
        break;
      default:
        jj_la1[56] = jj_gen;
        ;
      }
      Comment();
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void ConditionAttribute() throws net.sourceforge.pmd.lang.ast.ParseException {
                            /*@bgen(jjtree) ConditionAttribute */
  ASTConditionAttribute jjtn000 = new ASTConditionAttribute(JJTCONDITIONATTRIBUTE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      jj_consume_token(IF);
      Expression();
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void Declaration() throws net.sourceforge.pmd.lang.ast.ParseException {
                     /*@bgen(jjtree) Declaration */
  ASTDeclaration jjtn000 = new ASTDeclaration(JJTDECLARATION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      SimpleName();
      switch (jj_nt.kind) {
      case LSQUARE:
        ArraySubscripts();
        break;
      default:
        jj_la1[57] = jj_gen;
        ;
      }
      switch (jj_nt.kind) {
      case LPAREN:
      case EQ_SIGN:
      case ASSIGN:
        Modification();
        break;
      default:
        jj_la1[58] = jj_gen;
        ;
      }
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void Modification() throws net.sourceforge.pmd.lang.ast.ParseException {
    switch (jj_nt.kind) {
    case LPAREN:
      ASTLongModification jjtn001 = new ASTLongModification(JJTLONGMODIFICATION);
      boolean jjtc001 = true;
      jjtree.openNodeScope(jjtn001, getToken(1));
      try {
        ClassModification();
        switch (jj_nt.kind) {
        case EQ_SIGN:
          jj_consume_token(EQ_SIGN);
          Expression();
          break;
        default:
          jj_la1[59] = jj_gen;
          ;
        }
      } catch (Throwable jjte001) {
      if (jjtc001) {
        jjtree.clearNodeScope(jjtn001);
        jjtc001 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte001 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte001;}
      }
      if (jjte001 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte001;}
      }
      {if (true) throw (Error)jjte001;}
      } finally {
      if (jjtc001) {
        jjtree.closeNodeScope(jjtn001, true, getToken(0));
      }
      }
      break;
    case EQ_SIGN:
        ASTShortModification jjtn002 = new ASTShortModification(JJTSHORTMODIFICATION);
        boolean jjtc002 = true;
        jjtree.openNodeScope(jjtn002, getToken(1));
      try {
        jj_consume_token(EQ_SIGN);
        Expression();
      } catch (Throwable jjte002) {
        if (jjtc002) {
          jjtree.clearNodeScope(jjtn002);
          jjtc002 = false;
        } else {
          jjtree.popNode();
        }
        if (jjte002 instanceof RuntimeException) {
          {if (true) throw (RuntimeException)jjte002;}
        }
        if (jjte002 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
          {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte002;}
        }
        {if (true) throw (Error)jjte002;}
      } finally {
        if (jjtc002) {
          jjtree.closeNodeScope(jjtn002, true, getToken(0));
        }
      }
      break;
    case ASSIGN:
        ASTAssignmentModification jjtn003 = new ASTAssignmentModification(JJTASSIGNMENTMODIFICATION);
        boolean jjtc003 = true;
        jjtree.openNodeScope(jjtn003, getToken(1));
      try {
        jj_consume_token(ASSIGN);
        Expression();
      } catch (Throwable jjte003) {
        if (jjtc003) {
          jjtree.clearNodeScope(jjtn003);
          jjtc003 = false;
        } else {
          jjtree.popNode();
        }
        if (jjte003 instanceof RuntimeException) {
          {if (true) throw (RuntimeException)jjte003;}
        }
        if (jjte003 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
          {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte003;}
        }
        {if (true) throw (Error)jjte003;}
      } finally {
        if (jjtc003) {
          jjtree.closeNodeScope(jjtn003, true, getToken(0));
        }
      }
      break;
    default:
      jj_la1[60] = jj_gen;
      jj_consume_token(-1);
      throw net.sourceforge.pmd.util.AssertionUtil.shouldNotReachHere("consumetoken(-1) should have thrown");
    }
  }

  final public void ClassModification() throws net.sourceforge.pmd.lang.ast.ParseException {
                           /*@bgen(jjtree) ClassModification */
  ASTClassModification jjtn000 = new ASTClassModification(JJTCLASSMODIFICATION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      jj_consume_token(LPAREN);
      switch (jj_nt.kind) {
      case DOT:
      case FINAL:
      case REDECLARE:
      case REPLACEABLE:
      case EACH:
      case IDENT:
        ArgumentList();
        break;
      default:
        jj_la1[61] = jj_gen;
        ;
      }
      jj_consume_token(RPAREN);
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void ArgumentList() throws net.sourceforge.pmd.lang.ast.ParseException {
                      /*@bgen(jjtree) ArgumentList */
  ASTArgumentList jjtn000 = new ASTArgumentList(JJTARGUMENTLIST);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      Argument();
      label_9:
      while (true) {
        switch (jj_nt.kind) {
        case COMMA:
          ;
          break;
        default:
          jj_la1[62] = jj_gen;
          break label_9;
        }
        jj_consume_token(COMMA);
        Argument();
      }
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void Argument() throws net.sourceforge.pmd.lang.ast.ParseException {
                  /*@bgen(jjtree) Argument */
  ASTArgument jjtn000 = new ASTArgument(JJTARGUMENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      switch (jj_nt.kind) {
      case DOT:
      case FINAL:
      case REPLACEABLE:
      case EACH:
      case IDENT:
        ElementModificationOrReplaceable();
        break;
      case REDECLARE:
        ElementRedeclaration();
        break;
      default:
        jj_la1[63] = jj_gen;
        jj_consume_token(-1);
        throw net.sourceforge.pmd.util.AssertionUtil.shouldNotReachHere("consumetoken(-1) should have thrown");
      }
    } catch (Throwable jjte000) {
        if (jjtc000) {
          jjtree.clearNodeScope(jjtn000);
          jjtc000 = false;
        } else {
          jjtree.popNode();
        }
        if (jjte000 instanceof RuntimeException) {
          {if (true) throw (RuntimeException)jjte000;}
        }
        if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
          {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
        }
        {if (true) throw (Error)jjte000;}
    } finally {
        if (jjtc000) {
          jjtree.closeNodeScope(jjtn000, true, getToken(0));
        }
    }
  }

  final public void ElementModificationOrReplaceable() throws net.sourceforge.pmd.lang.ast.ParseException {
                                          /*@bgen(jjtree) ElementModificationOrReplaceable */
  ASTElementModificationOrReplaceable jjtn000 = new ASTElementModificationOrReplaceable(JJTELEMENTMODIFICATIONORREPLACEABLE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      switch (jj_nt.kind) {
      case EACH:
       ASTEachClause jjtn001 = new ASTEachClause(JJTEACHCLAUSE);
       boolean jjtc001 = true;
       jjtree.openNodeScope(jjtn001, getToken(1));
        try {
          jj_consume_token(EACH);
        } finally {
       if (jjtc001) {
         jjtree.closeNodeScope(jjtn001, true, getToken(0));
       }
        }
        break;
      default:
        jj_la1[64] = jj_gen;
        ;
      }
      switch (jj_nt.kind) {
      case FINAL:
       ASTFinalClause jjtn002 = new ASTFinalClause(JJTFINALCLAUSE);
       boolean jjtc002 = true;
       jjtree.openNodeScope(jjtn002, getToken(1));
        try {
          jj_consume_token(FINAL);
        } finally {
       if (jjtc002) {
         jjtree.closeNodeScope(jjtn002, true, getToken(0));
       }
        }
        break;
      default:
        jj_la1[65] = jj_gen;
        ;
      }
      switch (jj_nt.kind) {
      case DOT:
      case IDENT:
        ElementModification();
        break;
      case REPLACEABLE:
        ElementReplaceable();
        break;
      default:
        jj_la1[66] = jj_gen;
        jj_consume_token(-1);
        throw net.sourceforge.pmd.util.AssertionUtil.shouldNotReachHere("consumetoken(-1) should have thrown");
      }
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void ElementModification() throws net.sourceforge.pmd.lang.ast.ParseException {
                             /*@bgen(jjtree) ElementModification */
  ASTElementModification jjtn000 = new ASTElementModification(JJTELEMENTMODIFICATION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      Name();
      switch (jj_nt.kind) {
      case LPAREN:
      case EQ_SIGN:
      case ASSIGN:
        Modification();
        break;
      default:
        jj_la1[67] = jj_gen;
        ;
      }
      StringComment();
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void ElementRedeclaration() throws net.sourceforge.pmd.lang.ast.ParseException {
                              /*@bgen(jjtree) ElementRedeclaration */
  ASTElementRedeclaration jjtn000 = new ASTElementRedeclaration(JJTELEMENTREDECLARATION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      jj_consume_token(REDECLARE);
      switch (jj_nt.kind) {
      case EACH:
       ASTEachClause jjtn001 = new ASTEachClause(JJTEACHCLAUSE);
       boolean jjtc001 = true;
       jjtree.openNodeScope(jjtn001, getToken(1));
        try {
          jj_consume_token(EACH);
        } finally {
       if (jjtc001) {
         jjtree.closeNodeScope(jjtn001, true, getToken(0));
       }
        }
        break;
      default:
        jj_la1[68] = jj_gen;
        ;
      }
      switch (jj_nt.kind) {
      case FINAL:
       ASTFinalClause jjtn002 = new ASTFinalClause(JJTFINALCLAUSE);
       boolean jjtc002 = true;
       jjtree.openNodeScope(jjtn002, getToken(1));
        try {
          jj_consume_token(FINAL);
        } finally {
       if (jjtc002) {
         jjtree.closeNodeScope(jjtn002, true, getToken(0));
       }
        }
        break;
      default:
        jj_la1[69] = jj_gen;
        ;
      }
      switch (jj_nt.kind) {
      case DOT:
      case PARTIAL:
      case CLASS:
      case MODEL:
      case OPERATOR:
      case RECORD:
      case BLOCK:
      case EXPANDABLE:
      case CONNECTOR:
      case TYPE:
      case PACKAGE:
      case PURE:
      case IMPURE:
      case FUNCTION:
      case FLOW:
      case STREAM:
      case DISCRETE:
      case PARAMETER:
      case CONSTANT:
      case INPUT:
      case OUTPUT:
      case IDENT:
        switch (jj_nt.kind) {
        case PARTIAL:
        case CLASS:
        case MODEL:
        case OPERATOR:
        case RECORD:
        case BLOCK:
        case EXPANDABLE:
        case CONNECTOR:
        case TYPE:
        case PACKAGE:
        case PURE:
        case IMPURE:
        case FUNCTION:
          ShortClassDefinition();
          break;
        case DOT:
        case FLOW:
        case STREAM:
        case DISCRETE:
        case PARAMETER:
        case CONSTANT:
        case INPUT:
        case OUTPUT:
        case IDENT:
          ComponentClause1();
          break;
        default:
          jj_la1[70] = jj_gen;
          jj_consume_token(-1);
          throw net.sourceforge.pmd.util.AssertionUtil.shouldNotReachHere("consumetoken(-1) should have thrown");
        }
        break;
      case REPLACEABLE:
        ElementReplaceable();
        break;
      default:
        jj_la1[71] = jj_gen;
        jj_consume_token(-1);
        throw net.sourceforge.pmd.util.AssertionUtil.shouldNotReachHere("consumetoken(-1) should have thrown");
      }
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void ElementReplaceable() throws net.sourceforge.pmd.lang.ast.ParseException {
                            /*@bgen(jjtree) ElementReplaceable */
  ASTElementReplaceable jjtn000 = new ASTElementReplaceable(JJTELEMENTREPLACEABLE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      jj_consume_token(REPLACEABLE);
      switch (jj_nt.kind) {
      case PARTIAL:
      case CLASS:
      case MODEL:
      case OPERATOR:
      case RECORD:
      case BLOCK:
      case EXPANDABLE:
      case CONNECTOR:
      case TYPE:
      case PACKAGE:
      case PURE:
      case IMPURE:
      case FUNCTION:
        ShortClassDefinition();
        break;
      case DOT:
      case FLOW:
      case STREAM:
      case DISCRETE:
      case PARAMETER:
      case CONSTANT:
      case INPUT:
      case OUTPUT:
      case IDENT:
        ComponentClause1();
        break;
      default:
        jj_la1[72] = jj_gen;
        jj_consume_token(-1);
        throw net.sourceforge.pmd.util.AssertionUtil.shouldNotReachHere("consumetoken(-1) should have thrown");
      }
      switch (jj_nt.kind) {
      case CONSTRAINEDBY:
        ConstrainingClause();
        break;
      default:
        jj_la1[73] = jj_gen;
        ;
      }
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void ComponentClause1() throws net.sourceforge.pmd.lang.ast.ParseException {
                          /*@bgen(jjtree) ComponentClause1 */
  ASTComponentClause1 jjtn000 = new ASTComponentClause1(JJTCOMPONENTCLAUSE1);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      TypePrefix();
      TypeSpecifier();
      ComponentDeclaration1();
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void ComponentDeclaration1() throws net.sourceforge.pmd.lang.ast.ParseException {
                               /*@bgen(jjtree) ComponentDeclaration1 */
  ASTComponentDeclaration1 jjtn000 = new ASTComponentDeclaration1(JJTCOMPONENTDECLARATION1);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      Declaration();
      Comment();
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void ShortClassDefinition() throws net.sourceforge.pmd.lang.ast.ParseException {
                              /*@bgen(jjtree) ShortClassDefinition */
  ASTShortClassDefinition jjtn000 = new ASTShortClassDefinition(JJTSHORTCLASSDEFINITION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      ClassPrefixes();
      ShortClassSpecifier();
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void EquationSection() throws net.sourceforge.pmd.lang.ast.ParseException {
                         /*@bgen(jjtree) EquationSection */
  ASTEquationSection jjtn000 = new ASTEquationSection(JJTEQUATIONSECTION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      switch (jj_nt.kind) {
      case INITIAL:
       ASTInitialClause jjtn001 = new ASTInitialClause(JJTINITIALCLAUSE);
       boolean jjtc001 = true;
       jjtree.openNodeScope(jjtn001, getToken(1));
        try {
          jj_consume_token(INITIAL);
        } finally {
       if (jjtc001) {
         jjtree.closeNodeScope(jjtn001, true, getToken(0));
       }
        }
        break;
      default:
        jj_la1[74] = jj_gen;
        ;
      }
      jj_consume_token(EQUATION);
      label_10:
      while (true) {
        if (jj_2_13(2)) {
          ;
        } else {
          break label_10;
        }
        Equation();
        jj_consume_token(SC);
      }
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void AlgorithmSection() throws net.sourceforge.pmd.lang.ast.ParseException {
                          /*@bgen(jjtree) AlgorithmSection */
  ASTAlgorithmSection jjtn000 = new ASTAlgorithmSection(JJTALGORITHMSECTION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      switch (jj_nt.kind) {
      case INITIAL:
       ASTInitialClause jjtn001 = new ASTInitialClause(JJTINITIALCLAUSE);
       boolean jjtc001 = true;
       jjtree.openNodeScope(jjtn001, getToken(1));
        try {
          jj_consume_token(INITIAL);
        } finally {
       if (jjtc001) {
         jjtree.closeNodeScope(jjtn001, true, getToken(0));
       }
        }
        break;
      default:
        jj_la1[75] = jj_gen;
        ;
      }
      jj_consume_token(ALGORITHM);
      label_11:
      while (true) {
        switch (jj_nt.kind) {
        case LPAREN:
        case DOT:
        case IF:
        case BREAK:
        case RETURN:
        case FOR:
        case WHILE:
        case WHEN:
        case IDENT:
          ;
          break;
        default:
          jj_la1[76] = jj_gen;
          break label_11;
        }
        Statement();
        jj_consume_token(SC);
      }
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void Equation() throws net.sourceforge.pmd.lang.ast.ParseException {
                  /*@bgen(jjtree) Equation */
  ASTEquation jjtn000 = new ASTEquation(JJTEQUATION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      if (jj_2_14(2147483647)) {
                                                                             ASTRegularEquation jjtn001 = new ASTRegularEquation(JJTREGULAREQUATION);
                                                                             boolean jjtc001 = true;
                                                                             jjtree.openNodeScope(jjtn001, getToken(1));
        try {
          SimpleExpression();
          jj_consume_token(EQ_SIGN);
          Expression();
        } catch (Throwable jjte001) {
                                                                             if (jjtc001) {
                                                                               jjtree.clearNodeScope(jjtn001);
                                                                               jjtc001 = false;
                                                                             } else {
                                                                               jjtree.popNode();
                                                                             }
                                                                             if (jjte001 instanceof RuntimeException) {
                                                                               {if (true) throw (RuntimeException)jjte001;}
                                                                             }
                                                                             if (jjte001 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
                                                                               {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte001;}
                                                                             }
                                                                             {if (true) throw (Error)jjte001;}
        } finally {
                                                                             if (jjtc001) {
                                                                               jjtree.closeNodeScope(jjtn001, true, getToken(0));
                                                                             }
        }
      } else {
        switch (jj_nt.kind) {
        case IF:
          IfEquation();
          break;
        case FOR:
          ForEquation();
          break;
        case CONNECT:
          ConnectClause();
          break;
        case WHEN:
          WhenEquation();
          break;
        case DOT:
        case IDENT:
            ASTFunctionCallEquation jjtn002 = new ASTFunctionCallEquation(JJTFUNCTIONCALLEQUATION);
            boolean jjtc002 = true;
            jjtree.openNodeScope(jjtn002, getToken(1));
          try {
            Name();
            FunctionCallArgs();
          } catch (Throwable jjte002) {
            if (jjtc002) {
              jjtree.clearNodeScope(jjtn002);
              jjtc002 = false;
            } else {
              jjtree.popNode();
            }
            if (jjte002 instanceof RuntimeException) {
              {if (true) throw (RuntimeException)jjte002;}
            }
            if (jjte002 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
              {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte002;}
            }
            {if (true) throw (Error)jjte002;}
          } finally {
            if (jjtc002) {
              jjtree.closeNodeScope(jjtn002, true, getToken(0));
            }
          }
          break;
        default:
          jj_la1[77] = jj_gen;
          jj_consume_token(-1);
          throw net.sourceforge.pmd.util.AssertionUtil.shouldNotReachHere("consumetoken(-1) should have thrown");
        }
      }
      Comment();
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void Statement() throws net.sourceforge.pmd.lang.ast.ParseException {
                   /*@bgen(jjtree) Statement */
  ASTStatement jjtn000 = new ASTStatement(JJTSTATEMENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      if (jj_2_15(2147483647)) {
                                                     ASTAssignmentStatement jjtn001 = new ASTAssignmentStatement(JJTASSIGNMENTSTATEMENT);
                                                     boolean jjtc001 = true;
                                                     jjtree.openNodeScope(jjtn001, getToken(1));
        try {
          ComponentReference();
          jj_consume_token(ASSIGN);
          Expression();
        } catch (Throwable jjte001) {
                                                     if (jjtc001) {
                                                       jjtree.clearNodeScope(jjtn001);
                                                       jjtc001 = false;
                                                     } else {
                                                       jjtree.popNode();
                                                     }
                                                     if (jjte001 instanceof RuntimeException) {
                                                       {if (true) throw (RuntimeException)jjte001;}
                                                     }
                                                     if (jjte001 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
                                                       {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte001;}
                                                     }
                                                     {if (true) throw (Error)jjte001;}
        } finally {
                                                     if (jjtc001) {
                                                       jjtree.closeNodeScope(jjtn001, true, getToken(0));
                                                     }
        }
      } else {
        switch (jj_nt.kind) {
        case DOT:
        case IDENT:
            ASTFunctionCallStatement jjtn002 = new ASTFunctionCallStatement(JJTFUNCTIONCALLSTATEMENT);
            boolean jjtc002 = true;
            jjtree.openNodeScope(jjtn002, getToken(1));
          try {
            ComponentReference();
            FunctionCallArgs();
          } catch (Throwable jjte002) {
            if (jjtc002) {
              jjtree.clearNodeScope(jjtn002);
              jjtc002 = false;
            } else {
              jjtree.popNode();
            }
            if (jjte002 instanceof RuntimeException) {
              {if (true) throw (RuntimeException)jjte002;}
            }
            if (jjte002 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
              {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte002;}
            }
            {if (true) throw (Error)jjte002;}
          } finally {
            if (jjtc002) {
              jjtree.closeNodeScope(jjtn002, true, getToken(0));
            }
          }
          break;
        case LPAREN:
            ASTAssignmentFromMultiResultFunctionCall jjtn003 = new ASTAssignmentFromMultiResultFunctionCall(JJTASSIGNMENTFROMMULTIRESULTFUNCTIONCALL);
            boolean jjtc003 = true;
            jjtree.openNodeScope(jjtn003, getToken(1));
          try {
            jj_consume_token(LPAREN);
            OutputExpressionList();
            jj_consume_token(RPAREN);
            jj_consume_token(ASSIGN);
            ComponentReference();
            FunctionCallArgs();
          } catch (Throwable jjte003) {
            if (jjtc003) {
              jjtree.clearNodeScope(jjtn003);
              jjtc003 = false;
            } else {
              jjtree.popNode();
            }
            if (jjte003 instanceof RuntimeException) {
              {if (true) throw (RuntimeException)jjte003;}
            }
            if (jjte003 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
              {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte003;}
            }
            {if (true) throw (Error)jjte003;}
          } finally {
            if (jjtc003) {
              jjtree.closeNodeScope(jjtn003, true, getToken(0));
            }
          }
          break;
        case BREAK:
            ASTBreakStatement jjtn004 = new ASTBreakStatement(JJTBREAKSTATEMENT);
            boolean jjtc004 = true;
            jjtree.openNodeScope(jjtn004, getToken(1));
          try {
            jj_consume_token(BREAK);
          } finally {
            if (jjtc004) {
              jjtree.closeNodeScope(jjtn004, true, getToken(0));
            }
          }
          break;
        case RETURN:
            ASTReturnStatement jjtn005 = new ASTReturnStatement(JJTRETURNSTATEMENT);
            boolean jjtc005 = true;
            jjtree.openNodeScope(jjtn005, getToken(1));
          try {
            jj_consume_token(RETURN);
          } finally {
            if (jjtc005) {
              jjtree.closeNodeScope(jjtn005, true, getToken(0));
            }
          }
          break;
        case IF:
          IfStatement();
          break;
        case FOR:
          ForStatement();
          break;
        case WHILE:
          WhileStatement();
          break;
        case WHEN:
          WhenStatement();
          break;
        default:
          jj_la1[78] = jj_gen;
          jj_consume_token(-1);
          throw net.sourceforge.pmd.util.AssertionUtil.shouldNotReachHere("consumetoken(-1) should have thrown");
        }
      }
      Comment();
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void IfEquation() throws net.sourceforge.pmd.lang.ast.ParseException {
                    /*@bgen(jjtree) IfEquation */
  ASTIfEquation jjtn000 = new ASTIfEquation(JJTIFEQUATION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      jj_consume_token(IF);
            ASTIfClause jjtn001 = new ASTIfClause(JJTIFCLAUSE);
            boolean jjtc001 = true;
            jjtree.openNodeScope(jjtn001, getToken(1));
      try {
        Expression();
      } catch (Throwable jjte001) {
            if (jjtc001) {
              jjtree.clearNodeScope(jjtn001);
              jjtc001 = false;
            } else {
              jjtree.popNode();
            }
            if (jjte001 instanceof RuntimeException) {
              {if (true) throw (RuntimeException)jjte001;}
            }
            if (jjte001 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
              {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte001;}
            }
            {if (true) throw (Error)jjte001;}
      } finally {
            if (jjtc001) {
              jjtree.closeNodeScope(jjtn001, true, getToken(0));
            }
      }
      jj_consume_token(THEN);
              ASTThenClause jjtn002 = new ASTThenClause(JJTTHENCLAUSE);
              boolean jjtc002 = true;
              jjtree.openNodeScope(jjtn002, getToken(1));
      try {
        EquationList();
      } catch (Throwable jjte002) {
              if (jjtc002) {
                jjtree.clearNodeScope(jjtn002);
                jjtc002 = false;
              } else {
                jjtree.popNode();
              }
              if (jjte002 instanceof RuntimeException) {
                {if (true) throw (RuntimeException)jjte002;}
              }
              if (jjte002 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
                {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte002;}
              }
              {if (true) throw (Error)jjte002;}
      } finally {
              if (jjtc002) {
                jjtree.closeNodeScope(jjtn002, true, getToken(0));
              }
      }
      label_12:
      while (true) {
        switch (jj_nt.kind) {
        case ELSEIF:
          ;
          break;
        default:
          jj_la1[79] = jj_gen;
          break label_12;
        }
       ASTElseIfClause jjtn003 = new ASTElseIfClause(JJTELSEIFCLAUSE);
       boolean jjtc003 = true;
       jjtree.openNodeScope(jjtn003, getToken(1));
        try {
          jj_consume_token(ELSEIF);
          Expression();
          jj_consume_token(THEN);
          EquationList();
        } catch (Throwable jjte003) {
       if (jjtc003) {
         jjtree.clearNodeScope(jjtn003);
         jjtc003 = false;
       } else {
         jjtree.popNode();
       }
       if (jjte003 instanceof RuntimeException) {
         {if (true) throw (RuntimeException)jjte003;}
       }
       if (jjte003 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
         {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte003;}
       }
       {if (true) throw (Error)jjte003;}
        } finally {
       if (jjtc003) {
         jjtree.closeNodeScope(jjtn003, true, getToken(0));
       }
        }
      }
      switch (jj_nt.kind) {
      case ELSE:
        jj_consume_token(ELSE);
              ASTElseClause jjtn004 = new ASTElseClause(JJTELSECLAUSE);
              boolean jjtc004 = true;
              jjtree.openNodeScope(jjtn004, getToken(1));
        try {
          EquationList();
        } catch (Throwable jjte004) {
              if (jjtc004) {
                jjtree.clearNodeScope(jjtn004);
                jjtc004 = false;
              } else {
                jjtree.popNode();
              }
              if (jjte004 instanceof RuntimeException) {
                {if (true) throw (RuntimeException)jjte004;}
              }
              if (jjte004 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
                {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte004;}
              }
              {if (true) throw (Error)jjte004;}
        } finally {
              if (jjtc004) {
                jjtree.closeNodeScope(jjtn004, true, getToken(0));
              }
        }
        break;
      default:
        jj_la1[80] = jj_gen;
        ;
      }
      jj_consume_token(END);
      jj_consume_token(IF);
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void IfStatement() throws net.sourceforge.pmd.lang.ast.ParseException {
                     /*@bgen(jjtree) IfStatement */
  ASTIfStatement jjtn000 = new ASTIfStatement(JJTIFSTATEMENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      jj_consume_token(IF);
            ASTIfClause jjtn001 = new ASTIfClause(JJTIFCLAUSE);
            boolean jjtc001 = true;
            jjtree.openNodeScope(jjtn001, getToken(1));
      try {
        Expression();
      } catch (Throwable jjte001) {
            if (jjtc001) {
              jjtree.clearNodeScope(jjtn001);
              jjtc001 = false;
            } else {
              jjtree.popNode();
            }
            if (jjte001 instanceof RuntimeException) {
              {if (true) throw (RuntimeException)jjte001;}
            }
            if (jjte001 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
              {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte001;}
            }
            {if (true) throw (Error)jjte001;}
      } finally {
            if (jjtc001) {
              jjtree.closeNodeScope(jjtn001, true, getToken(0));
            }
      }
      jj_consume_token(THEN);
              ASTThenClause jjtn002 = new ASTThenClause(JJTTHENCLAUSE);
              boolean jjtc002 = true;
              jjtree.openNodeScope(jjtn002, getToken(1));
      try {
        StatementList();
      } catch (Throwable jjte002) {
              if (jjtc002) {
                jjtree.clearNodeScope(jjtn002);
                jjtc002 = false;
              } else {
                jjtree.popNode();
              }
              if (jjte002 instanceof RuntimeException) {
                {if (true) throw (RuntimeException)jjte002;}
              }
              if (jjte002 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
                {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte002;}
              }
              {if (true) throw (Error)jjte002;}
      } finally {
              if (jjtc002) {
                jjtree.closeNodeScope(jjtn002, true, getToken(0));
              }
      }
      label_13:
      while (true) {
        switch (jj_nt.kind) {
        case ELSEIF:
          ;
          break;
        default:
          jj_la1[81] = jj_gen;
          break label_13;
        }
       ASTElseIfClause jjtn003 = new ASTElseIfClause(JJTELSEIFCLAUSE);
       boolean jjtc003 = true;
       jjtree.openNodeScope(jjtn003, getToken(1));
        try {
          jj_consume_token(ELSEIF);
          Expression();
          jj_consume_token(THEN);
          StatementList();
        } catch (Throwable jjte003) {
       if (jjtc003) {
         jjtree.clearNodeScope(jjtn003);
         jjtc003 = false;
       } else {
         jjtree.popNode();
       }
       if (jjte003 instanceof RuntimeException) {
         {if (true) throw (RuntimeException)jjte003;}
       }
       if (jjte003 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
         {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte003;}
       }
       {if (true) throw (Error)jjte003;}
        } finally {
       if (jjtc003) {
         jjtree.closeNodeScope(jjtn003, true, getToken(0));
       }
        }
      }
      switch (jj_nt.kind) {
      case ELSE:
        jj_consume_token(ELSE);
              ASTElseClause jjtn004 = new ASTElseClause(JJTELSECLAUSE);
              boolean jjtc004 = true;
              jjtree.openNodeScope(jjtn004, getToken(1));
        try {
          StatementList();
        } catch (Throwable jjte004) {
              if (jjtc004) {
                jjtree.clearNodeScope(jjtn004);
                jjtc004 = false;
              } else {
                jjtree.popNode();
              }
              if (jjte004 instanceof RuntimeException) {
                {if (true) throw (RuntimeException)jjte004;}
              }
              if (jjte004 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
                {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte004;}
              }
              {if (true) throw (Error)jjte004;}
        } finally {
              if (jjtc004) {
                jjtree.closeNodeScope(jjtn004, true, getToken(0));
              }
        }
        break;
      default:
        jj_la1[82] = jj_gen;
        ;
      }
      jj_consume_token(END);
      jj_consume_token(IF);
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void ForEquation() throws net.sourceforge.pmd.lang.ast.ParseException {
                     /*@bgen(jjtree) ForEquation */
  ASTForEquation jjtn000 = new ASTForEquation(JJTFOREQUATION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      jj_consume_token(FOR);
      ForIndices();
      jj_consume_token(LOOP);
      EquationList();
      jj_consume_token(END);
      jj_consume_token(FOR);
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void EquationList() throws net.sourceforge.pmd.lang.ast.ParseException {
                      /*@bgen(jjtree) EquationList */
  ASTEquationList jjtn000 = new ASTEquationList(JJTEQUATIONLIST);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      label_14:
      while (true) {
        if (jj_2_16(2147483647)) {
          ;
        } else {
          break label_14;
        }
        Equation();
        jj_consume_token(SC);
      }
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void StatementList() throws net.sourceforge.pmd.lang.ast.ParseException {
                       /*@bgen(jjtree) StatementList */
  ASTStatementList jjtn000 = new ASTStatementList(JJTSTATEMENTLIST);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      label_15:
      while (true) {
        switch (jj_nt.kind) {
        case LPAREN:
        case DOT:
        case IF:
        case BREAK:
        case RETURN:
        case FOR:
        case WHILE:
        case WHEN:
        case IDENT:
          ;
          break;
        default:
          jj_la1[83] = jj_gen;
          break label_15;
        }
        Statement();
        jj_consume_token(SC);
      }
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void ForStatement() throws net.sourceforge.pmd.lang.ast.ParseException {
                      /*@bgen(jjtree) ForStatement */
  ASTForStatement jjtn000 = new ASTForStatement(JJTFORSTATEMENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      jj_consume_token(FOR);
      ForIndices();
      jj_consume_token(LOOP);
      StatementList();
      jj_consume_token(END);
      jj_consume_token(FOR);
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void ForIndices() throws net.sourceforge.pmd.lang.ast.ParseException {
                    /*@bgen(jjtree) ForIndices */
  ASTForIndices jjtn000 = new ASTForIndices(JJTFORINDICES);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      ForIndex();
      label_16:
      while (true) {
        switch (jj_nt.kind) {
        case COMMA:
          ;
          break;
        default:
          jj_la1[84] = jj_gen;
          break label_16;
        }
        jj_consume_token(COMMA);
        ForIndex();
      }
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void ForIndex() throws net.sourceforge.pmd.lang.ast.ParseException {
                  /*@bgen(jjtree) ForIndex */
  ASTForIndex jjtn000 = new ASTForIndex(JJTFORINDEX);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      SimpleName();
      switch (jj_nt.kind) {
      case IN:
        jj_consume_token(IN);
        Expression();
        break;
      default:
        jj_la1[85] = jj_gen;
        ;
      }
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void WhileStatement() throws net.sourceforge.pmd.lang.ast.ParseException {
                        /*@bgen(jjtree) WhileStatement */
  ASTWhileStatement jjtn000 = new ASTWhileStatement(JJTWHILESTATEMENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      jj_consume_token(WHILE);
      Expression();
      jj_consume_token(LOOP);
      StatementList();
      jj_consume_token(END);
      jj_consume_token(WHILE);
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void WhenEquation() throws net.sourceforge.pmd.lang.ast.ParseException {
                      /*@bgen(jjtree) WhenEquation */
  ASTWhenEquation jjtn000 = new ASTWhenEquation(JJTWHENEQUATION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      jj_consume_token(WHEN);
              ASTWhenClause jjtn001 = new ASTWhenClause(JJTWHENCLAUSE);
              boolean jjtc001 = true;
              jjtree.openNodeScope(jjtn001, getToken(1));
      try {
        Expression();
      } catch (Throwable jjte001) {
              if (jjtc001) {
                jjtree.clearNodeScope(jjtn001);
                jjtc001 = false;
              } else {
                jjtree.popNode();
              }
              if (jjte001 instanceof RuntimeException) {
                {if (true) throw (RuntimeException)jjte001;}
              }
              if (jjte001 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
                {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte001;}
              }
              {if (true) throw (Error)jjte001;}
      } finally {
              if (jjtc001) {
                jjtree.closeNodeScope(jjtn001, true, getToken(0));
              }
      }
      jj_consume_token(THEN);
              ASTThenClause jjtn002 = new ASTThenClause(JJTTHENCLAUSE);
              boolean jjtc002 = true;
              jjtree.openNodeScope(jjtn002, getToken(1));
      try {
        EquationList();
      } catch (Throwable jjte002) {
              if (jjtc002) {
                jjtree.clearNodeScope(jjtn002);
                jjtc002 = false;
              } else {
                jjtree.popNode();
              }
              if (jjte002 instanceof RuntimeException) {
                {if (true) throw (RuntimeException)jjte002;}
              }
              if (jjte002 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
                {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte002;}
              }
              {if (true) throw (Error)jjte002;}
      } finally {
              if (jjtc002) {
                jjtree.closeNodeScope(jjtn002, true, getToken(0));
              }
      }
      label_17:
      while (true) {
        switch (jj_nt.kind) {
        case ELSEWHEN:
          ;
          break;
        default:
          jj_la1[86] = jj_gen;
          break label_17;
        }
       ASTElseWhenClause jjtn003 = new ASTElseWhenClause(JJTELSEWHENCLAUSE);
       boolean jjtc003 = true;
       jjtree.openNodeScope(jjtn003, getToken(1));
        try {
          jj_consume_token(ELSEWHEN);
          Expression();
          jj_consume_token(THEN);
          EquationList();
        } catch (Throwable jjte003) {
       if (jjtc003) {
         jjtree.clearNodeScope(jjtn003);
         jjtc003 = false;
       } else {
         jjtree.popNode();
       }
       if (jjte003 instanceof RuntimeException) {
         {if (true) throw (RuntimeException)jjte003;}
       }
       if (jjte003 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
         {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte003;}
       }
       {if (true) throw (Error)jjte003;}
        } finally {
       if (jjtc003) {
         jjtree.closeNodeScope(jjtn003, true, getToken(0));
       }
        }
      }
      jj_consume_token(END);
      jj_consume_token(WHEN);
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void WhenStatement() throws net.sourceforge.pmd.lang.ast.ParseException {
                       /*@bgen(jjtree) WhenStatement */
  ASTWhenStatement jjtn000 = new ASTWhenStatement(JJTWHENSTATEMENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      jj_consume_token(WHEN);
              ASTWhenClause jjtn001 = new ASTWhenClause(JJTWHENCLAUSE);
              boolean jjtc001 = true;
              jjtree.openNodeScope(jjtn001, getToken(1));
      try {
        Expression();
      } catch (Throwable jjte001) {
              if (jjtc001) {
                jjtree.clearNodeScope(jjtn001);
                jjtc001 = false;
              } else {
                jjtree.popNode();
              }
              if (jjte001 instanceof RuntimeException) {
                {if (true) throw (RuntimeException)jjte001;}
              }
              if (jjte001 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
                {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte001;}
              }
              {if (true) throw (Error)jjte001;}
      } finally {
              if (jjtc001) {
                jjtree.closeNodeScope(jjtn001, true, getToken(0));
              }
      }
      jj_consume_token(THEN);
              ASTThenClause jjtn002 = new ASTThenClause(JJTTHENCLAUSE);
              boolean jjtc002 = true;
              jjtree.openNodeScope(jjtn002, getToken(1));
      try {
        StatementList();
      } catch (Throwable jjte002) {
              if (jjtc002) {
                jjtree.clearNodeScope(jjtn002);
                jjtc002 = false;
              } else {
                jjtree.popNode();
              }
              if (jjte002 instanceof RuntimeException) {
                {if (true) throw (RuntimeException)jjte002;}
              }
              if (jjte002 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
                {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte002;}
              }
              {if (true) throw (Error)jjte002;}
      } finally {
              if (jjtc002) {
                jjtree.closeNodeScope(jjtn002, true, getToken(0));
              }
      }
      label_18:
      while (true) {
        switch (jj_nt.kind) {
        case ELSEWHEN:
          ;
          break;
        default:
          jj_la1[87] = jj_gen;
          break label_18;
        }
       ASTElseWhenClause jjtn003 = new ASTElseWhenClause(JJTELSEWHENCLAUSE);
       boolean jjtc003 = true;
       jjtree.openNodeScope(jjtn003, getToken(1));
        try {
          jj_consume_token(ELSEWHEN);
          Expression();
          jj_consume_token(THEN);
          StatementList();
        } catch (Throwable jjte003) {
       if (jjtc003) {
         jjtree.clearNodeScope(jjtn003);
         jjtc003 = false;
       } else {
         jjtree.popNode();
       }
       if (jjte003 instanceof RuntimeException) {
         {if (true) throw (RuntimeException)jjte003;}
       }
       if (jjte003 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
         {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte003;}
       }
       {if (true) throw (Error)jjte003;}
        } finally {
       if (jjtc003) {
         jjtree.closeNodeScope(jjtn003, true, getToken(0));
       }
        }
      }
      jj_consume_token(END);
      jj_consume_token(WHEN);
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void ConnectClause() throws net.sourceforge.pmd.lang.ast.ParseException {
                       /*@bgen(jjtree) ConnectClause */
  ASTConnectClause jjtn000 = new ASTConnectClause(JJTCONNECTCLAUSE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      jj_consume_token(CONNECT);
      jj_consume_token(LPAREN);
      ComponentReference();
      jj_consume_token(COMMA);
      ComponentReference();
      jj_consume_token(RPAREN);
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void Expression() throws net.sourceforge.pmd.lang.ast.ParseException {
    switch (jj_nt.kind) {
    case LPAREN:
    case LCURL:
    case LSQUARE:
    case DOT:
    case END:
    case DER:
    case INITIAL:
    case NOT:
    case TRUE:
    case FALSE:
    case PLUS:
    case MINUS:
    case DOT_PLUS:
    case DOT_MINUS:
    case IDENT:
    case STRING:
    case UNSIGNED_NUMBER:
      SimpleExpression();
      break;
    case IF:
      IfExpression();
      break;
    default:
      jj_la1[88] = jj_gen;
      jj_consume_token(-1);
      throw net.sourceforge.pmd.util.AssertionUtil.shouldNotReachHere("consumetoken(-1) should have thrown");
    }
  }

  final public void IfExpression() throws net.sourceforge.pmd.lang.ast.ParseException {
                      /*@bgen(jjtree) IfExpression */
  ASTIfExpression jjtn000 = new ASTIfExpression(JJTIFEXPRESSION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
       ASTIfClause jjtn001 = new ASTIfClause(JJTIFCLAUSE);
       boolean jjtc001 = true;
       jjtree.openNodeScope(jjtn001, getToken(1));
      try {
        jj_consume_token(IF);
        Expression();
      } catch (Throwable jjte001) {
       if (jjtc001) {
         jjtree.clearNodeScope(jjtn001);
         jjtc001 = false;
       } else {
         jjtree.popNode();
       }
       if (jjte001 instanceof RuntimeException) {
         {if (true) throw (RuntimeException)jjte001;}
       }
       if (jjte001 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
         {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte001;}
       }
       {if (true) throw (Error)jjte001;}
      } finally {
       if (jjtc001) {
         jjtree.closeNodeScope(jjtn001, true, getToken(0));
       }
      }
       ASTThenClause jjtn002 = new ASTThenClause(JJTTHENCLAUSE);
       boolean jjtc002 = true;
       jjtree.openNodeScope(jjtn002, getToken(1));
      try {
        jj_consume_token(THEN);
        Expression();
      } catch (Throwable jjte002) {
       if (jjtc002) {
         jjtree.clearNodeScope(jjtn002);
         jjtc002 = false;
       } else {
         jjtree.popNode();
       }
       if (jjte002 instanceof RuntimeException) {
         {if (true) throw (RuntimeException)jjte002;}
       }
       if (jjte002 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
         {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte002;}
       }
       {if (true) throw (Error)jjte002;}
      } finally {
       if (jjtc002) {
         jjtree.closeNodeScope(jjtn002, true, getToken(0));
       }
      }
      label_19:
      while (true) {
        switch (jj_nt.kind) {
        case ELSEIF:
          ;
          break;
        default:
          jj_la1[89] = jj_gen;
          break label_19;
        }
       ASTElseIfClause jjtn003 = new ASTElseIfClause(JJTELSEIFCLAUSE);
       boolean jjtc003 = true;
       jjtree.openNodeScope(jjtn003, getToken(1));
        try {
          jj_consume_token(ELSEIF);
          Expression();
          jj_consume_token(THEN);
          Expression();
        } catch (Throwable jjte003) {
       if (jjtc003) {
         jjtree.clearNodeScope(jjtn003);
         jjtc003 = false;
       } else {
         jjtree.popNode();
       }
       if (jjte003 instanceof RuntimeException) {
         {if (true) throw (RuntimeException)jjte003;}
       }
       if (jjte003 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
         {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte003;}
       }
       {if (true) throw (Error)jjte003;}
        } finally {
       if (jjtc003) {
         jjtree.closeNodeScope(jjtn003, true, getToken(0));
       }
        }
      }
       ASTElseClause jjtn004 = new ASTElseClause(JJTELSECLAUSE);
       boolean jjtc004 = true;
       jjtree.openNodeScope(jjtn004, getToken(1));
      try {
        jj_consume_token(ELSE);
        Expression();
      } catch (Throwable jjte004) {
       if (jjtc004) {
         jjtree.clearNodeScope(jjtn004);
         jjtc004 = false;
       } else {
         jjtree.popNode();
       }
       if (jjte004 instanceof RuntimeException) {
         {if (true) throw (RuntimeException)jjte004;}
       }
       if (jjte004 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
         {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte004;}
       }
       {if (true) throw (Error)jjte004;}
      } finally {
       if (jjtc004) {
         jjtree.closeNodeScope(jjtn004, true, getToken(0));
       }
      }
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void SimpleExpression() throws net.sourceforge.pmd.lang.ast.ParseException {
                                                /*@bgen(jjtree) #SimpleExpression(> 1) */
  ASTSimpleExpression jjtn000 = new ASTSimpleExpression(JJTSIMPLEEXPRESSION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      LogicalExpression();
      switch (jj_nt.kind) {
      case COLON:
        jj_consume_token(COLON);
        LogicalExpression();
        switch (jj_nt.kind) {
        case COLON:
          jj_consume_token(COLON);
          LogicalExpression();
          break;
        default:
          jj_la1[90] = jj_gen;
          ;
        }
        break;
      default:
        jj_la1[91] = jj_gen;
        ;
      }
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1, getToken(0));
      }
    }
  }

  final public void LogicalExpression() throws net.sourceforge.pmd.lang.ast.ParseException {
                                                  /*@bgen(jjtree) #LogicalExpression(> 1) */
  ASTLogicalExpression jjtn000 = new ASTLogicalExpression(JJTLOGICALEXPRESSION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      LogicalTerm();
      label_20:
      while (true) {
        switch (jj_nt.kind) {
        case OR:
          ;
          break;
        default:
          jj_la1[92] = jj_gen;
          break label_20;
        }
        jj_consume_token(OR);
        LogicalTerm();
      }
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1, getToken(0));
      }
    }
  }

  final public void LogicalTerm() throws net.sourceforge.pmd.lang.ast.ParseException {
                                      /*@bgen(jjtree) #LogicalTerm(> 1) */
  ASTLogicalTerm jjtn000 = new ASTLogicalTerm(JJTLOGICALTERM);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      LogicalFactor();
      label_21:
      while (true) {
        switch (jj_nt.kind) {
        case AND:
          ;
          break;
        default:
          jj_la1[93] = jj_gen;
          break label_21;
        }
        jj_consume_token(AND);
        LogicalFactor();
      }
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1, getToken(0));
      }
    }
  }

  final public void LogicalFactor() throws net.sourceforge.pmd.lang.ast.ParseException {
    switch (jj_nt.kind) {
    case NOT:
        ASTNegated jjtn001 = new ASTNegated(JJTNEGATED);
        boolean jjtc001 = true;
        jjtree.openNodeScope(jjtn001, getToken(1));
      try {
        jj_consume_token(NOT);
        Relation();
      } catch (Throwable jjte001) {
        if (jjtc001) {
          jjtree.clearNodeScope(jjtn001);
          jjtc001 = false;
        } else {
          jjtree.popNode();
        }
        if (jjte001 instanceof RuntimeException) {
          {if (true) throw (RuntimeException)jjte001;}
        }
        if (jjte001 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
          {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte001;}
        }
        {if (true) throw (Error)jjte001;}
      } finally {
        if (jjtc001) {
          jjtree.closeNodeScope(jjtn001, true, getToken(0));
        }
      }
      break;
    case LPAREN:
    case LCURL:
    case LSQUARE:
    case DOT:
    case END:
    case DER:
    case INITIAL:
    case TRUE:
    case FALSE:
    case PLUS:
    case MINUS:
    case DOT_PLUS:
    case DOT_MINUS:
    case IDENT:
    case STRING:
    case UNSIGNED_NUMBER:
      Relation();
      break;
    default:
      jj_la1[94] = jj_gen;
      jj_consume_token(-1);
      throw net.sourceforge.pmd.util.AssertionUtil.shouldNotReachHere("consumetoken(-1) should have thrown");
    }
  }

  final public void Relation() throws net.sourceforge.pmd.lang.ast.ParseException {
                                /*@bgen(jjtree) #Relation(> 1) */
  ASTRelation jjtn000 = new ASTRelation(JJTRELATION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      ArithmeticExpression();
      switch (jj_nt.kind) {
      case LT:
      case LE:
      case GT:
      case GE:
      case EQ:
      case NEQ:
        RelOp();
        ArithmeticExpression();
        break;
      default:
        jj_la1[95] = jj_gen;
        ;
      }
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1, getToken(0));
      }
    }
  }

  final public void RelOp() throws net.sourceforge.pmd.lang.ast.ParseException {
               /*@bgen(jjtree) RelOp */
  ASTRelOp jjtn000 = new ASTRelOp(JJTRELOP);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      switch (jj_nt.kind) {
      case LT:
        jj_consume_token(LT);
           jjtree.closeNodeScope(jjtn000, true, getToken(0));
           jjtc000 = false;
           jjtn000.setOperator("<");
        break;
      case LE:
        jj_consume_token(LE);
           jjtree.closeNodeScope(jjtn000, true, getToken(0));
           jjtc000 = false;
           jjtn000.setOperator("<=");
        break;
      case GT:
        jj_consume_token(GT);
           jjtree.closeNodeScope(jjtn000, true, getToken(0));
           jjtc000 = false;
           jjtn000.setOperator(">");
        break;
      case GE:
        jj_consume_token(GE);
           jjtree.closeNodeScope(jjtn000, true, getToken(0));
           jjtc000 = false;
           jjtn000.setOperator(">=");
        break;
      case EQ:
        jj_consume_token(EQ);
           jjtree.closeNodeScope(jjtn000, true, getToken(0));
           jjtc000 = false;
           jjtn000.setOperator("==");
        break;
      case NEQ:
        jj_consume_token(NEQ);
            jjtree.closeNodeScope(jjtn000, true, getToken(0));
            jjtc000 = false;
            jjtn000.setOperator("<>");
        break;
      default:
        jj_la1[96] = jj_gen;
        jj_consume_token(-1);
        throw net.sourceforge.pmd.util.AssertionUtil.shouldNotReachHere("consumetoken(-1) should have thrown");
      }
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void ArithmeticExpression() throws net.sourceforge.pmd.lang.ast.ParseException {
                                                        /*@bgen(jjtree) #ArithmeticExpression(> 1) */
  ASTArithmeticExpression jjtn000 = new ASTArithmeticExpression(JJTARITHMETICEXPRESSION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      switch (jj_nt.kind) {
      case PLUS:
      case MINUS:
      case DOT_PLUS:
      case DOT_MINUS:
        AddOp();
        break;
      default:
        jj_la1[97] = jj_gen;
        ;
      }
      Term();
      label_22:
      while (true) {
        switch (jj_nt.kind) {
        case PLUS:
        case MINUS:
        case DOT_PLUS:
        case DOT_MINUS:
          ;
          break;
        default:
          jj_la1[98] = jj_gen;
          break label_22;
        }
        AddOp();
        Term();
      }
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1, getToken(0));
      }
    }
  }

  final public void AddOp() throws net.sourceforge.pmd.lang.ast.ParseException {
               /*@bgen(jjtree) AddOp */
  ASTAddOp jjtn000 = new ASTAddOp(JJTADDOP);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      switch (jj_nt.kind) {
      case PLUS:
        jj_consume_token(PLUS);
               jjtree.closeNodeScope(jjtn000, true, getToken(0));
               jjtc000 = false;
               jjtn000.setOperator("+");
        break;
      case MINUS:
        jj_consume_token(MINUS);
                jjtree.closeNodeScope(jjtn000, true, getToken(0));
                jjtc000 = false;
                jjtn000.setOperator("-");
        break;
      case DOT_PLUS:
        jj_consume_token(DOT_PLUS);
                   jjtree.closeNodeScope(jjtn000, true, getToken(0));
                   jjtc000 = false;
                   jjtn000.setOperator(".+");
        break;
      case DOT_MINUS:
        jj_consume_token(DOT_MINUS);
                   jjtree.closeNodeScope(jjtn000, true, getToken(0));
                   jjtc000 = false;
                   jjtn000.setOperator(".-");
        break;
      default:
        jj_la1[99] = jj_gen;
        jj_consume_token(-1);
        throw net.sourceforge.pmd.util.AssertionUtil.shouldNotReachHere("consumetoken(-1) should have thrown");
      }
    } finally {
        if (jjtc000) {
          jjtree.closeNodeScope(jjtn000, true, getToken(0));
        }
    }
  }

  final public void Term() throws net.sourceforge.pmd.lang.ast.ParseException {
                        /*@bgen(jjtree) #Term(> 1) */
  ASTTerm jjtn000 = new ASTTerm(JJTTERM);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      Factor();
      label_23:
      while (true) {
        switch (jj_nt.kind) {
        case ASTERISK:
        case SLASH:
        case DOT_ASTERISK:
        case DOT_SLASH:
          ;
          break;
        default:
          jj_la1[100] = jj_gen;
          break label_23;
        }
        MulOp();
        Factor();
      }
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1, getToken(0));
      }
    }
  }

  final public void MulOp() throws net.sourceforge.pmd.lang.ast.ParseException {
               /*@bgen(jjtree) MulOp */
  ASTMulOp jjtn000 = new ASTMulOp(JJTMULOP);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      switch (jj_nt.kind) {
      case ASTERISK:
        jj_consume_token(ASTERISK);
                       jjtree.closeNodeScope(jjtn000, true, getToken(0));
                       jjtc000 = false;
                       jjtn000.setOperator("*");
        break;
      case SLASH:
        jj_consume_token(SLASH);
                       jjtree.closeNodeScope(jjtn000, true, getToken(0));
                       jjtc000 = false;
                       jjtn000.setOperator("/");
        break;
      case DOT_ASTERISK:
        jj_consume_token(DOT_ASTERISK);
                       jjtree.closeNodeScope(jjtn000, true, getToken(0));
                       jjtc000 = false;
                       jjtn000.setOperator(".*");
        break;
      case DOT_SLASH:
        jj_consume_token(DOT_SLASH);
                       jjtree.closeNodeScope(jjtn000, true, getToken(0));
                       jjtc000 = false;
                       jjtn000.setOperator("./");
        break;
      default:
        jj_la1[101] = jj_gen;
        jj_consume_token(-1);
        throw net.sourceforge.pmd.util.AssertionUtil.shouldNotReachHere("consumetoken(-1) should have thrown");
      }
    } finally {
        if (jjtc000) {
          jjtree.closeNodeScope(jjtn000, true, getToken(0));
        }
    }
  }

  final public void Factor() throws net.sourceforge.pmd.lang.ast.ParseException {
                            /*@bgen(jjtree) #Factor(> 1) */
  ASTFactor jjtn000 = new ASTFactor(JJTFACTOR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      Primary();
      switch (jj_nt.kind) {
      case HAT:
      case DOT_HAT:
        switch (jj_nt.kind) {
        case HAT:
          jj_consume_token(HAT);
                          jjtn000.setOperator("^");
          break;
        case DOT_HAT:
          jj_consume_token(DOT_HAT);
                          jjtn000.setOperator(".^");
          break;
        default:
          jj_la1[102] = jj_gen;
          jj_consume_token(-1);
          throw net.sourceforge.pmd.util.AssertionUtil.shouldNotReachHere("consumetoken(-1) should have thrown");
        }
        Primary();
        break;
      default:
        jj_la1[103] = jj_gen;
        ;
      }
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1, getToken(0));
      }
    }
  }

  final public void Primary() throws net.sourceforge.pmd.lang.ast.ParseException {
    switch (jj_nt.kind) {
    case UNSIGNED_NUMBER:
      NumberLiteral();
      break;
    case STRING:
      StringLiteral();
      break;
    case FALSE:
        ASTFalseLiteral jjtn001 = new ASTFalseLiteral(JJTFALSELITERAL);
        boolean jjtc001 = true;
        jjtree.openNodeScope(jjtn001, getToken(1));
      try {
        jj_consume_token(FALSE);
      } finally {
        if (jjtc001) {
          jjtree.closeNodeScope(jjtn001, true, getToken(0));
        }
      }
      break;
    case TRUE:
        ASTTrueLiteral jjtn002 = new ASTTrueLiteral(JJTTRUELITERAL);
        boolean jjtc002 = true;
        jjtree.openNodeScope(jjtn002, getToken(1));
      try {
        jj_consume_token(TRUE);
      } finally {
        if (jjtc002) {
          jjtree.closeNodeScope(jjtn002, true, getToken(0));
        }
      }
      break;
    default:
      jj_la1[106] = jj_gen;
      if (jj_2_17(2147483647)) {
                                                                                  ASTFunctionInvocation jjtn005 = new ASTFunctionInvocation(JJTFUNCTIONINVOCATION);
                                                                                  boolean jjtc005 = true;
                                                                                  jjtree.openNodeScope(jjtn005, getToken(1));
        try {
          switch (jj_nt.kind) {
          case DOT:
          case IDENT:
            Name();
            break;
          case DER:
                                                                                              ASTDerClause jjtn003 = new ASTDerClause(JJTDERCLAUSE);
                                                                                              boolean jjtc003 = true;
                                                                                              jjtree.openNodeScope(jjtn003, getToken(1));
            try {
              jj_consume_token(DER);
            } finally {
                                                                                              if (jjtc003) {
                                                                                                jjtree.closeNodeScope(jjtn003, true, getToken(0));
                                                                                              }
            }
            break;
          case INITIAL:
                                                                                                                 ASTInitialClause jjtn004 = new ASTInitialClause(JJTINITIALCLAUSE);
                                                                                                                 boolean jjtc004 = true;
                                                                                                                 jjtree.openNodeScope(jjtn004, getToken(1));
            try {
              jj_consume_token(INITIAL);
            } finally {
                                                                                                                 if (jjtc004) {
                                                                                                                   jjtree.closeNodeScope(jjtn004, true, getToken(0));
                                                                                                                 }
            }
            break;
          default:
            jj_la1[104] = jj_gen;
            jj_consume_token(-1);
            throw net.sourceforge.pmd.util.AssertionUtil.shouldNotReachHere("consumetoken(-1) should have thrown");
          }
          FunctionCallArgs();
        } catch (Throwable jjte005) {
                                                                                  if (jjtc005) {
                                                                                    jjtree.clearNodeScope(jjtn005);
                                                                                    jjtc005 = false;
                                                                                  } else {
                                                                                    jjtree.popNode();
                                                                                  }
                                                                                  if (jjte005 instanceof RuntimeException) {
                                                                                    {if (true) throw (RuntimeException)jjte005;}
                                                                                  }
                                                                                  if (jjte005 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
                                                                                    {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte005;}
                                                                                  }
                                                                                  {if (true) throw (Error)jjte005;}
        } finally {
                                                                                  if (jjtc005) {
                                                                                    jjtree.closeNodeScope(jjtn005, true, getToken(0));
                                                                                  }
        }
      } else {
        switch (jj_nt.kind) {
        case DOT:
        case IDENT:
          ComponentReference();
          break;
        case LPAREN:
          jj_consume_token(LPAREN);
          OutputExpressionList();
          jj_consume_token(RPAREN);
          break;
        case LSQUARE:
        ASTListOfExpressionLists jjtn006 = new ASTListOfExpressionLists(JJTLISTOFEXPRESSIONLISTS);
        boolean jjtc006 = true;
        jjtree.openNodeScope(jjtn006, getToken(1));
          try {
            jj_consume_token(LSQUARE);
            ExpressionList();
            label_24:
            while (true) {
              switch (jj_nt.kind) {
              case SC:
                ;
                break;
              default:
                jj_la1[105] = jj_gen;
                break label_24;
              }
              jj_consume_token(SC);
              ExpressionList();
            }
            jj_consume_token(RSQUARE);
          } catch (Throwable jjte006) {
        if (jjtc006) {
          jjtree.clearNodeScope(jjtn006);
          jjtc006 = false;
        } else {
          jjtree.popNode();
        }
        if (jjte006 instanceof RuntimeException) {
          {if (true) throw (RuntimeException)jjte006;}
        }
        if (jjte006 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
          {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte006;}
        }
        {if (true) throw (Error)jjte006;}
          } finally {
        if (jjtc006) {
          jjtree.closeNodeScope(jjtn006, true, getToken(0));
        }
          }
          break;
        case LCURL:
          jj_consume_token(LCURL);
          FunctionArguments();
          jj_consume_token(RCURL);
          break;
        case END:
          jj_consume_token(END);
          break;
        default:
          jj_la1[107] = jj_gen;
          jj_consume_token(-1);
          throw net.sourceforge.pmd.util.AssertionUtil.shouldNotReachHere("consumetoken(-1) should have thrown");
        }
      }
    }
  }

  final public void NumberLiteral() throws net.sourceforge.pmd.lang.ast.ParseException {
 /*@bgen(jjtree) NumberLiteral */
    ASTNumberLiteral jjtn000 = new ASTNumberLiteral(JJTNUMBERLITERAL);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000, getToken(1));net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken t;
    try {
      t = jj_consume_token(UNSIGNED_NUMBER);
      jjtree.closeNodeScope(jjtn000, true, getToken(0));
      jjtc000 = false;
      jjtn000.setValue(t.getImage());
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void StringLiteral() throws net.sourceforge.pmd.lang.ast.ParseException {
 /*@bgen(jjtree) StringLiteral */
    ASTStringLiteral jjtn000 = new ASTStringLiteral(JJTSTRINGLITERAL);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000, getToken(1));net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken t;
    try {
      t = jj_consume_token(STRING);
      jjtree.closeNodeScope(jjtn000, true, getToken(0));
      jjtc000 = false;
      jjtn000.setValue(t.getImage());
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void Name() throws net.sourceforge.pmd.lang.ast.ParseException {
              /*@bgen(jjtree) Name */
  ASTName jjtn000 = new ASTName(JJTNAME);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      switch (jj_nt.kind) {
      case DOT:
        jj_consume_token(DOT);
             jjtn000.markAbsolute();
        break;
      default:
        jj_la1[108] = jj_gen;
        ;
      }
      SimpleName();
      label_25:
      while (true) {
        if (jj_2_18(2)) {
          ;
        } else {
          break label_25;
        }
        jj_consume_token(DOT);
        SimpleName();
      }
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void SimpleName() throws net.sourceforge.pmd.lang.ast.ParseException {
 /*@bgen(jjtree) SimpleName */
    ASTSimpleName jjtn000 = new ASTSimpleName(JJTSIMPLENAME);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000, getToken(1));net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken t;
    try {
      t = jj_consume_token(IDENT);
      jjtree.closeNodeScope(jjtn000, true, getToken(0));
      jjtc000 = false;
      jjtn000.setName(t.getImage());
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void SubscriptedName() throws net.sourceforge.pmd.lang.ast.ParseException {
                         /*@bgen(jjtree) SubscriptedName */
  ASTSubscriptedName jjtn000 = new ASTSubscriptedName(JJTSUBSCRIPTEDNAME);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      SimpleName();
      switch (jj_nt.kind) {
      case LSQUARE:
        ArraySubscripts();
        break;
      default:
        jj_la1[109] = jj_gen;
        ;
      }
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void ComponentReference() throws net.sourceforge.pmd.lang.ast.ParseException {
                            /*@bgen(jjtree) ComponentReference */
  ASTComponentReference jjtn000 = new ASTComponentReference(JJTCOMPONENTREFERENCE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      switch (jj_nt.kind) {
      case DOT:
        jj_consume_token(DOT);
             jjtn000.markAbsolute();
        break;
      default:
        jj_la1[110] = jj_gen;
        ;
      }
      SubscriptedName();
      label_26:
      while (true) {
        switch (jj_nt.kind) {
        case DOT:
          ;
          break;
        default:
          jj_la1[111] = jj_gen;
          break label_26;
        }
        jj_consume_token(DOT);
        SubscriptedName();
      }
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void FunctionCallArgs() throws net.sourceforge.pmd.lang.ast.ParseException {
                          /*@bgen(jjtree) FunctionCallArgs */
  ASTFunctionCallArgs jjtn000 = new ASTFunctionCallArgs(JJTFUNCTIONCALLARGS);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      jj_consume_token(LPAREN);
      switch (jj_nt.kind) {
      case LPAREN:
      case LCURL:
      case LSQUARE:
      case DOT:
      case FUNCTION:
      case END:
      case DER:
      case IF:
      case INITIAL:
      case NOT:
      case TRUE:
      case FALSE:
      case PLUS:
      case MINUS:
      case DOT_PLUS:
      case DOT_MINUS:
      case IDENT:
      case STRING:
      case UNSIGNED_NUMBER:
        FunctionArguments();
        break;
      default:
        jj_la1[112] = jj_gen;
        ;
      }
      jj_consume_token(RPAREN);
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void FunctionArguments() throws net.sourceforge.pmd.lang.ast.ParseException {
                           /*@bgen(jjtree) FunctionArguments */
  ASTFunctionArguments jjtn000 = new ASTFunctionArguments(JJTFUNCTIONARGUMENTS);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      if (jj_2_19(2)) {
        NamedArguments();
      } else {
        switch (jj_nt.kind) {
        case LPAREN:
        case LCURL:
        case LSQUARE:
        case DOT:
        case FUNCTION:
        case END:
        case DER:
        case IF:
        case INITIAL:
        case NOT:
        case TRUE:
        case FALSE:
        case PLUS:
        case MINUS:
        case DOT_PLUS:
        case DOT_MINUS:
        case IDENT:
        case STRING:
        case UNSIGNED_NUMBER:
          FunctionArgument();
          switch (jj_nt.kind) {
          case COMMA:
          case FOR:
            switch (jj_nt.kind) {
            case COMMA:
              jj_consume_token(COMMA);
              FunctionArguments();
              break;
            case FOR:
              jj_consume_token(FOR);
              ForIndices();
              break;
            default:
              jj_la1[113] = jj_gen;
              jj_consume_token(-1);
              throw net.sourceforge.pmd.util.AssertionUtil.shouldNotReachHere("consumetoken(-1) should have thrown");
            }
            break;
          default:
            jj_la1[114] = jj_gen;
            ;
          }
          break;
        default:
          jj_la1[115] = jj_gen;
          jj_consume_token(-1);
          throw net.sourceforge.pmd.util.AssertionUtil.shouldNotReachHere("consumetoken(-1) should have thrown");
        }
      }
    } catch (Throwable jjte000) {
        if (jjtc000) {
          jjtree.clearNodeScope(jjtn000);
          jjtc000 = false;
        } else {
          jjtree.popNode();
        }
        if (jjte000 instanceof RuntimeException) {
          {if (true) throw (RuntimeException)jjte000;}
        }
        if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
          {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
        }
        {if (true) throw (Error)jjte000;}
    } finally {
        if (jjtc000) {
          jjtree.closeNodeScope(jjtn000, true, getToken(0));
        }
    }
  }

  final public void NamedArguments() throws net.sourceforge.pmd.lang.ast.ParseException {
                        /*@bgen(jjtree) NamedArguments */
  ASTNamedArguments jjtn000 = new ASTNamedArguments(JJTNAMEDARGUMENTS);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      NamedArgument();
      switch (jj_nt.kind) {
      case COMMA:
        jj_consume_token(COMMA);
        NamedArguments();
        break;
      default:
        jj_la1[116] = jj_gen;
        ;
      }
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void NamedArgument() throws net.sourceforge.pmd.lang.ast.ParseException {
                       /*@bgen(jjtree) NamedArgument */
  ASTNamedArgument jjtn000 = new ASTNamedArgument(JJTNAMEDARGUMENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      SimpleName();
      jj_consume_token(EQ_SIGN);
      FunctionArgument();
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void FunctionArgument() throws net.sourceforge.pmd.lang.ast.ParseException {
                          /*@bgen(jjtree) FunctionArgument */
  ASTFunctionArgument jjtn000 = new ASTFunctionArgument(JJTFUNCTIONARGUMENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      switch (jj_nt.kind) {
      case FUNCTION:
        jj_consume_token(FUNCTION);
        Name();
        jj_consume_token(LPAREN);
        switch (jj_nt.kind) {
        case IDENT:
          NamedArguments();
          break;
        default:
          jj_la1[117] = jj_gen;
          ;
        }
        jj_consume_token(RPAREN);
        break;
      case LPAREN:
      case LCURL:
      case LSQUARE:
      case DOT:
      case END:
      case DER:
      case IF:
      case INITIAL:
      case NOT:
      case TRUE:
      case FALSE:
      case PLUS:
      case MINUS:
      case DOT_PLUS:
      case DOT_MINUS:
      case IDENT:
      case STRING:
      case UNSIGNED_NUMBER:
        Expression();
        break;
      default:
        jj_la1[118] = jj_gen;
        jj_consume_token(-1);
        throw net.sourceforge.pmd.util.AssertionUtil.shouldNotReachHere("consumetoken(-1) should have thrown");
      }
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void OutputExpressionList() throws net.sourceforge.pmd.lang.ast.ParseException {
                              /*@bgen(jjtree) OutputExpressionList */
  ASTOutputExpressionList jjtn000 = new ASTOutputExpressionList(JJTOUTPUTEXPRESSIONLIST);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      switch (jj_nt.kind) {
      case LPAREN:
      case LCURL:
      case LSQUARE:
      case DOT:
      case END:
      case DER:
      case IF:
      case INITIAL:
      case NOT:
      case TRUE:
      case FALSE:
      case PLUS:
      case MINUS:
      case DOT_PLUS:
      case DOT_MINUS:
      case IDENT:
      case STRING:
      case UNSIGNED_NUMBER:
        Expression();
        break;
      default:
        jj_la1[119] = jj_gen;
        ;
      }
      label_27:
      while (true) {
        switch (jj_nt.kind) {
        case COMMA:
          ;
          break;
        default:
          jj_la1[120] = jj_gen;
          break label_27;
        }
        jj_consume_token(COMMA);
        switch (jj_nt.kind) {
        case LPAREN:
        case LCURL:
        case LSQUARE:
        case DOT:
        case END:
        case DER:
        case IF:
        case INITIAL:
        case NOT:
        case TRUE:
        case FALSE:
        case PLUS:
        case MINUS:
        case DOT_PLUS:
        case DOT_MINUS:
        case IDENT:
        case STRING:
        case UNSIGNED_NUMBER:
          Expression();
          break;
        default:
          jj_la1[121] = jj_gen;
          ;
        }
      }
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void ExpressionList() throws net.sourceforge.pmd.lang.ast.ParseException {
                        /*@bgen(jjtree) ExpressionList */
  ASTExpressionList jjtn000 = new ASTExpressionList(JJTEXPRESSIONLIST);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      Expression();
      label_28:
      while (true) {
        switch (jj_nt.kind) {
        case COMMA:
          ;
          break;
        default:
          jj_la1[122] = jj_gen;
          break label_28;
        }
        jj_consume_token(COMMA);
        Expression();
      }
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void ArraySubscripts() throws net.sourceforge.pmd.lang.ast.ParseException {
                         /*@bgen(jjtree) ArraySubscripts */
  ASTArraySubscripts jjtn000 = new ASTArraySubscripts(JJTARRAYSUBSCRIPTS);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      jj_consume_token(LSQUARE);
      Subscript();
      label_29:
      while (true) {
        switch (jj_nt.kind) {
        case COMMA:
          ;
          break;
        default:
          jj_la1[123] = jj_gen;
          break label_29;
        }
        jj_consume_token(COMMA);
        Subscript();
      }
      jj_consume_token(RSQUARE);
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void Subscript() throws net.sourceforge.pmd.lang.ast.ParseException {
                   /*@bgen(jjtree) Subscript */
  ASTSubscript jjtn000 = new ASTSubscript(JJTSUBSCRIPT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      switch (jj_nt.kind) {
      case COLON:
        ASTColonSubsript jjtn001 = new ASTColonSubsript(JJTCOLONSUBSRIPT);
        boolean jjtc001 = true;
        jjtree.openNodeScope(jjtn001, getToken(1));
        try {
          jj_consume_token(COLON);
        } finally {
        if (jjtc001) {
          jjtree.closeNodeScope(jjtn001, true, getToken(0));
        }
        }
        break;
      case LPAREN:
      case LCURL:
      case LSQUARE:
      case DOT:
      case END:
      case DER:
      case IF:
      case INITIAL:
      case NOT:
      case TRUE:
      case FALSE:
      case PLUS:
      case MINUS:
      case DOT_PLUS:
      case DOT_MINUS:
      case IDENT:
      case STRING:
      case UNSIGNED_NUMBER:
        Expression();
        break;
      default:
        jj_la1[124] = jj_gen;
        jj_consume_token(-1);
        throw net.sourceforge.pmd.util.AssertionUtil.shouldNotReachHere("consumetoken(-1) should have thrown");
      }
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void Comment() throws net.sourceforge.pmd.lang.ast.ParseException {
                 /*@bgen(jjtree) Comment */
  ASTComment jjtn000 = new ASTComment(JJTCOMMENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      StringComment();
      switch (jj_nt.kind) {
      case ANNOTATION:
        Annotation();
        break;
      default:
        jj_la1[125] = jj_gen;
        ;
      }
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  final public void StringComment() throws net.sourceforge.pmd.lang.ast.ParseException {
 /*@bgen(jjtree) #StringComment( ! skip) */
    ASTStringComment jjtn000 = new ASTStringComment(JJTSTRINGCOMMENT);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000, getToken(1));boolean skip = true;
    StringBuilder sb = new StringBuilder();
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken t;
    try {
      switch (jj_nt.kind) {
      case STRING:
        t = jj_consume_token(STRING);
          sb.append(t);
        label_30:
        while (true) {
          switch (jj_nt.kind) {
          case PLUS:
            ;
            break;
          default:
            jj_la1[126] = jj_gen;
            break label_30;
          }
          jj_consume_token(PLUS);
          t = jj_consume_token(STRING);
                               sb.append(t);
        }
        skip = false;
        break;
      default:
        jj_la1[127] = jj_gen;
        ;
      }
      jjtree.closeNodeScope(jjtn000,  ! skip, getToken(0));
      jjtc000 = false;
      jjtn000.setComment(sb.toString());
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000,  ! skip, getToken(0));
      }
    }
  }

  final public void Annotation() throws net.sourceforge.pmd.lang.ast.ParseException {
                    /*@bgen(jjtree) Annotation */
  ASTAnnotation jjtn000 = new ASTAnnotation(JJTANNOTATION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000, getToken(1));
    try {
      jj_consume_token(ANNOTATION);
      ClassModification();
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof net.sourceforge.pmd.lang.ast.ParseException) {
        {if (true) throw (net.sourceforge.pmd.lang.ast.ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true, getToken(0));
      }
    }
  }

  private boolean jj_2_1(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_1(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(0, xla); }
  }

  private boolean jj_2_2(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_2(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(1, xla); }
  }

  private boolean jj_2_3(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_3(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(2, xla); }
  }

  private boolean jj_2_4(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_4(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(3, xla); }
  }

  private boolean jj_2_5(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_5(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(4, xla); }
  }

  private boolean jj_2_6(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_6(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(5, xla); }
  }

  private boolean jj_2_7(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_7(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(6, xla); }
  }

  private boolean jj_2_8(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_8(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(7, xla); }
  }

  private boolean jj_2_9(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_9(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(8, xla); }
  }

  private boolean jj_2_10(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_10(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(9, xla); }
  }

  private boolean jj_2_11(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_11(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(10, xla); }
  }

  private boolean jj_2_12(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_12(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(11, xla); }
  }

  private boolean jj_2_13(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_13(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(12, xla); }
  }

  private boolean jj_2_14(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_14(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(13, xla); }
  }

  private boolean jj_2_15(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_15(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(14, xla); }
  }

  private boolean jj_2_16(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_16(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(15, xla); }
  }

  private boolean jj_2_17(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_17(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(16, xla); }
  }

  private boolean jj_2_18(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_18(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(17, xla); }
  }

  private boolean jj_2_19(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_19(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(18, xla); }
  }

  private boolean jj_3R_155() {
    if (jj_3R_169()) return true;
    if (jj_3R_154()) return true;
    return false;
  }

  private boolean jj_3R_163() {
    if (jj_scan_token(OUTER)) return true;
    return false;
  }

  private boolean jj_3R_162() {
    if (jj_scan_token(INNER)) return true;
    return false;
  }

  private boolean jj_3R_141() {
    if (jj_3R_154()) return true;
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_155()) jj_scanpos = xsp;
    return false;
  }

  private boolean jj_3R_161() {
    if (jj_scan_token(FINAL)) return true;
    return false;
  }

  private boolean jj_3R_160() {
    if (jj_scan_token(REDECLARE)) return true;
    return false;
  }

  private boolean jj_3R_131() {
    if (jj_3R_141()) return true;
    return false;
  }

  private boolean jj_3R_153() {
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_160()) jj_scanpos = xsp;
    xsp = jj_scanpos;
    if (jj_3R_161()) jj_scanpos = xsp;
    xsp = jj_scanpos;
    if (jj_3R_162()) jj_scanpos = xsp;
    xsp = jj_scanpos;
    if (jj_3R_163()) jj_scanpos = xsp;
    xsp = jj_scanpos;
    if (jj_3R_164()) {
    jj_scanpos = xsp;
    if (jj_3R_165()) return true;
    }
    return false;
  }

  private boolean jj_3R_113() {
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_130()) {
    jj_scanpos = xsp;
    if (jj_3R_131()) return true;
    }
    return false;
  }

  private boolean jj_3R_130() {
    if (jj_scan_token(NOT)) return true;
    if (jj_3R_141()) return true;
    return false;
  }

  private boolean jj_3R_152() {
    if (jj_3R_159()) return true;
    return false;
  }

  private boolean jj_3R_140() {
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_151()) {
    jj_scanpos = xsp;
    if (jj_3R_152()) {
    jj_scanpos = xsp;
    if (jj_3R_153()) return true;
    }
    }
    return false;
  }

  private boolean jj_3R_151() {
    if (jj_3R_158()) return true;
    return false;
  }

  private boolean jj_3R_114() {
    if (jj_scan_token(AND)) return true;
    if (jj_3R_113()) return true;
    return false;
  }

  private boolean jj_3R_122() {
    if (jj_3R_140()) return true;
    return false;
  }

  private boolean jj_3R_84() {
    if (jj_3R_113()) return true;
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    while (true) {
      xsp = jj_scanpos;
      if (jj_3R_114()) { jj_scanpos = xsp; break; }
    }
    return false;
  }

  private boolean jj_3R_91() {
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    while (true) {
      xsp = jj_scanpos;
      if (jj_3R_122()) { jj_scanpos = xsp; break; }
    }
    return false;
  }

  private boolean jj_3R_85() {
    if (jj_scan_token(OR)) return true;
    if (jj_3R_84()) return true;
    return false;
  }

  private boolean jj_3R_66() {
    if (jj_3R_84()) return true;
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    while (true) {
      xsp = jj_scanpos;
      if (jj_3R_85()) { jj_scanpos = xsp; break; }
    }
    return false;
  }

  private boolean jj_3R_86() {
    if (jj_scan_token(COLON)) return true;
    if (jj_3R_66()) return true;
    return false;
  }

  private boolean jj_3_9() {
    if (jj_3R_40()) return true;
    if (jj_scan_token(EQ_SIGN)) return true;
    return false;
  }

  private boolean jj_3R_67() {
    if (jj_scan_token(COLON)) return true;
    if (jj_3R_66()) return true;
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_86()) jj_scanpos = xsp;
    return false;
  }

  private boolean jj_3R_43() {
    if (jj_3R_66()) return true;
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_67()) jj_scanpos = xsp;
    return false;
  }

  private boolean jj_3R_115() {
    if (jj_scan_token(ELSEIF)) return true;
    if (jj_3R_44()) return true;
    if (jj_scan_token(THEN)) return true;
    if (jj_3R_44()) return true;
    return false;
  }

  private boolean jj_3R_94() {
    if (jj_3R_120()) return true;
    return false;
  }

  private boolean jj_3R_87() {
    if (jj_scan_token(IF)) return true;
    if (jj_3R_44()) return true;
    if (jj_scan_token(THEN)) return true;
    if (jj_3R_44()) return true;
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    while (true) {
      xsp = jj_scanpos;
      if (jj_3R_115()) { jj_scanpos = xsp; break; }
    }
    if (jj_scan_token(ELSE)) return true;
    if (jj_3R_44()) return true;
    return false;
  }

  private boolean jj_3R_69() {
    if (jj_3R_87()) return true;
    return false;
  }

  private boolean jj_3R_68() {
    if (jj_3R_43()) return true;
    return false;
  }

  private boolean jj_3R_44() {
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_68()) {
    jj_scanpos = xsp;
    if (jj_3R_69()) return true;
    }
    return false;
  }

  private boolean jj_3_8() {
    if (jj_3R_39()) return true;
    return false;
  }

  private boolean jj_3_7() {
    if (jj_3R_38()) return true;
    return false;
  }

  private boolean jj_3R_93() {
    if (jj_scan_token(EXTERNAL)) return true;
    return false;
  }

  private boolean jj_3R_124() {
    if (jj_scan_token(PROTECTED)) return true;
    return false;
  }

  private boolean jj_3R_92() {
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_123()) {
    jj_scanpos = xsp;
    if (jj_3R_124()) {
    jj_scanpos = xsp;
    if (jj_3_7()) {
    jj_scanpos = xsp;
    if (jj_3_8()) return true;
    }
    }
    }
    return false;
  }

  private boolean jj_3R_123() {
    if (jj_scan_token(PUBLIC)) return true;
    return false;
  }

  private boolean jj_3R_82() {
    if (jj_scan_token(CONNECT)) return true;
    if (jj_scan_token(LPAREN)) return true;
    if (jj_3R_40()) return true;
    if (jj_scan_token(COMMA)) return true;
    if (jj_3R_40()) return true;
    if (jj_scan_token(RPAREN)) return true;
    return false;
  }

  private boolean jj_3R_74() {
    if (jj_3R_91()) return true;
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    while (true) {
      xsp = jj_scanpos;
      if (jj_3R_92()) { jj_scanpos = xsp; break; }
    }
    xsp = jj_scanpos;
    if (jj_3R_93()) jj_scanpos = xsp;
    xsp = jj_scanpos;
    if (jj_3R_94()) jj_scanpos = xsp;
    return false;
  }

  private boolean jj_3R_271() {
    if (jj_3R_35()) return true;
    if (jj_3R_70()) return true;
    return false;
  }

  private boolean jj_3R_128() {
    if (jj_scan_token(WHEN)) return true;
    return false;
  }

  private boolean jj_3R_272() {
    if (jj_scan_token(COMMA)) return true;
    if (jj_3R_271()) return true;
    return false;
  }

  private boolean jj_3R_119() {
    if (jj_scan_token(ELSEWHEN)) return true;
    if (jj_3R_44()) return true;
    if (jj_scan_token(THEN)) return true;
    if (jj_3R_116()) return true;
    return false;
  }

  private boolean jj_3R_270() {
    if (jj_3R_271()) return true;
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    while (true) {
      xsp = jj_scanpos;
      if (jj_3R_272()) { jj_scanpos = xsp; break; }
    }
    return false;
  }

  private boolean jj_3R_83() {
    if (jj_scan_token(WHEN)) return true;
    if (jj_3R_44()) return true;
    if (jj_scan_token(THEN)) return true;
    if (jj_3R_116()) return true;
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    while (true) {
      xsp = jj_scanpos;
      if (jj_3R_119()) { jj_scanpos = xsp; break; }
    }
    if (jj_scan_token(END)) return true;
    if (jj_scan_token(WHEN)) return true;
    return false;
  }

  private boolean jj_3R_36() {
    if (jj_3R_52()) return true;
    return false;
  }

  private boolean jj_3R_34() {
    if (jj_scan_token(OPERATOR)) return true;
    return false;
  }

  private boolean jj_3R_127() {
    if (jj_scan_token(WHILE)) return true;
    return false;
  }

  private boolean jj_3R_144() {
    if (jj_scan_token(IN)) return true;
    if (jj_3R_44()) return true;
    return false;
  }

  private boolean jj_3R_129() {
    if (jj_3R_35()) return true;
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_144()) jj_scanpos = xsp;
    return false;
  }

  private boolean jj_3R_269() {
    if (jj_3R_270()) return true;
    return false;
  }

  private boolean jj_3R_135() {
    if (jj_scan_token(COMMA)) return true;
    if (jj_3R_129()) return true;
    return false;
  }

  private boolean jj_3R_266() {
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_269()) jj_scanpos = xsp;
    return false;
  }

  private boolean jj_3R_32() {
    if (jj_3R_35()) return true;
    if (jj_scan_token(EQ_SIGN)) return true;
    if (jj_scan_token(DER)) return true;
    return false;
  }

  private boolean jj_3R_112() {
    if (jj_3R_129()) return true;
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    while (true) {
      xsp = jj_scanpos;
      if (jj_3R_135()) { jj_scanpos = xsp; break; }
    }
    return false;
  }

  private boolean jj_3_16() {
    if (jj_3R_42()) return true;
    if (jj_scan_token(SC)) return true;
    return false;
  }

  private boolean jj_3R_51() {
    if (jj_scan_token(IMPURE)) return true;
    return false;
  }

  private boolean jj_3R_126() {
    if (jj_scan_token(FOR)) return true;
    return false;
  }

  private boolean jj_3R_261() {
    if (jj_3R_35()) return true;
    if (jj_scan_token(EQ_SIGN)) return true;
    if (jj_scan_token(ENUMERATION)) return true;
    if (jj_scan_token(LPAREN)) return true;
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_scan_token(12)) {
    jj_scanpos = xsp;
    if (jj_3R_266()) return true;
    }
    if (jj_scan_token(RPAREN)) return true;
    if (jj_3R_70()) return true;
    return false;
  }

  private boolean jj_3R_265() {
    if (jj_3R_137()) return true;
    return false;
  }

  private boolean jj_3R_264() {
    if (jj_3R_111()) return true;
    return false;
  }

  private boolean jj_3R_134() {
    if (jj_3R_42()) return true;
    if (jj_scan_token(SC)) return true;
    return false;
  }

  private boolean jj_3R_116() {
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    while (true) {
      xsp = jj_scanpos;
      if (jj_3R_134()) { jj_scanpos = xsp; break; }
    }
    return false;
  }

  private boolean jj_3R_255() {
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3_6()) {
    jj_scanpos = xsp;
    if (jj_3R_261()) return true;
    }
    return false;
  }

  private boolean jj_3_6() {
    if (jj_3R_35()) return true;
    if (jj_scan_token(EQ_SIGN)) return true;
    if (jj_3R_36()) return true;
    if (jj_3R_37()) return true;
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_264()) jj_scanpos = xsp;
    xsp = jj_scanpos;
    if (jj_3R_265()) jj_scanpos = xsp;
    if (jj_3R_70()) return true;
    return false;
  }

  private boolean jj_3R_81() {
    if (jj_scan_token(FOR)) return true;
    if (jj_3R_112()) return true;
    if (jj_scan_token(LOOP)) return true;
    if (jj_3R_116()) return true;
    if (jj_scan_token(END)) return true;
    if (jj_scan_token(FOR)) return true;
    return false;
  }

  private boolean jj_3R_50() {
    if (jj_scan_token(PURE)) return true;
    return false;
  }

  private boolean jj_3R_33() {
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_50()) {
    jj_scanpos = xsp;
    if (jj_3R_51()) return true;
    }
    return false;
  }

  private boolean jj_3R_49() {
    if (jj_scan_token(EXTENDS)) return true;
    if (jj_3R_35()) return true;
    return false;
  }

  private boolean jj_3R_125() {
    if (jj_scan_token(IF)) return true;
    return false;
  }

  private boolean jj_3R_117() {
    if (jj_scan_token(ELSEIF)) return true;
    if (jj_3R_44()) return true;
    if (jj_scan_token(THEN)) return true;
    if (jj_3R_116()) return true;
    return false;
  }

  private boolean jj_3R_118() {
    if (jj_scan_token(ELSE)) return true;
    if (jj_3R_116()) return true;
    return false;
  }

  private boolean jj_3R_230() {
    if (jj_scan_token(OPERATOR)) return true;
    return false;
  }

  private boolean jj_3R_48() {
    if (jj_3R_35()) return true;
    if (jj_3R_73()) return true;
    if (jj_3R_74()) return true;
    if (jj_scan_token(END)) return true;
    return false;
  }

  private boolean jj_3R_31() {
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_48()) {
    jj_scanpos = xsp;
    if (jj_3R_49()) return true;
    }
    return false;
  }

  private boolean jj_3_15() {
    if (jj_3R_40()) return true;
    if (jj_scan_token(ASSIGN)) return true;
    return false;
  }

  private boolean jj_3R_229() {
    if (jj_scan_token(PACKAGE)) return true;
    return false;
  }

  private boolean jj_3_5() {
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_33()) jj_scanpos = xsp;
    xsp = jj_scanpos;
    if (jj_3R_34()) jj_scanpos = xsp;
    if (jj_scan_token(FUNCTION)) return true;
    return false;
  }

  private boolean jj_3R_80() {
    if (jj_scan_token(IF)) return true;
    if (jj_3R_44()) return true;
    if (jj_scan_token(THEN)) return true;
    if (jj_3R_116()) return true;
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    while (true) {
      xsp = jj_scanpos;
      if (jj_3R_117()) { jj_scanpos = xsp; break; }
    }
    xsp = jj_scanpos;
    if (jj_3R_118()) jj_scanpos = xsp;
    if (jj_scan_token(END)) return true;
    if (jj_scan_token(IF)) return true;
    return false;
  }

  private boolean jj_3R_228() {
    if (jj_scan_token(TYPE)) return true;
    return false;
  }

  private boolean jj_3R_110() {
    if (jj_3R_128()) return true;
    return false;
  }

  private boolean jj_3R_227() {
    if (jj_scan_token(CONNECTOR)) return true;
    return false;
  }

  private boolean jj_3R_109() {
    if (jj_3R_127()) return true;
    return false;
  }

  private boolean jj_3R_108() {
    if (jj_3R_126()) return true;
    return false;
  }

  private boolean jj_3R_226() {
    if (jj_scan_token(BLOCK)) return true;
    return false;
  }

  private boolean jj_3_4() {
    if (jj_scan_token(EXPANDABLE)) return true;
    if (jj_scan_token(CONNECTOR)) return true;
    return false;
  }

  private boolean jj_3R_106() {
    if (jj_scan_token(RETURN)) return true;
    return false;
  }

  private boolean jj_3R_107() {
    if (jj_3R_125()) return true;
    return false;
  }

  private boolean jj_3R_105() {
    if (jj_scan_token(BREAK)) return true;
    return false;
  }

  private boolean jj_3R_120() {
    if (jj_scan_token(ANNOTATION)) return true;
    if (jj_3R_137()) return true;
    return false;
  }

  private boolean jj_3R_225() {
    if (jj_scan_token(RECORD)) return true;
    return false;
  }

  private boolean jj_3_3() {
    if (jj_scan_token(OPERATOR)) return true;
    if (jj_scan_token(RECORD)) return true;
    return false;
  }

  private boolean jj_3R_104() {
    if (jj_scan_token(LPAREN)) return true;
    return false;
  }

  private boolean jj_3R_224() {
    if (jj_scan_token(MODEL)) return true;
    return false;
  }

  private boolean jj_3R_103() {
    if (jj_3R_40()) return true;
    return false;
  }

  private boolean jj_3R_136() {
    if (jj_scan_token(PLUS)) return true;
    if (jj_scan_token(STRING)) return true;
    return false;
  }

  private boolean jj_3R_223() {
    if (jj_scan_token(CLASS)) return true;
    return false;
  }

  private boolean jj_3R_102() {
    if (jj_3R_40()) return true;
    return false;
  }

  private boolean jj_3_14() {
    if (jj_3R_43()) return true;
    if (jj_scan_token(EQ_SIGN)) return true;
    if (jj_3R_44()) return true;
    return false;
  }

  private boolean jj_3R_90() {
    if (jj_scan_token(STRING)) return true;
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    while (true) {
      xsp = jj_scanpos;
      if (jj_3R_136()) { jj_scanpos = xsp; break; }
    }
    return false;
  }

  private boolean jj_3R_222() {
    if (jj_scan_token(PARTIAL)) return true;
    return false;
  }

  private boolean jj_3R_73() {
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_90()) jj_scanpos = xsp;
    return false;
  }

  private boolean jj_3R_78() {
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_102()) {
    jj_scanpos = xsp;
    if (jj_3R_103()) {
    jj_scanpos = xsp;
    if (jj_3R_104()) {
    jj_scanpos = xsp;
    if (jj_3R_105()) {
    jj_scanpos = xsp;
    if (jj_3R_106()) {
    jj_scanpos = xsp;
    if (jj_3R_107()) {
    jj_scanpos = xsp;
    if (jj_3R_108()) {
    jj_scanpos = xsp;
    if (jj_3R_109()) {
    jj_scanpos = xsp;
    if (jj_3R_110()) return true;
    }
    }
    }
    }
    }
    }
    }
    }
    return false;
  }

  private boolean jj_3R_65() {
    if (jj_3R_37()) return true;
    if (jj_3R_46()) return true;
    return false;
  }

  private boolean jj_3R_197() {
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_222()) jj_scanpos = xsp;
    xsp = jj_scanpos;
    if (jj_3R_223()) {
    jj_scanpos = xsp;
    if (jj_3R_224()) {
    jj_scanpos = xsp;
    if (jj_3R_225()) {
    jj_scanpos = xsp;
    if (jj_3_3()) {
    jj_scanpos = xsp;
    if (jj_3R_226()) {
    jj_scanpos = xsp;
    if (jj_3_4()) {
    jj_scanpos = xsp;
    if (jj_3R_227()) {
    jj_scanpos = xsp;
    if (jj_3R_228()) {
    jj_scanpos = xsp;
    if (jj_3R_229()) {
    jj_scanpos = xsp;
    if (jj_3_5()) {
    jj_scanpos = xsp;
    if (jj_3R_230()) return true;
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    return false;
  }

  private boolean jj_3R_64() {
    if (jj_3R_83()) return true;
    return false;
  }

  private boolean jj_3R_63() {
    if (jj_3R_82()) return true;
    return false;
  }

  private boolean jj_3R_62() {
    if (jj_3R_81()) return true;
    return false;
  }

  private boolean jj_3_2() {
    if (jj_3R_32()) return true;
    return false;
  }

  private boolean jj_3R_61() {
    if (jj_3R_80()) return true;
    return false;
  }

  private boolean jj_3_1() {
    if (jj_3R_31()) return true;
    return false;
  }

  private boolean jj_3R_60() {
    if (jj_3R_43()) return true;
    if (jj_scan_token(EQ_SIGN)) return true;
    if (jj_3R_44()) return true;
    return false;
  }

  private boolean jj_3R_88() {
    if (jj_3R_120()) return true;
    return false;
  }

  private boolean jj_3R_70() {
    if (jj_3R_73()) return true;
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_88()) jj_scanpos = xsp;
    return false;
  }

  private boolean jj_3R_196() {
    if (jj_scan_token(ENCAPSULATED)) return true;
    return false;
  }

  private boolean jj_3R_42() {
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_60()) {
    jj_scanpos = xsp;
    if (jj_3R_61()) {
    jj_scanpos = xsp;
    if (jj_3R_62()) {
    jj_scanpos = xsp;
    if (jj_3R_63()) {
    jj_scanpos = xsp;
    if (jj_3R_64()) {
    jj_scanpos = xsp;
    if (jj_3R_65()) return true;
    }
    }
    }
    }
    }
    if (jj_3R_70()) return true;
    return false;
  }

  private boolean jj_3R_143() {
    if (jj_3R_44()) return true;
    return false;
  }

  private boolean jj_3R_185() {
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_196()) jj_scanpos = xsp;
    if (jj_3R_197()) return true;
    return false;
  }

  private boolean jj_3R_56() {
    if (jj_3R_78()) return true;
    return false;
  }

  private boolean jj_3R_132() {
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_142()) {
    jj_scanpos = xsp;
    if (jj_3R_143()) return true;
    }
    return false;
  }

  private boolean jj_3R_142() {
    if (jj_scan_token(COLON)) return true;
    return false;
  }

  private boolean jj_3R_133() {
    if (jj_scan_token(COMMA)) return true;
    if (jj_3R_132()) return true;
    return false;
  }

  private boolean jj_3R_55() {
    if (jj_scan_token(INITIAL)) return true;
    return false;
  }

  private boolean jj_3R_39() {
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_55()) jj_scanpos = xsp;
    if (jj_scan_token(ALGORITHM)) return true;
    while (true) {
      xsp = jj_scanpos;
      if (jj_3R_56()) { jj_scanpos = xsp; break; }
    }
    return false;
  }

  private boolean jj_3_13() {
    if (jj_3R_42()) return true;
    return false;
  }

  private boolean jj_3R_150() {
    if (jj_scan_token(FOR)) return true;
    if (jj_3R_112()) return true;
    return false;
  }

  private boolean jj_3R_111() {
    if (jj_scan_token(LSQUARE)) return true;
    if (jj_3R_132()) return true;
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    while (true) {
      xsp = jj_scanpos;
      if (jj_3R_133()) { jj_scanpos = xsp; break; }
    }
    if (jj_scan_token(RSQUARE)) return true;
    return false;
  }

  private boolean jj_3R_245() {
    if (jj_scan_token(COMMA)) return true;
    if (jj_3R_44()) return true;
    return false;
  }

  private boolean jj_3R_54() {
    if (jj_scan_token(INITIAL)) return true;
    return false;
  }

  private boolean jj_3R_248() {
    if (jj_3R_251()) return true;
    return false;
  }

  private boolean jj_3R_38() {
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_54()) jj_scanpos = xsp;
    if (jj_scan_token(EQUATION)) return true;
    while (true) {
      xsp = jj_scanpos;
      if (jj_3_13()) { jj_scanpos = xsp; break; }
    }
    return false;
  }

  private boolean jj_3R_242() {
    if (jj_3R_251()) return true;
    return false;
  }

  private boolean jj_3R_237() {
    if (jj_3R_44()) return true;
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    while (true) {
      xsp = jj_scanpos;
      if (jj_3R_245()) { jj_scanpos = xsp; break; }
    }
    return false;
  }

  private boolean jj_3R_252() {
    if (jj_3R_44()) return true;
    return false;
  }

  private boolean jj_3R_250() {
    if (jj_3R_197()) return true;
    if (jj_3R_255()) return true;
    return false;
  }

  private boolean jj_3R_244() {
    if (jj_scan_token(COMMA)) return true;
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_252()) jj_scanpos = xsp;
    return false;
  }

  private boolean jj_3R_235() {
    if (jj_scan_token(INITIAL)) return true;
    return false;
  }

  private boolean jj_3R_243() {
    if (jj_3R_44()) return true;
    return false;
  }

  private boolean jj_3R_256() {
    if (jj_3R_262()) return true;
    if (jj_3R_70()) return true;
    return false;
  }

  private boolean jj_3R_236() {
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_243()) jj_scanpos = xsp;
    while (true) {
      xsp = jj_scanpos;
      if (jj_3R_244()) { jj_scanpos = xsp; break; }
    }
    return false;
  }

  private boolean jj_3R_148() {
    if (jj_3R_44()) return true;
    return false;
  }

  private boolean jj_3R_157() {
    if (jj_3R_47()) return true;
    return false;
  }

  private boolean jj_3R_251() {
    if (jj_3R_52()) return true;
    if (jj_3R_198()) return true;
    if (jj_3R_256()) return true;
    return false;
  }

  private boolean jj_3R_249() {
    if (jj_3R_254()) return true;
    return false;
  }

  private boolean jj_3R_139() {
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_149()) {
    jj_scanpos = xsp;
    if (jj_3R_150()) return true;
    }
    return false;
  }

  private boolean jj_3R_149() {
    if (jj_scan_token(COMMA)) return true;
    if (jj_3R_89()) return true;
    return false;
  }

  private boolean jj_3R_247() {
    if (jj_3R_250()) return true;
    return false;
  }

  private boolean jj_3R_138() {
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_147()) {
    jj_scanpos = xsp;
    if (jj_3R_148()) return true;
    }
    return false;
  }

  private boolean jj_3R_147() {
    if (jj_scan_token(FUNCTION)) return true;
    if (jj_3R_37()) return true;
    if (jj_scan_token(LPAREN)) return true;
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_157()) jj_scanpos = xsp;
    if (jj_scan_token(RPAREN)) return true;
    return false;
  }

  private boolean jj_3R_241() {
    if (jj_3R_250()) return true;
    return false;
  }

  private boolean jj_3R_240() {
    if (jj_scan_token(REPLACEABLE)) return true;
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_247()) {
    jj_scanpos = xsp;
    if (jj_3R_248()) return true;
    }
    xsp = jj_scanpos;
    if (jj_3R_249()) jj_scanpos = xsp;
    return false;
  }

  private boolean jj_3R_221() {
    if (jj_3R_240()) return true;
    return false;
  }

  private boolean jj_3R_220() {
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_241()) {
    jj_scanpos = xsp;
    if (jj_3R_242()) return true;
    }
    return false;
  }

  private boolean jj_3R_234() {
    if (jj_scan_token(DER)) return true;
    return false;
  }

  private boolean jj_3R_72() {
    if (jj_3R_35()) return true;
    if (jj_scan_token(EQ_SIGN)) return true;
    if (jj_3R_138()) return true;
    return false;
  }

  private boolean jj_3R_219() {
    if (jj_scan_token(FINAL)) return true;
    return false;
  }

  private boolean jj_3R_218() {
    if (jj_scan_token(EACH)) return true;
    return false;
  }

  private boolean jj_3R_146() {
    if (jj_scan_token(COMMA)) return true;
    if (jj_3R_47()) return true;
    return false;
  }

  private boolean jj_3R_195() {
    if (jj_scan_token(REDECLARE)) return true;
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_218()) jj_scanpos = xsp;
    xsp = jj_scanpos;
    if (jj_3R_219()) jj_scanpos = xsp;
    xsp = jj_scanpos;
    if (jj_3R_220()) {
    jj_scanpos = xsp;
    if (jj_3R_221()) return true;
    }
    return false;
  }

  private boolean jj_3R_233() {
    if (jj_3R_37()) return true;
    return false;
  }

  private boolean jj_3R_47() {
    if (jj_3R_72()) return true;
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_146()) jj_scanpos = xsp;
    return false;
  }

  private boolean jj_3R_246() {
    if (jj_3R_253()) return true;
    return false;
  }

  private boolean jj_3R_239() {
    if (jj_3R_37()) return true;
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_246()) jj_scanpos = xsp;
    if (jj_3R_73()) return true;
    return false;
  }

  private boolean jj_3R_217() {
    if (jj_3R_240()) return true;
    return false;
  }

  private boolean jj_3R_121() {
    if (jj_3R_138()) return true;
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_139()) jj_scanpos = xsp;
    return false;
  }

  private boolean jj_3R_216() {
    if (jj_3R_239()) return true;
    return false;
  }

  private boolean jj_3_19() {
    if (jj_3R_47()) return true;
    return false;
  }

  private boolean jj_3R_89() {
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3_19()) {
    jj_scanpos = xsp;
    if (jj_3R_121()) return true;
    }
    return false;
  }

  private boolean jj_3R_215() {
    if (jj_scan_token(FINAL)) return true;
    return false;
  }

  private boolean jj_3R_214() {
    if (jj_scan_token(EACH)) return true;
    return false;
  }

  private boolean jj_3R_71() {
    if (jj_3R_89()) return true;
    return false;
  }

  private boolean jj_3R_194() {
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_214()) jj_scanpos = xsp;
    xsp = jj_scanpos;
    if (jj_3R_215()) jj_scanpos = xsp;
    xsp = jj_scanpos;
    if (jj_3R_216()) {
    jj_scanpos = xsp;
    if (jj_3R_217()) return true;
    }
    return false;
  }

  private boolean jj_3R_46() {
    if (jj_scan_token(LPAREN)) return true;
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_71()) jj_scanpos = xsp;
    if (jj_scan_token(RPAREN)) return true;
    return false;
  }

  private boolean jj_3R_184() {
    if (jj_3R_195()) return true;
    return false;
  }

  private boolean jj_3R_59() {
    if (jj_scan_token(DOT)) return true;
    if (jj_3R_58()) return true;
    return false;
  }

  private boolean jj_3R_183() {
    if (jj_3R_194()) return true;
    return false;
  }

  private boolean jj_3R_170() {
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_183()) {
    jj_scanpos = xsp;
    if (jj_3R_184()) return true;
    }
    return false;
  }

  private boolean jj_3R_171() {
    if (jj_scan_token(COMMA)) return true;
    if (jj_3R_170()) return true;
    return false;
  }

  private boolean jj_3R_57() {
    if (jj_scan_token(DOT)) return true;
    return false;
  }

  private boolean jj_3R_40() {
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_57()) jj_scanpos = xsp;
    if (jj_3R_58()) return true;
    while (true) {
      xsp = jj_scanpos;
      if (jj_3R_59()) { jj_scanpos = xsp; break; }
    }
    return false;
  }

  private boolean jj_3R_79() {
    if (jj_3R_111()) return true;
    return false;
  }

  private boolean jj_3R_156() {
    if (jj_3R_170()) return true;
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    while (true) {
      xsp = jj_scanpos;
      if (jj_3R_171()) { jj_scanpos = xsp; break; }
    }
    return false;
  }

  private boolean jj_3R_58() {
    if (jj_3R_35()) return true;
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_79()) jj_scanpos = xsp;
    return false;
  }

  private boolean jj_3R_99() {
    if (jj_scan_token(CONSTANT)) return true;
    return false;
  }

  private boolean jj_3R_145() {
    if (jj_3R_156()) return true;
    return false;
  }

  private boolean jj_3R_137() {
    if (jj_scan_token(LPAREN)) return true;
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_145()) jj_scanpos = xsp;
    if (jj_scan_token(RPAREN)) return true;
    return false;
  }

  private boolean jj_3R_35() {
    if (jj_scan_token(IDENT)) return true;
    return false;
  }

  private boolean jj_3R_259() {
    if (jj_scan_token(ASSIGN)) return true;
    if (jj_3R_44()) return true;
    return false;
  }

  private boolean jj_3R_238() {
    if (jj_scan_token(SC)) return true;
    if (jj_3R_237()) return true;
    return false;
  }

  private boolean jj_3R_263() {
    if (jj_scan_token(EQ_SIGN)) return true;
    if (jj_3R_44()) return true;
    return false;
  }

  private boolean jj_3R_258() {
    if (jj_scan_token(EQ_SIGN)) return true;
    if (jj_3R_44()) return true;
    return false;
  }

  private boolean jj_3_18() {
    if (jj_scan_token(DOT)) return true;
    if (jj_3R_35()) return true;
    return false;
  }

  private boolean jj_3R_53() {
    if (jj_scan_token(DOT)) return true;
    return false;
  }

  private boolean jj_3R_37() {
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_53()) jj_scanpos = xsp;
    if (jj_3R_35()) return true;
    while (true) {
      xsp = jj_scanpos;
      if (jj_3_18()) { jj_scanpos = xsp; break; }
    }
    return false;
  }

  private boolean jj_3R_257() {
    if (jj_3R_137()) return true;
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_263()) jj_scanpos = xsp;
    return false;
  }

  private boolean jj_3R_253() {
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_257()) {
    jj_scanpos = xsp;
    if (jj_3R_258()) {
    jj_scanpos = xsp;
    if (jj_3R_259()) return true;
    }
    }
    return false;
  }

  private boolean jj_3R_232() {
    if (jj_scan_token(STRING)) return true;
    return false;
  }

  private boolean jj_3R_268() {
    if (jj_3R_253()) return true;
    return false;
  }

  private boolean jj_3R_267() {
    if (jj_3R_111()) return true;
    return false;
  }

  private boolean jj_3R_262() {
    if (jj_3R_35()) return true;
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_267()) jj_scanpos = xsp;
    xsp = jj_scanpos;
    if (jj_3R_268()) jj_scanpos = xsp;
    return false;
  }

  private boolean jj_3R_45() {
    if (jj_3R_37()) return true;
    return false;
  }

  private boolean jj_3R_231() {
    if (jj_scan_token(UNSIGNED_NUMBER)) return true;
    return false;
  }

  private boolean jj_3R_98() {
    if (jj_scan_token(PARAMETER)) return true;
    return false;
  }

  private boolean jj_3_17() {
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_45()) {
    jj_scanpos = xsp;
    if (jj_scan_token(48)) {
    jj_scanpos = xsp;
    if (jj_scan_token(53)) return true;
    }
    }
    if (jj_3R_46()) return true;
    return false;
  }

  private boolean jj_3R_101() {
    if (jj_scan_token(OUTPUT)) return true;
    return false;
  }

  private boolean jj_3R_207() {
    if (jj_scan_token(LCURL)) return true;
    if (jj_3R_89()) return true;
    if (jj_scan_token(RCURL)) return true;
    return false;
  }

  private boolean jj_3R_206() {
    if (jj_scan_token(LSQUARE)) return true;
    if (jj_3R_237()) return true;
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    while (true) {
      xsp = jj_scanpos;
      if (jj_3R_238()) { jj_scanpos = xsp; break; }
    }
    if (jj_scan_token(RSQUARE)) return true;
    return false;
  }

  private boolean jj_3R_205() {
    if (jj_scan_token(LPAREN)) return true;
    if (jj_3R_236()) return true;
    if (jj_scan_token(RPAREN)) return true;
    return false;
  }

  private boolean jj_3R_96() {
    if (jj_scan_token(STREAM)) return true;
    return false;
  }

  private boolean jj_3R_204() {
    if (jj_3R_40()) return true;
    return false;
  }

  private boolean jj_3R_203() {
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_233()) {
    jj_scanpos = xsp;
    if (jj_3R_234()) {
    jj_scanpos = xsp;
    if (jj_3R_235()) return true;
    }
    }
    if (jj_3R_46()) return true;
    return false;
  }

  private boolean jj_3R_202() {
    if (jj_scan_token(TRUE)) return true;
    return false;
  }

  private boolean jj_3R_201() {
    if (jj_scan_token(FALSE)) return true;
    return false;
  }

  private boolean jj_3R_200() {
    if (jj_3R_232()) return true;
    return false;
  }

  private boolean jj_3R_209() {
    if (jj_scan_token(DOT_HAT)) return true;
    return false;
  }

  private boolean jj_3R_199() {
    if (jj_3R_231()) return true;
    return false;
  }

  private boolean jj_3R_191() {
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_199()) {
    jj_scanpos = xsp;
    if (jj_3R_200()) {
    jj_scanpos = xsp;
    if (jj_3R_201()) {
    jj_scanpos = xsp;
    if (jj_3R_202()) {
    jj_scanpos = xsp;
    if (jj_3R_203()) {
    jj_scanpos = xsp;
    if (jj_3R_204()) {
    jj_scanpos = xsp;
    if (jj_3R_205()) {
    jj_scanpos = xsp;
    if (jj_3R_206()) {
    jj_scanpos = xsp;
    if (jj_3R_207()) {
    jj_scanpos = xsp;
    if (jj_scan_token(31)) return true;
    }
    }
    }
    }
    }
    }
    }
    }
    }
    return false;
  }

  private boolean jj_3R_208() {
    if (jj_scan_token(HAT)) return true;
    return false;
  }

  private boolean jj_3R_192() {
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_208()) {
    jj_scanpos = xsp;
    if (jj_3R_209()) return true;
    }
    if (jj_3R_191()) return true;
    return false;
  }

  private boolean jj_3R_198() {
    if (jj_3R_37()) return true;
    return false;
  }

  private boolean jj_3R_77() {
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_100()) {
    jj_scanpos = xsp;
    if (jj_3R_101()) return true;
    }
    return false;
  }

  private boolean jj_3R_100() {
    if (jj_scan_token(INPUT)) return true;
    return false;
  }

  private boolean jj_3R_175() {
    if (jj_3R_191()) return true;
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_192()) jj_scanpos = xsp;
    return false;
  }

  private boolean jj_3R_76() {
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_97()) {
    jj_scanpos = xsp;
    if (jj_3R_98()) {
    jj_scanpos = xsp;
    if (jj_3R_99()) return true;
    }
    }
    return false;
  }

  private boolean jj_3R_97() {
    if (jj_scan_token(DISCRETE)) return true;
    return false;
  }

  private boolean jj_3R_75() {
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_95()) {
    jj_scanpos = xsp;
    if (jj_3R_96()) return true;
    }
    return false;
  }

  private boolean jj_3R_95() {
    if (jj_scan_token(FLOW)) return true;
    return false;
  }

  private boolean jj_3R_213() {
    if (jj_scan_token(DOT_SLASH)) return true;
    return false;
  }

  private boolean jj_3R_52() {
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_75()) jj_scanpos = xsp;
    xsp = jj_scanpos;
    if (jj_3R_76()) jj_scanpos = xsp;
    xsp = jj_scanpos;
    if (jj_3R_77()) jj_scanpos = xsp;
    return false;
  }

  private boolean jj_3R_212() {
    if (jj_scan_token(DOT_ASTERISK)) return true;
    return false;
  }

  private boolean jj_3R_211() {
    if (jj_scan_token(SLASH)) return true;
    return false;
  }

  private boolean jj_3R_210() {
    if (jj_scan_token(ASTERISK)) return true;
    return false;
  }

  private boolean jj_3R_193() {
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_210()) {
    jj_scanpos = xsp;
    if (jj_3R_211()) {
    jj_scanpos = xsp;
    if (jj_3R_212()) {
    jj_scanpos = xsp;
    if (jj_3R_213()) return true;
    }
    }
    }
    return false;
  }

  private boolean jj_3R_186() {
    if (jj_3R_52()) return true;
    if (jj_3R_198()) return true;
    return false;
  }

  private boolean jj_3R_176() {
    if (jj_3R_193()) return true;
    if (jj_3R_175()) return true;
    return false;
  }

  private boolean jj_3R_260() {
    if (jj_3R_137()) return true;
    return false;
  }

  private boolean jj_3R_167() {
    if (jj_3R_175()) return true;
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    while (true) {
      xsp = jj_scanpos;
      if (jj_3R_176()) { jj_scanpos = xsp; break; }
    }
    return false;
  }

  private boolean jj_3R_254() {
    if (jj_scan_token(CONSTRAINEDBY)) return true;
    if (jj_3R_37()) return true;
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_260()) jj_scanpos = xsp;
    return false;
  }

  private boolean jj_3R_190() {
    if (jj_scan_token(DOT_MINUS)) return true;
    return false;
  }

  private boolean jj_3R_41() {
    if (jj_scan_token(DOT)) return true;
    if (jj_scan_token(ASTERISK)) return true;
    return false;
  }

  private boolean jj_3R_189() {
    if (jj_scan_token(DOT_PLUS)) return true;
    return false;
  }

  private boolean jj_3R_188() {
    if (jj_scan_token(MINUS)) return true;
    return false;
  }

  private boolean jj_3R_187() {
    if (jj_scan_token(PLUS)) return true;
    return false;
  }

  private boolean jj_3R_174() {
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_187()) {
    jj_scanpos = xsp;
    if (jj_3R_188()) {
    jj_scanpos = xsp;
    if (jj_3R_189()) {
    jj_scanpos = xsp;
    if (jj_3R_190()) return true;
    }
    }
    }
    return false;
  }

  private boolean jj_3R_173() {
    if (jj_3R_186()) return true;
    return false;
  }

  private boolean jj_3R_159() {
    if (jj_scan_token(EXTENDS)) return true;
    return false;
  }

  private boolean jj_3_12() {
    if (jj_3R_37()) return true;
    if (jj_scan_token(DOT)) return true;
    if (jj_scan_token(LCURL)) return true;
    return false;
  }

  private boolean jj_3R_168() {
    if (jj_3R_174()) return true;
    if (jj_3R_167()) return true;
    return false;
  }

  private boolean jj_3_11() {
    if (jj_3R_37()) return true;
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_41()) {
    jj_scanpos = xsp;
    if (jj_scan_token(86)) return true;
    }
    return false;
  }

  private boolean jj_3R_166() {
    if (jj_3R_174()) return true;
    return false;
  }

  private boolean jj_3R_154() {
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_166()) jj_scanpos = xsp;
    if (jj_3R_167()) return true;
    while (true) {
      xsp = jj_scanpos;
      if (jj_3R_168()) { jj_scanpos = xsp; break; }
    }
    return false;
  }

  private boolean jj_3_10() {
    if (jj_3R_35()) return true;
    if (jj_scan_token(EQ_SIGN)) return true;
    return false;
  }

  private boolean jj_3R_182() {
    if (jj_scan_token(NEQ)) return true;
    return false;
  }

  private boolean jj_3R_181() {
    if (jj_scan_token(EQ)) return true;
    return false;
  }

  private boolean jj_3R_180() {
    if (jj_scan_token(GE)) return true;
    return false;
  }

  private boolean jj_3R_179() {
    if (jj_scan_token(GT)) return true;
    return false;
  }

  private boolean jj_3R_178() {
    if (jj_scan_token(LE)) return true;
    return false;
  }

  private boolean jj_3R_177() {
    if (jj_scan_token(LT)) return true;
    return false;
  }

  private boolean jj_3R_169() {
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_177()) {
    jj_scanpos = xsp;
    if (jj_3R_178()) {
    jj_scanpos = xsp;
    if (jj_3R_179()) {
    jj_scanpos = xsp;
    if (jj_3R_180()) {
    jj_scanpos = xsp;
    if (jj_3R_181()) {
    jj_scanpos = xsp;
    if (jj_3R_182()) return true;
    }
    }
    }
    }
    }
    return false;
  }

  private boolean jj_3R_165() {
    if (jj_scan_token(REPLACEABLE)) return true;
    return false;
  }

  private boolean jj_3R_172() {
    if (jj_3R_185()) return true;
    return false;
  }

  private boolean jj_3R_164() {
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken xsp;
    xsp = jj_scanpos;
    if (jj_3R_172()) {
    jj_scanpos = xsp;
    if (jj_3R_173()) return true;
    }
    return false;
  }

  private boolean jj_3R_158() {
    if (jj_scan_token(IMPORT)) return true;
    return false;
  }

  /** Generated net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken Manager. */
  public ModelicaParserImplTokenManager token_source;
  /** Current token. */
  public net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken token;
  /** Next token. */
  public net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken jj_nt;
  private net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken jj_scanpos, jj_lastpos;
  private int jj_la;
  private int jj_gen;
  final private int[] jj_la1 = new int[128];
  static private int[] jj_la1_0;
  static private int[] jj_la1_1;
  static private int[] jj_la1_2;
  static private int[] jj_la1_3;
  static {
      jj_la1_init_0();
      jj_la1_init_1();
      jj_la1_init_2();
      jj_la1_init_3();
   }
   private static void jj_la1_init_0() {
      jj_la1_0 = new int[] {0x2,0x4000,0x800,0x3fff8000,0x20000,0x8000,0x0,0x10000,0x18000000,0x18000000,0x100000,0x2c0000,0x400000,0x7000000,0x100000,0x4,0x40000000,0x40,0x4,0x0,0x1000,0x0,0x400,0x400,0x0,0x0,0x0,0x800,0x0,0x0,0x0,0x80000854,0x7fffa800,0x0,0x20000,0x0,0x0,0x3ffd8800,0x3ffd8800,0x0,0x3ffd8800,0x7fffa800,0x800,0x800,0x400,0x4,0x0,0x4,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x400,0x0,0x40,0x204,0x200,0x204,0x20800,0x400,0x20800,0x0,0x20000,0x800,0x204,0x0,0x20000,0x3ffd0800,0x3ffd0800,0x3ffd0800,0x0,0x0,0x0,0x804,0x800,0x804,0x0,0x0,0x0,0x0,0x804,0x400,0x0,0x0,0x0,0x80000854,0x0,0x1000,0x1000,0x0,0x0,0x80000854,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800,0x100,0x0,0x80000854,0x800,0x40,0x800,0x800,0xa0000854,0x400,0x400,0xa0000854,0x400,0x0,0xa0000854,0x80000854,0x400,0x80000854,0x400,0x400,0x80001854,0x0,0x0,0x0,};
   }
   private static void jj_la1_init_1() {
      jj_la1_1 = 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,0xe00006,0x6,0x0,0x0,0x1000000,0x8,0x1000000,0x250000,0xfef0,0x10,0x0,0x20,0x40,0xfe00,0xfe00,0x100,0xfe80,0xfef0,0x0,0x0,0x0,0x0,0x1000000,0x0,0x0,0x600,0x600,0x3800,0x3800,0xc000,0xc000,0x0,0x40000,0x0,0x80000,0x0,0x80000,0x100090,0x0,0x100090,0x100000,0x0,0x80,0x80000,0x100000,0x0,0xfe00,0xfe80,0xfe00,0x100,0x200000,0x200000,0x46040000,0x40060000,0x46040000,0x10000000,0x20000000,0x10000000,0x20000000,0x46040000,0x0,0x0,0x0,0x0,0x250000,0x10000000,0x0,0x0,0x0,0x0,0x210000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x210000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x250000,0x40000000,0x40000000,0x250000,0x0,0x0,0x250000,0x250000,0x0,0x250000,0x0,0x0,0x250000,0x1000000,0x0,0x0,};
   }
   private static void jj_la1_init_2() {
      jj_la1_2 = new int[] {0x0,0x0,0x2000000,0x0,0x0,0x0,0x2000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2000000,0x0,0x0,0x2000000,0x0,0x2000000,0x0,0x0,0x0,0x0,0x20000000,0x2000000,0x0,0x0,0x0,0x223181c0,0x2000000,0x0,0x0,0x0,0x0,0x2000000,0x2000000,0x0,0x2000000,0x2000000,0x400000,0x2000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2000000,0x0,0x2000000,0x0,0x0,0x2000000,0x0,0x0,0x0,0x2000000,0x2000000,0x2000000,0x0,0x0,0x0,0x2000006,0x2000004,0x2000006,0x0,0x0,0x0,0x0,0x2000006,0x0,0x1,0x8,0x8,0x223181c0,0x0,0x0,0x0,0x10,0x20,0x223181c0,0x7e00,0x7e00,0x318000,0x318000,0x318000,0xc60000,0xc60000,0x1080000,0x1080000,0x2000000,0x0,0x20000180,0x2000000,0x0,0x0,0x0,0x0,0x223181c0,0x0,0x0,0x223181c0,0x0,0x2000000,0x223181c0,0x223181c0,0x0,0x223181c0,0x0,0x0,0x223181c0,0x0,0x8000,0x20000000,};
   }
   private static void jj_la1_init_3() {
      jj_la1_3 = 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,0x4,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,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,0x4,0x0,0x0,0x0,0x0,0x0,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4,0x0,0x0,0x0,0x0,0x0,0x4,0x0,0x0,0x4,0x0,0x0,0x4,0x4,0x0,0x4,0x0,0x0,0x4,0x0,0x0,0x0,};
   }
  final private JJCalls[] jj_2_rtns = new JJCalls[19];
  private boolean jj_rescan = false;
  private int jj_gc = 0;

  /** Constructor with user supplied net.sourceforge.pmd.lang.ast.impl.javacc.CharStream. */
  public ModelicaParserImpl(net.sourceforge.pmd.lang.ast.impl.javacc.CharStream stream) {
    token_source = new ModelicaParserImplTokenManager(stream);
    token = token_source.input_stream.getTokenDocument().open();
    token.next = jj_nt = token_source.getNextToken();
    jj_gen = 0;
    for (int i = 0; i < 128; i++) jj_la1[i] = -1;
    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
  }

  /** Reinitialise. */
  public void ReInit(net.sourceforge.pmd.lang.ast.impl.javacc.CharStream stream) {
    token_source.ReInit(stream);
    token = token_source.input_stream.getTokenDocument().open();
    token.next = jj_nt = token_source.getNextToken();
    jjtree.reset();
    jj_gen = 0;
    for (int i = 0; i < 128; i++) jj_la1[i] = -1;
    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
  }

  /** Constructor with generated net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken Manager. */
  public ModelicaParserImpl(ModelicaParserImplTokenManager tm) {
    token_source = tm;
    token = token_source.input_stream.getTokenDocument().open();
    token.next = jj_nt = token_source.getNextToken();
    jj_gen = 0;
    for (int i = 0; i < 128; i++) jj_la1[i] = -1;
    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
  }

  /** Reinitialise. */
  public void ReInit(ModelicaParserImplTokenManager tm) {
    token_source = tm;
    token = token_source.input_stream.getTokenDocument().open();
    token.next = jj_nt = token_source.getNextToken();
    jjtree.reset();
    jj_gen = 0;
    for (int i = 0; i < 128; i++) jj_la1[i] = -1;
    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
  }

  private net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken jj_consume_token(int kind) throws net.sourceforge.pmd.lang.ast.ParseException {
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken oldToken = token;
    if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
    else jj_nt = jj_nt.next = token_source.getNextToken();
    if (token.kind == kind) {
      jj_gen++;
      if (++jj_gc > 100) {
        jj_gc = 0;
        for (int i = 0; i < jj_2_rtns.length; i++) {
          JJCalls c = jj_2_rtns[i];
          while (c != null) {
            if (c.gen < jj_gen) c.first = null;
            c = c.next;
          }
        }
      }
      return token;
    }
    jj_nt = token;
    token = oldToken;
    jj_kind = kind;
    throw generateParseException();
  }

  static private final class LookaheadSuccess extends java.lang.Error { }
  final private LookaheadSuccess jj_ls = new LookaheadSuccess();
  private boolean jj_scan_token(int kind) {
    if (jj_scanpos == jj_lastpos) {
      jj_la--;
      if (jj_scanpos.next == null) {
        jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
      } else {
        jj_lastpos = jj_scanpos = jj_scanpos.next;
      }
    } else {
      jj_scanpos = jj_scanpos.next;
    }
    if (jj_rescan) {
      int i = 0; net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken tok = token;
      while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
      if (tok != null) jj_add_error_token(kind, i);
    }
    if (jj_scanpos.kind != kind) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
    return false;
  }


/** Get the next net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken. */
  final public net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken getNextToken() {
    if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
    else jj_nt = jj_nt.next = token_source.getNextToken();
    jj_gen++;
    return token;
  }

/** Get the specific net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken. */
  final public net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken getToken(int index) {
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken t = token;
    for (int i = 0; i < index; i++) {
      if (t.next != null) t = t.next;
      else t = t.next = token_source.getNextToken();
    }
    return t;
  }

  private java.util.List jj_expentries = new java.util.ArrayList();
  private int[] jj_expentry;
  private int jj_kind = -1;
  private int[] jj_lasttokens = new int[100];
  private int jj_endpos;

  private void jj_add_error_token(int kind, int pos) {
    if (pos >= 100) return;
    if (pos == jj_endpos + 1) {
      jj_lasttokens[jj_endpos++] = kind;
    } else if (jj_endpos != 0) {
      jj_expentry = new int[jj_endpos];
      for (int i = 0; i < jj_endpos; i++) {
        jj_expentry[i] = jj_lasttokens[i];
      }
      jj_entries_loop: for (java.util.Iterator it = jj_expentries.iterator(); it.hasNext();) {
        int[] oldentry = (int[])(it.next());
        if (oldentry.length == jj_expentry.length) {
          for (int i = 0; i < jj_expentry.length; i++) {
            if (oldentry[i] != jj_expentry[i]) {
              continue jj_entries_loop;
            }
          }
          jj_expentries.add(jj_expentry);
          break jj_entries_loop;
        }
      }
      if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
    }
  }

  /** Generate net.sourceforge.pmd.lang.ast.ParseException. */
  public net.sourceforge.pmd.lang.ast.ParseException generateParseException() {
    jj_expentries.clear();
    boolean[] la1tokens = new boolean[104];
    if (jj_kind >= 0) {
      la1tokens[jj_kind] = true;
      jj_kind = -1;
    }
    for (int i = 0; i < 128; i++) {
      if (jj_la1[i] == jj_gen) {
        for (int j = 0; j < 32; j++) {
          if ((jj_la1_0[i] & (1< jj_gen) {
          jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
          switch (i) {
            case 0: jj_3_1(); break;
            case 1: jj_3_2(); break;
            case 2: jj_3_3(); break;
            case 3: jj_3_4(); break;
            case 4: jj_3_5(); break;
            case 5: jj_3_6(); break;
            case 6: jj_3_7(); break;
            case 7: jj_3_8(); break;
            case 8: jj_3_9(); break;
            case 9: jj_3_10(); break;
            case 10: jj_3_11(); break;
            case 11: jj_3_12(); break;
            case 12: jj_3_13(); break;
            case 13: jj_3_14(); break;
            case 14: jj_3_15(); break;
            case 15: jj_3_16(); break;
            case 16: jj_3_17(); break;
            case 17: jj_3_18(); break;
            case 18: jj_3_19(); break;
          }
        }
        p = p.next;
      } while (p != null);
      } catch(LookaheadSuccess ls) { }
    }
    jj_rescan = false;
  }

  private void jj_save(int index, int xla) {
    JJCalls p = jj_2_rtns[index];
    while (p.gen > jj_gen) {
      if (p.next == null) { p = p.next = new JJCalls(); break; }
      p = p.next;
    }
    p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
  }

  static final class JJCalls {
    int gen;
    net.sourceforge.pmd.lang.ast.impl.javacc.JavaccToken first;
    int arg;
    JJCalls next;
  }

}




© 2015 - 2024 Weber Informatics LLC | Privacy Policy