/// <summary>
/// R(A) -= R(A + 2)
/// pc += sBx
/// </summary>
public static void ForPrep(Instruction ins, ILuaVM vm)
{
ins.AsBx(out var a, out var sbx);
a += 1;
if (vm.Type(a) == ELuaType.String)
{
vm.PushNumber(vm.ToNumber(a));
vm.Replace(a);
}
if (vm.Type(a + 1) == ELuaType.String)
{
vm.PushNumber(vm.ToNumber(a + 1));
vm.Replace(a + 1);
}
if (vm.Type(a + 2) == ELuaType.String)
{
vm.PushNumber(vm.ToNumber(a + 2));
vm.Replace(a + 2);
}
// R(A) -= R(A + 2)
vm.PushValue(a);
vm.PushValue(a + 2);
vm.Arith(EArithOp.Sub);
vm.Replace(a);
// pc += sBx
vm.AddPC(sbx);
}
internal static void LoadK(Instruction i, ILuaVM vm)
{
var(a, bx) = i.ABx();
a += 1;
vm.GetConst(bx);
vm.Replace(a);
}
internal static void Closure(Instruction i, ILuaVM vm)
{
var(a, bx) = i.ABx();
a += 1;
vm.LoadProto(bx);
vm.Replace(a);
}
/// <summary>
/// R(A) = closure(KPROTO[Bx])
/// </summary>
public static void Closure(Instruction ins, ILuaVM vm)
{
ins.ABx(out var a, out var bx);
a += 1;
vm.LoadProto(bx);
vm.Replace(a);
}
internal static void NewTable(Instruction i, ILuaVM vm)
{
var(a, b, c) = i.ABC();
a += 1;
vm.CreateTable(Fb2int(b), Fb2int(c));
vm.Replace(a);
}
/// <summary>
/// R(A) = Kst(Bx)
/// </summary>
public static void LoadK(Instruction ins, ILuaVM vm)
{
ins.ABx(out var a, out var bx);
a += 1;
vm.GetConst(bx);
vm.Replace(a);
}
public static void LoadKx(int i, ILuaVM vm)
{
int a = Instruction.GetA(i) + 1;
int ax = Instruction.GetAx(vm.Fetch());
vm.GetConst(ax);
vm.Replace(a);
}
public static void LoadK(int i, ILuaVM vm)
{
int a = Instruction.GetA(i) + 1;
int bx = Instruction.GetBx(i);
vm.GetConst(bx);
vm.Replace(a);
}
//(iBx) R(A) := closure(KPROTO[Bx])
public static void Closure(int i, ILuaVM vm)
{
int a = Instruction.GetA(i);
int bx = Instruction.GetBx(i);
vm.LoadProto(bx);
vm.Replace(a);
}
/// <summary>
/// R(A) = {} (size = B, C)
/// </summary>
public static void NewTable(Instruction ins, ILuaVM vm)
{
ins.ABC(out var a, out var b, out var c);
a += 1;
vm.CreateTable(Fpb.Fb2Int(b), Fpb.Fb2Int(c));
vm.Replace(a);
}
/// <summary>
/// R(A) = Kst(extra arg)
/// </summary>
public static void LoadKx(Instruction ins, ILuaVM vm)
{
ins.ABx(out var a, out _);
a += 1;
new Instruction(vm.Fetch()).Ax(out var ax);
vm.GetConst(ax);
vm.Replace(a);
}
internal static void Not(Instruction i, ILuaVM vm)
{
var(a, b, _) = i.ABC();
a += 1;
b += 1;
vm.PushBoolean(!vm.ToBoolean(b));
vm.Replace(a);
}
internal static void LoadKx(Instruction i, ILuaVM vm)
{
var(a, _) = i.ABx();
a += 1;
int ax = ((Instruction)vm.Fetch()).Ax();
vm.GetConst(ax);
vm.Replace(a);
}
private static void unaryArith(int i, ILuaVM vm, ArithOpEnum op)
{
int a = Instruction.GetA(i) + 1;
int b = Instruction.GetB(i) + 1;
vm.PushValue(b);
vm.Arith(op);
vm.Replace(a);
}
internal static void Len(Instruction i, ILuaVM vm)
{
var(a, b, _) = i.ABC();
a += 1;
b += 1;
vm.Len(b);
vm.Replace(a);
}
/// <summary>
/// R(A) = UpValue[B][RK(C)]
/// </summary>
public static void GetTabUp(Instruction ins, ILuaVM vm)
{
ins.ABC(out var a, out var b, out var c);
a += 1;
b += 1;
vm.GetRK(c);
vm.GetTable(vm.LuaUpvalueIndex(b));
vm.Replace(a);
}
/// <summary>
/// R(A) = RK(B) op RK(C)
/// </summary>
private static void BinaryArith(Instruction ins, ILuaVM vm, EArithOp op)
{
ins.ABC(out var a, out var b, out var c);
a += 1;
vm.GetRK(b);
vm.GetRK(c);
vm.Arith(op);
vm.Replace(a);
}
internal static void GetTabUp(Instruction i, ILuaVM vm)
{
var(a, b, c) = i.ABC();
a += 1;
b += 1;
vm.GetRK(c);
vm.GetTable(LuaState.LuaUpvalueIndex(b));
vm.Replace(a);
}
//R(A) := R(B)[RK(C)]
public static void GetTable(int i, ILuaVM vm)
{
int a = Instruction.GetA(i) + 1;
int b = Instruction.GetB(i) + 1;
int c = Instruction.GetC(i);
vm.GetRK(c);
vm.GetTable(b);
vm.Replace(a);
}
public static void GetTable(Instruction i, ILuaVM vm)
{
var(a, b, c) = i.ABC();
a += 1;
b += 1;
vm.GetRK(c);
vm.GetTable(b);
vm.Replace(a);
}
private static void UnaryArith(Instruction i, ILuaVM vm, ArithOp op)
{
var(a, b, _) = i.ABC();
a += 1;
b += 1;
vm.PushValue(b);
vm.Arith(op);
vm.Replace(a);
}
/// <summary>
/// R(A) = R(B)[RK(C)]
/// </summary>
public static void GetTable(Instruction ins, ILuaVM vm)
{
ins.ABC(out var a, out var b, out var c);
a += 1;
b += 1;
vm.GetRK(c);
vm.GetTable(b);
vm.Replace(a);
}
private static void BinaryArith(Instruction i, ILuaVM vm, ArithOp op)
{
var(a, b, c) = i.ABC();
a += 1;
vm.GetRK(b);
vm.GetRK(c);
vm.Arith(op);
vm.Replace(a);
}
/// <summary>
/// R(A) = op R(B)
/// </summary>
private static void UnaryArith(Instruction ins, ILuaVM vm, EArithOp op)
{
ins.ABC(out var a, out var b, out _);
a += 1;
b += 1;
vm.PushValue(b);
vm.Arith(op);
vm.Replace(a);
}
private static void binaryArith(int i, ILuaVM vm, ArithOpEnum op)
{
int a = Instruction.GetA(i) + 1;
int b = Instruction.GetB(i);
int c = Instruction.GetC(i);
vm.GetRK(b);
vm.GetRK(c);
vm.Arith(op);
vm.Replace(a);
}
internal static void LoadBool(Instruction i, ILuaVM vm)
{
var(a, b, c) = i.ABC();
a += 1;
vm.PushBoolean(b != 0);
vm.Replace(a);
if (c != 0)
{
vm.AddPC(1);
}
}
internal static void Self(Instruction i, ILuaVM vm)
{
var(a, b, c) = i.ABC();
a += 1;
b += 1;
vm.Copy(b, a + 1);
vm.GetRK(c);
vm.GetTable(b);
vm.Replace(a);
}
/// <summary>
/// R(A) = (bool) B
/// if (C) pc++
/// </summary>
public static void LoadBool(Instruction ins, ILuaVM vm)
{
ins.ABC(out var a, out var b, out var c);
a += 1;
vm.PushBoolean(b != 0);
vm.Replace(a);
if (c != 0)
{
vm.AddPC(1);
}
}
internal static void ForPrep(Instruction i, ILuaVM vm)
{
var(a, sBx) = i.AsBx();
a += 1;
// R(A)-=R(A+2)
vm.PushValue(a);
vm.PushValue(a + 2);
vm.Arith(ArithOp.Sub);
vm.Replace(a);
// pc += sBx
vm.AddPC(sBx);
}
internal static void Concat(Instruction i, ILuaVM vm)
{
var(a, b, c) = i.ABC();
a += 1;
b += 1;
c += 1;
int n = c - b + 1;
vm.CheckStack(n);
for (int j = b; j <= c; j++)
{
vm.PushValue(j);
}
vm.Concat(n);
vm.Replace(a);
}
