Exemple #1
0
        /// <summary>
        /// 将源寄存器值赋值到目标寄存器,源寄存器由b指定,目标寄存器为a,c无效
        /// </summary>
        /// <param name="i"></param>
        public void Move(Instruction i)
        {
            int a = 0, b = 0, c = 0;

            i.ABC(ref a, ref b, ref c);
            luaState.CopyTo(b + 1, a + 1);
        }
Exemple #2
0
        /// <summary>
        /// setupval指令,将寄存器的值赋值给upval,a指定寄存器索引,b指定upval索引,c没用
        /// </summary>
        /// <param name="i"></param>
        public void SetUpval(Instruction i)
        {
            int a = 0, b = 0, c = 0;

            i.ABC(ref a, ref b, ref c);
            luaState.SetUpval(b, luaState.Get(a + 1));
        }
Exemple #3
0
        private static void printOperands(Instruction i)
        {
            int a, b, c, ax, bx, sbx;

            switch (i.OpMode())
            {
            case OpCodes.IABC:
                var abc = i.ABC();
                Console.Write($"{abc.Item1:D}", abc.Item1);
                if (i.BMode() != OpCodes.OpArgN)
                {
                    if (abc.Item2 > 0xFF)
                    {
                        Console.Write($" {-1 - (abc.Item2 & 0xFF):D}");
                    }
                    else
                    {
                        Console.Write($" {abc.Item2:D}");
                    }
                }

                if (i.CMode() != OpCodes.OpArgN)
                {
                    if (abc.Item3 > 0xFF)
                    {
                        Console.Write($"{-1 - (abc.Item3 & 0xFF):D}");
                    }
                    else
                    {
                        Console.Write($" {abc.Item3:D}");
                    }
                }

                break;

            case OpCodes.IABx:
                var aBx = i.ABx();
                Console.Write($" {aBx.Item1:D}");
                if (i.BMode() == OpCodes.OpArgK)
                {
                    Console.Write($"{-1 - aBx.Item2:D}");
                }
                else if (i.BMode() == OpCodes.OpArgU)
                {
                    Console.Write($" {aBx.Item2:D}");
                }

                break;

            case OpCodes.IAsBx:
                var asBx = i.AsBx();
                Console.Write($"{asBx.Item1:D} {asBx.Item2:D}");
                break;

            case OpCodes.IAx:
                ax = i.Ax();
                Console.Write($"{-1 - ax:D}");
                break;
            }
        }
Exemple #4
0
        /// <summary>
        /// not指令,求某个变量是否为nil,a指定结果寄存器索引,b指定变量寄存器索引
        /// </summary>
        /// <param name="i"></param>
        public void Not(Instruction i)
        {
            int a = 0, b = 0, c = 0;

            i.ABC(ref a, ref b, ref c);
            luaState.Push(new LuaValue(luaState.IsBool(b + 1), LuaValueType.Bool));
            luaState.Replace(a + 1);
        }
Exemple #5
0
    internal static void GetUpval(Instruction i, ILuaVM vm)
    {
        var(a, b, _) = i.ABC();
        a           += 1;
        b           += 1;

        vm.Copy(LuaState.LuaUpvalueIndex(b), a);
    }
Exemple #6
0
        /// <summary>
        /// 求长度指令,b代表变量寄存器索引,a代表结果目标索引
        /// </summary>
        /// <param name="i"></param>
        public void Len(Instruction i)
        {
            int a = 0, b = 0, c = 0;

            i.ABC(ref a, ref b, ref c);
            luaState.Len(b + 1);
            luaState.Replace(a + 1);
        }
Exemple #7
0
    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);
    }
Exemple #8
0
    internal static void Len(Instruction i, ILuaVM vm)
    {
        var(a, b, _) = i.ABC();
        a           += 1;
        b           += 1;

        vm.Len(b);
        vm.Replace(a);
    }
Exemple #9
0
    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);
    }
