Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /* Soot - a J*va Optimization Framework
   * Copyright (C) 1997-1999 Raja Vallee-Rai
   *
   * This library is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
   * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the
  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  * Boston, MA 02111-1307, USA.
  */
 
 /*
  * Modified by the Sable Research Group and others 1997-1999.  
  * See the 'credits' file distributed with Soot for the complete list of
  * contributors.  (Soot is distributed at http://www.sable.mcgill.ca/soot)
  */
 
 
 
 
 
 package soot.jimple;
 
 import soot.*;
 import java.util.*;

The Jimple class contains all the constructors for the components of the Jimple grammar for the Jimple body.

Immediate -> Local | Constant
RValue -> Local | Constant | ConcreteRef | Expr
Variable -> Local | ArrayRef | InstanceFieldRef | StaticFieldRef
 
 
 
 public class Jimple
 {
     public JimpleSingletons.Global g ) {}
     public static Jimple v() { return G.v().soot_jimple_Jimple(); }
 
     public final static String NEWARRAY = "newarray";
     public final static String NEWMULTIARRAY = "newmultiarray";
     public final static String NOP = "nop";
     public final static String RET = "ret";
     public final static String SPECIALINVOKE = "specialinvoke";
     public final static String DYNAMICINVOKE = "dynamicinvoke";
     public final static String STATICINVOKE = "staticinvoke";
     public final static String TABLESWITCH = "tableswitch";
     public final static String VIRTUALINVOKE = "virtualinvoke";
     public final static String NULL_TYPE = "null_type";
     public final static String UNKNOWN = "unknown";
     public final static String CMP = "cmp";
     public final static String CMPG = "cmpg";
     public final static String CMPL = "cmpl";
     public final static String ENTERMONITOR = "entermonitor";
     public final static String EXITMONITOR = "exitmonitor";
     public final static String INTERFACEINVOKE = "interfaceinvoke";
     public final static String LENGTHOF = "lengthof";
     public final static String LOOKUPSWITCH = "lookupswitch";
     public final static String NEG = "neg";    
     public final static String IF = "if";
     public final static String ABSTRACT = "abstract";
     public final static String BOOLEAN = "boolean";
     public final static String BREAK = "break";
     public final static String BYTE = "byte";
     public final static String CASE = "case";
     public final static String CATCH = "catch";
     public final static String CHAR = "char";
     public final static String CLASS = "class";
     public final static String FINAL = "final";
     public final static String NATIVE = "native";
     public final static String PUBLIC = "public";
     public final static String PROTECTED = "protected";
     public final static String PRIVATE = "private";
     public final static String STATIC = "static";
     public final static String SYNCHRONIZED = "synchronized";
     public final static String TRANSIENT = "transient";
     public final static String VOLATILE = "volatile";
     public final static String STRICTFP = "strictfp";
     public final static String ENUM = "enum";
     public final static String ANNOTATION = "annotation";
     public final static String INTERFACE = "interface";
     public final static String VOID = "void";
     public final static String SHORT = "short";
     public final static String INT = "int";
     public final static String LONG = "long";
     public final static String FLOAT = "float";
     public final static String DOUBLE = "double";
     public final static String EXTENDS = "extends";
    public final static String IMPLEMENTS = "implements";
    public final static String BREAKPOINT = "breakpoint";
    public final static String DEFAULT = "default";
    public final static String GOTO = "goto";
    public final static String INSTANCEOF = "instanceof";
    public final static String NEW = "new";
    public final static String RETURN = "return";
    public final static String THROW = "throw";
    public final static String THROWS = "throws";
    public final static String NULL = "null";
    public final static String FROM = "from";
    public final static String TO = "to";
    public final static String WITH = "with";
    public final static String CLS = "cls";
    public final static String TRUE = "true";
    public final static String FALSE = "false";
    public static List<StringjimpleKeywordList()
    {
        List<Stringl = new LinkedList<String>();
        l.add (); l.add (); l.add ();
        l.add (); l.add (); l.add ();
        l.add (); l.add (); l.add ();
        l.add (); l.add (); l.add (); l.add ();
        l.add (); l.add (); l.add ();
        l.add (); l.add (); l.add ();
        l.add (); l.add (); l.add (); l.add ();
        l.add (); l.add(); l.add (); l.add (); 
        l.add (); l.add (); l.add (); l.add ();
        l.add (); l.add (); l.add ();
        l.add (); l.add (); l.add ();
        l.add (); l.add (); l.add ();
        l.add (); l.add (); l.add ();
        l.add (); l.add (); l.add (); l.add ();
        l.add (); l.add (); l.add ();
        l.add (); l.add (); l.add (); 
        l.add (); l.add (); l.add (); l.add ();
        l.add (); l.add (); l.add (); l.add ();
        l.add (); l.add (); l.add ();
        return l;
    }
  
  public static boolean isJavaKeywordType(Type t)
  {
    return !(t instanceof StmtAddressType ||
             t instanceof UnknownType ||
                 t instanceof RefType ||
                 (t instanceof ArrayType && (!isJavaKeywordType(((ArrayType)t).))) ||
                 t instanceof ErroneousType );
  }
    public static Value cloneIfNecessary(Value val
    {
        ifval instanceof Local || val instanceof Constant )
            return val;
        else
            return (Valueval.clone();
    } 

    
Constructs a XorExpr(Immediate, Immediate) grammar chunk.
    public XorExpr newXorExpr(Value op1Value op2)
    {
        return new JXorExpr(op1op2);
    }


    
Constructs a UshrExpr(Immediate, Immediate) grammar chunk.
    public UshrExpr newUshrExpr(Value op1Value op2)
    {
        return new JUshrExpr(op1op2);
    }


    
Constructs a SubExpr(Immediate, Immediate) grammar chunk.
    public SubExpr newSubExpr(Value op1Value op2)
    {
        return new JSubExpr(op1op2);
    }


    
Constructs a ShrExpr(Immediate, Immediate) grammar chunk.
    public ShrExpr newShrExpr(Value op1Value op2)
    {
        return new JShrExpr(op1op2);
    }


    
Constructs a ShlExpr(Immediate, Immediate) grammar chunk.
    public ShlExpr newShlExpr(Value op1Value op2)
    {
        return new JShlExpr(op1op2);
    }


    
Constructs a RemExpr(Immediate, Immediate) grammar chunk.
    public RemExpr newRemExpr(Value op1Value op2)
    {
        return new JRemExpr(op1op2);
    }


    
Constructs a OrExpr(Immediate, Immediate) grammar chunk.
    public OrExpr newOrExpr(Value op1Value op2)
    {
        return new JOrExpr(op1op2);
    }


    
Constructs a NeExpr(Immediate, Immediate) grammar chunk.
    public NeExpr newNeExpr(Value op1Value op2)
    {
        return new JNeExpr(op1op2);
    }


    
Constructs a MulExpr(Immediate, Immediate) grammar chunk.
    public MulExpr newMulExpr(Value op1Value op2)
    {
        return new JMulExpr(op1op2);
    }


    
Constructs a LeExpr(Immediate, Immediate) grammar chunk.
    public LeExpr newLeExpr(Value op1Value op2)
    {
        return new JLeExpr(op1op2);
    }


    
Constructs a GeExpr(Immediate, Immediate) grammar chunk.
    public GeExpr newGeExpr(Value op1Value op2)
    {
        return new JGeExpr(op1op2);
    }


    
Constructs a EqExpr(Immediate, Immediate) grammar chunk.
    public EqExpr newEqExpr(Value op1Value op2)
    {
        return new JEqExpr(op1op2);
    }

    
Constructs a DivExpr(Immediate, Immediate) grammar chunk.
    public DivExpr newDivExpr(Value op1Value op2)
    {
        return new JDivExpr(op1op2);
    }


    
Constructs a CmplExpr(Immediate, Immediate) grammar chunk.
    public CmplExpr newCmplExpr(Value op1Value op2)
    {
        return new JCmplExpr(op1op2);
    }


    
Constructs a CmpgExpr(Immediate, Immediate) grammar chunk.
    public CmpgExpr newCmpgExpr(Value op1Value op2)
    {
        return new JCmpgExpr(op1op2);
    }


    
Constructs a CmpExpr(Immediate, Immediate) grammar chunk.
    public CmpExpr newCmpExpr(Value op1Value op2)
    {
        return new JCmpExpr(op1op2);
    }


    
Constructs a GtExpr(Immediate, Immediate) grammar chunk.
    public GtExpr newGtExpr(Value op1Value op2)
    {
        return new JGtExpr(op1op2);
    }


    
Constructs a LtExpr(Immediate, Immediate) grammar chunk.
    public LtExpr newLtExpr(Value op1Value op2)
    {
        return new JLtExpr(op1op2);
    }

    
Constructs a AddExpr(Immediate, Immediate) grammar chunk.
    public AddExpr newAddExpr(Value op1Value op2)
    {
        return new JAddExpr(op1op2);
    }


    
Constructs a AndExpr(Immediate, Immediate) grammar chunk.
    public AndExpr newAndExpr(Value op1Value op2)
    {
        return new JAndExpr(op1op2);
    }


    
Constructs a NegExpr(Immediate, Immediate) grammar chunk.
    public NegExpr newNegExpr(Value op)
    {
        return new JNegExpr(op);
    }


    
Constructs a LengthExpr(Immediate) grammar chunk.
    public LengthExpr newLengthExpr(Value op)
    {
        return new JLengthExpr(op);
    }


    
Constructs a CastExpr(Immediate, Type) grammar chunk.
    public CastExpr newCastExpr(Value op1Type t)
    {
        return new JCastExpr(op1t);
    }

    
Constructs a InstanceOfExpr(Immediate, Type) grammar chunk.
    public InstanceOfExpr newInstanceOfExpr(Value op1Type t)
    {
        return new JInstanceOfExpr(op1t);
    }


    
Constructs a NewExpr(RefType) grammar chunk.
    public NewExpr newNewExpr(RefType type)
    {
        return new JNewExpr(type);
    }


    
Constructs a NewArrayExpr(Type, Immediate) grammar chunk.
    public NewArrayExpr newNewArrayExpr(Type typeValue size)
    {
        return new JNewArrayExpr(typesize);
    }

    
Constructs a NewMultiArrayExpr(ArrayType, List of Immediate) grammar chunk.
    public NewMultiArrayExpr newNewMultiArrayExpr(ArrayType typeList sizes)
    {
        return new JNewMultiArrayExpr(typesizes);
    }


    
Constructs a NewStaticInvokeExpr(ArrayType, List of Immediate) grammar chunk.
    public StaticInvokeExpr newStaticInvokeExpr(SootMethodRef methodValue... args)
    {
        return new JStaticInvokeExpr(method, Arrays.asList(args));
    }
    
    public StaticInvokeExpr newStaticInvokeExpr(SootMethodRef methodList args)
    {
        return new JStaticInvokeExpr(methodargs);
    }

    
Constructs a NewSpecialInvokeExpr(Local base, SootMethodRef method, List of Immediate) grammar chunk.
    public SpecialInvokeExpr newSpecialInvokeExpr(Local baseSootMethodRef methodList args)
    {
        return new JSpecialInvokeExpr(basemethodargs);
    }

    
Constructs a NewDynamicInvokeExpr(SootMethodRef bootstrapMethodRef, List bootstrapArgs, SootMethodRef methodRef, List args) grammar chunk.
    public DynamicInvokeExpr newDynamicInvokeExpr(SootMethodRef bootstrapMethodRefList bootstrapArgsSootMethodRef methodRefList args){
    	return new JDynamicInvokeExpr(bootstrapMethodRefbootstrapArgsmethodRefargs);
    }

    
Constructs a NewVirtualInvokeExpr(Local base, SootMethodRef method, List of Immediate) grammar chunk.
    public VirtualInvokeExpr newVirtualInvokeExpr(Local baseSootMethodRef methodList args)
    {
        return new JVirtualInvokeExpr(basemethodargs);
    }


    
Constructs a NewInterfaceInvokeExpr(Local base, SootMethodRef method, List of Immediate) grammar chunk.
    public InterfaceInvokeExpr newInterfaceInvokeExpr(Local baseSootMethodRef methodList args)
    {
        return new JInterfaceInvokeExpr(basemethodargs);
    }


        
    
Constructs a NewStaticInvokeExpr(ArrayType, List of Immediate) grammar chunk. (no args)
    {
        return new JStaticInvokeExpr(methodnew ArrayList());
    }


    
Constructs a NewSpecialInvokeExpr(Local base, SootMethodRef method, List of Immediate) grammar chunk. (no args)
    {
        return new JSpecialInvokeExpr(basemethodnew ArrayList());
    }


    
Constructs a NewVirtualInvokeExpr(Local base, SootMethodRef method, List of Immediate) grammar chunk. (no args)
    {
        return new JVirtualInvokeExpr(basemethodnew ArrayList());
    }


    
Constructs a NewInterfaceInvokeExpr(Local base, SootMethodRef method, List of Immediate) grammar chunk. (no args)
    {
        return new JInterfaceInvokeExpr(basemethodnew ArrayList());
    }

    
    
Constructs a NewSpecialInvokeExpr(Local base, SootMethodRef method, List of Immediate) grammar chunk.
    public SpecialInvokeExpr newSpecialInvokeExpr(Local baseSootMethodRef methodValue arg)
    {
        return new JSpecialInvokeExpr(basemethod, Arrays.asList(new Value[] {arg}));
    }


    
Constructs a NewVirtualInvokeExpr(Local base, SootMethodRef method, List of Immediate) grammar chunk.
    public VirtualInvokeExpr newVirtualInvokeExpr(Local baseSootMethodRef methodValue arg)
    {
        return new JVirtualInvokeExpr(basemethod, Arrays.asList(new Value[] {arg}));
    }


    
Constructs a NewInterfaceInvokeExpr(Local base, SootMethodRef method, List of Immediate) grammar chunk.
    public InterfaceInvokeExpr newInterfaceInvokeExpr(Local baseSootMethodRef methodValue arg)
    {
        return new JInterfaceInvokeExpr(basemethod, Arrays.asList(new Value[] {arg}));
    }

    
    
Constructs a NewStaticInvokeExpr(ArrayType, List of Immediate) grammar chunk.
     
    public StaticInvokeExpr newStaticInvokeExpr(SootMethodRef methodValue arg1Value arg2)
    {
        return new JStaticInvokeExpr(method, Arrays.asList(new Value[] {arg1arg2}));
    }


    
Constructs a NewSpecialInvokeExpr(Local base, SootMethodRef method, List of Immediate) grammar chunk.
    public SpecialInvokeExpr newSpecialInvokeExpr(Local baseSootMethodRef methodValue arg1Value arg2)
    {
        return new JSpecialInvokeExpr(basemethod, Arrays.asList(new Value[] {arg1arg2}));
    }


    
Constructs a NewVirtualInvokeExpr(Local base, SootMethodRef method, List of Immediate) grammar chunk.
    public VirtualInvokeExpr newVirtualInvokeExpr(Local baseSootMethodRef methodValue arg1Value arg2)
    {
        return new JVirtualInvokeExpr(basemethod, Arrays.asList(new Value[] {arg1arg2}));
    }


    
Constructs a NewInterfaceInvokeExpr(Local base, SootMethodRef method, List of Immediate) grammar chunk.
    public InterfaceInvokeExpr newInterfaceInvokeExpr(Local baseSootMethodRef methodValue arg1Value arg2)
    {
        return new JInterfaceInvokeExpr(basemethod, Arrays.asList(new Value[] {arg1arg2}));
    }



    
Constructs a ThrowStmt(Immediate) grammar chunk.
    public ThrowStmt newThrowStmt(Value op)
    {
        return new JThrowStmt(op);
    }


    
Constructs a ExitMonitorStmt(Immediate) grammar chunk
    {
        return new JExitMonitorStmt(op);
    }


    
Constructs a EnterMonitorStmt(Immediate) grammar chunk.
    {
        return new JEnterMonitorStmt(op);
    }


    
Constructs a BreakpointStmt() grammar chunk.
    {
        return new JBreakpointStmt();
    }


    
Constructs a GotoStmt(Stmt) grammar chunk.
    public GotoStmt newGotoStmt(Unit target)
    {
        return new JGotoStmt(target);
    }
    public GotoStmt newGotoStmt(UnitBox stmtBox)
    {
        return new JGotoStmt(stmtBox);
    }



    
Constructs a NopStmt() grammar chunk.
    public NopStmt newNopStmt()
    {
        return new JNopStmt();
    }


    
Constructs a ReturnVoidStmt() grammar chunk.
    {
        return new JReturnVoidStmt();
    }


    
Constructs a ReturnStmt(Immediate) grammar chunk.
    public ReturnStmt newReturnStmt(Value op)
    {
        return new JReturnStmt(op);
    }


    
Constructs a RetStmt(Local) grammar chunk.
    public RetStmt newRetStmt(Value stmtAddress)
    {
        return new JRetStmt(stmtAddress);
    }


    
Constructs a IfStmt(Condition, Stmt) grammar chunk.
    public IfStmt newIfStmt(Value conditionUnit target)
    {
        return new JIfStmt(conditiontarget);
    }
    
    public IfStmt newIfStmt(Value conditionUnitBox target)
    {
        return new JIfStmt(conditiontarget);
    }


    
Constructs a IdentityStmt(Local, IdentityRef) grammar chunk.
    public IdentityStmt newIdentityStmt(Value localValue identityRef)
    {
        return new JIdentityStmt(localidentityRef);
    }


    
Constructs a AssignStmt(Variable, RValue) grammar chunk.
    public AssignStmt newAssignStmt(Value variableValue rvalue)
    {
        return new JAssignStmt(variablervalue);
    }


    
Constructs a InvokeStmt(InvokeExpr) grammar chunk.
    public InvokeStmt newInvokeStmt(Value op)
    {
        return new JInvokeStmt(op);
    }


    
Constructs a TableSwitchStmt(Immediate, int, int, List of Unit, Stmt) grammar chunk.
    public TableSwitchStmt newTableSwitchStmt(Value keyint lowIndexint highIndexList targetsUnit defaultTarget)
    {
        return new JTableSwitchStmt(keylowIndexhighIndextargetsdefaultTarget);
    }
    public TableSwitchStmt newTableSwitchStmt(Value keyint lowIndexint highIndexList<ObjecttargetsUnitBox defaultTarget)
    {                
        return new JTableSwitchStmt(keylowIndexhighIndextargetsdefaultTarget);
    }

    
Constructs a LookupSwitchStmt(Immediate, List of Immediate, List of Unit, Stmt) grammar chunk.
    public LookupSwitchStmt newLookupSwitchStmt(Value keyList lookupValuesList targetsUnit defaultTarget)
    {
        return new JLookupSwitchStmt(keylookupValuestargetsdefaultTarget);
    }
    
    public LookupSwitchStmt newLookupSwitchStmt(Value keyList<ObjectlookupValuesList<ObjecttargetsUnitBox defaultTarget)
    {
        return new JLookupSwitchStmt(keylookupValuestargetsdefaultTarget);
    }
    

    
Constructs a Local with the given name and type.
    public Local newLocal(String nameType t)
    {
        return new JimpleLocal(name.intern(), t);
    }

    
Constructs a new JTrap for the given exception on the given Stmt range with the given Stmt handler.
    public Trap newTrap(SootClass exceptionUnit beginStmtUnit endStmtUnit handlerStmt)
    {
        return new JTrap(exceptionbeginStmtendStmthandlerStmt);
    }
    public Trap newTrap(SootClass exceptionUnitBox beginStmtUnitBox endStmtUnitBox handlerStmt)
    {
        return new JTrap(exceptionbeginStmtendStmthandlerStmt);
    }


    
Constructs a StaticFieldRef(SootFieldRef) grammar chunk.
    {
        return new StaticFieldRef(f);
    }


    
Constructs a ThisRef(RefType) grammar chunk.
    public ThisRef newThisRef(RefType t)
    {
        return new ThisRef(t);
    }


    
Constructs a ParameterRef(SootMethod, int) grammar chunk.
    public ParameterRef newParameterRef(Type paramTypeint number)
    {
        return new ParameterRef(paramTypenumber);
    }

    
Constructs a InstanceFieldRef(Local, SootFieldRef) grammar chunk.
    {
        return new JInstanceFieldRef(basef);
    }


    
Constructs a CaughtExceptionRef() grammar chunk.
    {
        return new JCaughtExceptionRef();
    }


    
Constructs a ArrayRef(Local, Immediate) grammar chunk.
    public ArrayRef newArrayRef(Value baseValue index)
    {
        return new JArrayRef(baseindex);
    }
    // Note: This is NOT used to create the variable box in JAssignStmt.
    public ValueBox newVariableBox(Value value)
    {
        return new VariableBox(value);
    }
    public ValueBox newLocalBox(Value value)
    {
        return new JimpleLocalBox(value);
    }
    // Note: This is NOT used to create the rvalue box in JAssignStmt.
    public ValueBox newRValueBox(Value value)
    {
        return new RValueBox(value);
    }
    public ValueBox newImmediateBox(Value value)
    {
        return new ImmediateBox(value);
    }
    public ValueBox newArgBox(Value value)
    {
        return new ImmediateBox(value);
    }
    public ValueBox newIdentityRefBox(Value value)
    {
        return new IdentityRefBox(value);
    }
    public ValueBox newConditionExprBox(Value value)
    {
        return new ConditionExprBox(value);
    }
    public ValueBox newInvokeExprBox(Value value)
    {
        return new InvokeExprBox(value);
    }
    public UnitBox newStmtBox(Unit unit)
    {
        return new StmtBox((Stmtunit);
    }

    
    
Returns an empty JimpleBody associated with method m.
    public JimpleBody newBody(SootMethod m)
    {
        return new JimpleBody(m);
    }

    
Returns an empty JimpleBody with no associated method.
    public JimpleBody newBody()
    {
        return new JimpleBody();
    }
    /*
     * Uncomment these stubs to make it compile with old code using Soot
     * that does not know about SootField/MethodRefs.
     */
    /*
    public StaticFieldRef newStaticFieldRef(SootField f) {
        return newStaticFieldRef(f.makeRef());
    }
    public InstanceFieldRef newInstanceFieldRef(Value base, SootField f) {
        return newInstanceFieldRef(base, f.makeRef());
    }
    public StaticInvokeExpr newStaticInvokeExpr(SootMethod method, List args) {
        return newStaticInvokeExpr(method.makeRef(), args);
    }
    public SpecialInvokeExpr newSpecialInvokeExpr(Local base, SootMethod method, List args) {
        return newSpecialInvokeExpr(base, method.makeRef(), args);
    }
    public VirtualInvokeExpr newVirtualInvokeExpr(Local base, SootMethod method, List args) {
        return newVirtualInvokeExpr(base, method.makeRef(), args);
    }
    public InterfaceInvokeExpr newInterfaceInvokeExpr(Local base, SootMethod method, List args) {
        return newInterfaceInvokeExpr(base, method.makeRef(), args);
    }
    public StaticInvokeExpr newStaticInvokeExpr(SootMethod method) {
        return newStaticInvokeExpr(method.makeRef());
    }
    public SpecialInvokeExpr newSpecialInvokeExpr(Local base, SootMethod method) {
        return newSpecialInvokeExpr(base, method.makeRef());
    }
    public VirtualInvokeExpr newVirtualInvokeExpr(Local base, SootMethod method) {
        return newVirtualInvokeExpr(base, method.makeRef());
    }
    public InterfaceInvokeExpr newInterfaceInvokeExpr(Local base, SootMethod method) {
        return newInterfaceInvokeExpr(base, method.makeRef());
    }
    public StaticInvokeExpr newStaticInvokeExpr(SootMethod method, Value arg) {
        return newStaticInvokeExpr(method.makeRef(), arg);
    } 
    public SpecialInvokeExpr newSpecialInvokeExpr(Local base, SootMethod method, Value arg) {
        return newSpecialInvokeExpr(base, method.makeRef(), arg);
    }
    public VirtualInvokeExpr newVirtualInvokeExpr(Local base, SootMethod method, Value arg) {
        return newVirtualInvokeExpr(base, method.makeRef(), arg);
    }
    public InterfaceInvokeExpr newInterfaceInvokeExpr(Local base, SootMethod method, Value arg) {
        return newInterfaceInvokeExpr(base, method.makeRef(), arg);
    }
    public StaticInvokeExpr newStaticInvokeExpr(SootMethod method, Value arg1, Value arg2) {
        return newStaticInvokeExpr(method.makeRef(), arg1, arg2);
    }
    public SpecialInvokeExpr newSpecialInvokeExpr(Local base, SootMethod method, Value arg1, Value arg2) {
        return newSpecialInvokeExpr(base, method.makeRef(), arg1, arg2);
    }
    public VirtualInvokeExpr newVirtualInvokeExpr(Local base, SootMethod method, Value arg1, Value arg2) {
        return newVirtualInvokeExpr(base, method.makeRef(), arg1, arg2);
    }
    public InterfaceInvokeExpr newInterfaceInvokeExpr(Local base, SootMethod method, Value arg1, Value arg2) {
        return newInterfaceInvokeExpr(base, method.makeRef(), arg1, arg2);
    }
    */
New to GrepCode? Check out our FAQ X