public override string ToString(InstructionData aData)
{
var fromReg = (Registers)aData[0];
var toReg = (Registers)aData[1];
// mov R1, R2
return($"{AsmName} {fromReg}, {toReg}");
}
public override InstructionData Parse(string[] args)
{
InstructionData data =
default(InstructionData);
data.Metadata = new Metadata();
return(data);
}
public override bool Execute(InstructionData aData, Cpu aCpu)
{
aCpu.Registers[(Registers)aData[1]] =
aCpu.Vm.Memory
.GetInt((int)aData[0], GetSecurityContext(), false);
return(false);
}
public override bool Execute(InstructionData aData, Cpu aCpu)
{
aCpu.Vm.Memory.StackPushInt((int)aData[0]);
// Update the stack pointer register to reflect
// the new stack position.
// This must be done with a security-level context.
aCpu.Registers[(Registers.SP, SecurityContext.System)] =
public override string ToString(InstructionData aData)
{
var fromReg1 = (Registers)aData[0];
var fromReg2 = (Registers)aData[1];
// add R1, R2
return($"{AsmName} {fromReg1}, {fromReg2}");
}
public override bool Execute(InstructionData aData, Cpu aCpu)
{
aCpu.PushState();
aCpu.Registers[Registers.IP] = (int)aData[0];
return(false);
}
public override string ToString(InstructionData aData)
{
var address = (int)aData[0];
// call &$LITERAL
return((OutputLiteralsAsHex) ?
$"{AsmName} &$0x{address:X}" :
$"{AsmName} &${address:X}");
}
void Peek(ulong address, int length = 100)
{
string data = new InstructionData(address).fullData;
//Bytedata = PS4.ReadMemory(PID, address, length);
//DisassemblyTextBox.Text = GetDisassembly(address, Bytedata);
DisassemblyTextBox.Text = data;
Debugging(address);
}
public override bool Execute(InstructionData aData, Cpu aCpu)
{
if (aCpu.Registers[Registers.AC] != (int)aData[0])
{
aCpu.Registers[Registers.IP] = (int)aData[1];
}
return(false);
}
public override bool Execute(InstructionData aData, Cpu aCpu)
{
++aCpu.Registers[(Registers)aData[0]];
// We do not need to update the CPU flags
// here as the result is not going
// into the accumulator register.
return(false);
}
public override string ToString(InstructionData aData)
{
var literal = (int)aData[0];
var toReg = (Registers)aData[1];
// mov $LITERAL, R1
return((OutputLiteralsAsHex) ?
$"{AsmName} $0x{literal:X}, {toReg}" :
$"{AsmName} ${literal}, {toReg}");
}
public override string ToString(InstructionData aData)
{
var bit = (int)aData[0];
var fromReg = (Registers)aData[1];
// bit $LITERAL, R1
return((OutputLiteralsAsHex) ?
$"{AsmName} $0x{bit:X}, {fromReg}" :
$"{AsmName} ${bit}, {fromReg}");
}
public override InstructionData Parse(string[] args)
{
InstructionData data = default(InstructionData);
if (args.Length > 1)
{
data.Metadata = ushort.Parse(args[1]);
}
return(data);
}
public Character(GameObject obj, WorldController wc, int i, InstructionManager m) : base(obj, wc, i)
{
manager = m;
Instructions = manager.GetInstructionSet(this);
if (Instructions.Count > 0)
{
currentInstruction = Instructions.First.Value;
Instructions.RemoveFirst();
}
}
public override string ToString(InstructionData aData)
{
var fromReg = (Registers)aData[0];
var literal = (int)aData[1];
// and R1, $LITERAL
return((OutputLiteralsAsHex) ?
$"{AsmName} {fromReg}, $0x{literal:X}" :
$"{AsmName} {fromReg}, ${literal}");
}
public override string ToString(InstructionData aData)
{
var fromReg = (Registers)aData[0];
var address = (int)aData[1];
// jeq R1, &ADDRESS
return((OutputLiteralsAsHex) ?
$"{AsmName} {fromReg}, &0x{address:X}" :
$"{AsmName} {fromReg}, &{address}");
}
public ActionResult SaveInstruction(Instruction instruction)
{
ExperimentData experimentData = (ExperimentData)rsContext.getActivity(instruction.expID);
InstructionData instructionData = Adapting.getInstructionAsData(instruction);
instructionData.experimentOrder = experimentData.activities.Count;
experimentData.addStep(instructionData);
rsContext.SaveChanges();
return(RedirectToAction("EditExperiment", new { ExpID = instruction.expID }));
}
public override string ToString(InstructionData aData)
{
var literal = (int)aData[0];
var toAddr = (int)aData[1];
// mov $LITERAL, &ADDRESS
return((OutputLiteralsAsHex) ?
$"{AsmName} $0x{literal:X}, &0x{toAddr:X}" :
$"{AsmName} ${literal}, &{toAddr}");
}
public override string ToString(InstructionData aData)
{
var literal = (int)aData[0];
var address = (int)aData[1];
// jne $LITERAL, &ADDRESS
return((OutputLiteralsAsHex) ?
$"{AsmName} $0x{literal:X}, &0x{address:X}" :
$"{AsmName} ${literal}, &{address}");
}
public override string ToString(InstructionData aData)
{
var fromReg = (Registers)aData[0];
var memoryAddr = (int)aData[1];
// mov R1, &ADDRESS
return((OutputLiteralsAsHex) ?
$"{AsmName} {fromReg}, &0x{memoryAddr:X}" :
$"{AsmName} {fromReg}, &{memoryAddr}");
}
public override string ToString(InstructionData aData)
{
var memoryAddr = (int)aData[0];
var toReg = (Registers)aData[1];
// mov &ADDRESS, R1
return((OutputLiteralsAsHex) ?
$"{AsmName} &0x{memoryAddr:X}, {toReg}" :
$"{AsmName} &{memoryAddr:X}, {toReg}");
}
public override string ToString(InstructionData aData)
{
var sizeHintStr =
((InstructionSizeHint)aData[0]).ToString();
var fromReg = (Registers)aData[1];
var toReg = (Registers)aData[2];
// mov TYPE &R1, R2
return($"{AsmName} {sizeHintStr.ToUpper()} &{fromReg}, {toReg}");
}
public void AddInstruction(InstructionBuilder instructionBuilder, Token[] argTokens)
{
// todo1[ak] check args
if (this.IsFinished)
{
throw new ApplicationException(); // todo2[ak]
}
InstructionData data = new InstructionData(instructionBuilder, argTokens);
_instructionDatas.Add(data);
}
public override bool Execute(InstructionData aData, Cpu aCpu)
{
// We do not care if this writes to executable
// memory.
aCpu.Vm.Memory
.SetInt((int)aData[1],
(int)aData[0],
GetSecurityContext(),
false);
return(false);
}
public override bool Execute(InstructionData aData, Cpu aCpu)
{
// We do not care if this write
// is within an executable region or not.
aCpu.Vm.Memory
.SetInt((int)aData[1],
aCpu.Registers[(Registers)aData[0]],
GetSecurityContext(),
false);
return(false);
}
public override bool Execute(InstructionData aData, Cpu aCpu)
{
var val =
aCpu.Registers[(Registers)aData[1]];
var bitSet =
Utils.IsBitSet(val, (int)aData[0]) ? 1 : 0;
aCpu.SetResultFlagPair(bitSet);
return(false);
}
public override bool Execute(PlayerBot bot, InstructionData data)
{
if (Core.Ball != null)
{
Position Pos = new Position();
Pos.X = (int)Core.Ball.Position3d.X;
Pos.Y = (int)Core.Ball.Position3d.Z;
Pos.Z = (int)Core.Ball.Position3d.Y;
bot.Pos = Pos;
}
return(true);
}
void RevertInstructionsToTime(float t)
{
if (DoneInstructions.Count > 0)
{
while (DoneInstructions.Count > 0 && DoneInstructions.Peek().Value1 > t)
{
if (currentInstruction != null)
{
Instructions.AddFirst(currentInstruction);
}
currentInstruction = DoneInstructions.Pop().Value2;
}
}
}
public static InstructionData getInstructionAsData(Instruction instruction)
{
InstructionData iData = new InstructionData();
iData.ActivityName = instruction.ActivityName;
iData.expID = instruction.expID;
iData.id = instruction.id;
iData.isMainActivity = instruction.isMainActivity;
iData.RoomId = instruction.RoomId;
iData.Command = instruction.Command;
return(iData);
}
public void TestJumpBeforeInstruction()
{
// We need to add the position at which
// the program will be loaded in memory.
// This will give us an absolute
// address to work with.
const int address =
(
sizeof(OpCode) * 2 +
sizeof(Registers) +
sizeof(int) +
Compiler.InitialAddress
);
var program = new []
{
new CompilerIns(OpCode.MOV_LIT_REG,
new object[] { 0, Registers.R1 }),
new CompilerIns(OpCode.NOP),
new CompilerIns(OpCode.LABEL, new object[] { "AAA" }),
new CompilerIns(OpCode.NOP),
new CompilerIns(OpCode.JNE_REG,
new object[] { Registers.R1, 0 },
new [] { new AsmLabel("AAA", 1) }),
};
Vm.LoadAndInitialize(QuickCompile.RawCompile(program));
var ins = new InstructionData()
{
OpCode = OpCode.NOP
};
var i = 0;
while (i < 4)
{
ins = Vm.Cpu.Step();
i++;
}
if (ins is null)
{
Assert.Fail("Expected an instruction but none was returned.");
}
Assert.IsTrue(address == (int)ins.Args[1].Value);
}
public static Instruction getInstructionFromData(InstructionData instructionData)
{
Instruction i = new Instruction();
i.ActivityName = instructionData.ActivityName;
i.expID = instructionData.expID;
i.id = instructionData.id;
i.isMainActivity = instructionData.isMainActivity;
i.RoomId = instructionData.RoomId;
i.Type = instructionData.Type;
i.Command = instructionData.Command;
return(i);
}
private Instruction CreateInstruction(MethodDefinition method, ILWeaver weaver, InstructionData instructionData, List<Instruction> insts, Patcher patcher)
{
var opcode = opCodes[instructionData.OpCode];
var optype = instructionData.OpType;
Instruction Instruction = null;
switch (optype)
{
case OpType.None:
Instruction = Instruction.Create(opcode);
break;
case OpType.Byte:
Instruction = Instruction.Create(opcode, Convert.ToByte(instructionData.Operand));
break;
case OpType.SByte:
Instruction = Instruction.Create(opcode, Convert.ToSByte(instructionData.Operand));
break;
case OpType.Int32:
Instruction = Instruction.Create(opcode, Convert.ToInt32(instructionData.Operand));
break;
case OpType.Int64:
Instruction = Instruction.Create(opcode, Convert.ToInt64(instructionData.Operand));
break;
case OpType.Single:
Instruction = Instruction.Create(opcode, Convert.ToSingle(instructionData.Operand));
break;
case OpType.Double:
Instruction = Instruction.Create(opcode, Convert.ToDouble(instructionData.Operand));
break;
case OpType.String:
Instruction = Instruction.Create(opcode, Convert.ToString(instructionData.Operand));
break;
case OpType.VerbatimString:
Instruction = Instruction.Create(opcode, Regex.Unescape(Convert.ToString(instructionData.Operand)));
break;
case OpType.Instruction:
var index = Convert.ToInt32(instructionData.Operand);
Instruction = Instruction.Create(opcode, index < 1024 ? weaver.Instructions[index] : insts[index - 1024]);
break;
case OpType.Variable:
Instruction = Instruction.Create(opcode, method.Body.Variables[Convert.ToInt32(instructionData.Operand)]);
break;
case OpType.Parameter:
Instruction = Instruction.Create(opcode, method.Parameters[Convert.ToInt32(instructionData.Operand)]);
break;
case OpType.Field:
var fieldData = Convert.ToString(instructionData.Operand).Split('|');
var fieldType = GetType(fieldData[0], fieldData[1], patcher);
if (fieldType == null) return null;
var fieldField = fieldType.Fields.FirstOrDefault(f => f.Name.Equals(fieldData[2]));
if (fieldField == null)
{
ShowMsg(string.Format("The Field '{0}' for '{1}' could not be found!", fieldData[2], Name), "Missing Field", patcher);
return null;
}
Instruction = Instruction.Create(opcode, method.Module.Import(fieldField));
break;
case OpType.Method:
var methodData = Convert.ToString(instructionData.Operand).Split('|');
var methodType = GetType(methodData[0], methodData[1], patcher);
if (methodType == null) return null;
var methodMethod = methodType.Methods.FirstOrDefault(f => f.Name.Equals(methodData[2]));
if (methodMethod == null)
{
ShowMsg(string.Format("The Method '{0}' for '{1}' could not be found!", methodData[2], Name), "Missing Method", patcher);
return null;
}
Instruction = Instruction.Create(opcode, method.Module.Import(methodMethod));
break;
case OpType.Generic:
break;
case OpType.Type:
var typeData = Convert.ToString(instructionData.Operand).Split('|');
var typeType = GetType(typeData[0], typeData[1], patcher);
if (typeType == null) return null;
Instruction = Instruction.Create(opcode, method.Module.Import(typeType));
break;
default:
throw new ArgumentOutOfRangeException();
}
return Instruction;
}
