Examples of FieldRef

com.litecoding.smali2java.entity.smali.FieldRef
com.pclewis.mcpatcher.FieldRef
Reference to a field within a class. @see JavaRef
fr.xlim.ssd.capmanipulator.library.FieldRef
org.allspice.bytecode.FieldRef
Represents the reference of non-static field. Such a value will have an object reference on the stack. @author egoff
org.jvnet.sorcerer.Tag.FieldRef
soot.jimple.FieldRef

Examples of org.allspice.bytecode.FieldRef

    case fieldref: {
      if (type == TypeCode.VOID) {
        ilc.add(InstructionConstants.POP) ;
      }
      else {
        FieldRef fdef = (FieldRef)lval ;
        Type typ = TypeDefConverter.makeType(fdef.getType()) ;
        ilc.add(ilc.getInstructionFactory().createPutField(fdef.clazz.toString(), fdef.name, typ)) ;
      }
      break ;
    }
    case staticref: {
      if (type != TypeCode.VOID) {        
        StaticFieldRef fdef = (StaticFieldRef)lval ;
        Type typ = TypeDefConverter.makeType(fdef.getType()) ;
        ilc.add(ilc.getInstructionFactory().createPutStatic(fdef.clazz.toString(), fdef.name, typ)) ;
      }
      break ;
    }
    }

View Full Code Here

Examples of org.jvnet.sorcerer.Tag.FieldRef

                        case INTERFACE:
                            gen.add(new TypeRef(cu,srcPos,id,(TypeElement)e));
                            break;
                        case FIELD: // such as objects imported by static import.
                        case ENUM_CONSTANT:
                            gen.add(new FieldRef(cu,srcPos,id,(VariableElement)e));
                            break;
                        case PARAMETER:
                        case EXCEPTION_PARAMETER:
                        case LOCAL_VARIABLE:
                            gen.add(new LocalVarRef(cu,srcPos,id,(VariableElement)e));
                            break;
                        }
                    }
                }


                return super.visitIdentifier(id,_);
            }


            /**
             * "exp.token"
             */
            public Void visitMemberSelect(MemberSelectTree mst, Void _) {
                // avoid marking 'Foo.class' as static reference
                if(!mst.getIdentifier().equals(CLASS)) {
                    // just select the 'token' portion
                    long ep = srcPos.getEndPosition(cu,mst);
                    long sp = ep-mst.getIdentifier().length();


                    // marker for the selected identifier
                    Element e = TreeUtil.getElement(mst);
                    if(e!=null) {
                        switch(e.getKind()) {
                        case FIELD:
                        case ENUM_CONSTANT:
                            gen.add(new FieldRef(sp, ep, PositionUtils.getLineNumber(lineMap, sp), PositionUtils.getColNumber(lineMap, sp), (VariableElement)e));
                            break;


                        // these show up in the import statement
                        case ANNOTATION_TYPE:
                        case CLASS:

View Full Code Here

Examples of soot.jimple.FieldRef

                    addEdge( source, s, clinit, Kind.CLINIT );
                  }
                }
            }
            if( s.containsFieldRef() ) {
                FieldRef fr = s.getFieldRef();
                if( fr instanceof StaticFieldRef ) {
                    SootClass cl = fr.getFieldRef().declaringClass();
                    for (SootMethod clinit : EntryPoints.v().clinitsOf(cl)) {
                        addEdge( source, s, clinit, Kind.CLINIT );
                    }
                }
            }

View Full Code Here

Examples of soot.jimple.FieldRef

      Stmt s = (Stmt) unit;
      List<ValueBox> useBoxes = s.getUseBoxes();
      for (ValueBox useBox : useBoxes) {
        Value val = useBox.getValue();
        if(val instanceof FieldRef) {
          FieldRef fieldRef = (FieldRef) val;
          if(fieldRef.getType() instanceof RefLikeType)
            usedFieldRefs.add(new EquivalentValue(fieldRef));            
        }
      }
    }

View Full Code Here

