Example #1
0
 private static int AddFunc(StackInfo stack, int args)
 {
     Assert.AreEqual(2, args);
     stack.Read(0, out var a);
     stack.Read(1, out var b);
     Assert.AreEqual(LuaValueType.Number, a.ValueType);
     Assert.AreEqual(LuaValueType.Number, b.ValueType);
     stack.Write(0, TypedValue.MakeDouble(a.NumberVal + b.NumberVal));
     return(1);
 }
        public LiteralExpressionGenerator(FunctionGenerator func, LiteralExpressionSyntaxNode expr) : base(0)
        {
            var type = expr.SpecializationType.GetVMSpecializationType();
            var k    = func.Constants;

            _constIndex = type switch
            {
                VMSpecializationType.Nil => k.GetUnspecializedNil(),
                VMSpecializationType.Bool => expr.BoolValue ? k.GetUnspecializedTrue() : k.GetUnspecializedFalse(),
                VMSpecializationType.Double => k.AddUnspecialized(TypedValue.MakeDouble(expr.DoubleValue)),
                VMSpecializationType.Int => k.AddUnspecialized(TypedValue.MakeInt(expr.Int32Value)),
                VMSpecializationType.String => k.AddUnspecialized(TypedValue.MakeString(expr.StringValue)),
                _ => throw new Exception(), //Internal exception.
            };

            _type = type.Deoptimize();
        }
Example #3
0
        public void TestAdd()
        {
            var closure = TestHelper.Compile("return function(a, b) return a + b end", null);

            var thread = new Thread();
            var stack  = thread.AllocateRootCSharpStack(3);

            var retCount = LuaInterpreter.Execute(stack, closure, 0, 0);

            Assert.AreEqual(1, retCount);
            stack.Read(0, out var retVal);

            Assert.AreEqual(LuaValueType.LClosure, retVal.ValueType);
            var retClosure = retVal.LClosureVal;

            //First call at offset 1: add(1, 2).

            stack.Write(1, TypedValue.MakeDouble(1));
            stack.Write(2, TypedValue.MakeDouble(2));
            retCount = LuaInterpreter.Execute(stack, retClosure, 1, 2);
            Assert.AreEqual(1, retCount);
            stack.Read(1, out retVal);

            Assert.AreEqual(LuaValueType.Number, retVal.ValueType);
            Assert.AreEqual(3, retVal.NumberVal);

            //Second call at offset 0: add(3, ret).

            stack.Write(0, TypedValue.MakeDouble(3));
            retCount = LuaInterpreter.Execute(stack, retClosure, 0, 2);
            Assert.AreEqual(1, retCount);
            stack.Read(0, out retVal);

            Assert.AreEqual(LuaValueType.Number, retVal.ValueType);
            Assert.AreEqual(6, retVal.NumberVal);
        }