protected override void VisitCallMethod(CallMethod node, object data)
{
ParameterValues paramVals =
state.Stack.Perform_CallMethod(node.Method,node.IsVirtCall);
if (node.IsVirtCall)
paramVals.ChooseVirtualMethod();
Exception exc = null;
Value retVal = null;
if (holder.ContainsMethodBody(paramVals.Method))
retVal = InterpretMethod(holder,holder[paramVals.Method],paramVals,out exc,indent+" ");
else
retVal = paramVals.Invoke(out exc);
if (exc == null)
{
if (retVal != null)
state.Stack.Push(retVal);
AddTask(node.Next);
}
else
HandleException(node,exc);
}
public override Node Clone()
{
CallMethod newNode = new CallMethod(method.Method,isVirtCall,isTailCall);
newNode.Options.CopyFrom(Options);
return(newNode); //Andrew: MBB!
}
protected internal virtual void VisitCallMethod(CallMethod node, object data)
{
throw new NodeNotSupportedException(node);
}
protected internal override void VisitCallMethod(CallMethod node, object data)
{
StackTypes stack = data as StackTypes;
Verifier.ProcessCallOrNewobj(node.MethodWithParams, stack, false);
AddTask(node.Next,stack);
if(node.IsTailCall && !IsRet(node.Next))
throw new VerifierException();
}
protected override void VisitNewObject(NewObject downNode, object o)
{
PointerToNode ptrUpNode = (o as Data).PointerToNode;
AnnotatedMethod method = Annotation.GetAnnotatedMethod(downNode);
Node upNode;
ArrayList list = new ArrayList();
for (int i = method.ParamVals.Count - 1; i > 0; i--)
if (Annotation.GetValueBTType(method.ParamVals[i].Val) == BTType.Static)
list.Add(this.state.Stack.Pop());
if (Annotation.GetValueBTType(method.ParamVals[0].Val) == BTType.Static)
{
Type objtype = downNode.Constructor.DeclaringType;
ObjectReferenceValue obj = new ObjectReferenceValue(FormatterServices.GetUninitializedObject(objtype));
FieldInfo[] fldInfos = ReflectionUtils.GetAllFields(objtype);
BTType[] btTypes = Annotation.GetObjectFieldBTTypes(downNode);
for (int i = 0; i < fldInfos.Length; i++)
if (btTypes[i] == BTType.Dynamic)
{
Variable varUp = this.mbbUp.Variables.CreateVar(fldInfos[i].FieldType, VariableKind.Local);
this.varsHash[new PointerToObjectFieldValue(obj.Obj, fldInfos[i])] = varUp;
ptrUpNode = SpecializingVisitor.initVariable(varUp, ptrUpNode);
}
list.Add(obj);
this.state.Stack.Push(obj);
upNode = new CallMethod(downNode.Constructor, false, false);
}
else
upNode = new NewObject(downNode.Constructor);
list.Reverse();
Value[] args = list.ToArray(typeof(Value)) as Value[];
this.callMethod(downNode, method, ptrUpNode, upNode, args);
}
protected override void VisitCallMethod(CallMethod downNode, object o)
{
PointerToNode ptrUpNode = (o as Data).PointerToNode;
bool isVirtCall = downNode.IsVirtCall && downNode.Method.IsVirtual;
AnnotatedMethod aMethod;
if (isVirtCall)
aMethod = Annotation.GetAnyAnnotatedMethod(downNode);
else
aMethod = Annotation.GetAnnotatedMethod(downNode);
ArrayList list = new ArrayList();
for (int i = aMethod.ParamVals.Count - 1; i >= 0; i--)
if (Annotation.GetValueBTType(aMethod.ParamVals[i].Val) == BTType.Static)
list.Add(this.state.Stack.Pop());
list.Reverse();
Value[] args = list.ToArray(typeof(Value)) as Value[];
MethodBase sMethod;
if (isVirtCall)
sMethod = (aMethod = Annotation.GetAnnotatedMethod(downNode, args[0].Type)).SourceMethod;
else
sMethod = aMethod.SourceMethod;
this.callMethod(downNode, aMethod, ptrUpNode, new CallMethod(sMethod, false, downNode.IsTailCall), args);
}
protected override void VisitCallMethod(CallMethod upNode, object o)
{
State state = o as State;
ParameterValues paramVals = state.Stack.Perform_CallMethod(upNode.Method, upNode.IsVirtCall);
AnnotatingVisitor.patchUpParamVals(paramVals);
Type retType = Annotation.GetReturnType(paramVals.Method);
ReferenceBTValue ret = AnnotatingVisitor.getReturnValue(upNode);
if (ret == null)
{
ret = ReferenceBTValue.NewReferenceBTValue(retType, BTType.Static);
AnnotatingVisitor.setReturnValue(upNode, ret);
}
this.callMethod(upNode, paramVals, ret, upNode.IsVirtCall && upNode.Method.IsVirtual);
if (ret != null)
{
ret.Creators[this].AddCreator(upNode);
state.Stack.Push(ret.ToStack(retType));
}
}
protected override void VisitCallMethod(CallMethod upNode, object o)
{
DepthContainer cnt = o as DepthContainer;
cnt.Depth += ParameterValues.GetParametersNumber(upNode.Method) - (Annotation.GetReturnType(upNode.Method) != typeof(void) ? 1 : 0);
}
protected internal override void VisitCallMethod(CallMethod node, object data)
{
if(HasPseudoParameter(node))
generator.Emit(OpCodes.Ldnull);
OpCode code = node.IsVirtCall ? OpCodes.Callvirt : OpCodes.Call;
if(node.Method is MethodInfo)
generator.Emit(code,node.Method as MethodInfo);
else
generator.Emit(code,node.Method as ConstructorInfo);
AddTask(node.Next,null);
}
