/// <summary>
/// Loads information from the selected cell when changed.
/// </summary>
/// <param name="ssp"></param>
private void CellSelectionChange(SpreadsheetPanel ssp)
{
LabelError.Visible = false;
ssp.GetSelection(out _col, out _row);
if (ssp.GetValue(_col, _row, out string value))
{
BoxValue.Text = value;
}
else
{
BoxValue.Clear();
}
_selection = $"{(char) ('A' + _col)}{_row + 1}";
ButtonUpdate.Text = $@"Update: {_selection}";
BoxSelected.Text = _selection;
try
{
object contents = _spreadsheet.GetCellContents(_selection);
if (contents is Formula)
{
contents = $"={contents}";
}
BoxContents.Text = contents.ToString();
}
catch (Exception e)
{
LabelError.Visible = true;
LabelError.Text = e.Message;
}
}
public BoxValue <T> InitValue <T>(string key) where T : new()
{
if (values.TryGetValue(typeof(T), out var hashtable))
{
if (hashtable.TryGetValue(key, out var value))
{
return((BoxValue <T>)value);
}
else
{
var newValue = new BoxValue <T>(new T());
hashtable.Add(key, newValue);
return(newValue);
}
}
else
{
hashtable = new Dictionary <string, object>();
values.Add(typeof(T), hashtable);
var newValue = new BoxValue <T>(new T());
hashtable.Add(key, newValue);
return(newValue);
}
}
protected internal override void VisitBoxValue(BoxValue node, object data)
{
StackTypes stack = data as StackTypes;
Verifier.ProcessBox(stack, node.Type);
AddTask(node.Next, stack);
}
public BoxValue <T> InitValue <T>(string key, Func <T> initializeMethod)
{
if (values.TryGetValue(typeof(T), out var hashtable))
{
if (hashtable.TryGetValue(key, out var value))
{
return((BoxValue <T>)value);
}
else
{
var newValue = new BoxValue <T>(initializeMethod());
hashtable.Add(key, newValue);
return(newValue);
}
}
else
{
hashtable = new Dictionary <string, object>();
values.Add(typeof(T), hashtable);
var newValue = new BoxValue <T>(initializeMethod());
hashtable.Add(key, newValue);
return(newValue);
}
}
public BoxPosition(string top, string right, string bottom, string left)
{
this.Top = new BoxValue(top);
this.Left = new BoxValue(left);
this.Right = new BoxValue(right);
this.Bottom = new BoxValue(bottom);
}
public void IdentifyBox(bool onstart = false)
{
lastStats = stats;
stats = getrandom(onstart);
if (lastStats == null)
{
lastStats = stats;
}
backPanel.sprite = stats.image_Sprite;
backPanel.color = stats.tierColor;
tierBackSprite.sprite = stats.tier_Sprite;
}
/*protected void AutoTransition(AnimationStateMachine animationStateMachine, AnimationState animationState,
* AnimationState targetState, float transitionDuration = 0.0f, float transitionOffset = 0.0f, float transitionTime = 1.0f)
* {
* var animator = animationStateMachine.animator;
* int layer = animationStateMachine.stateMachineLayer;
* var blendData = new AnimationBlendData(transitionDuration, transitionOffset);
*
* animationState.AddUpdate( (animationTime) =>
* {
* if (!animator.IsInTransition(layer) && animationTime >= transitionTime)
* animationStateMachine.SetCurrentState(targetState, blendData);
* });
* }*/
protected void StaggerCondition(HealthController health, AnimationState animationState)
{
BoxValue <bool> damaged = new BoxValue <bool>(false);
health.onStaggerCallback += (data) =>
{
damaged.value = true;
};
animationState.AddCanEnter(() => damaged.value);
animationState.AddOnBegin(() => damaged.value = false);
animationState.AddOnEnd(() => damaged.value = false);
}
void Awake()
{
node = new State();
node.AddOnBegin(onBegin.Invoke);
node.AddOnUpdate(onUpdate.Invoke);
node.AddOnEnd(onEnd.Invoke);
node.AddShallReturn(() =>
{
BoxValue <bool> b = new BoxValue <bool>(true);
shallReturn.Invoke(b);
return(b.value);
});
if (autoRun)
{
QuestManager.instance.stateMachine.AddExistingState(node);
}
}
public BoxValue getrandom(bool onstart)
{
int totalweight = 0;
var boxes = LevelManager.Instance.boxIdentity.Where(x => x.minimumLevelAppear <= LevelManager.Instance.currentLevel && (onstart ? x.appearOnStart : true));
// Debug.Log(LevelManager.Instance.currentLevel);
foreach (BoxValue item in boxes)
{
totalweight += item.weight;
}
int num = Random.Range(0, totalweight);
BoxValue a = null;
foreach (BoxValue item in boxes)
{
if (num < item.weight)
{
a = item;
break;
}
num -= item.weight;
}
return(a);
}
private void OnLoaded(object sender, RoutedEventArgs e)
{
BoxValue.Focus();
}
/// <summary>
/// Creates an element from the archetype and adds the element to the node.
/// </summary>
/// <param name="arch">The element archetype.</param>
/// <returns>The created element. Null if the archetype is invalid.</returns>
public ISurfaceNodeElement AddElement(NodeElementArchetype arch)
{
ISurfaceNodeElement element = null;
switch (arch.Type)
{
case NodeElementType.Input:
element = new InputBox(this, arch);
break;
case NodeElementType.Output:
element = new OutputBox(this, arch);
break;
case NodeElementType.BoolValue:
element = new BoolValue(this, arch);
break;
case NodeElementType.FloatValue:
element = new FloatValue(this, arch);
break;
case NodeElementType.IntegerValue:
element = new IntegerValue(this, arch);
break;
case NodeElementType.ColorValue:
element = new ColorValue(this, arch);
break;
case NodeElementType.ComboBox:
element = new ComboBoxElement(this, arch);
break;
case NodeElementType.Asset:
element = new AssetSelect(this, arch);
break;
case NodeElementType.Text:
element = new TextView(this, arch);
break;
case NodeElementType.TextBox:
element = new TextBoxView(this, arch);
break;
case NodeElementType.SkeletonBoneIndexSelect:
element = new SkeletonBoneIndexSelectElement(this, arch);
break;
case NodeElementType.BoxValue:
element = new BoxValue(this, arch);
break;
case NodeElementType.EnumValue:
element = new EnumValue(this, arch);
break;
case NodeElementType.SkeletonNodeNameSelect:
element = new SkeletonNodeNameSelectElement(this, arch);
break;
//default: throw new NotImplementedException("Unknown node element type: " + arch.Type);
}
if (element != null)
{
AddElement(element);
}
return(element);
}
protected override void VisitBoxValue(BoxValue node, object data)
{
state.Stack.Perform_BoxValue(node.Type);
nextNode = node.Next;
}
public override void InitBehaviours(AiBehaviourController controller)
{
var stateMachine = controller.stateMachine;
var inputHolder = controller.GetComponentInParent <InputHolder>();
var transform = controller.transform;
FocusPriority priorityFocus = controller.focusPriority;
AttentionMode painAttention = AiBehaviourPackUtility.GetAttentionPain(controller);
var tExecute = new Timer();
var lookAroundMethod = new LookAround(new RangedFloat(0.5f, 0.8f), new RangedFloat(25, 50));
// TODO if seeker is not defined create MoveToDestination instead
var moveToDestination = new MoveToDestinationNavigation(controller.GetComponent <Seeker>());
var velocityAccumulator = new VelocityAccumulator(0.89f, 0.075f);
var destination = controller.InitBlackboardValue <Vector2>("destination");
////////////////
var idle = painAttention.AddNewState(true)
.AddOnBegin(() => tExecute.RestartRandom(0.15f, 0.3f))
.AddOnBegin(inputHolder.ResetInput)
.AddShallReturn(tExecute.IsReady)
.SetUtility(0.1f);
;
var moveAway = painAttention.AddNewState(true)
.AddOnBegin(inputHolder.ResetInput)
.AddOnBegin(() => tExecute.RestartRandom(0.25f, 0.325f))
.AddOnUpdate(() =>
{
Vector2 toTarget = painAttention.focus.ToTarget();
inputHolder.positionInput = -toTarget;
inputHolder.rotationInput = toTarget;
inputHolder.directionInput = toTarget;
//Debug.Log(painAttention.activeTime);
})
.AddShallReturn(() => tExecute.IsReady())
.SetUtility(() => 10)
.AddCanEnter(() => painAttention.activeTime < 0.1f)
;
BoxValue <Vector2> initialDirection = new BoxValue <Vector2>(Vector2.zero);
var hit = painAttention.AddNewState(true)
.AddOnBegin(inputHolder.ResetInput)
.AddOnBegin(() => tExecute.RestartRandom(1.0f, 1.5f))
.AddOnBegin(() => inputHolder.directionInput = transform.up)
.AddOnUpdate(() =>
{
Vector2 toTarget = painAttention.focus.ToTarget();
inputHolder.positionInput = tExecute.IsReady(0.2f) ? Vector2.zero : -toTarget;
if (tExecute.IsReady(0.2f))
{
inputHolder.directionInput = PolarVector2.MoveTowards(
inputHolder.directionInput.GetPolarVector(), toTarget.GetPolarVector(), 3.5f, 0.25f);
inputHolder.keys[0] = true;
}
//Debug.Log(painAttention.activeTime);
})
.AddShallReturn(() => tExecute.IsReady())
.SetUtility(() => 15)
.AddCanEnter(() => painAttention.activeTime < 0.1f)
;
/// TODO:
/// later (if have not switched to another event) ai will have search behaviours
/// look around ( standard 360 degrees with agressive switches)
/// move randomly around
/// search manager (which will somehow generate points to check)
/// once in a while look at random point close to the hit position
}
public void SetCenter(string horizontal, string vertical)
{
this.boxCenterX = new BoxValue(horizontal);
this.boxCenterY = new BoxValue(vertical);
}
public void SetSize(string width, string height)
{
this.boxWidth = new BoxValue(width);
this.boxHeight = new BoxValue(height);
}
protected internal virtual void VisitBoxValue(BoxValue node, object data)
{
throw new NodeNotSupportedException(node);
}
/// <summary>
/// Creates an element from the archetype and adds the element to the node.
/// </summary>
/// <param name="arch">The element archetype.</param>
/// <returns>The created element. Null if the archetype is invalid.</returns>
public ISurfaceNodeElement AddElement(NodeElementArchetype arch)
{
ISurfaceNodeElement element = null;
switch (arch.Type)
{
case NodeElementType.Input:
element = new InputBox(this, arch);
break;
case NodeElementType.Output:
element = new OutputBox(this, arch);
break;
case NodeElementType.BoolValue:
element = new BoolValue(this, arch);
break;
case NodeElementType.FloatValue:
element = new FloatValue(this, arch);
break;
case NodeElementType.IntegerValue:
element = new IntegerValue(this, arch);
break;
case NodeElementType.ColorValue:
element = new ColorValue(this, arch);
break;
case NodeElementType.ComboBox:
element = new ComboBoxElement(this, arch);
break;
case NodeElementType.Asset:
element = new AssetSelect(this, arch);
break;
case NodeElementType.Text:
element = new TextView(this, arch);
break;
case NodeElementType.TextBox:
element = new TextBoxView(this, arch);
break;
case NodeElementType.SkeletonNodeSelect:
element = new SkeletonNodeSelectElement(this, arch);
break;
case NodeElementType.BoxValue:
element = new BoxValue(this, arch);
break;
case NodeElementType.EnumValue:
element = new EnumValue(this, arch);
break;
}
if (element != null)
{
AddElement(element);
}
return(element);
}
public static MethodBodyBlock Convert(MethodEx method)
{
if (!method.IsVerified)
{
throw new ConvertionException();
}
MethodInfoExtention _method_ = new MethodInfoExtention(method.Method);
MethodBodyBlock mainBlock = new MethodBodyBlock(_method_.GetReturnType().type);
mainBlock.Options["StackTypes"] = new StackTypes();
Block currentBlock = mainBlock;
Node[] heads = new Node[method.Count];
Node[] tails = new Node[method.Count];
Node head = null;
Node tail = null;
Node firstBlock = null;
Node lastBlock = null;
int iNum, iNumNext;
Variable[] locals = new Variable[method.Locals.Count];
Variable[] args = new Variable[_method_.ArgCount];
VariablesList methodVarList = mainBlock.Variables;
for (int i = 0; i < args.Length; i++)
{
args[i] = methodVarList.CreateVar(_method_.GetArgType(i).type, VariableKind.Parameter);
args[i].Name = "Arg" + i;
// methodVarList.Add(args[i]);
}
for (int i = 0; i < locals.Length; i++)
{
locals[i] = methodVarList.CreateVar(method.Locals[i], VariableKind.Local);
locals[i].Name = "Loc" + i;
// methodVarList.Add(locals[i]);
}
BlockType nextBlockType;
int nextBlockStart = -1;
int nextBlockEnd = 1 << 30;
int nextBlockIndex;
Type nextCatchBlockType;
Hashtable tryBlocks = new Hashtable();
Hashtable filterBlocks = new Hashtable();
Stack blockEnds = new Stack();
blockEnds.Push(method.Count);
FindNextBlockStart(method.EHClauses, out nextBlockType, ref nextBlockStart, ref nextBlockEnd, out nextCatchBlockType, out nextBlockIndex);
//Nodes and blocks creation, blocks linkage
for (iNum = 0; iNum < method.Count; iNum++)
{
while (iNum == (int)blockEnds.Peek())
{
currentBlock = currentBlock.Parent;
blockEnds.Pop();
}
firstBlock = null;
lastBlock = null;
Node thisBlock = null;
while (iNum == nextBlockStart)
{
Block currentBlockOld = currentBlock;
switch (nextBlockType)
{
case BlockType.Try:
currentBlock = new ProtectedBlock();
break;
case BlockType.Catch:
currentBlock = new CatchBlock(nextCatchBlockType);
break;
case BlockType.Finally:
currentBlock = new FinallyBlock(false);
break;
case BlockType.Filter:
currentBlock = new FilterBlock();
break;
case BlockType.FilteredCatch:
currentBlock = new UserFilteredBlock();
break;
}
currentBlock.setParent(currentBlockOld);
blockEnds.Push(nextBlockEnd);
if (thisBlock == null)
{
thisBlock = firstBlock = currentBlock;
}
else
{
thisBlock.Next = currentBlock;
thisBlock = currentBlock;
}
switch (nextBlockType)
{
case BlockType.Try:
tryBlocks.Add(new Segment(nextBlockStart, nextBlockEnd), thisBlock);
break;
case BlockType.Filter:
filterBlocks.Add(new Segment(nextBlockStart, nextBlockEnd), thisBlock);
break;
case BlockType.Finally:
case BlockType.Catch:
{
Segment tryBlockKey = FindProtectedBlock(method.EHClauses, nextBlockIndex);
ProtectedBlock tryBlock = tryBlocks[tryBlockKey] as ProtectedBlock;
tryBlock.AddHandler(thisBlock as EHBlock);
} break;
case BlockType.FilteredCatch:
{
Segment tryBlockKey = FindProtectedBlock(method.EHClauses, nextBlockIndex);
ProtectedBlock tryBlock = tryBlocks[tryBlockKey] as ProtectedBlock;
tryBlock.AddHandler(thisBlock as EHBlock);
Segment filterKey = FindFilterBlock(method.EHClauses, nextBlockIndex);
FilterBlock filterBlock = filterBlocks[filterKey] as FilterBlock;
(thisBlock as UserFilteredBlock).Filter = filterBlock;
} break;
}
FindNextBlockStart(method.EHClauses, out nextBlockType, ref nextBlockStart, ref nextBlockEnd, out nextCatchBlockType, out nextBlockIndex);
}
lastBlock = thisBlock;
Instruction i = method[iNum];
switch (i.Code)
{
case InstructionCode.NEG:
case InstructionCode.NOT:
{
head = tail = new UnaryOp(UnaryOpFromCode(i.Code));
/*!*/ head.setParent(currentBlock);
} break;
case InstructionCode.ADD:
case InstructionCode.AND:
case InstructionCode.CEQ:
case InstructionCode.CGT:
case InstructionCode.CLT:
case InstructionCode.DIV:
case InstructionCode.MUL:
case InstructionCode.OR:
case InstructionCode.REM:
case InstructionCode.SHL:
case InstructionCode.SHR:
case InstructionCode.SUB:
case InstructionCode.XOR:
{
head = tail = new BinaryOp(BinaryOpFromCode(i.Code), i.OverflowFlag, i.UnsignedFlag);
/*!*/ head.setParent(currentBlock);
} break;
case InstructionCode.LDC:
head = tail = new LoadConst(i.Param);
/*!*/ head.setParent(currentBlock);
break;
case InstructionCode.LDARG:
head = tail = new LoadVar(args[(int)(i.Param)]);
/*!*/ head.setParent(currentBlock);
break;
case InstructionCode.LDLOC:
head = tail = new LoadVar(locals[(int)(i.Param)]);
/*!*/ head.setParent(currentBlock);
break;
case InstructionCode.LDARGA:
head = tail = new LoadVarAddr(args[(int)(i.Param)]);
/*!*/ head.setParent(currentBlock);
break;
case InstructionCode.LDLOCA:
head = tail = new LoadVarAddr(locals[(int)(i.Param)]);
/*!*/ head.setParent(currentBlock);
break;
case InstructionCode.LDIND:
head = tail = new LoadIndirect(i.TypeBySuffixOrParam());
/*!*/ head.setParent(currentBlock);
break;
case InstructionCode.LDFLD:
{
FieldInfo field = i.Param as FieldInfo;
if (field.IsStatic)
{
head = new RemoveStackTop();
/*!*/ head.setParent(currentBlock);
//remove the object instance when accessing the static field with LDFLD
tail = new LoadField(field);
/*!*/ tail.setParent(currentBlock);
head.Next = tail;
}
else
{
head = tail = new LoadField(field);
/*!*/ head.setParent(currentBlock);
}
} break;
case InstructionCode.LDFLDA:
{
FieldInfo field = i.Param as FieldInfo;
if (field.IsStatic)
{
head = new RemoveStackTop();
/*!*/ head.setParent(currentBlock);
tail = new LoadFieldAddr(field);
/*!*/ tail.setParent(currentBlock);
head.Next = tail;
}
else
{
head = tail = new LoadFieldAddr(field);
/*!*/ head.setParent(currentBlock);
}
} break;
case InstructionCode.LDSFLD:
head = tail = new LoadField(i.Param as FieldInfo);
/*!*/ head.setParent(currentBlock);
break;
case InstructionCode.LDSFLDA:
head = tail = new LoadFieldAddr(i.Param as FieldInfo);
/*!*/ head.setParent(currentBlock);
break;
case InstructionCode.LDELEM:
head = tail = new LoadElement(i.TypeBySuffixOrParam());
/*!*/ head.setParent(currentBlock);
break;
case InstructionCode.LDELEMA:
head = tail = new LoadElementAddr(i.TypeBySuffixOrParam());
/*!*/ head.setParent(currentBlock);
break;
case InstructionCode.LDOBJ:
head = tail = new LoadIndirect(i.Param as Type);
/*!*/ head.setParent(currentBlock);
break;
case InstructionCode.SIZEOF:
head = tail = new LoadSizeOfValue(i.Param as Type);
/*!*/ head.setParent(currentBlock);
break;
case InstructionCode.LDLEN:
head = tail = new LoadLength();
/*!*/ head.setParent(currentBlock);
break;
case InstructionCode.LDTOKEN:
if (i.Param is Type)
{
head = tail = new LoadConst((i.Param as Type).TypeHandle);
}
else if (i.Param is MethodBase)
{
head = tail = new LoadConst((i.Param as MethodBase).MethodHandle);
}
else if (i.Param is FieldInfo)
{
head = tail = new LoadConst((i.Param as FieldInfo).FieldHandle);
}
else
{
throw new ConvertionException();
}
/*!*/ head.setParent(currentBlock);
break;
case InstructionCode.LDNULL:
head = tail = new LoadConst(null);
/*!*/ head.setParent(currentBlock);
break;
case InstructionCode.LDSTR:
head = tail = new LoadConst(i.Param);
/*!*/ head.setParent(currentBlock);
break;
case InstructionCode.STARG:
head = tail = new StoreVar(args[(int)(i.Param)]);
/*!*/ head.setParent(currentBlock);
break;
case InstructionCode.STLOC:
head = tail = new StoreVar(locals[(int)(i.Param)]);
/*!*/ head.setParent(currentBlock);
break;
case InstructionCode.STIND:
head = tail = new StoreIndirect(i.TypeBySuffixOrParam());
/*!*/ head.setParent(currentBlock);
break;
case InstructionCode.STFLD:
{
FieldInfo field = i.Param as FieldInfo;
if (field.IsStatic)
{
head = new StoreField(field);
/*!*/ head.setParent(currentBlock);
tail = new RemoveStackTop();
/*!*/ tail.setParent(currentBlock);
head.Next = tail;
}
else
{
head = tail = new StoreField(i.Param as FieldInfo);
/*!*/ head.setParent(currentBlock);
}
} break;
case InstructionCode.STSFLD:
head = tail = new StoreField(i.Param as FieldInfo);
/*!*/ head.setParent(currentBlock);
break;
case InstructionCode.STELEM:
head = tail = new StoreElement(i.TypeBySuffixOrParam());
/*!*/ head.setParent(currentBlock);
break;
case InstructionCode.STOBJ:
head = tail = new StoreIndirect(i.Param as Type);
/*!*/ head.setParent(currentBlock);
break;
case InstructionCode.CPOBJ:
head = new LoadIndirect(i.Param as Type);
/*!*/ head.setParent(currentBlock);
tail = new StoreIndirect(i.Param as Type);
/*!*/ tail.setParent(currentBlock);
head.Next = tail;
break;
case InstructionCode.DUP:
head = tail = new DuplicateStackTop();
/*!*/ head.setParent(currentBlock);
break;
case InstructionCode.CALL:
head = tail = new CallMethod(i.Param as MethodBase, false, i.HasTail);
/*!*/ head.setParent(currentBlock);
break;
case InstructionCode.CALLVIRT:
MethodInfo callee = i.Param as MethodInfo;
head = tail = new CallMethod(callee, callee.IsVirtual, i.HasTail);
/*!*/ head.setParent(currentBlock);
break;
case InstructionCode.NEWOBJ:
{ ConstructorInfo ctor = i.Param as ConstructorInfo;
if (Verifier.IsDelegate(ctor.DeclaringType))
{
if (Verifier.IsInstanceDispatch(method, iNum))
{
heads[iNum - 1] = tails[iNum - 1] = null;
head = tail = new CreateDelegate(ctor, method[iNum - 1].Param as MethodInfo, false);
}
else if (Verifier.IsVirtualDispatch(method, iNum))
{
heads[iNum - 2] = tails[iNum - 2] = null;
heads[iNum - 1] = tails[iNum - 1] = null;
head = tail = new CreateDelegate(ctor, method[iNum - 1].Param as MethodInfo, true);
}
}
else
{
head = tail = new NewObject(ctor);
}
/*!*/ head.setParent(currentBlock); } break;
case InstructionCode.NEWARR:
head = tail = new NewArray(i.Param as Type);
/*!*/ head.setParent(currentBlock);
break;
case InstructionCode.INITOBJ:
head = tail = new InitValue(i.Param as Type);
/*!*/ head.setParent(currentBlock);
break;
case InstructionCode.ISINST:
head = tail = new CastClass(i.Param as Type, false);
/*!*/ head.setParent(currentBlock);
break;
case InstructionCode.CASTCLASS:
head = tail = new CastClass(i.Param as Type, true);
/*!*/ head.setParent(currentBlock);
break;
case InstructionCode.BOX:
head = tail = new BoxValue(i.Param as Type);
/*!*/ head.setParent(currentBlock);
break;
case InstructionCode.UNBOX:
head = tail = new UnboxValue(i.Param as Type);
/*!*/ head.setParent(currentBlock);
break;
case InstructionCode.CONV:
head = tail = new ConvertValue(i.TypeBySuffixOrParam(), i.OverflowFlag, i.UnsignedFlag);
/*!*/ head.setParent(currentBlock);
break;
case InstructionCode.POP:
head = tail = new RemoveStackTop();
/*!*/ head.setParent(currentBlock);
break;
case InstructionCode.BEQ:
head = new BinaryOp(BinaryOp.ArithOp.CEQ, false, false);
/*!*/ head.setParent(currentBlock);
tail = new Branch();
/*!*/ tail.setParent(currentBlock);
head.Next = tail;
break;
case InstructionCode.BNE:
head = new BinaryOp(BinaryOp.ArithOp.CEQ, false, false);
/*!*/ head.setParent(currentBlock);
tail = new Branch();
/*!*/ tail.setParent(currentBlock);
head.Next = tail;
break;
case InstructionCode.BGE:
if (TypeFixer.IsFloatOrCompatible(i.Stack.Top()))
{
head = new BinaryOp(BinaryOp.ArithOp.CLT, false, !i.UnsignedFlag);
}
else
{
head = new BinaryOp(BinaryOp.ArithOp.CLT, false, i.UnsignedFlag);
}
tail = new Branch();
/*!*/ head.setParent(currentBlock);
/*!*/ tail.setParent(currentBlock);
head.Next = tail;
break;
case InstructionCode.BGT:
head = new BinaryOp(BinaryOp.ArithOp.CGT, false, i.UnsignedFlag);
tail = new Branch();
/*!*/ head.setParent(currentBlock);
/*!*/ tail.setParent(currentBlock);
head.Next = tail;
break;
case InstructionCode.BLE:
if (TypeFixer.IsFloatOrCompatible(i.Stack.Top()))
{
head = new BinaryOp(BinaryOp.ArithOp.CGT, false, !i.UnsignedFlag);
}
else
{
head = new BinaryOp(BinaryOp.ArithOp.CGT, false, i.UnsignedFlag);
}
tail = new Branch();
/*!*/ head.setParent(currentBlock);
/*!*/ tail.setParent(currentBlock);
head.Next = tail;
break;
case InstructionCode.BLT:
head = new BinaryOp(BinaryOp.ArithOp.CLT, false, i.UnsignedFlag);
tail = new Branch();
/*!*/ head.setParent(currentBlock);
/*!*/ tail.setParent(currentBlock);
head.Next = tail;
break;
case InstructionCode.BRTRUE:
head = tail = new Branch();
/*!*/ head.setParent(currentBlock);
break;
case InstructionCode.BRFALSE:
head = tail = new Branch();
/*!*/ head.setParent(currentBlock);
break;
case InstructionCode.SWITCH:
head = tail = new Switch((i.Param as int[]).Length);
/*!*/ head.setParent(currentBlock);
break;
case InstructionCode.BR:
case InstructionCode.NOP:
case InstructionCode.BREAK:
case InstructionCode.LDFTN: // Expecting further delegate construction...
case InstructionCode.LDVIRTFTN: //
head = tail = new DummyNode();
/*!*/ head.setParent(currentBlock);
break;
case InstructionCode.THROW:
head = tail = new ThrowException();
/*!*/ head.setParent(currentBlock);
break;
case InstructionCode.RET:
case InstructionCode.ENDFINALLY:
case InstructionCode.ENDFILTER:
case InstructionCode.LEAVE:
head = tail = new Leave();
/*!*/ head.setParent(currentBlock);
break;
default:
throw new ConvertionException();
}
if (head != null)
{
head.Options["StackTypes"] = i.Stack.Clone() as StackTypes;
}
if (head != tail) //=> head :: BinaryOp, tail :: Branch
//|| head :: LoadIndirect, tail :: StoreIndirect
{
if (head is BinaryOp && tail is Branch)
{
StackTypes stack = i.Stack.Clone() as StackTypes;
stack.Pop();
stack.Pop();
stack.Push(typeof(int));
tail.Options["StackTypes"] = stack;
}
else if (head is LoadIndirect && tail is StoreIndirect)
{
StackTypes stack = i.Stack.Clone() as StackTypes;
TypeEx type = stack.Pop(); //type == S&
stack.Push(type.type.GetElementType());
tail.Options["StackTypes"] = stack;
}
}
if (firstBlock != null)
{
lastBlock.Next = head;
for (Node n = firstBlock; n != head; n = n.Next)
{
n.Options["StackTypes"] = i.Stack.Clone() as StackTypes;
}
head = firstBlock;
if (tail == null)
{
tail = lastBlock; //This may occure what the NOP instruction starts some block
}
}
heads[iNum] = head;
tails[iNum] = tail;
} //for
mainBlock.Next = heads[0];
//Control flow linkage
for (iNum = 0; iNum < method.Count; iNum++)
{
if (heads[iNum] == null)
{
throw new ConvertionException(); //impossible :)
}
Instruction i = method[iNum];
switch (i.Code)
{
case InstructionCode.BR:
case InstructionCode.LEAVE:
tails[iNum].Next = heads[(int)i.Param];
break;
case InstructionCode.RET:
case InstructionCode.ENDFINALLY:
case InstructionCode.ENDFILTER:
case InstructionCode.THROW:
case InstructionCode.RETHROW:
break;
case InstructionCode.BRFALSE: //false
case InstructionCode.BGE: //false
case InstructionCode.BLE: //false
case InstructionCode.BNE: //false
tails[iNum].Next = heads[(int)i.Param];
(tails[iNum] as Branch).Alt = heads[iNum + 1];
break;
case InstructionCode.BRTRUE: //true
case InstructionCode.BEQ: //true
case InstructionCode.BGT: //true
case InstructionCode.BLT: //true
tails[iNum].Next = heads[iNum + 1];
(tails[iNum] as Branch).Alt = heads[(int)i.Param];
break;
case InstructionCode.SWITCH:
tails[iNum].Next = heads[iNum + 1];
Switch node = tails[iNum] as Switch;
int[] alt = i.Param as int[];
for (int j = 0; j < node.Count; j++)
{
node[j] = heads[alt[j]];
}
break;
default:
tails[iNum].Next = heads[iNum + 1];
break;
}
}
//Removing DummyNodes
for (iNum = 0; iNum < method.Count; iNum++)
{
if (heads[iNum] is DummyNode)
{
Node dummy = heads[iNum];
Node[] prev = new Node[dummy.PrevArray.Count];
for (int j = 0; j < prev.Length; j++)
{
prev[j] = dummy.PrevArray[j];
}
for (int j = 0; j < prev.Length; j++)
{
prev[j].NextArray[prev[j].NextArray.IndexOf(dummy)] = dummy.Next;
}
dummy.RemoveFromGraph();
}
}
return(mainBlock);
}
