javaparser.java

检查Java程序漏洞

    try {
      if (jj_2_4(2)) {
        Initializer();
      } else if (jj_2_5(2147483647)) {
        NestedClassDeclaration();
      } else if (jj_2_6(2147483647)) {
        NestedInterfaceDeclaration();
      } else if (jj_2_7(2147483647)) {
        ConstructorDeclaration();
      } else if (jj_2_8(2147483647)) {
        MethodDeclaration();
      } else if (enumLookahead()) {
        EnumDeclaration();
      } else {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case BOOLEAN:
        case BYTE:
        case CHAR:
        case DOUBLE:
        case FINAL:
        case FLOAT:
        case INT:
        case LONG:
        case PRIVATE:
        case PROTECTED:
        case PUBLIC:
        case SHORT:
        case STATIC:
        case TRANSIENT:
        case VOLATILE:
        case IDENTIFIER:
          FieldDeclaration();
          break;
        case SEMICOLON:
          jj_consume_token(SEMICOLON);
          break;
        default:
          jj_la1[12] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
    } 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 ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (RuntimeException)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void EnumDeclaration() throws ParseException {
 /*@bgen(jjtree) EnumDeclaration */
 ASTEnumDeclaration jjtn000 = new ASTEnumDeclaration(this, JJTENUMDECLARATION);
 boolean jjtc000 = true;
 jjtree.openNodeScope(jjtn000);Token t = null;
    try {
      label_6:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case FINAL:
        case PRIVATE:
        case PROTECTED:
        case PUBLIC:
        case STATIC:
          ;
          break;
        default:
          jj_la1[13] = jj_gen;
          break label_6;
        }
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case PUBLIC:
          jj_consume_token(PUBLIC);
                          jjtn000.setPublic();
          break;
        case PROTECTED:
          jj_consume_token(PROTECTED);
                          jjtn000.setProtected();
          break;
        case PRIVATE:
          jj_consume_token(PRIVATE);
                          jjtn000.setPrivate();
          break;
        case STATIC:
          jj_consume_token(STATIC);
                          jjtn000.setStatic();
          break;
        case FINAL:
          jj_consume_token(FINAL);
                          jjtn000.setFinal();
          break;
        default:
          jj_la1[14] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
      t = jj_consume_token(IDENTIFIER);
    if (!t.image.equals("enum")) {
      {if (true) throw new ParseException("ERROR: expecting enum");}
    }
    if (!this.isJDK15) {
      {if (true) throw new ParseException("ERROR: Can't use enum as a keyword in pre-JDK 1.5 target");}
    }
      jj_consume_token(IDENTIFIER);
      jj_consume_token(LBRACE);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case IMPLEMENTS:
        jj_consume_token(IMPLEMENTS);
        NameList();
        break;
      default:
        jj_la1[15] = jj_gen;
        ;
      }
      EnumElement();
      label_7:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case COMMA:
          ;
          break;
        default:
          jj_la1[16] = jj_gen;
          break label_7;
        }
        jj_consume_token(COMMA);
        EnumElement();
      }
      jj_consume_token(RBRACE);
      jj_consume_token(SEMICOLON);
    } 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 ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (RuntimeException)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void EnumElement() throws ParseException {
 /*@bgen(jjtree) EnumElement */
 ASTEnumElement jjtn000 = new ASTEnumElement(this, JJTENUMELEMENT);
 boolean jjtc000 = true;
 jjtree.openNodeScope(jjtn000);Token t = null;
    try {
      t = jj_consume_token(IDENTIFIER);
                      jjtn000.setImage(t.image);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case LPAREN:
        Arguments();
        break;
      default:
        jj_la1[17] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case LBRACE:
        ClassBody();
        break;
      default:
        jj_la1[18] = 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 ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (RuntimeException)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
      }
    }
  }

