package Sequenic.T2ext.Instrumenter;

import org.apache.bcel.* ;
import org.apache.bcel.generic.*;
import org.apache.bcel.classfile.* ;

/**
 * A simple example of how to use BCEL to inject 'sensors' for instrumentation. 
 * Look at the code in main.
 *
 * @author Wishnu Prasetya
 *
 */
public class InjectionSimpleExample {

	/**
	 * Our target class...
	 */
	Class C ;
	
	/**
	 * BCEL representation of a target class C; it allows a class file to
	 * be analyzed, but not transformed.
	 */
	JavaClass clazz ;
	
	/**
	 * BCEL interface to manipulate a class.
	 */
	ClassGen classGen ;
	
	/**
	 * Our target method ...
	 * Note that this is bcel.classfle.Method; not java.lang.Reflect.Method
	 */
	Method m = null ;
	
	/**
	 * A method generator; this will hold the new version of m:
	 */
	MethodGen mGen = null ;
	
	/**
	 * Constructor; will set-up some stuffs before injecting into the target
	 * method.
	 */
	public InjectionSimpleExample(Class target, String methodName){
		
		C = target ;
		
		// Load-up the class:
		try {  clazz = Repository.lookupClass(C); }
		catch (Exception e) {
			throw new Error(e) ;
		}
			
		// Set-up the class-gen to allow manipulation on the class:
		classGen = new ClassGen(clazz) ;
		
		// Ok, now we can start injecting; but first we need to get the 'method'
		// whose name you specified above. Unfortunately is a bit complicated;
		// the code below is not nice, but will do:
		Method[] methods = clazz.getMethods() ;
		for (int i=0; i<methods.length; i++) 
			if (methods[i].getName().equals(methodName)) { m = methods[i] ; break ; }
		assert m != null ;
		
		// Set-up the method generator to construct a new (injected) m:
		mGen = new MethodGen(m,C.getName(),classGen.getConstantPool()) ;

	}
	
	/**
	 * To inject a call to Sensor.testtick
	 */
	public InstructionList mk_testtickINSTR(ClassGen cgen, long x, int y, String info) {
		InstructionFactory ifact = new InstructionFactory(cgen);
		InstructionList ilist = new InstructionList();		
		ConstantPoolGen pgen = cgen.getConstantPool();
		// Load parameters for the call to testtick;
		// pass x,y, and info through:
		ilist.append(ifact.createConstant(x)) ;
		ilist.append(ifact.createConstant(y)) ;
		ilist.append(ifact.createConstant(info)) ;
		ilist.append(ifact.createInvoke("Sequenic.T2ext.Instrumenter.Sensor", "testtick",
			    Type.VOID, 
			    new Type[] { Type.LONG, Type.INT,Type.STRING }, 
			    Constants.INVOKESTATIC));
		return ilist;
	}
	
	/**
	 * Will inject a sensor at the start of the target method.
	 */
	public void injectAtTheStart(){
		
		InstructionList il = mGen.getInstructionList() ;	
		System.out.println("ORIGINAL instructions:") ;
		System.out.println(il) ;
		
		il.insert(il.getStart(),mk_testtickINSTR(classGen,0,0,"boo!")) ;
		
		// Let BCEL recompute some position related info and do some sanity check:
		il.setPositions(true) ;
		
		System.out.println("\nNEW instructions:") ;
		System.out.println(il) ;
		System.out.println("\nNEW constants-pool:") ;
		System.out.println(classGen.getConstantPool()) ;
		
		// Let BCEL recompute the max-stack size for the new method:
		mGen.setMaxStack();
		
		// This is not necessary here, but elsewhere you may want to do this
		// to let il to be reused:
		il.dispose() ;
	}
	
	/**
	 * True if the instruction at this handle is a jump-target.
	 * Currently still very simplistic implementation.
	 */
	static public boolean isJumpTarget(InstructionHandle h){
		InstructionTargeter[] targeters = h.getTargeters() ;
		if (targeters==null) return false ;
		for (int k=0; k<targeters.length; k++) {
			if (targeters[k] instanceof GotoInstruction ||
					targeters[k] instanceof IfInstruction)
				return true ;
		}
		return false ;
	}
	
	/**
	 * This will inject a sensor before the first jump-target. Note
	 * this involves re-directing the jumps to that target so that
	 * they now jump to the inserted sensor.
	 */
	public void injectBeforeATarget(){
		
		InstructionList il = mGen.getInstructionList() ;	
		System.out.println("ORIGINAL instructions:") ;
		System.out.println(il) ;
		
		// Ok, let's find the first jump-target:
		// The starting instruction is somehow marked as being
		// targeted; so we'll skip it:
		InstructionHandle h = il.getStart() ;
		while (h!=null && !isJumpTarget(h)) h = h.getNext() ;
		assert h!=null ;
		
		// Now h should point to a jump-target; inject before it:
	
		InstructionHandle k = il.insert(h,mk_testtickINSTR(classGen,0,1,"boo!")) ;
		
		// k should point to where the where the sensor is inserted,
		// Now redirect the jumps:
		il.redirectBranches(h,k) ;
		
		il.setPositions(true) ;
		
		System.out.println("\nNEW instructions:") ;
		System.out.println(il) ;
		
		mGen.setMaxStack();		
	}
	
	/**
	 * Finalize the transformation, and save it in a new class file.
	 * I won't bother here with fixing the location where this file would be;
	 * so if you're using IDE you may have to look for the location where
	 * it will put the file.
	 */
	public void done(){
		// Replace m with the new one:
		classGen.removeMethod(m);
		classGen.addMethod(mGen.getMethod()) ;
		// Now save:
		try {
		    classGen.getJavaClass().dump(C.getSimpleName() + ".class");
		  } 
		catch(Exception e) { 
			throw new Error(e) ;
		}		
	}
	
	/**
	 * Showing some injections in the class "Simple".
	 */
	static public void main(String[] args) {
		// Specify the injection target: the method foo from class Simple.
		// Let's do some set-up work first:
		InjectionSimpleExample i = new InjectionSimpleExample(Simple.class, "foo") ;
		
		// Now inject, then done:
		// This old and new instruction lists will be echoed in console.
		//i.injectAtTheStart();
		i.injectBeforeATarget() ;
		i.done();
		// Search the saved class file, and execute it to see how injected code execute
	}
	
}