initializeThisJoinPoint();
 	protected void prepareForMungers() {		// if we're a constructor call, we need to remove the new:dup or the new:dup_x1:swap, 		// and store all our		// arguments on the frame.				// ??? This is a bit of a hack (for the Java langauge).  We do this because		// we sometime add code "outsideBefore" when dealing with weaving join points.  We only		// do this for exposing state that is on the stack.  It turns out to just work for 		// everything except for constructor calls and exception handlers.  If we were to clean		// this up, every ShadowRange would have three instructionHandle points, the start of 		// the arg-setup code, the start of the running code, and the end of the running code.		if (getKind() == ConstructorCall) {			deleteNewAndDup();			initializeArgVars();		} else if (getKind() == ExceptionHandler) {			ShadowRange range = getRange();			InstructionList body = range.getBody();			InstructionHandle start = range.getStart();			InstructionHandle freshIh = body.insert(start, InstructionConstants.NOP);			InstructionTargeter[] targeters = start.getTargeters();			for (int i = 0; i < targeters.length; i++) {				InstructionTargeter t = targeters[i];				if (t instanceof ExceptionRange) {					ExceptionRange er = (ExceptionRange) t;					er.updateTarget(start, freshIh, body);				}			}		}		// now we ask each munger to request our state		for (Iterator iter = mungers.iterator(); iter.hasNext();) {			ShadowMunger munger = (ShadowMunger) iter.next();			munger.specializeOn(this);		}			    // If we are an expression kind, we require our target/arguments on the stack	    // before we do our actual thing.  However, they may have been removed	    // from the stack as the shadowMungers have requested state.  	    // if any of our shadowMungers requested either the arguments or target, 	    // the munger will have added code	    // to pop the target/arguments into temporary variables, represented by 	    // targetVar and argVars.  In such a case, we must make sure to re-push the 	    // values.  		    // If we are nonExpressionKind, we don't expect arguments on the stack	    // so this is moot.  If our argVars happen to be null, then we know that	    // no ShadowMunger has squirrelled away our arguments, so they're still	    // on the stack.				InstructionFactory fact = getFactory();		if (getKind().argsOnStack() && argVars != null) {			range.insert(				BcelRenderer.renderExprs(fact, world, argVars),				Range.InsideBefore);			if (targetVar != null) {				range.insert(					BcelRenderer.renderExpr(fact, world, targetVar),					Range.InsideBefore);			}			if (getKind() == ConstructorCall) {				range.insert((Instruction) InstructionFactory.createDup(1), Range.InsideBefore);				range.insert(					fact.createNew(						(ObjectType) BcelWorld.makeBcelType(							getSignature().getDeclaringType())),					Range.InsideBefore);			}		} 	}