Exemple #10
0
    internal static void SetTabUp(Instruction i, ILuaVM vm)
    {
        var(a, b, c) = i.ABC();
        a           += 1;

        vm.GetRK(b);
        vm.GetRK(c);
        vm.SetTable(LuaState.LuaUpvalueIndex(a));
    }
Exemple #11
0
    internal static void TForCall(Instruction i, ILuaVM vm)
    {
        var(a, _, c) = i.ABC();
        a           += 1;

        PushFuncAndArgs(a, 3, vm);
        vm.Call(2, c);
        PopResults(a + 3, c + 1, vm);
    }
Exemple #12
0
    public static void SetTable(Instruction i, ILuaVM vm)
    {
        var(a, b, c) = i.ABC();
        a           += 1;

        vm.GetRK(b);
        vm.GetRK(c);
        vm.SetTable(a);
    }
Exemple #13
0
        /// <summary>
        /// NEWTABLE指令(iABC模式)创建空表,并将其放入指定寄存器。寄存器索引由操作数A指定,表的初始数组容量和哈希表容量分别由操作数B和C指定。
        /// </summary>
        /// <param name="i"></param>
        public void NewTable(Instruction i)
        {
            int a = 0, b = 0, c = 0;

            i.ABC(ref a, ref b, ref c);
            a += 1;
            luaState.CreatLuaTable(b, c);
            luaState.Replace(a);
        }
Exemple #14
0
    internal static void Test(Instruction i, ILuaVM vm)
    {
        var(a, _, c) = i.ABC();
        a           += 1;

        if (vm.ToBoolean(a) != (c != 0))
        {
            vm.AddPC(1);
        }
    }
Exemple #15
0
    internal static void Call(Instruction i, ILuaVM vm)
    {
        var(a, b, c) = i.ABC();
        a           += 1;

        int nArgs = PushFuncAndArgs(a, b, vm);

        vm.Call(nArgs, c - 1);
        PopResults(a, c, vm);
    }
Exemple #16
0
    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);
    }
Exemple #17
0
    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);
    }
Exemple #18
0
 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);
     }
 }
Exemple #19
0
    internal static void Vararg(Instruction i, ILuaVM vm)
    {
        var(a, b, _) = i.ABC();
        a           += 1;

        if (b != 1)
        {
            vm.LoadVararg(b - 1);
            PopResults(a, b, vm);
        }
    }
Exemple #20
0
    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);
    }
Exemple #21
0
        /// <summary>
        /// 连续为寄存器置n个nil值,寄存器起始索引为a,数量为b,c无效
        /// </summary>
        /// <param name="i"></param>
        public void LoadNil(Instruction i)
        {
            int a = 0, b = 0, c = 0;

            i.ABC(ref a, ref b, ref c);
            luaState.Push(new LuaValue());
            for (int j = a + 1; j <= a + b; j++)
            {
                luaState.CopyTo(-1, j);
            }
            luaState.Pop(1);
        }
Exemple #22
0
    private static void Compare(Instruction i, ILuaVM vm, CompareOp op)
    {
        var(a, b, c) = i.ABC();

        vm.GetRK(b);
        vm.GetRK(c);
        if (vm.Compare(-2, -1, op) != (a != 0))
        {
            vm.AddPC(1);
        }
        vm.Pop(2);
    }
Exemple #23
0
        /// <summary>
        /// SETTABLE指令(iABC模式)根据键往表里赋值。其中表位于寄存器中,索引由操作数A指定;键和值可能位于寄存器中,也可能在常量表里,索引分别由操作数B和C指定。
        /// </summary>
        /// <param name="i"></param>
        public void SetTable(Instruction i)
        {
            int a = 0, b = 0, c = 0;

            i.ABC(ref a, ref b, ref c);
            luaState.GetRK(b);
            luaState.GetRK(c);
            var value = luaState.Pop();
            var key   = luaState.Pop();

            luaState.SetTable(a + 1, key, value);
        }