// This production is to determine lookahead only.
  final public void MethodDeclarationLookahead() throws ParseException {
 /*@bgen(jjtree) MethodDeclarationLookahead */
  ASTMethodDeclarationLookahead jjtn000 = new ASTMethodDeclarationLookahead(this, JJTMETHODDECLARATIONLOOKAHEAD);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      label_8:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case ABSTRACT:
        case FINAL:
        case NATIVE:
        case PRIVATE:
        case PROTECTED:
        case PUBLIC:
        case STATIC:
        case SYNCHRONIZED:
        case STRICTFP:
          ;
          break;
        default:
          jj_la1[19] = jj_gen;
          break label_8;
        }
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case PUBLIC:
          jj_consume_token(PUBLIC);
          break;
        case PROTECTED:
          jj_consume_token(PROTECTED);
          break;
        case PRIVATE:
          jj_consume_token(PRIVATE);
          break;
        case STATIC:
          jj_consume_token(STATIC);
          break;
        case ABSTRACT:
          jj_consume_token(ABSTRACT);
          break;
        case FINAL:
          jj_consume_token(FINAL);
          break;
        case NATIVE:
          jj_consume_token(NATIVE);
          break;
        case SYNCHRONIZED:
          jj_consume_token(SYNCHRONIZED);
          break;
        case STRICTFP:
          jj_consume_token(STRICTFP);
          break;
        default:
          jj_la1[20] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
      ResultType();
      jj_consume_token(IDENTIFIER);
      jj_consume_token(LPAREN);
    } 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 ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (RuntimeException)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void InterfaceDeclaration() throws ParseException {
 /*@bgen(jjtree) InterfaceDeclaration */
  ASTInterfaceDeclaration jjtn000 = new ASTInterfaceDeclaration(this, JJTINTERFACEDECLARATION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      label_9:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case ABSTRACT:
        case PUBLIC:
        case STRICTFP:
          ;
          break;
        default:
          jj_la1[21] = jj_gen;
          break label_9;
        }
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case ABSTRACT:
          jj_consume_token(ABSTRACT);
                  jjtn000.setAbstract();
          break;
        case PUBLIC:
          jj_consume_token(PUBLIC);
                  jjtn000.setPublic();
          break;
        case STRICTFP:
          jj_consume_token(STRICTFP);
                  jjtn000.setStrict();
          break;
        default:
          jj_la1[22] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
      UnmodifiedInterfaceDeclaration();
    } 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 ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (RuntimeException)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void NestedInterfaceDeclaration() throws ParseException {
 /*@bgen(jjtree) NestedInterfaceDeclaration */
  ASTNestedInterfaceDeclaration jjtn000 = new ASTNestedInterfaceDeclaration(this, JJTNESTEDINTERFACEDECLARATION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      label_10:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case ABSTRACT:
        case FINAL:
        case PRIVATE:
        case PROTECTED:
        case PUBLIC:
        case STATIC:
        case STRICTFP:
          ;
          break;
        default:
          jj_la1[23] = jj_gen;
          break label_10;
        }
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case STATIC:
          jj_consume_token(STATIC);
                     jjtn000.setStatic();
          break;
        case ABSTRACT:
          jj_consume_token(ABSTRACT);
                    jjtn000.setAbstract();
          break;
        case FINAL:
          jj_consume_token(FINAL);
                    jjtn000.setFinal();
          break;
        case PUBLIC:
          jj_consume_token(PUBLIC);
                    jjtn000.setPublic();
          break;
        case PROTECTED:
          jj_consume_token(PROTECTED);
                    jjtn000.setProtected();
          break;
        case PRIVATE:
          jj_consume_token(PRIVATE);
                    jjtn000.setPrivate();
          break;
        case STRICTFP:
          jj_consume_token(STRICTFP);
                    jjtn000.setStrict();
          break;
        default:
          jj_la1[24] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
      UnmodifiedInterfaceDeclaration();
    } 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 ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (RuntimeException)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void UnmodifiedInterfaceDeclaration() throws ParseException {
 /*@bgen(jjtree) UnmodifiedInterfaceDeclaration */
 ASTUnmodifiedInterfaceDeclaration jjtn000 = new ASTUnmodifiedInterfaceDeclaration(this, JJTUNMODIFIEDINTERFACEDECLARATION);
 boolean jjtc000 = true;
 jjtree.openNodeScope(jjtn000);Token t = null;
    try {
      jj_consume_token(INTERFACE);
      t = jj_consume_token(IDENTIFIER);
     jjtn000.setImage( t.image );
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case EXTENDS:
        jj_consume_token(EXTENDS);
        NameList();
        break;
      default:
        jj_la1[25] = jj_gen;
        ;
      }
      jj_consume_token(LBRACE);
      label_11:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case ABSTRACT:
        case BOOLEAN:
        case BYTE:
        case CHAR:
        case CLASS:
        case DOUBLE:
        case FINAL:
        case FLOAT:
        case INT:
        case INTERFACE:
        case LONG:
        case NATIVE:
        case PRIVATE:
        case PROTECTED:
        case PUBLIC:
        case SHORT:
        case STATIC:
        case SYNCHRONIZED:
        case TRANSIENT:
        case VOID:
        case VOLATILE:
        case STRICTFP:
        case IDENTIFIER:
        case SEMICOLON:
          ;
          break;
        default:
          jj_la1[26] = jj_gen;
          break label_11;
        }
        InterfaceMemberDeclaration();
      }
      jj_consume_token(RBRACE);
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {