Java LocalVariableGen.setStart方法代码示例

import org.apache.bcel.generic.LocalVariableGen; //导入方法依赖的package包/类
public void setVarStartEnd(int slot, int start_pc, int end_pc, String name) {
	Integer islot = Integer.valueOf(slot);
	if (localVarGenBySlot.containsKey(islot)) {
		name = name.replaceAll("[^a-zA-Z0-9]", "_");
		LocalVariableGen l = (LocalVariableGen)localVarGenBySlot.get(islot);
		l.setEnd(lastInstrHandles[end_pc-1]);
		if (start_pc > 1)
			l.setStart(lastInstrHandles[start_pc-2]);
		l.setName(name);
	}
}
 

import org.apache.bcel.generic.LocalVariableGen; //导入方法依赖的package包/类
/**
 * A new IdcMetaclass object is created to wrap de 
 * real metaclass providing additional functionality.
 * 
 * <pre>
 * 		NEW IdcMetaclass 
 * 		DUP
 * 		LDC <<model_name>>
 * 		LDC <<class_name>>
 * 		INVOKESPECIAL IdcMetaclass.<init>
 * 		ASTORE !!#variable!!
 * </pre>
 */
@Override
public void generate(GenScope scope) {
	InstructionList il       = scope.getInstructionList();
	InstructionFactory ifact = scope.getInstructionFactory();
	ConstantPoolGen cpg      = scope.getConstantPool();

	LocalVariableGen lvg = null;
	
	if ( getKind() == ReadMetaKind.METACLASS) {		
		lvg = scope.newLocalVariable(this, DefaultTypes.IdcMetaclass);
		
		lvg.setStart(il.append(ifact.createNew(DefaultTypes.IdcMetaclass)));
		il.append(new DUP());
		
		// il.append(new LDC(cpg.addString(getModel().getName())));
		scope.generateGetTransformation();
		scope.generateGetModel(getModel().getName());
		// CommonGen.generateGetModel(getModel().getName(), il, ifact, scope);

		il.append(new LDC(cpg.addString(getClassName())));
		il.append(ifact.createInvoke(DefaultTypes.IdcMetaclass.getClassName(), "<init>",
			Type.VOID, new Type[] { DefaultTypes.IdcTransformation, DefaultTypes.IModel, Type.STRING },
			Constants.INVOKESPECIAL));
	} else if ( getKind() == ReadMetaKind.THIS_TRANSFORMATION_OBJECT ||
			    getKind() == ReadMetaKind.THIS_TRANSFORMATION_METHOD_HANDLER ) {
		lvg = scope.newLocalVariable(this, DefaultTypes.IdcTransformation);			
		lvg.setStart(il.append(InstructionConstants.NOP));

		scope.generateGetTransformation();
	} else if ( getKind() == ReadMetaKind.MODEL ){
		lvg = scope.newLocalVariable(this, DefaultTypes.IModel);			
		lvg.setStart(il.append(InstructionConstants.NOP));
		scope.generateGetModel(getModel().getName());	
	} else {
		throw new IllegalArgumentException();
	}
	
	il.append(new ASTORE(lvg.getIndex()));
}
 

import org.apache.bcel.generic.LocalVariableGen; //导入方法依赖的package包/类
/**
 * <<GET_IMODEL(THIS)>> 
	 * ALOAD !!#receptor_variable!!
    * LDC <<featureName>>
 * INVOKEINTERFACE getFeature
 */	 
