Exemple #1
0
 public static void LinyeePushNumber(LinyeeState L, ly_Number n)
 {
     LinyeeLock(L);
     SetNValue(L.top, n);
     IncrementTop(L);
     LinyeeUnlock(L);
 }
Exemple #2
0
        public static void Arith(LinyeeState L, StkId ra, TValue rb,
                                 TValue rc, TMS op)
        {
            TValue tempb = new LinyeeTypeValue(), tempc = new LinyeeTypeValue();
            TValue b, c;

            if ((b = luaV_tonumber(rb, tempb)) != null &&
                (c = luaV_tonumber(rc, tempc)) != null)
            {
                ly_Number nb = NValue(b), nc = NValue(c);
                switch (op)
                {
                case TMS.TM_ADD: SetNValue(ra, luai_numadd(nb, nc)); break;

                case TMS.TM_SUB: SetNValue(ra, luai_numsub(nb, nc)); break;

                case TMS.TM_MUL: SetNValue(ra, luai_nummul(nb, nc)); break;

                case TMS.TM_DIV: SetNValue(ra, luai_numdiv(nb, nc)); break;

                case TMS.TM_MOD: SetNValue(ra, luai_nummod(nb, nc)); break;

                case TMS.TM_POW: SetNValue(ra, luai_numpow(nb, nc)); break;

                case TMS.TM_UNM: SetNValue(ra, luai_numunm(nb)); break;

                default: LinyeeAssert(false); break;
                }
            }
            else if (call_binTM(L, rb, rc, ra, op) == 0)
            {
                LinyeeGArithError(L, rb, rc);
            }
        }
Exemple #3
0
 /*
 ** search function for integers
 */
 public static TValue luaH_getnum(Table t, int key)
 {
     /* (1 <= key && key <= t.sizearray) */
     if ((uint)(key - 1) < (uint)t.sizearray)
     {
         return(t.array[key - 1]);
     }
     else
     {
         ly_Number nk = CastNum(key);
         Node      n  = hashnum(t, nk);
         do            /* check whether `key' is somewhere in the chain */
         {
             if (TTIsNumber(gkey(n)) && luai_numeq(NValue(gkey(n)), nk))
             {
                 return(gval(n));         /* that's it */
             }
             else
             {
                 n = gnext(n);
             }
         } while (n != null);
         return(LinyeeONilObject);
     }
 }
Exemple #4
0
 /*
 ** hash for ly_Numbers
 */
 private static Node hashnum(Table t, ly_Number n)
 {
     byte[] a = BitConverter.GetBytes(n);
     for (int i = 1; i < a.Length; i++)
     {
         a[0] += a[i];
     }
     return(hashmod(t, (int)a[0]));
 }
Exemple #5
0
 public static int luaV_tostring(LinyeeState L, StkId obj)
 {
     if (!TTIsNumber(obj))
     {
         return(0);
     }
     else
     {
         ly_Number n = NValue(obj);
         CharPtr   s = ly_number2str(n);
         SetSValue2S(L, obj, luaS_new(L, s));
         return(1);
     }
 }
Exemple #6
0
 /*
 ** returns the index for `key' if `key' is an appropriate key to live in
 ** the array part of the table, -1 otherwise.
 */
 private static int arrayindex(TValue key)
 {
     if (TTIsNumber(key))
     {
         ly_Number n = NValue(key);
         int       k;
         ly_number2int(out k, n);
         if (luai_numeq(CastNum(k), n))
         {
             return(k);
         }
     }
     return(-1);       /* `key' did not match some condition */
 }
Exemple #7
0
        /*
        ** main search function
        */
        public static TValue luaH_get(Table t, TValue key)
        {
            switch (TType(key))
            {
            case LINYEE_TNIL: return(LinyeeONilObject);

            case LINYEE_TSTRING: return(luaH_getstr(t, RawTSValue(key)));

            case LINYEE_TNUMBER: {
                int       k;
                ly_Number n = NValue(key);
                ly_number2int(out k, n);
                if (luai_numeq(CastNum(k), NValue(key)))   /* index is int? */
                {
                    return(luaH_getnum(t, k));             /* use specialized version */
                }
                /* else go through ... actually on second thoughts don't, because this is C#*/
                Node node = mainposition(t, key);
                do
                {                  /* check whether `key' is somewhere in the chain */
                    if (LinyeeORawEqualObj(key2tval(node), key) != 0)
                    {
                        return(gval(node));                         /* that's it */
                    }
                    else
                    {
                        node = gnext(node);
                    }
                } while (node != null);
                return(LinyeeONilObject);
            }

            default: {
                Node node = mainposition(t, key);
                do              /* check whether `key' is somewhere in the chain */
                {
                    if (LinyeeORawEqualObj(key2tval(node), key) != 0)
                    {
                        return(gval(node));           /* that's it */
                    }
                    else
                    {
                        node = gnext(node);
                    }
                } while (node != null);
                return(LinyeeONilObject);
            }
            }
        }