Examples of soot.jimple.FieldRef

                            if (debug) {
                                System.out
                                        .println("handling as assignment to Field");
                            }


                            FieldRef oldFieldRef = (FieldRef) stmt.getLeftOp();
                            SootField field = oldFieldRef.getField();
                            Map fieldToReplacementField = (Map) entityFieldToTokenFieldToReplacementField
                                    .get(field);
                            Map fieldToReplacementLocal = (Map) localToFieldToLocal
                                    .get(stmt.getRightOp());


                            //        System.out.println("fieldToReplacementField = " + fieldToReplacementField);
                            //                             System.out.println("fieldToReplacementLocal = " + fieldToReplacementLocal);
                            if ((fieldToReplacementLocal != null)
                                    && (fieldToReplacementField != null)) {
                                doneSomething = true;
                                // Replace references to fields with token types.
                                {
                                    SootField replacementField = (SootField) entityFieldToIsNotNullField
                                            .get(field);


                                    //System.out.println("replacementField = " + replacementField);
                                    FieldRef isNotNullFieldRef;


                                    if (oldFieldRef instanceof InstanceFieldRef) {
                                        isNotNullFieldRef = Jimple
                                                .v()
                                                .newInstanceFieldRef(
                                                        ((InstanceFieldRef) oldFieldRef)
                                                                .getBase(),
                                                        replacementField
                                                                .makeRef());
                                    } else {
                                        isNotNullFieldRef = Jimple.v()
                                                .newStaticFieldRef(
                                                        replacementField
                                                                .makeRef());
                                    }


                                    body
                                            .getUnits()
                                            .insertBefore(
                                                    Jimple
                                                            .v()
                                                            .newAssignStmt(
                                                                    isNotNullFieldRef,
                                                                    (Local) localToIsNotNullLocal
                                                                            .get(stmt
                                                                                    .getRightOp())),
                                                    unit);
                                }


                                if (debug) {
                                    System.out.println("local = "
                                            + stmt.getLeftOp());
                                }


                                for (Iterator tokenFields = fieldToReplacementField
                                        .keySet().iterator(); tokenFields
                                        .hasNext();) {
                                    SootField tokenField = (SootField) tokenFields
                                            .next();


                                    if (debug) {
                                        System.out.println("tokenField = "
                                                + tokenField);
                                    }


                                    SootField replacementField = (SootField) fieldToReplacementField
                                            .get(tokenField);
                                    Local replacementLocal = (Local) fieldToReplacementLocal
                                            .get(tokenField);


                                    if (debug) {
                                        System.out
                                                .println("replacementLocal = "
                                                        + replacementLocal);
                                    }


                                    FieldRef fieldRef;


                                    if (stmt.getLeftOp() instanceof InstanceFieldRef) {
                                        Local base = (Local) ((InstanceFieldRef) stmt
                                                .getLeftOp()).getBase();
                                        fieldRef = Jimple.v()
                                                .newInstanceFieldRef(
                                                        base,
                                                        replacementField
                                                                .makeRef());
                                    } else {
                                        fieldRef = Jimple.v()
                                                .newStaticFieldRef(
                                                        replacementField
                                                                .makeRef());
                                    }


                                    body.getUnits().insertBefore(
                                            Jimple.v().newAssignStmt(fieldRef,
                                                    replacementLocal), unit);
                                }


                                stmt.getRightOpBox().setValue(NullConstant.v());


                                // body.getUnits().remove(unit);
                            }
                        } else if (stmt.getLeftOp() instanceof Local
                                && stmt.getRightOp() instanceof FieldRef) {
                            if (debug) {
                                System.out
                                        .println("handling as assignment from Field");
                            }


                            FieldRef oldFieldRef = (FieldRef) stmt.getRightOp();
                            Map fieldToReplacementLocal = (Map) localToFieldToLocal
                                    .get(stmt.getLeftOp());
                            SootField field = oldFieldRef.getField();
                            Map fieldToReplacementField = (Map) entityFieldToTokenFieldToReplacementField
                                    .get(field);


                            // There are some fields that represent
                            // singleton tokens.  Deal with them
                            // specially.


                            // This is awkward, but it is simpler than
                            // doing a dataflow analysis of the static
                            // initializer of the token class to
                            // figure out what the value is.
                            boolean isSingleton = false;
                            if (field.getName().equals("TRUE")
                                    || field.getName().equals("FALSE")
                                    || field.getName().equals("ZERO")
                                    || field.getName().equals("ONE")) {
                                isSingleton = true;
                            }


                            if ((isSingleton)
                                    && (fieldToReplacementLocal != null)) {
                                doneSomething = true;


                                // Replace references to fields with
                                // token types.  The special fields
                                // should never be null
                                body.getUnits().insertBefore(
                                        Jimple.v().newAssignStmt(
                                                (Local) localToIsNotNullLocal
                                                        .get(stmt.getLeftOp()),
                                                IntConstant.v(1)), unit);


                                if (debug) {
                                    System.out.println("local = "
                                            + stmt.getLeftOp());
                                }


                                for (Iterator localFields = fieldToReplacementLocal
                                        .keySet().iterator(); localFields
                                        .hasNext();) {
                                    SootField localField = (SootField) localFields
                                            .next();


                                    if (debug) {
                                        System.out.println("localField = "
                                                + localField);
                                    }


                                    //     if (localField.getName().equals("_isNil")) {
                                    //                                         Local replacementLocal = (Local) fieldToReplacementLocal
                                    //                                                 .get(localField);


                                    //                                         body
                                    //                                                 .getUnits()
                                    //                                                 .insertBefore(
                                    //                                                         Jimple
                                    //                                                                 .v()
                                    //                                                                 .newAssignStmt(
                                    //                                                                         replacementLocal,
                                    //                                                                         IntConstant
                                    //                                                                                 .v(1)),
                                    //                                                         unit);
                                    //                                     } else
                                    if (localField.getName().equals(
                                            "_unitCategoryExponents")) {


                                        Local replacementLocal = (Local) fieldToReplacementLocal
                                                .get(localField);
                                        body
                                                .getUnits()
                                                .insertBefore(
                                                        Jimple
                                                                .v()
                                                                .newAssignStmt(
                                                                        replacementLocal,
                                                                        NullConstant
                                                                                .v()),
                                                        unit);
                                    } else if (localField.getName().equals(
                                            "_value")) {


                                        Local replacementLocal = (Local) fieldToReplacementLocal
                                                .get(localField);


                                        if (field
                                                .getSignature()
                                                .equals(
                                                        "<ptolemy.data.BooleanToken: ptolemy.data.BooleanToken TRUE>")) {
                                            body.getUnits().insertBefore(
                                                    Jimple.v().newAssignStmt(
                                                            replacementLocal,
                                                            IntConstant.v(1)),
                                                    unit);
                                        } else if (field
                                                .getSignature()
                                                .equals(
                                                        "<ptolemy.data.BooleanToken: ptolemy.data.BooleanToken FALSE>")) {


                                            body.getUnits().insertBefore(
                                                    Jimple.v().newAssignStmt(
                                                            replacementLocal,
                                                            IntConstant.v(0)),
                                                    unit);
                                        } else if (field
                                                .getSignature()
                                                .equals(
                                                        "<ptolemy.data.UnsignedByteToken: ptolemy.data.UnsignedByteToken ONE>")) {
                                            body.getUnits().insertBefore(
                                                    Jimple.v().newAssignStmt(
                                                            replacementLocal,
                                                            IntConstant.v(1)),
                                                    unit);
                                        } else if (field
                                                .getSignature()
                                                .equals(
                                                        "<ptolemy.data.UnsignedByteToken: ptolemy.data.UnsignedByteToken ZERO>")) {


                                            body.getUnits().insertBefore(
                                                    Jimple.v().newAssignStmt(
                                                            replacementLocal,
                                                            IntConstant.v(0)),
                                                    unit);
                                        } else if (field
                                                .getSignature()
                                                .equals(
                                                        "<ptolemy.data.IntToken: ptolemy.data.IntToken ONE>")) {
                                            body.getUnits().insertBefore(
                                                    Jimple.v().newAssignStmt(
                                                            replacementLocal,
                                                            IntConstant.v(1)),
                                                    unit);
                                        } else if (field
                                                .getSignature()
                                                .equals(
                                                        "<ptolemy.data.IntToken: ptolemy.data.IntToken ZERO>")) {


                                            body.getUnits().insertBefore(
                                                    Jimple.v().newAssignStmt(
                                                            replacementLocal,
                                                            IntConstant.v(0)),
                                                    unit);
                                        } else if (field
                                                .getSignature()
                                                .equals(
                                                        "<ptolemy.data.LongToken: ptolemy.data.LongToken ONE>")) {
                                            body.getUnits().insertBefore(
                                                    Jimple.v().newAssignStmt(
                                                            replacementLocal,
                                                            LongConstant.v(1)),
                                                    unit);
                                        } else if (field
                                                .getSignature()
                                                .equals(
                                                        "<ptolemy.data.LongToken: ptolemy.data.LongToken ZERO>")) {


                                            body.getUnits().insertBefore(
                                                    Jimple.v().newAssignStmt(
                                                            replacementLocal,
                                                            LongConstant.v(0)),
                                                    unit);
                                        } else if (field
                                                .getSignature()
                                                .equals(
                                                        "<ptolemy.data.DoubleToken: ptolemy.data.DoubleToken ONE>")) {


                                            body.getUnits().insertBefore(
                                                    Jimple.v().newAssignStmt(
                                                            replacementLocal,
                                                            DoubleConstant
                                                                    .v(1.0)),
                                                    unit);
                                        } else if (field
                                                .getSignature()
                                                .equals(
                                                        "<ptolemy.data.DoubleToken: ptolemy.data.DoubleToken ZERO>")) {


                                            body.getUnits().insertBefore(
                                                    Jimple.v().newAssignStmt(
                                                            replacementLocal,
                                                            DoubleConstant
                                                                    .v(0.0)),
                                                    unit);
                                        }
                                    } else {
                                        throw new RuntimeException(
                                                "Unknown Field in Token: "
                                                        + localField
                                                                .getSignature());
                                    }
                                }


                                stmt.getRightOpBox().setValue(NullConstant.v());


                                //body.getUnits().remove(unit);
                            } else if ((fieldToReplacementLocal != null)
                                    && (fieldToReplacementField != null)) {
                                doneSomething = true;
                                // Replace references to fields with token types.
                                // FIXME properly handle isNotNull field?
                                {
                                    SootField replacementField = (SootField) entityFieldToIsNotNullField
                                            .get(field);


                                    //   System.out.println("replacementField = " + replacementField);
                                    FieldRef isNotNullFieldRef;


                                    if (oldFieldRef instanceof InstanceFieldRef) {
                                        isNotNullFieldRef = Jimple
                                                .v()
                                                .newInstanceFieldRef(
                                                        ((InstanceFieldRef) oldFieldRef)
                                                                .getBase(),
                                                        replacementField
                                                                .makeRef());
                                    } else {
                                        isNotNullFieldRef = Jimple.v()
                                                .newStaticFieldRef(
                                                        replacementField
                                                                .makeRef());
                                    }


                                    body
                                            .getUnits()
                                            .insertBefore(
                                                    Jimple
                                                            .v()
                                                            .newAssignStmt(
                                                                    (Local) localToIsNotNullLocal
                                                                            .get(stmt
                                                                                    .getLeftOp()),
                                                                    isNotNullFieldRef),
                                                    unit);
                                }


                                if (debug) {
                                    System.out.println("local = "
                                            + stmt.getLeftOp());
                                }


                                for (Iterator tokenFields = fieldToReplacementField
                                        .keySet().iterator(); tokenFields
                                        .hasNext();) {
                                    SootField tokenField = (SootField) tokenFields
                                            .next();


                                    if (debug) {
                                        System.out.println("tokenField = "
                                                + tokenField);
                                    }


                                    SootField replacementField = (SootField) fieldToReplacementField
                                            .get(tokenField);
                                    Local replacementLocal = (Local) fieldToReplacementLocal
                                            .get(tokenField);
                                    FieldRef fieldRef;


                                    if (stmt.getRightOp() instanceof InstanceFieldRef) {
                                        Local base = (Local) ((InstanceFieldRef) stmt
                                                .getRightOp()).getBase();
                                        fieldRef = Jimple.v()

View Full Code Here

Examples of soot.jimple.FieldRef

                if (unit instanceof Stmt) {
                    Stmt stmt = (Stmt) unit;


                    // Add accessed fields.
                    if (stmt.containsFieldRef()) {
                        FieldRef fieldRef = stmt.getFieldRef();
                        SootField field = fieldRef.getField();
                        nodes.add(field);
                    }


                    // Add directly called methods.
                    if (!leaf && stmt.containsInvokeExpr()) {

View Full Code Here

Examples of soot.jimple.FieldRef

                        .hasNext();) {
                    ValueBox box = (ValueBox) boxes.next();
                    Value value = box.getValue();


                    if (value instanceof FieldRef) {
                        FieldRef ref = (FieldRef) value;


                        if (ref.getField() == theField) {
                            System.out.println("removing stmt = " + stmt);
                            units.remove(stmt);
                        }
                    }
                }


                // Inline all the uses.
                if (Evaluator.isValueConstantValued(newValue)) {
                    for (Iterator boxes = stmt.getUseBoxes().iterator(); boxes
                            .hasNext();) {
                        ValueBox box = (ValueBox) boxes.next();
                        Value value = box.getValue();


                        if (value instanceof FieldRef) {
                            FieldRef ref = (FieldRef) value;


                            if (ref.getField() == theField) {
                                System.out.println("inlining stmt = " + stmt);


                                box.setValue(Evaluator
                                        .getConstantValueOf(newValue));
                            }
                        }
                    }
                }
            }
        }


        if (Modifier.isStatic(theField.getModifiers())) {
            SootMethod method;


            // create a class initializer if one does not already exist.
            if (theClass.declaresMethodByName("<clinit>")) {
                method = theClass.getMethodByName("<clinit>");
            } else {
                method = new SootMethod("<clinit>", new LinkedList(), NullType
                        .v(), Modifier.PUBLIC);
                theClass.addMethod(method);
            }


            JimpleBody body = (JimpleBody) method.retrieveActiveBody();
            Chain units = body.getUnits();
            Stmt insertPoint = (Stmt) units.getLast();
            Local local = Jimple.v().newLocal("_CGTemp" + theField.getName(),
                    theField.getType());
            body.getLocals().add(local);
            units.insertBefore(Jimple.v().newAssignStmt(local, newValue),
                    insertPoint);


            FieldRef fieldRef = Jimple.v()
                    .newStaticFieldRef(theField.makeRef());
            units.insertBefore(Jimple.v().newAssignStmt(fieldRef, local),
                    insertPoint);
        } else {
            for (Iterator methods = theClass.getMethods().iterator(); methods
                    .hasNext();) {
                SootMethod method = (SootMethod) methods.next();


                // ignore things that aren't initializers.
                if (!method.getName().equals("<init>")) {
                    continue;
                }


                JimpleBody body = (JimpleBody) method.retrieveActiveBody();
                Chain units = body.getUnits();
                Stmt insertPoint = (Stmt) units.getLast();
                Local local = Jimple.v().newLocal(
                        "_CGTemp" + theField.getName(), theField.getType());
                body.getLocals().add(local);
                units.insertBefore(Jimple.v().newAssignStmt(local, newValue),
                        insertPoint);


                FieldRef fieldRef = Jimple.v().newInstanceFieldRef(
                        body.getThisLocal(), theField.makeRef());
                units.insertBefore(Jimple.v().newAssignStmt(fieldRef, local),
                        insertPoint);
            }
        }

View Full Code Here

Examples of soot.jimple.FieldRef

                    ValueBox box = (ValueBox) boxes.next();
                    Value value = box.getValue();


                    if (value instanceof FieldRef) {
                        // Fix references to fields
                        FieldRef r = (FieldRef) value;
                        SootFieldRef fieldRef = r.getFieldRef();
                        if (fieldRef.type() instanceof RefType) {
                            RefType fieldType = (RefType) fieldRef.type();
                            SootClass fieldClass = fieldType.getSootClass();
                            if (fieldClass == oldClass) {
                                r.setFieldRef(Scene.v().makeFieldRef(
                                        fieldRef.declaringClass(),
                                        fieldRef.name(), RefType.v(newClass),
                                        fieldRef.isStatic()));
                            }
                            fieldRef = r.getFieldRef();
                        }


                        if (fieldRef.declaringClass() == oldClass) {
                            // We might also have a reference to a field
                            // which is not actually declared in the
                            // oldclass, in which case, we just fix up
                            // the ref to point to the new super class
                            r.setFieldRef(Scene.v().makeFieldRef(newClass,
                                    fieldRef.name(), fieldRef.type(),
                                    fieldRef.isStatic()));
                        } else if (fieldRef.declaringClass().getName()
                                .startsWith(oldClass.getName())) {
                            SootClass changeClass = _getInnerClassCopy(
                                    oldClass, r.getField().getDeclaringClass(),
                                    newClass);
                            r.setFieldRef(changeClass.getFieldByName(
                                    r.getField().getName()).makeRef());
                        }//  else if (r.getField().getDeclaringClass() == oldClass) {
                        //                             r.setFieldRef(
                        //                                     newClass.getFieldByName(
                        //                                             r.getField().getName()).makeRef());


                        //                             //   System.out.println("fieldRef = " +
                        //                             //              box.getValue());
                        //                         }


                    } else if (value instanceof CastExpr) {
                        // Fix casts
                        CastExpr r = (CastExpr) value;
                        Type type = r.getType();


                        if (type instanceof RefType) {
                            SootClass refClass = ((RefType) type)
                                    .getSootClass();


                            if (refClass == oldClass) {
                                r.setCastType(RefType.v(newClass));


                                // System.out.println("newValue = " +
                                //        box.getValue());
                            } else if (refClass.getName().startsWith(
                                    oldClass.getName())) {
                                SootClass changeClass = _getInnerClassCopy(
                                        oldClass, refClass, newClass);
                                r.setCastType(RefType.v(changeClass));
                            }
                        }
                    } else if (value instanceof ThisRef) {
                        // Fix references to 'this'
                        ThisRef r = (ThisRef) value;
                        Type type = r.getType();


                        if (type instanceof RefType
                                && (((RefType) type).getSootClass() == oldClass)) {
                            box.setValue(Jimple.v().newThisRef(
                                    RefType.v(newClass)));
                        }
                    } else if (value instanceof ParameterRef) {
                        // Fix references to a parameter
                        ParameterRef r = (ParameterRef) value;
                        Type type = r.getType();


                        if (type instanceof RefType
                                && (((RefType) type).getSootClass() == oldClass)) {
                            box.setValue(Jimple.v().newParameterRef(
                                    RefType.v(newClass), r.getIndex()));
                        }
                    } else if (value instanceof InvokeExpr) {
                        // Fix up the method invokes.
                        InvokeExpr r = (InvokeExpr) value;
                        SootMethodRef methodRef = r.getMethodRef();
                        System.out.println("invoke = " + r);


                        List newParameterTypes = new LinkedList();
                        for (Iterator i = methodRef.parameterTypes().iterator(); i
                                .hasNext();) {
                            Type type = (Type) i.next();
                            if (type instanceof RefType
                                    && (((RefType) type).getSootClass() == oldClass)) {
                                System.out.println("matchedParameter = "
                                        + newClass);
                                newParameterTypes.add(RefType.v(newClass));
                            } else if (type instanceof RefType
                                    && (((RefType) type).getSootClass()
                                            .getName().startsWith(oldClass
                                            .getName()))) {
                                System.out.println("matchedParameter = "
                                        + newClass);
                                SootClass changeClass = _getInnerClassCopy(
                                        oldClass, ((RefType) type)
                                                .getSootClass(), newClass);
                                newParameterTypes.add(RefType.v(changeClass));
                            } else {
                                newParameterTypes.add(type);
                            }


                        }


                        Type newReturnType = methodRef.returnType();
                        if (newReturnType instanceof RefType
                                && (((RefType) newReturnType).getSootClass() == oldClass)) {
                            newReturnType = RefType.v(newClass);
                        }


                        // Update the parameter types and the return type.
                        methodRef = Scene.v().makeMethodRef(
                                methodRef.declaringClass(), methodRef.name(),
                                newParameterTypes, newReturnType,
                                methodRef.isStatic());
                        r.setMethodRef(methodRef);


                        if (methodRef.declaringClass() == oldClass) {
                            r.setMethodRef(Scene.v().makeMethodRef(newClass,
                                    methodRef.name(),
                                    methodRef.parameterTypes(),
                                    methodRef.returnType(),
                                    methodRef.isStatic()));
                            // System.out.println("newValue = " +
                            // box.getValue());
                        } else if (methodRef.declaringClass().getName()
                                .startsWith(oldClass.getName())) {
                            SootClass changeClass = _getInnerClassCopy(
                                    oldClass, methodRef.declaringClass(),
                                    newClass);
                            r.setMethodRef(Scene.v().makeMethodRef(changeClass,
                                    methodRef.name(),
                                    methodRef.parameterTypes(),
                                    methodRef.returnType(),
                                    methodRef.isStatic()));
                        }
                    } else if (value instanceof NewExpr) {
                        // Fix up the object creations.
                        NewExpr r = (NewExpr) value;


                        if (r.getBaseType().getSootClass() == oldClass) {
                            r.setBaseType(RefType.v(newClass));


                            //   System.out.println("newValue = " +
                            //           box.getValue());
                        } else if (r.getBaseType().getSootClass().getName()
                                .startsWith(oldClass.getName())) {
                            SootClass changeClass = _getInnerClassCopy(
                                    oldClass, r.getBaseType().getSootClass(),
                                    newClass);
                            r.setBaseType(RefType.v(changeClass));
                        }
                    }


                    //    System.out.println("value = " + value);
                    //   System.out.println("class = " +

View Full Code Here

Examples of soot.jimple.FieldRef

                    ValueBox box = (ValueBox) boxes.next();
                    Value value = box.getValue();


                    if (value instanceof FieldRef) {
                        // Fix references to fields
                        FieldRef r = (FieldRef) value;
                        SootFieldRef fieldRef = r.getFieldRef();


                        if (r.getField().getDeclaringClass() != superClass
                                && fieldRef.declaringClass() == superClass) {
                            // We might also have a reference to a method
                            // which is not actually declared in the
                            // superclass, in which case, we just fix up
                            // the ref to point to the new super class
                            r.setFieldRef(Scene.v().makeFieldRef(
                                    superClass.getSuperclass(),
                                    fieldRef.name(), fieldRef.type(),
                                    fieldRef.isStatic()));
                        }
                    }

View Full Code Here

Examples of soot.jimple.FieldRef

                }


                // Otherwise there is nothing to be done.
            } else if (rightOp instanceof FieldRef) {
                // System.out.println("fieldRef stmt = " + stmt);
                FieldRef fieldRef = (FieldRef) rightOp;
                SootField field = fieldRef.getField();
                TypeTag tag = (TypeTag) field.getTag("_CGType");
                Object newType;


                if (tag == null) {
                    //  System.out.println("No Tag... Existing type = " + in.get(rightOp));

View Full Code Here

0 1 2

TOP

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.