javaparser.java

检查Java程序漏洞

    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 Name() throws ParseException {
 /*@bgen(jjtree) Name */
  ASTName jjtn000 = new ASTName(this, JJTNAME);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);StringBuffer s = new StringBuffer();
  Token t = null;
    try {
      t = jj_consume_token(IDENTIFIER);
    jjtn000.testingOnly__setBeginLine( t.beginLine);
    jjtn000.testingOnly__setBeginColumn( t.beginColumn);
    s.append(t.image);
      label_21:
      while (true) {
        if (jj_2_17(2)) {
          ;
        } else {
          break label_21;
        }
        jj_consume_token(DOT);
        t = jj_consume_token(IDENTIFIER);
        s.append(".");
        s.append(t.image);
      }
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
    jjtn000.setImage( s.toString() );
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void NameList() throws ParseException {
 /*@bgen(jjtree) NameList */
  ASTNameList jjtn000 = new ASTNameList(this, JJTNAMELIST);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      Name();
      label_22:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case COMMA:
          ;
          break;
        default:
          jj_la1[53] = jj_gen;
          break label_22;
        }
        jj_consume_token(COMMA);
        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 ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (RuntimeException)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/*
 * Expression syntax follows.
 */
  final public void Expression() throws ParseException {
 /*@bgen(jjtree) Expression */
  ASTExpression jjtn000 = new ASTExpression(this, JJTEXPRESSION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      ConditionalExpression();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case ASSIGN:
      case PLUSASSIGN:
      case MINUSASSIGN:
      case STARASSIGN:
      case SLASHASSIGN:
      case ANDASSIGN:
      case ORASSIGN:
      case XORASSIGN:
      case REMASSIGN:
      case LSHIFTASSIGN:
      case RSIGNEDSHIFTASSIGN:
      case RUNSIGNEDSHIFTASSIGN:
        AssignmentOperator();
        Expression();
        break;
      default:
        jj_la1[54] = 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);
    }
    }
  }

  final public void AssignmentOperator() throws ParseException {
 /*@bgen(jjtree) AssignmentOperator */
  ASTAssignmentOperator jjtn000 = new ASTAssignmentOperator(this, JJTASSIGNMENTOPERATOR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case ASSIGN:
        jj_consume_token(ASSIGN);
                jjtree.closeNodeScope(jjtn000, true);
                jjtc000 = false;
               jjtn000.setImage("=");
        break;
      case STARASSIGN:
        jj_consume_token(STARASSIGN);
                jjtree.closeNodeScope(jjtn000, true);
                jjtc000 = false;
               jjtn000.setImage("*=");
        break;
      case SLASHASSIGN:
        jj_consume_token(SLASHASSIGN);
                jjtree.closeNodeScope(jjtn000, true);
                jjtc000 = false;
               jjtn000.setImage("/=");
        break;
      case REMASSIGN:
        jj_consume_token(REMASSIGN);
                jjtree.closeNodeScope(jjtn000, true);
                jjtc000 = false;
               jjtn000.setImage("%=");
        break;
      case PLUSASSIGN:
        jj_consume_token(PLUSASSIGN);
                jjtree.closeNodeScope(jjtn000, true);
                jjtc000 = false;
               jjtn000.setImage("+=");
        break;
      case MINUSASSIGN:
        jj_consume_token(MINUSASSIGN);
                jjtree.closeNodeScope(jjtn000, true);
                jjtc000 = false;
               jjtn000.setImage("-=");
        break;
      case LSHIFTASSIGN:
        jj_consume_token(LSHIFTASSIGN);
                jjtree.closeNodeScope(jjtn000, true);
                jjtc000 = false;
               jjtn000.setImage("<<=");
        break;
      case RSIGNEDSHIFTASSIGN:
        jj_consume_token(RSIGNEDSHIFTASSIGN);
                jjtree.closeNodeScope(jjtn000, true);
                jjtc000 = false;
               jjtn000.setImage(">>=");
        break;
      case RUNSIGNEDSHIFTASSIGN:
        jj_consume_token(RUNSIGNEDSHIFTASSIGN);
                jjtree.closeNodeScope(jjtn000, true);
                jjtc000 = false;
               jjtn000.setImage(">>>=");
        break;
      case ANDASSIGN:
        jj_consume_token(ANDASSIGN);
                jjtree.closeNodeScope(jjtn000, true);
                jjtc000 = false;
               jjtn000.setImage("&=");
        break;
      case XORASSIGN:
        jj_consume_token(XORASSIGN);
                jjtree.closeNodeScope(jjtn000, true);
                jjtc000 = false;
               jjtn000.setImage("^=");
        break;
      case ORASSIGN:
        jj_consume_token(ORASSIGN);
                jjtree.closeNodeScope(jjtn000, true);
                jjtc000 = false;
               jjtn000.setImage("|=");
        break;
      default:
        jj_la1[55] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    } finally {
        if (jjtc000) {
          jjtree.closeNodeScope(jjtn000, true);
        }
    }
  }

  final public void ConditionalExpression() throws ParseException {
    ConditionalOrExpression();
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case HOOK:
      jj_consume_token(HOOK);
      Expression();
      jj_consume_token(COLON);
      ConditionalExpression();
      break;
    default:
      jj_la1[56] = jj_gen;
      ;
    }
  }

  final public void ConditionalOrExpression() throws ParseException {
    ConditionalAndExpression();
    label_23:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case SC_OR:
        ;
        break;
      default:
        jj_la1[57] = jj_gen;
        break label_23;
      }
      jj_consume_token(SC_OR);
      ConditionalAndExpression();
    }
  }

  final public void ConditionalAndExpression() throws ParseException {
 /*@bgen(jjtree) ConditionalAndExpression */
  ASTConditionalAndExpression jjtn000 = new ASTConditionalAndExpression(this, JJTCONDITIONALANDEXPRESSION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      InclusiveOrExpression();
      label_24:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case SC_AND:
          ;
          break;
        default:
          jj_la1[58] = jj_gen;
          break label_24;
        }
        jj_consume_token(SC_AND);
        InclusiveOrExpression();
      }
    } 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 InclusiveOrExpression() throws ParseException {
    ExclusiveOrExpression();
    label_25:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case BIT_OR:
        ;
        break;
      default:
        jj_la1[59] = jj_gen;
        break label_25;
      }
      jj_consume_token(BIT_OR);
      ExclusiveOrExpression();
    }
  }

  final public void ExclusiveOrExpression() throws ParseException {
    AndExpression();
    label_26:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case XOR:
        ;
        break;
      default:
        jj_la1[60] = jj_gen;
        break label_26;
      }
      jj_consume_token(XOR);
      AndExpression();
    }
  }

  final public void AndExpression() throws ParseException {
    EqualityExpression();
    label_27:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case BIT_AND:
        ;
        break;
      default:
        jj_la1[61] = jj_gen;
        break label_27;
      }
      jj_consume_token(BIT_AND);
      EqualityExpression();
    }
  }

  final public void EqualityExpression() throws ParseException {
    InstanceOfExpression();
    label_28:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case EQ:
      case NE:
        ;
        break;
      default:
        jj_la1[62] = jj_gen;
        break label_28;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case EQ:
        jj_consume_token(EQ);
        break;
      case NE:
        jj_consume_token(NE);
        break;
      default:
        jj_la1[63] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      InstanceOfExpression();
    }
  }

  final public void InstanceOfExpression() throws ParseException {
 /*@bgen(jjtree) InstanceOfExpression */
  ASTInstanceOfExpression jjtn000 = new ASTInstanceOfExpression(this, JJTINSTANCEOFEXPRESSION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      RelationalExpression();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case INSTANCEOF:
        jj_consume_token(INSTANCEOF);
        Type();
        break;
      default:
        jj_la1[64] = 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);
    }
    }
  }

  final public void RelationalExpression() throws ParseException {
    ShiftExpression();
    label_29:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case GT:
      case LT:
      case LE:
      case GE:
        ;
        break;
      default:
        jj_la1[65] = jj_gen;
        break label_29;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case LT:
        jj_consume_token(LT);
        break;
      case GT:
        jj_consume_token(GT);
        break;
      case LE:
        jj_consume_token(LE);
        break;
      case GE:
        jj_consume_token(GE);
        break;
      default:
        jj_la1[66] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      ShiftExpression();
    }
  }

  final public void ShiftExpression() throws ParseException {
    AdditiveExpression();
    label_30:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case LSHIFT:
      case RSIGNEDSHIFT:
      case RUNSIGNEDSHIFT:
        ;
        break;
      default:
        jj_la1[67] = jj_gen;
        break label_30;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case LSHIFT:
        jj_consume_token(LSHIFT);
        break;
      case RSIGNEDSHIFT:
        jj_consume_token(RSIGNEDSHIFT);
        break;
      case RUNSIGNEDSHIFT:
        jj_consume_token(RUNSIGNEDSHIFT);
        break;
      default:
        jj_la1[68] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();