Exemple #8
0
        public static ly_Integer LinyeeToInteger(LinyeeState L, int idx)
        {
            TValue n = new LinyeeTypeValue();
            TValue o = Index2Address(L, idx);

            if (tonumber(ref o, n) != 0)
            {
                ly_Integer res;
                ly_Number  num = NValue(o);
                ly_number2integer(out res, num);
                return(res);
            }
            else
            {
                return(0);
            }
        }
Exemple #9
0
        public static void arith_op(LinyeeState L, op_delegate op, TMS tm, StkId base_, Instruction i, TValue[] k, StkId ra, InstructionPtr pc)
        {
            TValue rb = RKB(L, base_, i, k);
            TValue rc = RKC(L, base_, i, k);

            if (TTIsNumber(rb) && TTIsNumber(rc))
            {
                ly_Number nb = NValue(rb), nc = NValue(rc);
                SetNValue(ra, op(nb, nc));
            }
            else
            {
                //Protect(
                L.savedpc = InstructionPtr.Assign(pc);
                Arith(L, ra, rb, rc, tm);
                base_ = L.base_;
                //);
            }
        }
Exemple #10
0
        private static int maxn(LinyeeState L)
        {
            ly_Number max = 0;

            LinyeeLCheckType(L, 1, LINYEE_TTABLE);
            LinyeePushNil(L);        /* first key */
            while (LinyeeNext(L, 1) != 0)
            {
                LinyeePop(L, 1);          /* remove value */
                if (LinyeeType(L, -1) == LINYEE_TNUMBER)
                {
                    ly_Number v = LinyeeToNumber(L, -1);
                    if (v > max)
                    {
                        max = v;
                    }
                }
            }
            LinyeePushNumber(L, max);
            return(1);
        }
