cppparser.java

检查Java程序漏洞

      superclass_init();
    }
  }

  static final public void superclass_init() throws ParseException {
    qualified_id();
    jj_consume_token(LPARENTHESIS);
    if (jj_2_74(1)) {
      expression_list();
    } else {
      ;
    }
    jj_consume_token(RPARENTHESIS);
  }

  static final public void dtor_declarator() throws ParseException {
    if (jj_2_75(2147483647)) {
      scope_override();
    } else {
      ;
    }
    simple_dtor_declarator();
  }

  static final public void simple_dtor_declarator() throws ParseException {
    jj_consume_token(TILDE);
    if (IsCtor()) {

    } else {
      jj_consume_token(-1);
      throw new ParseException();
    }
    jj_consume_token(ID);
    jj_consume_token(LPARENTHESIS);
    if (jj_2_76(1)) {
      parameter_list();
    } else {
      ;
    }
    jj_consume_token(RPARENTHESIS);
  }

  static final public void parameter_list() throws ParseException {
    if (jj_2_78(1)) {
      parameter_declaration_list();
      if (jj_2_77(2)) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case COMMA:
          jj_consume_token(COMMA);
          break;
        default:
          jj_la1[74] = jj_gen;
          ;
        }
        jj_consume_token(ELLIPSIS);
      } else {
        ;
      }
    } else {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case ELLIPSIS:
        jj_consume_token(ELLIPSIS);
        break;
      default:
        jj_la1[75] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    }
  }

  static final public void parameter_declaration_list() throws ParseException {
    parameter_declaration();
    label_19:
    while (true) {
      if (jj_2_79(2)) {
        ;
      } else {
        break label_19;
      }
      jj_consume_token(COMMA);
      parameter_declaration();
    }
  }

  static final public void parameter_declaration() throws ParseException {
    declaration_specifiers();
    if (jj_2_80(2147483647)) {
      declarator();
    } else {
      abstract_declarator();
    }
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case ASSIGNEQUAL:
      jj_consume_token(ASSIGNEQUAL);
      assignment_expression();
      break;
    default:
      jj_la1[76] = jj_gen;
      ;
    }
  }

  static final public void initializer() throws ParseException {
    if (jj_2_81(3)) {
      jj_consume_token(LCURLYBRACE);
      initializer();
      label_20:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case COMMA:
          ;
          break;
        default:
          jj_la1[77] = jj_gen;
          break label_20;
        }
        jj_consume_token(COMMA);
        initializer();
      }
      jj_consume_token(RCURLYBRACE);
    } else if (jj_2_82(1)) {
      assignment_expression();
    } else {
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  static final public void type_name() throws ParseException {
    declaration_specifiers();
    abstract_declarator();
  }

  static final public void abstract_declarator() throws ParseException {
    if (jj_2_84(2)) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case LPARENTHESIS:
        jj_consume_token(LPARENTHESIS);
        abstract_declarator();
        jj_consume_token(RPARENTHESIS);
        label_21:
        while (true) {
          abstract_declarator_suffix();
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case LSQUAREBRACKET:
          case LPARENTHESIS:
            ;
            break;
          default:
            jj_la1[78] = jj_gen;
            break label_21;
          }
        }
        break;
      case LSQUAREBRACKET:
        label_22:
        while (true) {
          jj_consume_token(LSQUAREBRACKET);
          if (jj_2_83(1)) {
            constant_expression();
          } else {
            ;
          }
          jj_consume_token(RSQUAREBRACKET);
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case LSQUAREBRACKET:
            ;
            break;
          default:
            jj_la1[79] = jj_gen;
            break label_22;
          }
        }
        break;
      case SCOPE:
      case AMPERSAND:
      case STAR:
      case ID:
        ptr_operator();
        abstract_declarator();
        break;
      default:
        jj_la1[80] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    } else {
      ;
    }
  }

  static final public void abstract_declarator_suffix() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case LSQUAREBRACKET:
      jj_consume_token(LSQUAREBRACKET);
      if (jj_2_85(1)) {
        constant_expression();
      } else {
        ;
      }
      jj_consume_token(RSQUAREBRACKET);
      break;
    case LPARENTHESIS:
      jj_consume_token(LPARENTHESIS);
      if (jj_2_86(1)) {
        parameter_list();
      } else {
        ;
      }
      jj_consume_token(RPARENTHESIS);
      break;
    default:
      jj_la1[81] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  static final public void template_head() throws ParseException {
    jj_consume_token(TEMPLATE);
    jj_consume_token(LESSTHAN);
    template_parameter_list();
    jj_consume_token(GREATERTHAN);
  }

  static final public void template_parameter_list() throws ParseException {
    template_parameter();
    label_23:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case COMMA:
        ;
        break;
      default:
        jj_la1[82] = jj_gen;
        break label_23;
      }
      jj_consume_token(COMMA);
      template_parameter();
    }
  }

  static final public void template_parameter() throws ParseException {
  Token t;
    if (jj_2_87(3)) {
      jj_consume_token(CLASS);
      t = jj_consume_token(ID);
                       sym.PutTypeName(t.image);
    } else if (jj_2_88(1)) {
      parameter_declaration();
    } else {
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  static final public void template_id() throws ParseException {
    jj_consume_token(ID);
    jj_consume_token(LESSTHAN);
    template_argument_list();
    jj_consume_token(GREATERTHAN);
  }

  static final public void template_argument_list() throws ParseException {
    template_argument();
    label_24:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case COMMA:
        ;
        break;
      default:
        jj_la1[83] = jj_gen;
        break label_24;
      }
      jj_consume_token(COMMA);
      template_argument();
    }
  }

  static final public void template_argument() throws ParseException {
    if (jj_2_89(3)) {
      type_name();
    } else if (jj_2_90(1)) {
      shift_expression();
    } else {
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  static final public void statement_list() throws ParseException {
    label_25:
    while (true) {
      statement();
      if (jj_2_91(2147483647)) {
        ;
      } else {
        break label_25;
      }
    }
  }

  static final public void statement() throws ParseException {
    if (jj_2_92(2147483647)) {
      declaration();
    } else if (jj_2_93(2147483647)) {
      expression();
      jj_consume_token(SEMICOLON);
    } else {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case LCURLYBRACE:
        compound_statement();
        break;
      case IF:
      case SWITCH:
        selection_statement();
        break;
      case BREAK:
      case CONTINUE:
      case GOTO:
      case RETURN:
        jump_statement();
        break;
      case SEMICOLON:
        jj_consume_token(SEMICOLON);
        break;
      case TRY:
        try_block();
        break;
      case THROW:
        throw_statement();
        break;
      default:
        jj_la1[84] = jj_gen;
        if (jj_2_94(2)) {
          labeled_statement();
        } else {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case DO:
          case FOR:
          case WHILE:
            iteration_statement();
            break;
          default:
            jj_la1[85] = jj_gen;
            jj_consume_token(-1);
            throw new ParseException();
          }
        }
      }
    }
  }

  static final public void labeled_statement() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case ID:
      jj_consume_token(ID);
      jj_consume_token(COLON);
      statement();
      break;
    case CASE:
      jj_consume_token(CASE);
      constant_expression();
      jj_consume_token(COLON);
      statement();
      break;
    case _DEFAULT:
      jj_consume_token(_DEFAULT);
      jj_consume_token(COLON);
      statement();
      break;
    default:
      jj_la1[86] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  static final public void compound_statement() throws ParseException {
    jj_consume_token(LCURLYBRACE);
     sym.OpenScope(null, false);
    if (jj_2_95(1)) {
      statement_list();
    } else {
      ;
    }
     sym.CloseScope();
    jj_consume_token(RCURLYBRACE);
  }

  static final public void selection_statement() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case IF:
      jj_consume_token(IF);
      jj_consume_token(LPARENTHESIS);
      expression();
      jj_consume_token(RPARENTHESIS);
      statement();
      if (jj_2_96(2)) {
        jj_consume_token(ELSE);
        statement();
      } else {
        ;
      }
      break;
    case SWITCH:
      jj_consume_token(SWITCH);
      jj_consume_token(LPARENTHESIS);
      expression();
      jj_consume_token(RPARENTHESIS);
      statement();
      break;
    default:
      jj_la1[87] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  static final public void iteration_statement() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case WHILE:
      jj_consume_token(WHILE);
      jj_consume_token(LPARENTHESIS);
      expression();
      jj_consume_token(RPARENTHESIS);
      statement();
      break;
    case DO:
      jj_consume_token(DO);
      statement();
      jj_consume_token(WHILE);
      jj_consume_token(LPARENTHESIS);
      expression();
      jj_consume_token(RPARENTHESIS);
      jj_consume_token(SEMICOLON);
      break;
    case FOR:
      jj_consume_token(FOR);
      jj_consume_token(LPARENTHESIS);
      if (jj_2_97(3)) {
        declaration();
      } else if (jj_2_98(1)) {
        expression();
        jj_consume_token(SEMICOLON);
      } else {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case SEMICOLON:
          jj_consume_token(SEMICOLON);
          break;
        default:
          jj_la1[88] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
      if (jj_2_99(1)) {
        expression();
      } else {
        ;
      }
      jj_consume_token(SEMICOLON);
      if (jj_2_100(1)) {
        expression();
      } else {
        ;
      }
      jj_consume_token(RPARENTHESIS);
      statement();
      break;
    default:
      jj_la1[89] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  static final public void jump_statement() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case GOTO:
      jj_consume_token(GOTO);
      jj_consume_token(ID);
      jj_consume_token(SEMICOLON);
      break;
    case CONTINUE:
      jj_consume_token(CONTINUE);
      jj_consume_token(SEMICOLON);
      break;
    case BREAK:
      jj_consume_token(BREAK);
      jj_consume_token(SEMICOLON);
      break;
    case RETURN:
      jj_consume_token(RETURN);
      if (jj_2_101(1)) {
        expression();
      } else {
        ;
      }
      jj_consume_token(SEMICOLON);
      break;
    default:
      jj_la1[90] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  static final public void try_block() throws ParseException {
    jj_consume_token(TRY);
    compound_statement();
    label_26:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case CATCH:
      case 129:
        ;
        break;
      default:
        jj_la1[91] = jj_gen;
        break label_26;
      }
      handler();
    }
  }

  static final public void handler() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case CATCH:
      jj_consume_token(CATCH);
      jj_consume_token(LPARENTHESIS);
      exception_declaration();
      jj_consume_token(RPARENTHESIS);
      compound_statement();
      break;
    case 129:
      jj_consume_token(129);
      compound_statement();
      break;
    default:
      jj_la1[92] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  static final public void exception_declaration() throws ParseException {
    if (jj_2_102(1)) {
      parameter_declaration_list();
    } else {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case ELLIPSIS:
        jj_consume_token(ELLIPSIS);