basicverifier.java

jboss规则引擎

                expected2 = BasicValue.INT_VALUE;
                break;
            case DALOAD :
                expected1 = newValue( Type.getType( "[D" ) );
                expected2 = BasicValue.INT_VALUE;
                break;
            case AALOAD :
                expected1 = newValue( Type.getType( "[Ljava/lang/Object;" ) );
                expected2 = BasicValue.INT_VALUE;
                break;
            case IADD :
            case ISUB :
            case IMUL :
            case IDIV :
            case IREM :
            case ISHL :
            case ISHR :
            case IUSHR :
            case IAND :
            case IOR :
            case IXOR :
            case IF_ICMPEQ :
            case IF_ICMPNE :
            case IF_ICMPLT :
            case IF_ICMPGE :
            case IF_ICMPGT :
            case IF_ICMPLE :
                expected1 = BasicValue.INT_VALUE;
                expected2 = BasicValue.INT_VALUE;
                break;
            case FADD :
            case FSUB :
            case FMUL :
            case FDIV :
            case FREM :
            case FCMPL :
            case FCMPG :
                expected1 = BasicValue.FLOAT_VALUE;
                expected2 = BasicValue.FLOAT_VALUE;
                break;
            case LADD :
            case LSUB :
            case LMUL :
            case LDIV :
            case LREM :
            case LAND :
            case LOR :
            case LXOR :
            case LCMP :
                expected1 = BasicValue.LONG_VALUE;
                expected2 = BasicValue.LONG_VALUE;
                break;
            case LSHL :
            case LSHR :
            case LUSHR :
                expected1 = BasicValue.LONG_VALUE;
                expected2 = BasicValue.INT_VALUE;
                break;
            case DADD :
            case DSUB :
            case DMUL :
            case DDIV :
            case DREM :
            case DCMPL :
            case DCMPG :
                expected1 = BasicValue.DOUBLE_VALUE;
                expected2 = BasicValue.DOUBLE_VALUE;
                break;
            case IF_ACMPEQ :
            case IF_ACMPNE :
                expected1 = BasicValue.REFERENCE_VALUE;
                expected2 = BasicValue.REFERENCE_VALUE;
                break;
            case PUTFIELD :
                final FieldInsnNode fin = (FieldInsnNode) insn;
                expected1 = newValue( Type.getType( "L" + fin.owner + ";" ) );
                expected2 = newValue( Type.getType( fin.desc ) );
                break;
            default :
                throw new RuntimeException( "Internal error." );
        }
        if ( !isSubTypeOf( value1,
                           expected1 ) ) {
            throw new AnalyzerException( "First argument",
                                         expected1,
                                         value1 );
        } else if ( !isSubTypeOf( value2,
                                  expected2 ) ) {
            throw new AnalyzerException( "Second argument",
                                         expected2,
                                         value2 );
        }
        if ( insn.getOpcode() == Opcodes.AALOAD ) {
            return getElementValue( value1 );
        } else {
            return super.binaryOperation( insn,
                                          value1,
                                          value2 );
        }
    }

    public Value ternaryOperation(final AbstractInsnNode insn,
                                  final Value value1,
                                  final Value value2,
                                  final Value value3) throws AnalyzerException {
        Value expected1;
        Value expected3;
        switch ( insn.getOpcode() ) {
            case IASTORE :
                expected1 = newValue( Type.getType( "[I" ) );
                expected3 = BasicValue.INT_VALUE;
                break;
            case BASTORE :
                if ( !isSubTypeOf( value1,
                                   newValue( Type.getType( "[Z" ) ) ) ) {
                    expected1 = newValue( Type.getType( "[B" ) );
                } else {
                    expected1 = newValue( Type.getType( "[Z" ) );
                }
                expected3 = BasicValue.INT_VALUE;
                break;
            case CASTORE :
                expected1 = newValue( Type.getType( "[C" ) );
                expected3 = BasicValue.INT_VALUE;
                break;
            case SASTORE :
                expected1 = newValue( Type.getType( "[S" ) );
                expected3 = BasicValue.INT_VALUE;
                break;
            case LASTORE :
                expected1 = newValue( Type.getType( "[J" ) );
                expected3 = BasicValue.LONG_VALUE;
                break;
            case FASTORE :
                expected1 = newValue( Type.getType( "[F" ) );
                expected3 = BasicValue.FLOAT_VALUE;
                break;
            case DASTORE :
                expected1 = newValue( Type.getType( "[D" ) );
                expected3 = BasicValue.DOUBLE_VALUE;
                break;
            case AASTORE :
                expected1 = value1;
                expected3 = BasicValue.REFERENCE_VALUE;
                break;
            default :
                throw new RuntimeException( "Internal error." );
        }
        if ( !isSubTypeOf( value1,
                           expected1 ) ) {
            throw new AnalyzerException( "First argument",
                                         "a " + expected1 + " array reference",
                                         value1 );
        } else if ( value2 != BasicValue.INT_VALUE ) {
            throw new AnalyzerException( "Second argument",
                                         BasicValue.INT_VALUE,
                                         value2 );
        } else if ( !isSubTypeOf( value3,
                                  expected3 ) ) {
            throw new AnalyzerException( "Third argument",
                                         expected3,
                                         value3 );
        }
        return null;
    }

    public Value naryOperation(final AbstractInsnNode insn,
                               final List values) throws AnalyzerException {
        final int opcode = insn.getOpcode();
        if ( opcode == Opcodes.MULTIANEWARRAY ) {
            for ( int i = 0; i < values.size(); ++i ) {
                if ( values.get( i ) != BasicValue.INT_VALUE ) {
                    throw new AnalyzerException( null,
                                                 BasicValue.INT_VALUE,
                                                 (Value) values.get( i ) );
                }
            }
        } else {
            int i = 0;
            int j = 0;
            if ( opcode != Opcodes.INVOKESTATIC ) {
                String own = ((MethodInsnNode) insn).owner;
                if ( own.charAt( 0 ) != '[' ) { // can happen with JDK1.5 clone()
                    own = "L" + own + ";";
                }
                final Type owner = Type.getType( own );
                if ( !isSubTypeOf( (Value) values.get( i++ ),
                                   newValue( owner ) ) ) {
                    throw new AnalyzerException( "Method owner",
                                                 newValue( owner ),
                                                 (Value) values.get( 0 ) );
                }
            }
            final Type[] args = Type.getArgumentTypes( ((MethodInsnNode) insn).desc );
            while ( i < values.size() ) {
                final Value expected = newValue( args[j++] );
                final Value encountered = (Value) values.get( i++ );
                if ( !isSubTypeOf( encountered,
                                   expected ) ) {
                    throw new AnalyzerException( "Argument " + j,
                                                 expected,
                                                 encountered );
                }
            }
        }
        return super.naryOperation( insn,
                                    values );
    }

    protected boolean isArrayValue(final Value value) {
        return ((BasicValue) value).isReference();
    }

    protected Value getElementValue(final Value objectArrayValue) throws AnalyzerException {
        return BasicValue.REFERENCE_VALUE;
    }

    protected boolean isSubTypeOf(final Value value,
                                  final Value expected) {
        return value == expected;
    }
}