Exemple #11
0
        public static void luaV_execute(LinyeeState L, int nexeccalls)
        {
            LClosure cl;
            StkId    base_;

            TValue[] k;
            /*const*/ InstructionPtr pc;

reentry:    /* entry point */
            LinyeeAssert(IsLinyee(L.ci));
            pc    = InstructionPtr.Assign(L.savedpc);
            cl    = CLValue(L.ci.func).l;
            base_ = L.base_;
            k     = cl.p.k;
            /* main loop of interpreter */
            for (;;)
            {
                /*const*/ Instruction i = InstructionPtr.inc(ref pc)[0];
                StkId ra;
                if (((L.hookmask & (LINYEE_MASKLINE | LINYEE_MASKCOUNT)) != 0) &&
                    (((--L.hookcount) == 0) || ((L.hookmask & LINYEE_MASKLINE) != 0)))
                {
                    traceexec(L, pc);
                    if (L.status == LINYEE_YIELD)          /* did hook yield? */
                    {
                        L.savedpc = new InstructionPtr(pc.codes, pc.pc - 1);
                        return;
                    }
                    base_ = L.base_;
                }
                /* warning!! several calls may realloc the stack and invalidate `ra' */
                ra = RA(L, base_, i);
                LinyeeAssert(base_ == L.base_ && L.base_ == L.ci.base_);
                LinyeeAssert(base_ <= L.top && ((L.top - L.stack) <= L.stacksize));
                LinyeeAssert(L.top == L.ci.top || (LinyeeGCheckOpenOp(i) != 0));
                //Dump(pc.pc, i);
                switch (GET_OPCODE(i))
                {
                case OpCode.OP_MOVE: {
                    SetObj2S(L, ra, RB(L, base_, i));
                    continue;
                }

                case OpCode.OP_LOADK: {
                    SetObj2S(L, ra, KBx(L, i, k));
                    continue;
                }

                case OpCode.OP_LOADBOOL: {
                    SetBValue(ra, GETARG_B(i));
                    if (GETARG_C(i) != 0)
                    {
                        InstructionPtr.inc(ref pc);                                /* skip next instruction (if C) */
                    }
                    continue;
                }

                case OpCode.OP_LOADNIL: {
                    TValue rb = RB(L, base_, i);
                    do
                    {
                        SetNilValue(StkId.Dec(ref rb));
                    } while (rb >= ra);
                    continue;
                }

                case OpCode.OP_GETUPVAL: {
                    int b = GETARG_B(i);
                    SetObj2S(L, ra, cl.upvals[b].v);
                    continue;
                }

                case OpCode.OP_GETGLOBAL: {
                    TValue g  = new LinyeeTypeValue();
                    TValue rb = KBx(L, i, k);
                    SetHValue(L, g, cl.env);
                    LinyeeAssert(TTIsString(rb));
                    //Protect(
                    L.savedpc = InstructionPtr.Assign(pc);
                    luaV_gettable(L, g, rb, ra);
                    base_ = L.base_;
                    //);
                    L.savedpc = InstructionPtr.Assign(pc);
                    continue;
                }

                case OpCode.OP_GETTABLE: {
                    //Protect(
                    L.savedpc = InstructionPtr.Assign(pc);
                    luaV_gettable(L, RB(L, base_, i), RKC(L, base_, i, k), ra);
                    base_ = L.base_;
                    //);
                    L.savedpc = InstructionPtr.Assign(pc);
                    continue;
                }

                case OpCode.OP_SETGLOBAL: {
                    TValue g = new LinyeeTypeValue();
                    SetHValue(L, g, cl.env);
                    LinyeeAssert(TTIsString(KBx(L, i, k)));
                    //Protect(
                    L.savedpc = InstructionPtr.Assign(pc);
                    luaV_settable(L, g, KBx(L, i, k), ra);
                    base_ = L.base_;
                    //);
                    L.savedpc = InstructionPtr.Assign(pc);
                    continue;
                }

                case OpCode.OP_SETUPVAL: {
                    UpVal uv = cl.upvals[GETARG_B(i)];
                    SetObj(L, uv.v, ra);
                    LinyeeCBarrier(L, uv, ra);
                    continue;
                }

                case OpCode.OP_SETTABLE: {
                    //Protect(
                    L.savedpc = InstructionPtr.Assign(pc);
                    luaV_settable(L, ra, RKB(L, base_, i, k), RKC(L, base_, i, k));
                    base_ = L.base_;
                    //);
                    L.savedpc = InstructionPtr.Assign(pc);
                    continue;
                }

                case OpCode.OP_NEWTABLE: {
                    int b = GETARG_B(i);
                    int c = GETARG_C(i);
                    SetHValue(L, ra, luaH_new(L, LinyeeOFBInt(b), LinyeeOFBInt(c)));
                    //Protect(
                    L.savedpc = InstructionPtr.Assign(pc);
                    LinyeeCCheckGC(L);
                    base_ = L.base_;
                    //);
                    L.savedpc = InstructionPtr.Assign(pc);
                    continue;
                }

                case OpCode.OP_SELF: {
                    StkId rb = RB(L, base_, i);
                    SetObj2S(L, ra + 1, rb);
                    //Protect(
                    L.savedpc = InstructionPtr.Assign(pc);
                    luaV_gettable(L, rb, RKC(L, base_, i, k), ra);
                    base_ = L.base_;
                    //);
                    L.savedpc = InstructionPtr.Assign(pc);
                    continue;
                }

                case OpCode.OP_ADD: {
                    arith_op(L, luai_numadd, TMS.TM_ADD, base_, i, k, ra, pc);
                    continue;
                }

                case OpCode.OP_SUB: {
                    arith_op(L, luai_numsub, TMS.TM_SUB, base_, i, k, ra, pc);
                    continue;
                }

                case OpCode.OP_MUL: {
                    arith_op(L, luai_nummul, TMS.TM_MUL, base_, i, k, ra, pc);
                    continue;
                }

                case OpCode.OP_DIV: {
                    arith_op(L, luai_numdiv, TMS.TM_DIV, base_, i, k, ra, pc);
                    continue;
                }

                case OpCode.OP_MOD: {
                    arith_op(L, luai_nummod, TMS.TM_MOD, base_, i, k, ra, pc);
                    continue;
                }

                case OpCode.OP_POW: {
                    arith_op(L, luai_numpow, TMS.TM_POW, base_, i, k, ra, pc);
                    continue;
                }

                case OpCode.OP_UNM: {
                    TValue rb = RB(L, base_, i);
                    if (TTIsNumber(rb))
                    {
                        ly_Number nb = NValue(rb);
                        SetNValue(ra, luai_numunm(nb));
                    }
                    else
                    {
                        //Protect(
                        L.savedpc = InstructionPtr.Assign(pc);
                        Arith(L, ra, rb, rb, TMS.TM_UNM);
                        base_ = L.base_;
                        //);
                        L.savedpc = InstructionPtr.Assign(pc);
                    }
                    continue;
                }

                case OpCode.OP_NOT: {
                    int res = LIsFalse(RB(L, base_, i)) == 0 ? 0 : 1;              /* next assignment may change this value */
                    SetBValue(ra, res);
                    continue;
                }

                case OpCode.OP_LEN: {
                    TValue rb = RB(L, base_, i);
                    switch (TType(rb))
                    {
                    case LINYEE_TTABLE: {
                        SetNValue(ra, (ly_Number)luaH_getn(HValue(rb)));
                        break;
                    }

                    case LINYEE_TSTRING: {
                        SetNValue(ra, (ly_Number)TSValue(rb).len);
                        break;
                    }

                    default: {                /* try metamethod */
                        //Protect(
                        L.savedpc = InstructionPtr.Assign(pc);
                        if (call_binTM(L, rb, LinyeeONilObject, ra, TMS.TM_LEN) == 0)
                        {
                            LinyeeGTypeError(L, rb, "get length of");
                        }
                        base_ = L.base_;
                        //)
                        break;
                    }
                    }
                    continue;
                }

                case OpCode.OP_CONCAT: {
                    int b = GETARG_B(i);
                    int c = GETARG_C(i);
                    //Protect(
                    L.savedpc = InstructionPtr.Assign(pc);
                    luaV_concat(L, c - b + 1, c); LinyeeCCheckGC(L);
                    base_ = L.base_;
                    //);
                    SetObj2S(L, RA(L, base_, i), base_ + b);
                    continue;
                }

                case OpCode.OP_JMP: {
                    dojump(L, pc, GETARG_sBx(i));
                    continue;
                }

                case OpCode.OP_EQ: {
                    TValue rb = RKB(L, base_, i, k);
                    TValue rc = RKC(L, base_, i, k);
                    //Protect(
                    L.savedpc = InstructionPtr.Assign(pc);
                    if (equalobj(L, rb, rc) == GETARG_A(i))
                    {
                        dojump(L, pc, GETARG_sBx(pc[0]));
                    }
                    base_ = L.base_;
                    //);
                    InstructionPtr.inc(ref pc);
                    continue;
                }

                case OpCode.OP_LT: {
                    //Protect(
                    L.savedpc = InstructionPtr.Assign(pc);
                    if (luaV_lessthan(L, RKB(L, base_, i, k), RKC(L, base_, i, k)) == GETARG_A(i))
                    {
                        dojump(L, pc, GETARG_sBx(pc[0]));
                    }
                    base_ = L.base_;
                    //);
                    InstructionPtr.inc(ref pc);
                    continue;
                }

                case OpCode.OP_LE: {
                    //Protect(
                    L.savedpc = InstructionPtr.Assign(pc);
                    if (lessequal(L, RKB(L, base_, i, k), RKC(L, base_, i, k)) == GETARG_A(i))
                    {
                        dojump(L, pc, GETARG_sBx(pc[0]));
                    }
                    base_ = L.base_;
                    //);
                    InstructionPtr.inc(ref pc);
                    continue;
                }

                case OpCode.OP_TEST: {
                    if (LIsFalse(ra) != GETARG_C(i))
                    {
                        dojump(L, pc, GETARG_sBx(pc[0]));
                    }
                    InstructionPtr.inc(ref pc);
                    continue;
                }

                case OpCode.OP_TESTSET: {
                    TValue rb = RB(L, base_, i);
                    if (LIsFalse(rb) != GETARG_C(i))
                    {
                        SetObj2S(L, ra, rb);
                        dojump(L, pc, GETARG_sBx(pc[0]));
                    }
                    InstructionPtr.inc(ref pc);
                    continue;
                }

                case OpCode.OP_CALL: {
                    int b        = GETARG_B(i);
                    int nresults = GETARG_C(i) - 1;
                    if (b != 0)
                    {
                        L.top = ra + b;                      /* else previous instruction set top */
                    }
                    L.savedpc = InstructionPtr.Assign(pc);
                    switch (LinyeeDPreCall(L, ra, nresults))
                    {
                    case PCRLUA: {
                        nexeccalls++;
                        goto reentry;                  /* restart luaV_execute over new Linyee function */
                    }

                    case PCRC: {
                        /* it was a C function (`precall' called it); adjust results */
                        if (nresults >= 0)
                        {
                            L.top = L.ci.top;
                        }
                        base_ = L.base_;
                        continue;
                    }

                    default: {
                        return;                  /* yield */
                    }
                    }
                }

                case OpCode.OP_TAILCALL: {
                    int b = GETARG_B(i);
                    if (b != 0)
                    {
                        L.top = ra + b;                      /* else previous instruction set top */
                    }
                    L.savedpc = InstructionPtr.Assign(pc);
                    LinyeeAssert(GETARG_C(i) - 1 == LINYEE_MULTRET);
                    switch (LinyeeDPreCall(L, ra, LINYEE_MULTRET))
                    {
                    case PCRLUA: {
                        /* tail call: put new frame in place of previous one */
                        CallInfo ci = L.ci - 1;                  /* previous frame */
                        int      aux;
                        StkId    func  = ci.func;
                        StkId    pfunc = (ci + 1).func;             /* previous function index */
                        if (L.openupval != null)
                        {
                            LinyeeFClose(L, ci.base_);
                        }
                        L.base_ = ci.base_ = ci.func + (ci[1].base_ - pfunc);
                        for (aux = 0; pfunc + aux < L.top; aux++)                /* move frame down */
                        {
                            SetObj2S(L, func + aux, pfunc + aux);
                        }
                        ci.top = L.top = func + aux;                /* correct top */
                        LinyeeAssert(L.top == L.base_ + CLValue(func).l.p.maxstacksize);
                        ci.savedpc = InstructionPtr.Assign(L.savedpc);
                        ci.tailcalls++;                  /* one more call lost */
                        CallInfo.Dec(ref L.ci);          /* remove new frame */
                        goto reentry;
                    }

                    case PCRC: {                /* it was a C function (`precall' called it) */
                        base_ = L.base_;
                        continue;
                    }

                    default: {
                        return;                  /* yield */
                    }
                    }
                }

                case OpCode.OP_RETURN: {
                    int b = GETARG_B(i);
                    if (b != 0)
                    {
                        L.top = ra + b - 1;
                    }
                    if (L.openupval != null)
                    {
                        LinyeeFClose(L, base_);
                    }
                    L.savedpc = InstructionPtr.Assign(pc);
                    b         = LinyeeDPosCall(L, ra);
                    if (--nexeccalls == 0) /* was previous function running `here'? */
                    {
                        return;            /* no: return */
                    }
                    else                   /* yes: continue its execution */
                    {
                        if (b != 0)
                        {
                            L.top = L.ci.top;
                        }
                        LinyeeAssert(IsLinyee(L.ci));
                        LinyeeAssert(GET_OPCODE(L.ci.savedpc[-1]) == OpCode.OP_CALL);
                        goto reentry;
                    }
                }

                case OpCode.OP_FORLOOP: {
                    ly_Number step  = NValue(ra + 2);
                    ly_Number idx   = luai_numadd(NValue(ra), step);           /* increment index */
                    ly_Number limit = NValue(ra + 1);
                    if (luai_numlt(0, step) ? luai_numle(idx, limit)
                                                                                : luai_numle(limit, idx))
                    {
                        dojump(L, pc, GETARG_sBx(i));  /* jump back */
                        SetNValue(ra, idx);            /* update internal index... */
                        SetNValue(ra + 3, idx);        /* ...and external index */
                    }
                    continue;
                }

                case OpCode.OP_FORPREP: {
                    TValue init   = ra;
                    TValue plimit = ra + 1;
                    TValue pstep  = ra + 2;
                    L.savedpc = InstructionPtr.Assign(pc);              /* next steps may throw errors */
                    if (tonumber(ref init, ra) == 0)
                    {
                        LinyeeGRunError(L, LINYEE_QL("for") + " initial value must be a number");
                    }
                    else if (tonumber(ref plimit, ra + 1) == 0)
                    {
                        LinyeeGRunError(L, LINYEE_QL("for") + " limit must be a number");
                    }
                    else if (tonumber(ref pstep, ra + 2) == 0)
                    {
                        LinyeeGRunError(L, LINYEE_QL("for") + " step must be a number");
                    }
                    SetNValue(ra, luai_numsub(NValue(ra), NValue(pstep)));
                    dojump(L, pc, GETARG_sBx(i));
                    continue;
                }

                case OpCode.OP_TFORLOOP: {
                    StkId cb = ra + 3;              /* call base */
                    SetObj2S(L, cb + 2, ra + 2);
                    SetObj2S(L, cb + 1, ra + 1);
                    SetObj2S(L, cb, ra);
                    L.top = cb + 3;            /* func. + 2 args (state and index) */
                    //Protect(
                    L.savedpc = InstructionPtr.Assign(pc);
                    LinyeeDCall(L, cb, GETARG_C(i));
                    base_ = L.base_;
                    //);
                    L.top = L.ci.top;
                    cb    = RA(L, base_, i) + 3;          /* previous call may change the stack */
                    if (!TTIsNil(cb))                     /* continue loop? */
                    {
                        SetObj2S(L, cb - 1, cb);          /* save control variable */
                        dojump(L, pc, GETARG_sBx(pc[0])); /* jump back */
                    }
                    InstructionPtr.inc(ref pc);
                    continue;
                }

                case OpCode.OP_SETLIST: {
                    int   n = GETARG_B(i);
                    int   c = GETARG_C(i);
                    int   last;
                    Table h;
                    if (n == 0)
                    {
                        n     = CastInt(L.top - ra) - 1;
                        L.top = L.ci.top;
                    }
                    if (c == 0)
                    {
                        c = CastInt(pc[0]);
                        InstructionPtr.inc(ref pc);
                    }
                    runtime_check(L, TTIsTable(ra));
                    h    = HValue(ra);
                    last = ((c - 1) * LFIELDS_PER_FLUSH) + n;
                    if (last > h.sizearray)              /* needs more space? */
                    {
                        luaH_resizearray(L, h, last);    /* pre-alloc it at once */
                    }
                    for (; n > 0; n--)
                    {
                        TValue val = ra + n;
                        SetObj2T(L, luaH_setnum(L, h, last--), val);
                        LinyeeCBarrierT(L, h, val);
                    }
                    continue;
                }

                case OpCode.OP_CLOSE: {
                    LinyeeFClose(L, ra);
                    continue;
                }

                case OpCode.OP_CLOSURE: {
                    Proto   p;
                    Closure ncl;
                    int     nup, j;
                    p       = cl.p.p[GETARG_Bx(i)];
                    nup     = p.nups;
                    ncl     = LinyeeFNewLClosure(L, nup, cl.env);
                    ncl.l.p = p;
                    for (j = 0; j < nup; j++, InstructionPtr.inc(ref pc))
                    {
                        if (GET_OPCODE(pc[0]) == OpCode.OP_GETUPVAL)
                        {
                            ncl.l.upvals[j] = cl.upvals[GETARG_B(pc[0])];
                        }
                        else
                        {
                            LinyeeAssert(GET_OPCODE(pc[0]) == OpCode.OP_MOVE);
                            ncl.l.upvals[j] = LinyeeFindUpVal(L, base_ + GETARG_B(pc[0]));
                        }
                    }
                    SetCLValue(L, ra, ncl);
                    //Protect(
                    L.savedpc = InstructionPtr.Assign(pc);
                    LinyeeCCheckGC(L);
                    base_ = L.base_;
                    //);
                    continue;
                }

                case OpCode.OP_VARARG: {
                    int      b = GETARG_B(i) - 1;
                    int      j;
                    CallInfo ci = L.ci;
                    int      n  = CastInt(ci.base_ - ci.func) - cl.p.numparams - 1;
                    if (b == LINYEE_MULTRET)
                    {
                        //Protect(
                        L.savedpc = InstructionPtr.Assign(pc);
                        LinyeeDCheckStack(L, n);
                        base_ = L.base_;
                        //);
                        ra    = RA(L, base_, i);         /* previous call may change the stack */
                        b     = n;
                        L.top = ra + n;
                    }
                    for (j = 0; j < b; j++)
                    {
                        if (j < n)
                        {
                            SetObj2S(L, ra + j, ci.base_ - n + j);
                        }
                        else
                        {
                            SetNilValue(ra + j);
                        }
                    }
                    continue;
                }
                }
            }
        }
Exemple #12
0
 //public static Node gnode(Table t, int i)	{return t.node[i];}
 internal static Node hashpow2(Table t, ly_Number n)
 {
     return(gnode(t, (int)lmod(n, SizeNode(t))));
 }
Exemple #13
0
 internal static int CastInt(ly_Number i)
 {
     return((int)i);
 }
Exemple #14
0
 internal static ly_byte CastByte(ly_Number i)
 {
     return((ly_byte)i);
 }