protected internal override void VisitCastClass(CastClass node, object data)
{
StackTypes stack = data as StackTypes;
Verifier.ProcessCastClass(stack, new TypeEx(node.Type, true));
AddTask(node.Next, stack);
}
//Common verifier behaviour for all node types
override protected void DispatchNode(Node node, object data)
{
StackTypes stack = data as StackTypes;
if (stack == null)
{
throw new VerifierException();
}
StackTypes oldStack = GetNodeStack(node);
if (oldStack == null)
{
SetNodeStack(node, stack);
}
else
{
if (Verifier.IsStackMoreGeneral(oldStack, stack))
{
return;
}
stack = Verifier.DoMergeStacks(oldStack, stack); //throws VerifierException
SetNodeStack(node, stack);
}
CallVisitorMethod(node, stack.Clone());
}
protected internal override void VisitDuplicateStackTop(DuplicateStackTop node, object data)
{
StackTypes stack = data as StackTypes;
stack.Push(stack.Peek());
AddTask(node.Next, stack);
}
protected internal override void VisitUnboxValue(UnboxValue node, object data)
{
StackTypes stack = data as StackTypes;
Verifier.ProcessUnBox(stack, node.Type);
AddTask(node.Next, stack);
}
protected internal override void VisitNewObject(NewObject node, object data)
{
StackTypes stack = data as StackTypes;
Verifier.ProcessCallOrNewobj(node.CtorWithParams, stack, true);
AddTask(node.Next, stack);
}
protected internal override void VisitCreateDelegate(CreateDelegate node, object data)
{
StackTypes stack = data as StackTypes;
Verifier.ProcessDelegateConstruction(stack, node.Method, node.DelegateCtor);
AddTask(node.Next, stack);
}
//protected internal override void VisitLoadObject(LoadObject node, object data)
//{
// StackTypes stack = data as StackTypes;
// Verifier.ProcessLdObj(stack, node.Type);
// AddTask(node.Next,stack);
//}
protected internal override void VisitLoadSizeOfValue(LoadSizeOfValue node, object data)
{
StackTypes stack = data as StackTypes;
Verifier.ProcessSizeOf(stack, node.Type);
AddTask(node.Next, stack);
}
protected internal override void VisitLoadLength(LoadLength node, object data)
{
StackTypes stack = data as StackTypes;
Verifier.ProcessLdLen(stack);
AddTask(node.Next, stack);
}
protected internal override void VisitStoreElement(StoreElement node, object data)
{
StackTypes stack = data as StackTypes;
Verifier.ProcessStElem(stack, new TypeEx(node.Type));
AddTask(node.Next, stack);
}
//protected internal override void VisitCopyObject(CopyObject node, object data)
//{
// StackTypes stack = data as StackTypes;
// Verifier.ProcessCpObj(stack, node.Type);
// AddTask(node.Next,stack);
//}
protected internal override void VisitInitValue(InitValue node, object data)
{
StackTypes stack = data as StackTypes;
Verifier.ProcessInitObj(stack, node.Type);
AddTask(node.Next, stack);
}
protected internal override void VisitStoreVar(StoreVar node, object data)
{
StackTypes stack = data as StackTypes;
Verifier.ProcessSt(new TypeEx(node.Var.Type), stack);
AddTask(node.Next, stack);
}
protected internal override void VisitNewArray(NewArray node, object data)
{
StackTypes stack = data as StackTypes;
Verifier.ProcessNewArr(stack, node.Type);
AddTask(node.Next, stack);
}
protected internal override void VisitLoadVarAddr(LoadVarAddr node, object data)
{
StackTypes stack = data as StackTypes;
stack.Push(TypeEx.BuildRefType(node.Var.Type));
AddTask(node.Next, stack);
}
protected internal override void VisitLoadElementAddr(LoadElementAddr node, object data)
{
StackTypes stack = data as StackTypes;
Verifier.ProcessLdElem(stack, new TypeEx(node.Type), true);
AddTask(node.Next, stack);
}
protected internal override void VisitRemoveStackTop(RemoveStackTop node, object data)
{
StackTypes stack = data as StackTypes;
stack.Pop();
AddTask(node.Next, stack);
}
protected internal override void VisitBinaryOp(BinaryOp node, object data)
{
StackTypes stack = data as StackTypes;
Verifier.ProcessBinOp(GetOpType(node.Op, node.Unsigned, node.Overflow), stack);
AddTask(node.Next, stack);
}
protected internal override void VisitStoreIndirect(StoreIndirect node, object data)
{
StackTypes stack = data as StackTypes;
Verifier.ProcessStInd(node.Type, stack);
//looks like ProcessStInd method functions correctly in case of STOBJ
AddTask(node.Next, stack);
}
protected internal override void VisitBranch(Branch node, object data)
{
StackTypes stack = data as StackTypes;
Verifier.ProcessBrTrueFalse(stack);
AddTask(node.Next, stack);
AddTask(node.Alt, stack.Clone());
}
protected internal override void VisitCheckFinite(CheckFinite node, object data)
{
StackTypes stack = data as StackTypes;
Verifier.ProcessCkFinite(stack);
AddTask(node.Next, stack);
}
protected internal override void VisitConvertValue(ConvertValue node, object data)
{
StackTypes stack = data as StackTypes;
Verifier.ProcessConv(node.Type, stack);
AddTask(node.Next, stack);
}
private void InitDefaultValues()
{
SnapType = ScopedObject.SnapType;
StackType = (ScopedObject.DefinesBoundarys)?StackTypes.Center:StackTypes.Disabled;
AlignToSurface = (ScopedObject.DefinesBoundarys) ? 3 : 1;
DetailSettings = new FastPlaceDetailSettings();
DetailSettings._Scale = ScopedObject.transform.localScale;
}
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();
}
}
/* Visiting methods */
protected internal override void VisitServiceNode(ServiceNode node, object data)
{
StackTypes stack = data as StackTypes;
AddTask(node.Next, stack);
for (int i = 1; i < node.NextArray.Count; i++)
{
AddTask(node.NextArray[i], stack.Clone());
}
//Service nodes do not change the stack
}
protected internal override void VisitSwitch(Switch node, object data)
{
StackTypes stack = data as StackTypes;
Verifier.ProcessSwitch(stack);
AddTask(node.Next, stack);
for (int i = 1; i < node.NextArray.Count; i++)
{
AddTask(node.NextArray[i], stack.Clone());
}
}
protected internal override void VisitFinallyBlock(FinallyBlock node, object data)
{
StackTypes stack = data as StackTypes;
if (stack.Count != 0)
{
throw new VerifierException();
}
AddTask(node.Next, stack);
}
protected internal override void VisitCatchBlock(CatchBlock node, object data)
{
StackTypes stack = data as StackTypes;
if (stack.Count != 0)
{
throw new VerifierException();
}
stack.Push(node.Type);
AddTask(node.Next, stack);
}
protected internal override void VisitUserFilteredBlock(UserFilteredBlock node, object data)
{
StackTypes stack = data as StackTypes;
if (stack.Count != 0)
{
throw new VerifierException();
}
stack.Push(typeof(object));
AddTask(node.Next, stack);
AddTask(node.Filter, new StackTypes());
}
public void AutoStack(StackTypes StackType, LayerMask Layer)
{
if (StackType != StackTypes.Disabled)
{
if (GridPosChanged)
{
while (AutoStackSingle(OverlappingObjects(Layer, (StackType == StackTypes.Boundary) ? null : (float?)this.MinScale, true)))
{
} // stack until stacking is no longer possible
_LastStackY = Position.y; // set last stack position
}
PlaceAtPos(new Vector3(Position.x, _LastStackY, Position.z), Vector3.zero, false); // place at position. Dont update last grid position. It will override the actual last grid position to the free from one
}
}
// Auto stack functions
public void AutoStack(StackTypes StackType, System.Func <ModularPlacableObject[]> OverLapping)
{
if (StackType != StackTypes.Disabled)
{
if (GridPosChanged)
{
while (AutoStackSingle(OverLapping()))
{
}
_LastStackY = Position.y;
}
PlaceAtPos(new Vector3(Position.x, _LastStackY, Position.z), Vector3.zero, false); // place at position. Dont update last grid position. It will override the actual last grid position to the free from one
}
}
protected internal override void VisitStoreField(StoreField node, object data)
{
StackTypes stack = data as StackTypes;
if (node.Field.IsStatic)
{
Verifier.ProcessStSFld(stack, node.Field);
}
else
{
Verifier.ProcessStFld(stack, node.Field);
}
AddTask(node.Next, stack);
}