@Override
public void generate(GenScope scope) {
	InstructionList il       = scope.getInstructionList();
	InstructionFactory ifact = scope.getInstructionFactory();
	ConstantPoolGen cpg      = scope.getConstantPool();

	Variable realReceptor = scope.getRealVariable(this.receptor);

	LocalVariableGen lvg = scope.newLocalVariable(this, Type.OBJECT);

	// generate model access
	scope.generateGetModel(realReceptor);
	il.append(new DUP()); // for later calls of get/method calls (problem if I put the generateGetModel directly, not using the dup optimize, why?)
	
	
	// push receptor
	// push featureName
	scope.loadVariable(realReceptor, il);
	lvg.setStart(il.append(new LDC(cpg.addString(featureName))));
	
	if ( kind == GetKind.PLAIN_GET ) {
		appendGetFeature(il, ifact);
		il.append(InstructionFactory.SWAP);
		il.append(InstructionFactory.POP);
		// I should swap, and then pop...
		// il.append(new POP());
	} else {
		BranchInstruction branchToCall = InstructionFactory
				.createBranchInstruction(Constants.IFEQ, null);
		BranchInstruction branchToEnd = InstructionFactory
				.createBranchInstruction(Constants.GOTO, null);
		
		// hasFeature(f)
		// ifeq (jump if value == 0)
		appendHasFeature(il, ifact);
		lvg.setStart(il.append(branchToCall));

		// push receptor
		// push featureName
		// get & jump to the end
		/*
		scope.loadVariable(realReceptor, il);
		lvg.setStart(il.append(new LDC(cpg.addString(featureName))));
		*/
		if ( isStreamingMode(scope) ) {
			appendContinuableGetFeature(scope, realReceptor, il, ifact, cpg);
		} else {
			scope.loadVariable(realReceptor, il);
			il.append(new LDC(cpg.addString(featureName)));
			appendGetFeature(il, ifact);
			// branchToEnd.setTarget(appendGetFeature(il, ifact));
		}
		il.append(branchToEnd);
		
		// push receptor
		// push featureName
		// methodCall
		branchToCall.setTarget( il.append(InstructionConstants.NOP) ); // label for this part
		//scope.loadVariable(realReceptor, il);
		// lvg.setStart(il.append(new LDC(cpg.addString(featureName))));			
		lvg.setStart(il.append(InstructionConstants.POP)); // remove IModel
		appendMethodCall(scope, il, ifact);

		// NOP-end
		branchToEnd.setTarget( il.append(InstructionConstants.NOP) );
	}
	
	// store result
	il.append(new ASTORE( lvg.getIndex() ));
}
 

import org.apache.bcel.generic.LocalVariableGen; //导入方法依赖的package包/类
@Override
public void generate(GenScope scope) {
	InstructionList il       = scope.getInstructionList();
	InstructionFactory ifact = scope.getInstructionFactory();
	ConstantPoolGen cpg      = scope.getConstantPool();

	LocalVariableGen lvg = scope.newLocalVariable(this, Type.OBJECT);

	switch (kind.getValue()) {
	case LiteralKind.BOOLEAN_VALUE:
		if (getBooleanValue()) {
			il.append(InstructionConstants.ICONST_1);
		} else {
			il.append(InstructionConstants.ICONST_0);
		}
		il.append(ifact.createInvoke(Boolean.class.getName(), "valueOf",
				new ObjectType(Boolean.class.getName()),
				new Type[] { Type.BOOLEAN }, Constants.INVOKESTATIC));
		break;
	case LiteralKind.STRING_VALUE:
		lvg.setStart(il.append(new LDC(cpg.addString(getStringValue()))));
		break;
	case LiteralKind.NULL_VALUE:
		lvg.setStart(il.append(InstructionConstants.ACONST_NULL));
		break;
	case LiteralKind.INTEGER_VALUE:
		//lvg.setStart(il.append(new LDC(cpg.addInteger(intValue))));
		//il.append(new LDC(cpg.addInteger(intValue)));
		il.append(ifact.createConstant(intValue));
		il.append(ifact.createInvoke(Integer.class.getName(), "valueOf",
				new ObjectType(Integer.class.getName()),
				new Type[] { Type.INT }, Constants.INVOKESTATIC));
		break;
	case LiteralKind.DOUBLE_VALUE:
		//lvg.setStart(il.append(new LDC(cpg.addDouble(doubleValue))));
		lvg.setStart(il.append(ifact.createConstant(doubleValue)));
		il.append(ifact.createInvoke(Double.class.getName(), "valueOf",
				new ObjectType(Double.class.getName()), 
				new Type[] { Type.DOUBLE }, Constants.INVOKESTATIC));
		break;
	default:
		throw new IdcException("Not supported literal");
		// break;
	}
	il.append(new ASTORE(lvg.getIndex()));
}