public void EmitSetWindow(Operand op)
{
il.Arguments.LoadMachine();
EmitLoadOperand(op);
il.Call(Reflection <CompiledZMachine> .GetMethod("SetWindow", Types.Array <int>(), @public: false));
}
public override void Generate(ILBuilder il, ICompiler compiler)
{
il.Arguments.LoadMachine();
compiler.EmitLoadOperand(op1);
compiler.EmitLoadOperand(op2);
compiler.EmitLoadOperand(op3);
if (op4.HasValue)
{
compiler.EmitLoadOperand(op4.Value);
}
else
{
il.Load(0x82);
}
il.Call(Reflection <CompiledZMachine> .GetMethod("op_scan_table", Types.Array <ushort, ushort, ushort, ushort>(), @public: false));
using (var result = il.NewLocal <ushort>())
{
result.Store();
compiler.EmitStoreVariable(store, result);
result.Load();
il.Load(0);
il.Compare.NotEqual();
}
compiler.EmitBranch(branch);
}
public override void Generate(ILBuilder il, ICompiler compiler)
{
il.Arguments.LoadMachine();
compiler.EmitLoadOperand(textBufferOp);
compiler.EmitLoadOperand(parseBufferOp);
if (dictionaryOp != null)
{
compiler.EmitLoadOperand(dictionaryOp.Value);
}
else
{
il.Load(0);
}
if (flagOp != null)
{
compiler.EmitLoadOperand(flagOp.Value);
il.Load(0);
il.Compare.Equal();
il.Load(0);
il.Compare.Equal();
}
else
{
il.Load(0);
}
il.Call(Reflection <CompiledZMachine> .GetMethod("Tokenize", Types.Array <ushort, ushort, ushort, bool>(), @public: false));
}
public void EmitPrintChar(char ch)
{
il.Arguments.LoadMachine();
il.Load(ch);
il.Call(Reflection <CompiledZMachine> .GetMethod("PrintChar", Types.Array <char>(), @public: false));
}
public override void Generate(ILBuilder il, ICompiler compiler)
{
il.Arguments.LoadMachine();
compiler.EmitLoadOperand(addressOp);
compiler.EmitLoadOperand(widthOp);
if (heightOp != null)
{
compiler.EmitLoadOperand(heightOp.Value);
}
else
{
il.Load(1);
}
if (skipOp != null)
{
compiler.EmitLoadOperand(skipOp.Value);
}
else
{
il.Load(0);
}
il.Call(Reflection <CompiledZMachine> .GetMethod("op_print_table", Types.Array <ushort, ushort, ushort, ushort>(), @public: false));
}
public override void Generate(ILBuilder il, ICompiler compiler)
{
il.Arguments.LoadMachine();
compiler.EmitLoadOperand(textBufferOp);
compiler.EmitLoadOperand(parseBufferOp);
il.Call(Reflection <CompiledZMachine> .GetMethod("Read_Z3", Types.Array <ushort, ushort>(), @public: false));
}
public override void Generate(ILBuilder il, ICompiler compiler)
{
il.Arguments.LoadMachine();
compiler.EmitLoadOperand(op1);
compiler.EmitLoadOperand(op2);
compiler.EmitLoadOperand(op3);
il.Call(Reflection <CompiledZMachine> .GetMethod("op_copy_table", Types.Array <ushort, ushort, ushort>(), @public: false));
}
public void EmitSetColor(ILocal foreground, ILocal background)
{
il.Arguments.LoadMachine();
foreground.Load();
background.Load();
il.Call(Reflection <CompiledZMachine> .GetMethod("SetColors", Types.Array <ZColor, ZColor>(), @public: false));
}
public void EmitSetCursor(ILocal line, ILocal column)
{
il.Arguments.LoadMachine();
line.Load();
column.Load();
il.Call(Reflection <CompiledZMachine> .GetMethod("SetCursor", Types.Array <int, int>(), @public: false));
}
public void ThrowException <T>(string message) where T : Exception
{
var ctor = Reflection <T> .GetConstructor(Types.Array <string>());
Load(message);
Emit(OpCodes.Newobj, ctor);
Emit(OpCodes.Throw);
}
private void Profiler_ExitRoutine()
{
if (machine.Profiling)
{
il.Arguments.LoadMachine();
il.Load(routine.Address);
il.Call(Reflection <CompiledZMachine> .GetMethod("ExitRoutine", Types.Array <int>(), @public: false));
}
}
private static DynamicMethod CreateDynamicMethod(ZRoutine routine)
{
return(new DynamicMethod(
name: string.Format("{0:x4}_{1}_locals", routine.Address, routine.Locals.Length),
returnType: typeof(ushort),
parameterTypes: Types.Array <CompiledZMachine, byte[], ushort[], ushort[], int, ZRoutineCall[], int>(),
owner: typeof(CompiledZMachine),
skipVisibility: true));
}
public override void Generate(ILBuilder il, ICompiler compiler)
{
il.Arguments.LoadMachine();
compiler.EmitLoadOperand(addressOp);
il.Call(Reflection <CompiledZMachine> .GetMethod("ReadZText", Types.Array <int>(), @public: false));
compiler.EmitPrintText();
}
public void EmitPrintZWords(ushort[] zwords)
{
il.Arguments.LoadMachine();
var text = machine.ConvertZText(zwords);
il.Load(text);
il.Call(Reflection <CompiledZMachine> .GetMethod("PrintText", Types.Array <string>(), @public: false));
}
public void EmitPrintChar()
{
using (var ch = il.NewLocal <char>())
{
ch.Store();
il.Arguments.LoadMachine();
ch.Load();
il.Call(Reflection <CompiledZMachine> .GetMethod("PrintChar", Types.Array <char>(), @public: false));
}
}
public void EmitPrintText()
{
using (var text = il.NewLocal <string>())
{
text.Store();
il.Arguments.LoadMachine();
text.Load();
il.Call(Reflection <CompiledZMachine> .GetMethod("PrintText", Types.Array <string>(), @public: false));
}
}
public void FormatString(string format, ILocal arg0)
{
var stringFormat = Reflection <string> .GetMethod(
"Format",
Types.Array <string, object>(),
instance : false);
Load(format);
arg0.LoadAndBox();
Call(stringFormat);
}
private void EmitDirectCall(Operand addressOp, ReadOnlyArray <Operand> args)
{
if (machine.Profiling)
{
il.Arguments.LoadMachine();
if (addressOp.Value == 0)
{
il.Load(0);
}
else
{
il.Load(machine.UnpackRoutineAddress(addressOp.Value));
}
il.Load(false);
il.Call(Reflection <CompiledZMachine> .GetMethod("Profiler_Call", Types.Array <int, bool>(), @public: false));
}
if (addressOp.Value == 0)
{
il.Load(0);
EmitReturn();
}
else
{
var address = machine.UnpackRoutineAddress(addressOp.Value);
var routineCall = machine.GetRoutineCall(address);
var index = calls.Count;
calls.Add(routineCall);
// load routine call
il.Arguments.LoadCalls();
il.Load(index);
il.Emit(OpCodes.Ldelem_Ref);
foreach (var arg in args)
{
EmitLoadOperand(arg);
}
// The memory, stack and stack pointer are the last arguments passed in
// case any operands manipulate them.
il.Arguments.LoadMemory();
il.Arguments.LoadStack();
il.Arguments.LoadSP();
il.Call(ZRoutineCall.GetInvokeMethod(args.Length));
}
}
public void FormatString(string format, IRefLocal arg0, IRefLocal arg1, IRefLocal arg2)
{
var stringFormat = Reflection <string> .GetMethod(
"Format",
Types.Array <string, object, object, object>(),
instance : false);
Load(format);
arg0.Load();
arg0.LoadIndirectValueAndBox();
arg1.Load();
arg1.LoadIndirectValueAndBox();
arg2.Load();
arg2.LoadIndirectValueAndBox();
Call(stringFormat);
}
public override void Generate(ILBuilder il, ICompiler compiler)
{
using (var objNum = il.NewLocal <ushort>())
{
if (!ReuseFirstOperand)
{
compiler.EmitLoadOperand(objectOp);
}
objNum.Store();
il.Arguments.LoadMachine();
objNum.Load();
il.Call(Reflection <CompiledZMachine> .GetMethod("op_remove_obj", Types.Array <ushort>(), @public: false));
}
}
public override void Generate(ILBuilder il, ICompiler compiler)
{
using (var range = il.NewLocal <short>())
using (var result = il.NewLocal <ushort>())
{
var seed = il.NewLabel();
var done = il.NewLabel();
if (!ReuseFirstOperand)
{
compiler.EmitLoadOperand(rangeOp);
}
il.Convert.ToInt16();
range.Store();
range.Load();
il.Load(0);
seed.BranchIf(Condition.AtMost, @short: true);
il.Arguments.LoadMachine();
range.Load();
il.Call(Reflection <CompiledZMachine> .GetMethod("NextRandom", Types.Array <short>(), @public: false));
done.Branch(@short: true);
seed.Mark();
il.Arguments.LoadMachine();
range.Load();
il.Call(Reflection <CompiledZMachine> .GetMethod("SeedRandom", Types.Array <short>(), @public: false));
il.Load(0);
done.Mark();
il.Convert.ToUInt16();
result.Store();
compiler.EmitStoreVariable(store, result, reuse: ReuseStoreVariable);
}
}
public void FormatString(string format, params ILocal[] args)
{
var stringFormat = Reflection <string> .GetMethod(
"Format",
Types.Array <string, object[]>(),
instance : false);
var locArgs = NewArrayLocal <object>(args.Length);
for (int i = 0; i < args.Length; i++)
{
locArgs.StoreElement(
indexLoader: () => Load(i),
valueLoader: () => args[i].LoadAndBox());
}
Load(format);
locArgs.Load();
Call(stringFormat);
}
public override void Generate(ILBuilder il, ICompiler compiler)
{
il.Arguments.LoadMachine();
compiler.EmitLoadOperand(textBufferOp);
if (parseBufferOp != null)
{
compiler.EmitLoadOperand(parseBufferOp.Value);
}
else
{
il.Load(0);
}
using (var result = il.NewLocal <ushort>())
{
il.Call(Reflection <CompiledZMachine> .GetMethod("Read_Z5", Types.Array <ushort, ushort>(), @public: false));
result.Store();
compiler.EmitStoreVariable(store, result);
}
}
public override void Generate(ILBuilder il, ICompiler compiler)
{
if (ReuseFirstOperand)
{
using (var shortName = il.NewArrayLocal <ushort>())
{
compiler.EmitLoadObjectShortName(objectOp, reuse: true);
shortName.Store();
il.Arguments.LoadMachine();
shortName.Load();
}
}
else
{
il.Arguments.LoadMachine();
compiler.EmitLoadObjectShortName(objectOp);
}
il.Call(Reflection <CompiledZMachine> .GetMethod("ConvertZText", Types.Array <ushort[]>(), @public: false));
compiler.EmitPrintText();
}
private static void BringIndexIntoView(this VirtualizingPanel virtualizingPanel, int index)
{
if (bringIndexIntoView == null)
{
bringIndexIntoView = Reflection <VirtualizingPanel> .GetMethod("BringIndexIntoView", Types.Array <int>(), @public : false);
}
bringIndexIntoView.Invoke(virtualizingPanel, new object[] { index });
}
public override void Generate(ILBuilder il, ICompiler compiler)
{
using (var objNum = il.NewLocal <ushort>())
using (var destNum = il.NewLocal <ushort>())
{
var done = il.NewLabel();
compiler.EmitLoadValidObject(objectOp, done, reuse: ReuseFirstOperand);
objNum.Store();
compiler.EmitLoadValidObject(destinationOp, done);
destNum.Store();
il.Arguments.LoadMachine();
objNum.Load();
destNum.Load();
il.Call(Reflection <CompiledZMachine> .GetMethod("op_insert_obj", Types.Array <ushort, ushort>(), @public: false));
done.Mark();
}
}
private void EmitCalculatedCall(Operand addressOp, ReadOnlyArray <Operand> args, bool reuse)
{
using (var address = il.NewLocal <int>())
{
if (!reuse)
{
EmitLoadVariable((byte)addressOp.Value);
}
address.Store();
// is this address 0?
var nonZeroCall = il.NewLabel();
var done = il.NewLabel();
address.Load();
nonZeroCall.BranchIf(Condition.True);
if (machine.Profiling)
{
il.Arguments.LoadMachine();
il.Load(0);
il.Load(true);
var profilerCall = Reflection <CompiledZMachine> .GetMethod("Profiler_Call", Types.Array <int, bool>(), @public : false);
il.Call(profilerCall);
}
// discard any SP operands...
int spOperands = 0;
for (int i = 0; i < args.Length; i++)
{
if (args[i].IsStackVariable)
{
spOperands++;
}
}
if (spOperands > 0)
{
il.Arguments.LoadSP();
il.Math.Subtract(spOperands);
il.Arguments.StoreSP();
}
il.Load(0);
done.Branch();
nonZeroCall.Mark();
if (machine.Profiling)
{
il.Arguments.LoadMachine();
address.Load();
UnpackRoutineAddress();
il.Load(true);
il.Call(Reflection <CompiledZMachine> .GetMethod("Profiler_Call", Types.Array <int, bool>(), @public: false));
}
il.Arguments.LoadMachine();
address.Load();
UnpackRoutineAddress();
il.Call(Reflection <CompiledZMachine> .GetMethod("GetRoutineCall", Types.Array <int>(), @public: false));
foreach (var arg in args)
{
EmitLoadOperand(arg);
}
// The stack and stack pointer are the last arguments passed in
// case any operands manipulate them.
il.Arguments.LoadMemory();
il.Arguments.LoadStack();
il.Arguments.LoadSP();
il.Call(ZRoutineCall.GetInvokeMethod(args.Length));
done.Mark();
}
}
private void Profiler_ExecutingInstruction(Instruction instruction)
{
if (machine.Profiling)
{
il.Arguments.LoadMachine();
il.Load(instruction.Address);
il.Call(Reflection <CompiledZMachine> .GetMethod("ExecutingInstruction", Types.Array <int>(), @public: false));
}
}
public void EmitSelectMemoryStream(Operand operand)
{
il.Arguments.LoadMachine();
EmitLoadOperand(operand);
il.Call(Reflection <CompiledZMachine> .GetMethod("SelectMemoryStream", Types.Array <int>(), @public: false));
}