Exemple #24
0
    internal static void LoadNil(Instruction i, ILuaVM vm)
    {
        var(a, b, _) = i.ABC();
        a           += 1;

        vm.PushNil();
        for (int j = a; j <= a + b; j++)
        {
            vm.Copy(-1, j);
        }
        vm.Pop(1);
    }
Exemple #25
0
        /// <summary>
        /// gettableup指令,当某个upval是一个表,则通过该指令从该表中获取值,目标寄存器由a指定,upval索引由b指定,键由c指定,可能是常量也可能在寄存器中
        /// </summary>
        /// <param name="i"></param>
        public void GetUpTable(Instruction i)
        {
            int a = 0, b = 0, c = 0;

            i.ABC(ref a, ref b, ref c);
            luaState.GetRK(c);
            var table = luaState.GetUpval(b);
            var key   = luaState.Pop();

            luaState.Push((table.OValue as LuaTable)[key]);
            luaState.Replace(a + 1);
        }
Exemple #26
0
        /// <summary>
        /// 尾调用指令,使用当前函数帧继续调用函数
        /// </summary>
        /// <param name="i"></param>
        public void TailCall(Instruction i)
        {
            int a = 0, b = 0, c = 0;

            i.ABC(ref a, ref b, ref c);
            a += 1;
            c  = 0;
            int nArg = PushArgAndFunc(a, b);

            luaState.Call(nArg, c - 1);
            PopResults(a, c);
        }
Exemple #27
0
        /// <summary>
        /// Self指令,把对象和函数对象拷贝到两个相邻的寄存器中。对象在寄存器中,由操作数B指定,方法名在常量表中,操作数C指定,目标寄存器由操作数A指定。这样比两次Move少一个指令
        /// </summary>
        /// <param name="i"></param>
        public void Self(Instruction i)
        {
            int a = 0, b = 0, c = 0;

            i.ABC(ref a, ref b, ref c);
            a += 1;
            b += 1;
            luaState.CopyTo(b, a + 1);
            luaState.GetRK(c);
            luaState.GetTable(luaState.GetTopValue(), b);
            luaState.Replace(a);
        }
Exemple #28
0
        /// <summary>
        /// GETTABLE指令(iABC模式)根据键从表里取值,并放入目标寄存器中。
        /// 其中表位于寄存器中,索引由操作数B指定;键可能位于寄存器中,也可能在常量表里,索引由操作数C指定;目标寄存器索引则由操作数A指定。
        /// </summary>
        /// <param name="i"></param>
        public void GetTable(Instruction i)
        {
            int a = 0, b = 0, c = 0;

            i.ABC(ref a, ref b, ref c);
            a += 1;
            b += 1;
            luaState.GetRK(c);
            var key = luaState.Pop();

            luaState.GetTable(key, b);
            luaState.Replace(a);
        }
Exemple #29
0
        /// <summary>
        /// 变长参数指令。把传递给当前函数的连续多个参数加载到连续的指定寄存器中。A操作数指定第一个寄存器。B操作数指定数量。C操作数没用
        /// b == 1,表示没有,b > 1,表示 b-1个参数,b = 0表示把从栈顶到a的所有寄存器全部加载
        /// </summary>
        /// <param name="i"></param>
        public void Vararg(Instruction i)
        {
            int a = 0, b = 0, c = 0;

            i.ABC(ref a, ref b, ref c);
            a += 1;
            //b > 1和b>0统一处理
            if (b != 1)
            {
                luaState.LoadVararg(b - 1);
                PopResults(a, b);
            }
        }
Exemple #30
0
        /// <summary>
        /// 设置给定寄存器值为bool, a 为寄存器索引,b为bool值,c非0则跳过下一条指令
        /// </summary>
        /// <param name="i"></param>
        public void LoadBool(Instruction i)
        {
            int a = 0, b = 0, c = 0;

            i.ABC(ref a, ref b, ref c);
            a += 1;
            luaState.Push(new LuaValue(b != 0, LuaValueType.Bool));
            luaState.Replace(a, luaState.GetTopValue());
            if (c != 0)
            {
                luaState.AddPC();
            }
        }