Exemple #1
0
		public static UpVal luaF_findupval (LuaState L, StkId level) {
		  GlobalState g = G(L);
		  GCObjectRef pp = new OpenValRef(L);
		  UpVal p;
		  UpVal uv;
		  while (pp.get() != null && (p = ngcotouv(pp.get())).v >= level) {
			lua_assert(p.v != p.u.value);
			if (p.v == level) {  /* found a corresponding upvalue? */
			  if (isdead(g, obj2gco(p)))  /* is it dead? */
				changewhite(obj2gco(p));  /* ressurect it */
			  return p;
			}
			pp = new NextRef(p);
		  }
		  uv = luaM_new<UpVal>(L);  /* not found: create a new one */
		  uv.tt = LUA_TUPVAL;
		  uv.marked = luaC_white(g);
		  uv.v = level;  /* current value lives in the stack */
		  uv.next = pp.get();  /* chain it in the proper position */
		  pp.set( obj2gco(uv) );
		  uv.u.l.prev = g.uvhead;  /* double link it in `uvhead' list */
		  uv.u.l.next = g.uvhead.u.l.next;
		  uv.u.l.next.u.l.prev = uv;
		  g.uvhead.u.l.next = uv;
		  lua_assert(uv.u.l.next.u.l.prev == uv && uv.u.l.prev.u.l.next == uv);
		  return uv;
		}
Exemple #2
0
		public static int luaV_tostring (LuaState L, StkId obj) {
		  if (!TTIsNumber(obj))
			return 0;
		  else {
			lua_Number n = NValue(obj);
			CharPtr s = lua_number2str(n);
			SetSValue2S(L, obj, luaS_new(L, s));
			return 1;
		  }
		}
Exemple #3
0
 public static int luaV_tostring (lua_State L, StkId obj) {
     if (!ttisnumber(obj))
         return 0;
     else {
         lua_Number n = nvalue(obj);
         CharPtr s = lua_number2str(n);
         setsvalue2s(L, obj, luaS_new(L, s));
         return 1;
     }
 }
Exemple #4
0
 private static void callTMres (lua_State L, StkId res, TValue f,
                                TValue p1, TValue p2) {
     ptrdiff_t result = savestack(L, res);
     setobj2s(L, L.top, f);  /* push function */
     setobj2s(L, L.top+1, p1);  /* 1st argument */
     setobj2s(L, L.top+2, p2);  /* 2nd argument */
     luaD_checkstack(L, 3);
     L.top += 3;
     luaD_call(L, L.top-3, 1);
     res = restorestack(L, result);
     StkId.dec(ref L.top);
     setobjs2s(L, res, L.top);
 }
Exemple #5
0
		public static void Arith (LuaState L, StkId ra, TValue rb,
						   TValue rc, TMS op) {
		  TValue tempb = new LuaTypeValue(), tempc = new LuaTypeValue();
		  TValue b, c;
		  if ((b = luaV_tonumber(rb, tempb)) != null &&
			  (c = luaV_tonumber(rc, tempc)) != null) {
			lua_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: LuaAssert(false); break;
			}
		  }
		  else if (call_binTM(L, rb, rc, ra, op) == 0)
			LuaGArithError(L, rb, rc);
		}
Exemple #6
0
        public static int luaD_precall(LuaState L, StkId func, int nresults)
        {
            LClosure  cl;
            ptrdiff_t funcr;

            if (!ttisfunction(func))       /* `func' is not a function? */
            {
                func = tryfuncTM(L, func); /* check the `function' tag method */
            }
            funcr        = savestack(L, func);
            cl           = clvalue(func).l;
            L.ci.savedpc = InstructionPtr.Assign(L.savedpc);
            if (cl.isC == 0)
            {  /* Lua function? prepare its call */
                CallInfo ci;
                StkId    st, base_;
                Proto    p = cl.p;
                luaD_checkstack(L, p.maxstacksize);
                func = restorestack(L, funcr);
                if (p.is_vararg == 0)
                {  /* no varargs? */
                    base_ = L.stack[func + 1];
                    if (L.top > base_ + p.numparams)
                    {
                        L.top = base_ + p.numparams;
                    }
                }
                else
                {  /* vararg function */
                    int nargs = L.top - func - 1;
                    base_ = adjust_varargs(L, p, nargs);
                    func  = restorestack(L, funcr); /* previous call may change the stack */
                }
                ci      = inc_ci(L);                /* now `enter' new function */
                ci.func = func;
                L.base_ = ci.base_ = base_;
                ci.top  = L.base_ + p.maxstacksize;
                lua_assert(ci.top <= L.stack_last);
                L.savedpc    = new InstructionPtr(p.code, 0); /* starting point */
                ci.tailcalls = 0;
                ci.nresults  = nresults;
                for (st = L.top; st < ci.top; StkId.inc(ref st))
                {
                    setnilvalue(st);
                }
                L.top = ci.top;
                if ((L.hookmask & LUA_MASKCALL) != 0)
                {
                    InstructionPtr.inc(ref L.savedpc);  /* hooks assume 'pc' is already incremented */
                    luaD_callhook(L, LUA_HOOKCALL, -1);
                    InstructionPtr.dec(ref L.savedpc);  /* correct 'pc' */
                }
                return(PCRLUA);
            }
            else
            {  /* if is a C function, call it */
                CallInfo ci;
                int      n;
                luaD_checkstack(L, LUA_MINSTACK); /* ensure minimum stack size */
                ci      = inc_ci(L);              /* now `enter' new function */
                ci.func = restorestack(L, funcr);
                L.base_ = ci.base_ = ci.func + 1;
                ci.top  = L.top + LUA_MINSTACK;
                lua_assert(ci.top <= L.stack_last);
                ci.nresults = nresults;
                if ((L.hookmask & LUA_MASKCALL) != 0)
                {
                    luaD_callhook(L, LUA_HOOKCALL, -1);
                }
                lua_unlock(L);
                n = curr_func(L).c.f(L); /* do the actual call */
                lua_lock(L);
                if (n < 0)               /* yielding? */
                {
                    return(PCRYIELD);
                }
                else
                {
                    luaD_poscall(L, L.top - n);
                    return(PCRC);
                }
            }
        }
Exemple #7
0
        /*
        ** access functions (stack . C)
        */


        public static int LinyeeType(LinyeeState L, int idx)
        {
            StkId o = Index2Address(L, idx);

            return((o == LinyeeONilObject) ? LINYEE_TNONE : TType(o));
        }
		public static void LuaGConcatError (LuaState L, StkId p1, StkId p2) {
		  if (TTIsString(p1) || TTIsNumber(p1)) p1 = p2;
		  LuaAssert(!TTIsString(p1) && !TTIsNumber(p1));
		  LuaGTypeError(L, p1, "concatenate");
		}
Exemple #9
0
 public static void incr_top(LuaState L)
 {
     luaD_checkstack(L, 1);
     StkId.inc(ref L.top);
 }
Exemple #10
0
 public static int LuaDPosCall(LuaState L, StkId firstResult)
 {
     StkId res;
     int wanted, i;
     CallInfo ci;
     if ((L.hookmask & LUA_MASKRET) != 0)
         firstResult = CallRetHooks(L, firstResult);
     ci = CallInfo.Dec(ref L.ci);
     res = ci.func;  /* res == final position of 1st result */
     wanted = ci.nresults;
     L.base_ = (ci - 1).base_;  /* restore base */
     L.savedpc = InstructionPtr.Assign((ci - 1).savedpc);  /* restore savedpc */
     /* move results to correct place */
     for (i = wanted; i != 0 && firstResult < L.top; i--)
     {
         SetObj2S(L, res, firstResult);
         res = res + 1;
         firstResult = firstResult + 1;
     }
     while (i-- > 0)
         SetNilValue(StkId.Inc(ref res));
     L.top = res;
     return (wanted - LUA_MULTRET);  /* 0 iff wanted == LUA_MULTRET */
 }
Exemple #11
0
 private static StkId CallRetHooks(LuaState L, StkId firstResult)
 {
     ptrdiff_t fr = SaveStack(L, firstResult);  /* next call may change stack */
     LuaDCallHook(L, LUA_HOOKRET, -1);
     if (FIsLua(L.ci))
     {  /* Lua function? */
         while (((L.hookmask & LUA_MASKRET) != 0) && (L.ci.tailcalls-- != 0)) /* tail calls */
             LuaDCallHook(L, LUA_HOOKTAILRET, -1);
     }
     return RestoreStack(L, fr);
 }
Exemple #12
0
        /*
        ** access functions (stack . C)
        */


        public static int lua_type(lua_State L, int idx)
        {
            StkId o = index2adr(L, idx);

            return((o == luaO_nilobject) ? LUA_TNONE : ttype(o));
        }
Exemple #13
0
        public static bool lua_iscfunction(lua_State L, int idx)
        {
            StkId o = index2adr(L, idx);

            return(iscfunction(o));
        }
Exemple #14
0
        public static LinyeeNativeFunction LinyeeToCFunction(LinyeeState L, int idx)
        {
            StkId o = Index2Address(L, idx);

            return((!IsCFunction(o)) ? null : CLValue(o).c.f);
        }
Exemple #15
0
        public static LinyeeState LinyeeToThread(LinyeeState L, int idx)
        {
            StkId o = Index2Address(L, idx);

            return((!TTIsThread(o)) ? null : THValue(o));
        }
Exemple #16
0
 public static void IncrementTop(LinyeeState L)
 {
     ApiCheck(L, L.top < L.ci.top);
     StkId.Inc(ref L.top);
 }
Exemple #17
0
 public static void CheckValidIndex(LinyeeState L, StkId i)
 {
     ApiCheck(L, i != LinyeeONilObject);
 }
Exemple #18
0
        public static bool LinyeeIsCFunction(LinyeeState L, int idx)
        {
            StkId o = Index2Address(L, idx);

            return(IsCFunction(o));
        }
Exemple #19
0
		internal static TValue RKC(LuaState L, StkId base_, Instruction i, TValue[] k) { return ISK(GETARG_C(i)) != 0 ? k[INDEXK(GETARG_C(i))] : base_ + GETARG_C(i); }
Exemple #20
0
 public static void api_checkvalidindex(lua_State L, StkId i)
 {
     api_check(L, i != luaO_nilobject);
 }
Exemple #21
0
 // in the original C code these values save and restore the stack by number of bytes. marshalling sizeof
 // isn't that straightforward in managed languages, so i implement these by index instead.
 public static int savestack(LuaState L, StkId p)
 {
     return(p);
 }
Exemple #22
0
        public static lua_CFunction lua_tocfunction(lua_State L, int idx)
        {
            StkId o = index2adr(L, idx);

            return((!iscfunction(o)) ? null : clvalue(o).c.f);
        }
Exemple #23
0
 public static void LuaDSetErrorObj(LuaState L, int errcode, StkId oldtop)
 {
     switch (errcode)
     {
         case LUA_ERRMEM:
             {
                 SetSValue2S(L, oldtop, luaS_newliteral(L, MEMERRMSG));
                 break;
             }
         case LUA_ERRERR:
             {
                 SetSValue2S(L, oldtop, luaS_newliteral(L, "error in error handling"));
                 break;
             }
         case LUA_ERRSYNTAX:
         case LUA_ERRRUN:
             {
                 SetObj2S(L, oldtop, L.top - 1);  /* error message on current top */
                 break;
             }
     }
     L.top = oldtop + 1;
 }
Exemple #24
0
        /*
        ** returns true if function has been executed (C function)
        */
        public static int luaD_precall(lua_State L, StkId func, int nresults)
        {
            lua_CFunction f;
            CallInfo      ci;
            int           n; /* number of arguments (Lua) or returns (C) */
            ptrdiff_t     funcr = savestack(L, func);

            switch (ttype(func))
            {
            case LUA_TLCF:          /* light C function */
                f = fvalue(func);
                //goto Cfunc; //FIXME:removed, see below
                luaC_checkGC(L);                  /* stack grow uses memory */
                luaD_checkstack(L, LUA_MINSTACK); /* ensure minimum stack size */
                ci          = next_ci(L);         /* now 'enter' new function */
                ci.nresults = (short)nresults;    //FIXME:added, (short)
                ci.func     = restorestack(L, funcr);
                ci.top      = L.top + LUA_MINSTACK;
                lua_assert(ci.top <= L.stack_last);
                ci.callstatus = 0;
                if ((L.hookmask & LUA_MASKCALL) != 0)
                {
                    luaD_hook(L, LUA_HOOKCALL, -1);
                }
                lua_unlock(L);
                n = f(L);        /* do the actual call */
                lua_lock(L);
                api_checknelems(L, n);
                luaD_poscall(L, L.top - n, n);
                return(1);

            case LUA_TCCL: {          /* C closure */
                f = clCvalue(func).f;
                //Cfunc: //FIXME:removed, see upper
                luaC_checkGC(L);                  /* stack grow uses memory */
                luaD_checkstack(L, LUA_MINSTACK); /* ensure minimum stack size */
                ci          = next_ci(L);         /* now 'enter' new function */
                ci.nresults = (short)nresults;    //FIXME:added, (short)
                ci.func     = restorestack(L, funcr);
                ci.top      = L.top + LUA_MINSTACK;
                lua_assert(ci.top <= L.stack_last);
                ci.callstatus = 0;
                if ((L.hookmask & LUA_MASKCALL) != 0)
                {
                    luaD_hook(L, LUA_HOOKCALL, -1);
                }
                lua_unlock(L);
                n = f(L);        /* do the actual call */
                lua_lock(L);
                api_checknelems(L, n);
                luaD_poscall(L, L.top - n, n);
                return(1);
            }

            case LUA_TLCL: {          /* Lua function: prepare its call */
                StkId base_;
                Proto p = clLvalue(func).p;
                n = cast_int(L.top - func) - 1; /* number of real arguments */
                luaC_checkGC(L);                /* stack grow uses memory */
                luaD_checkstack(L, p.maxstacksize);
                for (; n < p.numparams; n++)
                {
                    setnilvalue(lua_TValue.inc(ref L.top));      /* complete missing arguments */
                }
                if (0 == p.is_vararg)
                {
                    func  = restorestack(L, funcr);
                    base_ = func + 1;
                }
                else
                {
                    base_ = adjust_varargs(L, p, n);
                    func  = restorestack(L, funcr); /* previous call can change stack */
                }
                ci           = next_ci(L);          /* now `enter' new function */
                ci.nresults  = (short)nresults;     //FIXME:added, (short)
                ci.func      = func;
                ci.u.l.base_ = base_;
                ci.top       = base_ + p.maxstacksize;
                lua_assert(ci.top <= L.stack_last);
                ci.u.l.savedpc = new InstructionPtr(p.code, 0); /* starting point */            //FIXME:??? //FIXME:???
                ci.callstatus  = CIST_LUA;
                L.top          = ci.top;
                if ((L.hookmask & LUA_MASKCALL) != 0)
                {
                    callhook(L, ci);
                }
                return(0);
            }

            default: {                                   /* not a function */
                luaD_checkstack(L, 1);                   /* ensure space for metamethod */
                func = restorestack(L, funcr);           /* previous call may change stack */
                tryfuncTM(L, func);                      /* try to get '__call' metamethod */
                return(luaD_precall(L, func, nresults)); /* now it must be a function */
            }
            }
        }
Exemple #25
0
 private static StkId TryFuncTM(LuaState L, StkId func)
 {
     /*const*/
     TValue tm = luaT_gettmbyobj(L, func, TMS.TM_CALL);
     StkId p;
     ptrdiff_t funcr = SaveStack(L, func);
     if (!TTIsFunction(tm))
         LuaGTypeError(L, func, "call");
     /* Open a hole inside the stack at `func' */
     for (p = L.top; p > func; StkId.Dec(ref p)) SetObj2S(L, p, p - 1);
     IncrTop(L);
     func = RestoreStack(L, funcr);  /* previous call may change stack */
     SetObj2S(L, func, tm);  /* tag method is the new function to be called */
     return func;
 }
Exemple #26
0
 public static void luaD_seterrorobj (lua_State L, int errcode, StkId oldtop) {
     switch (errcode) {
             case LUA_ERRMEM: {
                 setsvalue2s(L, oldtop, luaS_newliteral(L, MEMERRMSG));
                 break;
             }
             case LUA_ERRERR: {
                 setsvalue2s(L, oldtop, luaS_newliteral(L, "error in error handling"));
                 break;
             }
         case LUA_ERRSYNTAX:
             case LUA_ERRRUN: {
                 setobjs2s(L, oldtop, L.top-1);  /* error message on current top */
                 break;
             }
     }
     L.top = oldtop + 1;
 }
Exemple #27
0
		public static int luaH_next (LuaState L, Table t, StkId key) {
		  int i = findindex(L, t, key);  /* find original element */
		  for (i++; i < t.sizearray; i++) {  /* try first array part */
			if (!TTIsNil(t.array[i])) {  /* a non-nil value? */
			  SetNValue(key, CastNum(i+1));
			  SetObj2S(L, key+1, t.array[i]);
			  return 1;
			}
		  }
		  for (i -= t.sizearray; i < SizeNode(t); i++) {  /* then hash part */
			if (!TTIsNil(gval(gnode(t, i)))) {  /* a non-nil value? */
			  SetObj2S(L, key, key2tval(gnode(t, i)));
			  SetObj2S(L, key+1, gval(gnode(t, i)));
			  return 1;
			}
		  }
		  return 0;  /* no more elements */
		}
Exemple #28
0
		public static void luaV_settable (LuaState L, TValue t, TValue key, StkId val) {
		  int loop;
		  TValue temp = new LuaTypeValue();
		  for (loop = 0; loop < MAXTAGLOOP; loop++) {
			TValue tm;
			if (TTIsTable(t)) {  /* `t' is a table? */
			  Table h = HValue(t);
			  TValue oldval = luaH_set(L, h, key); /* do a primitive set */
			  if (!TTIsNil(oldval) ||  /* result is no nil? */
				  (tm = fasttm(L, h.metatable, TMS.TM_NEWINDEX)) == null) { /* or no TM? */
				SetObj2T(L, oldval, val);
			    h.flags = 0;
				LuaCBarrierT(L, h, val);
				return;
			  }
			  /* else will try the tag method */
			}
			else if (TTIsNil(tm = luaT_gettmbyobj(L, t, TMS.TM_NEWINDEX)))
			  LuaGTypeError(L, t, "index");
			if (TTIsFunction(tm)) {
			  callTM(L, tm, t, key, val);
			  return;
			}
			/* else repeat with `tm' */
			SetObj (L, temp, tm); /* avoid pointing inside table (may rehash) */
			t = temp;
		  }
		  LuaGRunError(L, "loop in settable");
		}
Exemple #29
0
 static CharPtr aux_upvalue(StkId fi, int n, ref TValue val)
 {
     Closure f;
     if (!ttisfunction(fi)) return null;
     f = clvalue(fi);
     if (f.c.isC != 0)
     {
         if (!(1 <= n && n <= f.c.nupvalues)) return null;
         val = f.c.upvalue[n - 1];
         return "";
     }
     else
     {
         Proto p = f.l.p;
         if (!(1 <= n && n <= p.sizeupvalues)) return null;
         val = f.l.upvals[n - 1].v;
         return getstr(p.upvalues[n - 1]);
     }
 }
Exemple #30
0
		public static int tostring(LuaState L, StkId o) {
			return ((TType(o) == LUA_TSTRING) || (luaV_tostring(L, o) != 0)) ? 1 : 0;
		}
 public static CharPtr svalue(StkId o)
 {
     return(getstr(rawtsvalue(o)));
 }
Exemple #32
0
        /*
        ** returns true if function has been executed (C function)
        */
        public static int luaD_precall(lua_State L, StkId func, int nresults)
        {
            LClosure  cl;
            ptrdiff_t funcr;

            if (!ttisfunction(func))       /* `func' is not a function? */
            {
                func = tryfuncTM(L, func); /* check the `function' tag method */
            }
            funcr         = savestack(L, func);
            cl            = clvalue(func).l;
            L.ci.nresults = (short)nresults; //FIXME:???
            if (cl.isC == 0)                 /* Lua function? prepare its call */
            {
                CallInfo ci;
                int      nparams, nargs;
                StkId    base_;
                Proto    p = cl.p;
                luaD_checkstack(L, p.maxstacksize);
                func    = restorestack(L, funcr);
                nargs   = cast_int(L.top - func) - 1; /* number of real arguments */
                nparams = p.numparams;                /* number of expected parameters */
                for (; nargs < nparams; nargs++)
                {
                    setnilvalue(lua_TValue.inc(ref L.top)); /* complete missing arguments */
                }
                if (p.is_vararg == 0)                       /* no varargs? */
                {
                    base_ = L.stack[func + 1];
                }
                else          /* vararg function */
                {
                    base_ = adjust_varargs(L, p, nargs);
                }
                ci           = next_ci(L); /* now `enter' new function */
                ci.func      = func;
                ci.u.l.base_ = base_;
                ci.top       = base_ + p.maxstacksize;
                lua_assert(ci.top <= L.stack_last);
                ci.u.l.savedpc   = new InstructionPtr(p.code, 0); /* starting point */        //FIXME:??? //FIXME:???
                ci.u.l.tailcalls = 0;
                ci.callstatus    = CIST_LUA;
                L.top            = ci.top;
                if ((L.hookmask & LUA_MASKCALL) != 0)
                {
                    InstructionPtr.inc(ref ci.u.l.savedpc);        /* hooks assume 'pc' is already incremented */
                    luaD_callhook(L, LUA_HOOKCALL, -1);
                    InstructionPtr.dec(ref ci.u.l.savedpc);        /* correct 'pc' */
                }
                return(0);
            }
            else          /* if is a C function, call it */
            {
                CallInfo ci;
                int      n;
                luaD_checkstack(L, LUA_MINSTACK); /* ensure minimum stack size */
                ci      = next_ci(L);             /* now `enter' new function */
                ci.func = restorestack(L, funcr);
                ci.top  = L.top + LUA_MINSTACK;
                lua_assert(ci.top <= L.stack_last);
                ci.callstatus = 0;
                if ((L.hookmask & LUA_MASKCALL) != 0)
                {
                    luaD_callhook(L, LUA_HOOKCALL, -1);
                }
                lua_unlock(L);
                n = curr_func(L).c.f(L);          /* do the actual call */
                lua_lock(L);
                luaD_poscall(L, L.top - n);
                return(1);
            }
        }
Exemple #33
0
		public static void luaV_gettable (LuaState L, TValue t, TValue key, StkId val) {
		  int loop;
		  for (loop = 0; loop < MAXTAGLOOP; loop++) {
			TValue tm;
			if (TTIsTable(t)) {  /* `t' is a table? */
			  Table h = HValue(t);
			  TValue res = luaH_get(h, key); /* do a primitive get */
			  if (!TTIsNil(res) ||  /* result is no nil? */
				  (tm = fasttm(L, h.metatable, TMS.TM_INDEX)) == null) { /* or no TM? */
				SetObj2S(L, val, res);
				return;
			  }
			  /* else will try the tag method */
			}
			else if (TTIsNil(tm = luaT_gettmbyobj(L, t, TMS.TM_INDEX)))
			  LuaGTypeError(L, t, "index");
			if (TTIsFunction(tm)) {
			  callTMres(L, val, tm, t, key);
			  return;
			}
			t = tm;  /* else repeat with `tm' */ 
		  }
		  LuaGRunError(L, "loop in gettable");
		}
Exemple #34
0
        public static int lua_isinteger(lua_State L, int idx)
        {
            StkId o = index2addr(L, idx);

            return(ttisinteger(o) ? 1 : 0);
        }
Exemple #35
0
		private static int call_binTM (LuaState L, TValue p1, TValue p2,
							   StkId res, TMS event_) {
		  TValue tm = luaT_gettmbyobj(L, p1, event_);  /* try first operand */
		  if (TTIsNil(tm))
			tm = luaT_gettmbyobj(L, p2, event_);  /* try second operand */
		  if (TTIsNil(tm)) return 0;
		  callTMres(L, res, tm, p1, p2);
		  return 1;
		}
Exemple #36
0
 public static TValue RC(lua_State L, StkId base_, Instruction i)
 {
     return(base_ + GETARG_C(i));
 }
Exemple #37
0
		public static int tonumber(ref StkId o, TValue n) {
			return ((TType(o) == LUA_TNUMBER || (((o) = luaV_tonumber(o, n)) != null))) ? 1 : 0;
		}
Exemple #38
0
 public static TValue RKC(lua_State L, StkId base_, Instruction i, TValue[] k)
 {
     return(ISK(GETARG_C(i)) != 0 ? k[INDEXK(GETARG_C(i))] : base_ + GETARG_C(i));
 }
Exemple #39
0
		internal static TValue RC(LuaState L, StkId base_, Instruction i) { return base_ + GETARG_C(i); }
Exemple #40
0
        //#define Protect(x)	{ {x;}; base = L.base_; }


        public static void arith_op(lua_State 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))
            {
                lua_Number nb = nvalue(rb), nc = nvalue(rc);
                setnvalue(ra, op(L, nb, nc));
            }
            else
            {
                //Protect(
                //L.savedpc = InstructionPtr.Assign(pc); //FIXME:
                Arith(L, ra, rb, rc, tm);
                base_ = L.base_;
                //);
            }
        }
Exemple #41
0
		public static void arith_op(LuaState 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))
				{
					lua_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 #42
0
        public static void luaV_execute(lua_State L, int nexeccalls)
        {
            LClosure cl;
            StkId    base_;

            TValue[] k;
reentry:    /* entry point */
            lua_assert(isLua(L.ci));
            cl    = clvalue(L.ci.func).l;
            base_ = L.base_;
            k     = cl.p.k;
            /* main loop of interpreter */
            for (;;)
            {
                /*const*/ Instruction i = InstructionPtr.inc(ref L.savedpc)[0];
                StkId ra;
                if (((L.hookmask & (LUA_MASKLINE | LUA_MASKCOUNT)) != 0) &&
                    (((--L.hookcount) == 0) || ((L.hookmask & LUA_MASKLINE) != 0)))
                {
                    traceexec(L);
                    if (L.status == LUA_YIELD)             /* did hook yield? */
                    {
                        InstructionPtr.dec(ref L.savedpc); /* undo increment */
                        return;
                    }
                    base_ = L.base_;
                }
                /* warning!! several calls may realloc the stack and invalidate `ra' */
                ra = RA(L, base_, i);
                lua_assert(base_ == L.base_ && L.base_ == L.ci.base_);
                lua_assert(base_ <= L.top && ((L.top - L.stack) <= L.stacksize));
                lua_assert(L.top == L.ci.top || (luaG_checkopenop(i) != 0));
                //Dump(L.savedpc.pc, i);	//FIXME:added, only for debugging
                switch (GET_OPCODE(i))
                {
                case OpCode.OP_MOVE: {
                    setobjs2s(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 L.savedpc);                                /* 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 TValue();
                    TValue rb = KBx(L, i, k);
                    sethvalue(L, g, cl.env);
                    lua_assert(ttisstring(rb));
                    //Protect(
                    //L.savedpc = InstructionPtr.Assign(pc); //FIXME:
                    luaV_gettable(L, g, rb, ra);
                    base_ = L.base_;
                    //);
                    //L.savedpc = InstructionPtr.Assign(pc); //FIXME:???
                    continue;
                }

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

                case OpCode.OP_SETGLOBAL: {
                    TValue g = new TValue();
                    sethvalue(L, g, cl.env);
                    lua_assert(ttisstring(KBx(L, i, k)));
                    //Protect(
                    //L.savedpc = InstructionPtr.Assign(pc); //FIXME:
                    luaV_settable(L, g, KBx(L, i, k), ra);
                    base_ = L.base_;
                    //);
                    //L.savedpc = InstructionPtr.Assign(pc); //FIXME:???
                    continue;
                }

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

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

                case OpCode.OP_NEWTABLE: {
                    int   b = GETARG_B(i);
                    int   c = GETARG_C(i);
                    Table t = luaH_new(L);
                    sethvalue(L, ra, t);
                    if (b != 0 || c != 0)
                    {
                        luaH_resize(L, t, luaO_fb2int(b), luaO_fb2int(c));
                    }
                    //Protect(
                    //L.savedpc = InstructionPtr.Assign(pc); //FIXME:
                    luaC_checkGC(L);
                    base_ = L.base_;
                    //);
                    //L.savedpc = InstructionPtr.Assign(pc); //FIXME:???
                    continue;
                }

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

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

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

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

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

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

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

                case OpCode.OP_UNM: {
                    TValue rb = RB(L, base_, i);
                    if (ttisnumber(rb))
                    {
                        lua_Number nb = nvalue(rb);
                        setnvalue(ra, luai_numunm(L, nb));
                    }
                    else
                    {
                        //Protect(
                        //L.savedpc = InstructionPtr.Assign(pc); //FIXME:
                        Arith(L, ra, rb, rb, TMS.TM_UNM);
                        base_ = L.base_;
                        //);
                        //L.savedpc = InstructionPtr.Assign(pc);//FIXME:???
                    }
                    continue;
                }

                case OpCode.OP_NOT: {
                    int res = l_isfalse(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 LUA_TTABLE: {
                        setnvalue(ra, (lua_Number)luaH_getn(hvalue(rb)));
                        break;
                    }

                    case LUA_TSTRING: {
                        setnvalue(ra, (lua_Number)tsvalue(rb).len);
                        break;
                    }

                    default: {                /* try metamethod */
                        //Protect(
                        //L.savedpc = InstructionPtr.Assign(pc); //FIXME:
                        if (call_binTM(L, rb, rb, ra, TMS.TM_LEN) == 0)
                        {
                            luaG_typeerror(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); //FIXME:
                    luaV_concat(L, c - b + 1, c); luaC_checkGC(L);
                    base_ = L.base_;
                    //);
                    setobjs2s(L, RA(L, base_, i), base_ + b);
                    continue;
                }

                case OpCode.OP_JMP: {
                    dojump(L, 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); //FIXME:
                    if (equalobj(L, rb, rc) == GETARG_A(i))
                    {
                        dojump(L, GETARG_sBx(L.savedpc[0]));
                    }
                    base_ = L.base_;
                    //);
                    InstructionPtr.inc(ref L.savedpc);
                    continue;
                }

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

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

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

                case OpCode.OP_TESTSET: {
                    TValue rb = RB(L, base_, i);
                    if (l_isfalse(rb) != GETARG_C(i))
                    {
                        setobjs2s(L, ra, rb);
                        dojump(L, GETARG_sBx(L.savedpc[0]));
                    }
                    InstructionPtr.inc(ref L.savedpc);
                    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 */
                    }
                    switch (luaD_precall(L, ra, nresults))
                    {
                    case PCRLUA: {
                        nexeccalls++;
                        goto reentry;                  /* restart luaV_execute over new Lua 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 */
                    }
                    lua_assert(GETARG_C(i) - 1 == LUA_MULTRET);
                    switch (luaD_precall(L, ra, LUA_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)
                        {
                            luaF_close(L, ci.base_);
                        }
                        L.base_ = ci.base_ = ci.func + (ci[1].base_ - pfunc);
                        for (aux = 0; pfunc + aux < L.top; aux++)                /* move frame down */
                        {
                            setobjs2s(L, func + aux, pfunc + aux);
                        }
                        ci.top = L.top = func + aux;                /* correct top */
                        lua_assert(L.top == L.base_ + clvalue(func).l.p.maxstacksize);
                        InstructionPtr.Assign(L.savedpc, ref ci.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)
                    {
                        luaF_close(L, base_);
                    }
                    b = luaD_poscall(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;
                        }
                        lua_assert(isLua(L.ci));
                        lua_assert(GET_OPCODE(L.ci.savedpc[-1]) == OpCode.OP_CALL);
                        goto reentry;
                    }
                }

                case OpCode.OP_FORLOOP: {
                    lua_Number step  = nvalue(ra + 2);
                    lua_Number idx   = luai_numadd(L, nvalue(ra), step);           /* increment index */
                    lua_Number limit = nvalue(ra + 1);
                    if (luai_numlt(L, 0, step) ? luai_numle(L, idx, limit)
                                                                                : luai_numle(L, limit, idx))
                    {
                        dojump(L, 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;
                    if (tonumber(ref init, ra) == 0)
                    {
                        luaG_runerror(L, LUA_QL("for") + " initial value must be a number");
                    }
                    else if (tonumber(ref plimit, ra + 1) == 0)
                    {
                        luaG_runerror(L, LUA_QL("for") + " limit must be a number");
                    }
                    else if (tonumber(ref pstep, ra + 2) == 0)
                    {
                        luaG_runerror(L, LUA_QL("for") + " step must be a number");
                    }
                    setnvalue(ra, luai_numsub(L, nvalue(ra), nvalue(pstep)));
                    dojump(L, GETARG_sBx(i));
                    continue;
                }

                case OpCode.OP_TFORLOOP: {
                    StkId cb = ra + 3;              /* call base */
                    setobjs2s(L, cb + 2, ra + 2);
                    setobjs2s(L, cb + 1, ra + 1);
                    setobjs2s(L, cb, ra);
                    L.top = cb + 3;            /* func. + 2 args (state and index) */
                    //Protect(
                    //L.savedpc = InstructionPtr.Assign(pc);//FIXME:
                    luaD_call(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? */
                    {
                        setobjs2s(L, cb - 1, cb);            /* save control variable */
                        dojump(L, GETARG_sBx(L.savedpc[0])); /* jump back */
                    }
                    InstructionPtr.inc(ref L.savedpc);
                    continue;
                }

                case OpCode.OP_SETLIST: {
                    int   n = GETARG_B(i);
                    int   c = GETARG_C(i);
                    int   last;
                    Table h;
                    if (n == 0)
                    {
                        n = cast_int(L.top - ra) - 1;
                    }

                    if (c == 0)
                    {
                        c = cast_int(L.savedpc[0]);
                        InstructionPtr.inc(ref L.savedpc);
                    }
                    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);
                        luaC_barriert(L, h, val);
                    }
                    L.top = L.ci.top; /* correct top (in case of previous open call) */
                    continue;
                }

                case OpCode.OP_CLOSE: {
                    luaF_close(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     = luaF_newLclosure(L, nup, cl.env);
                    ncl.l.p = p;
                    setclvalue(L, ra, ncl);
                    for (j = 0; j < nup; j++, InstructionPtr.inc(ref L.savedpc))
                    {
                        Instruction u = L.savedpc[0];
                        if (GET_OPCODE(u) == OpCode.OP_GETUPVAL)
                        {
                            ncl.l.upvals[j] = cl.upvals[GETARG_B(u)];
                        }
                        else
                        {
                            lua_assert(GET_OPCODE(u) == OpCode.OP_MOVE);
                            ncl.l.upvals[j] = luaF_findupval(L, base_ + GETARG_B(u));
                        }
                    }
                    //Protect(
                    //L.savedpc = InstructionPtr.Assign(pc);//FIXME:
                    luaC_checkGC(L);
                    base_ = L.base_;
                    //);
                    continue;
                }

                case OpCode.OP_VARARG: {
                    int      b = GETARG_B(i) - 1;
                    int      j;
                    CallInfo ci = L.ci;
                    int      n  = cast_int(ci.base_ - ci.func) - cl.p.numparams - 1;
                    if (b == LUA_MULTRET)
                    {
                        //Protect(
                        //L.savedpc = InstructionPtr.Assign(pc);//FIXME:
                        luaD_checkstack(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)
                        {
                            setobjs2s(L, ra + j, ci.base_ - n + j);
                        }
                        else
                        {
                            setnilvalue(ra + j);
                        }
                    }
                    continue;
                }
                }
            }
        }
Exemple #43
0
		private static void callTMres (LuaState L, StkId res, TValue f,
								TValue p1, TValue p2) {
		  ptrdiff_t result = SaveStack(L, res);
		  SetObj2S(L, L.top, f);  /* push function */
		  SetObj2S(L, L.top+1, p1);  /* 1st argument */
		  SetObj2S(L, L.top+2, p2);  /* 2nd argument */
		  LuaDCheckStack(L, 3);
		  L.top += 3;
		  LuaDCall(L, L.top-3, 1);
		  res = RestoreStack(L, result);
		  StkId.Dec(ref L.top);
		  SetObj2S(L, res, L.top);
		}
Exemple #44
0
        /*
        ** access functions (stack . C)
        */


        public static int lua_type(lua_State L, int idx)
        {
            StkId o = index2addr(L, idx);

            return(isvalid(o) ? ttypenv(o) : LUA_TNONE);
        }
Exemple #45
0
        public static int LuaDPreCall(LuaState L, StkId func, int nresults)
        {
            LClosure cl;
            ptrdiff_t funcr;
            if (!TTIsFunction(func)) /* `func' is not a function? */
                func = TryFuncTM(L, func);  /* check the `function' tag method */

            funcr = SaveStack(L, func);
            cl = CLValue(func).l;
            L.ci.savedpc = InstructionPtr.Assign(L.savedpc);

            if (cl.isC == 0)
            {  /* Lua function? prepare its call */
                CallInfo ci;
                StkId st, base_;
                Proto p = cl.p;
                LuaDCheckStack(L, p.maxstacksize);
                func = RestoreStack(L, funcr);
                if (p.is_vararg == 0)
                {  /* no varargs? */
                    base_ = L.stack[func + 1];
                    if (L.top > base_ + p.numparams)
                        L.top = base_ + p.numparams;
                }
                else
                {  /* vararg function */
                    int nargs = L.top - func - 1;
                    base_ = AdjustVarArgs(L, p, nargs);
                    func = RestoreStack(L, funcr);  /* previous call may change the stack */
                }
                ci = IncCI(L);  /* now `enter' new function */
                ci.func = func;
                L.base_ = ci.base_ = base_;
                ci.top = L.base_ + p.maxstacksize;
                LuaAssert(ci.top <= L.stack_last);
                L.savedpc = new InstructionPtr(p.code, 0);  /* starting point */
                ci.tailcalls = 0;
                ci.nresults = nresults;
                for (st = L.top; st < ci.top; StkId.Inc(ref st))
                    SetNilValue(st);
                L.top = ci.top;
                if ((L.hookmask & LUA_MASKCALL) != 0)
                {
                    InstructionPtr.inc(ref L.savedpc);  /* hooks assume 'pc' is already incremented */
                    LuaDCallHook(L, LUA_HOOKCALL, -1);
                    InstructionPtr.dec(ref L.savedpc);  /* correct 'pc' */
                }
                return PCRLUA;
            }
            else
            {  /* if is a C function, call it */
                CallInfo ci;
                int n;
                LuaDCheckStack(L, LUA_MINSTACK);  /* ensure minimum stack size */
                ci = IncCI(L);  /* now `enter' new function */
                ci.func = RestoreStack(L, funcr);
                L.base_ = ci.base_ = ci.func + 1;
                ci.top = L.top + LUA_MINSTACK;
                LuaAssert(ci.top <= L.stack_last);
                ci.nresults = nresults;
                if ((L.hookmask & LUA_MASKCALL) != 0)
                    LuaDCallHook(L, LUA_HOOKCALL, -1);
                LuaUnlock(L);
                n = CurrFunc(L).c.f(L);  /* do the actual call */
                LuaLock(L);
                if (n < 0)  /* yielding? */
                    return PCRYIELD;
                else
                {
                    LuaDPosCall(L, L.top - n);
                    return PCRC;
                }
            }
        }
Exemple #46
0
        public static bool lua_iscfunction(lua_State L, int idx)
        {
            StkId o = index2addr(L, idx);

            return(ttislcf(o) || (ttisCclosure(o)));
        }
Exemple #47
0
 // in the original C code these values save and restore the stack by number of bytes. marshalling sizeof
 // isn't that straightforward in managed languages, so i implement these by index instead.
 public static int SaveStack(LuaState L, StkId p)
 {
     return p;
 }
Exemple #48
0
 /* test for valid but not pseudo index */
 public static bool isstackindex(int i, StkId o)
 {
     return(isvalid(o) && !ispseudo(i));
 }
Exemple #49
0
        /*
        ** Call a function (C or Lua). The function to be called is at *func.
        ** The arguments are on the stack, right after the function.
        ** When returns, all the results are on the stack, starting at the original
        ** function position.
        */
        private static void LuaDCall(LuaState L, StkId func, int nResults)
        {
            if (++L.nCcalls >= LUAI_MAXCCALLS)
            {
                if (L.nCcalls == LUAI_MAXCCALLS)
                    LuaGRunError(L, "C stack overflow");
                else if (L.nCcalls >= (LUAI_MAXCCALLS + (LUAI_MAXCCALLS >> 3)))
                    LuaDThrow(L, LUA_ERRERR);  /* error while handing stack error */
            }

            if (LuaDPreCall(L, func, nResults) == PCRLUA)  /* is a Lua function? */
                luaV_execute(L, 1);  /* call it */

            L.nCcalls--;
            LuaCCheckGC(L);
        }
Exemple #50
0
 public static void api_checkstackindex(lua_State L, int i, StkId o)
 {
     api_check(L, isstackindex(i, o), "index not in the stack");
 }
Exemple #51
0
Fichier : lgc.cs Projet : oathx/Six
		private static void CheckStackSizes (LuaState L, StkId max) {
		  int ci_used = CastInt(L.ci - L.base_ci[0]);  /* number of `ci' in use */
		  int s_used = CastInt(max - L.stack);  /* part of stack in use */
		  if (L.size_ci > LUAI_MAXCALLS)  /* handling overflow? */
			return;  /* do not touch the stacks */
		  if (4*ci_used < L.size_ci && 2*BASICCISIZE < L.size_ci)
			LuaDReallocCI(L, L.size_ci/2);  /* still big enough... */
		  //condhardstacktests(luaD_reallocCI(L, ci_used + 1));
		  if (4*s_used < L.stacksize &&
			  2*(BASICSTACKSIZE+EXTRASTACK) < L.stacksize)
			LuaDRealAllocStack(L, L.stacksize/2);  /* still big enough... */
		  //condhardstacktests(luaD_reallocstack(L, s_used));
		}
Exemple #52
0
        public static lua_State lua_tothread(lua_State L, int idx)
        {
            StkId o = index2addr(L, idx);

            return((!ttisthread(o)) ? null : thvalue(o));
        }
Exemple #53
0
		/*
		** returns the index of a `key' for table traversals. First goes all
		** elements in the array part, then elements in the hash part. The
		** beginning of a traversal is signalled by -1.
		*/
		private static int findindex (LuaState L, Table t, StkId key) {
		  int i;
		  if (TTIsNil(key)) return -1;  /* first iteration */
		  i = arrayindex(key);
		  if (0 < i && i <= t.sizearray)  /* is `key' inside array part? */
			return i-1;  /* yes; that's the index (corrected to C) */
		  else {
			Node n = mainposition(t, key);
			do {  /* check whether `key' is somewhere in the chain */
			  /* key may be dead already, but it is ok to use it in `next' */
			  if ((LuaORawEqualObj(key2tval(n), key) != 0) ||
					(TType(gkey(n)) == LUATDEADKEY && IsCollectable(key) &&
					 GCValue(gkey(n)) == GCValue(key))) {
				i = CastInt(n - gnode(t, 0));  /* key index in hash table */
				/* hash elements are numbered after array ones */
				return i + t.sizearray;
			  }
			  else n = gnext(n);
			} while (n != null);
			LuaGRunError(L, "invalid key to " + LUA_QL("next"));  /* key not found */
			return 0;  /* to avoid warnings */
		  }
		}
Exemple #54
0
 public static int tostring(lua_State L, StkId o)
 {
     return(((ttype(o) == LUA_TSTRING) || (luaV_tostring(L, o) != 0)) ? 1 : 0);
 }
Exemple #55
0
		public static void luaF_close (LuaState L, StkId level) {
		  UpVal uv;
		  GlobalState g = G(L);
		  while (L.openupval != null && (uv = ngcotouv(L.openupval)).v >= level) {
			GCObject o = obj2gco(uv);
			lua_assert(!isblack(o) && uv.v != uv.u.value);
			L.openupval = uv.next;  /* remove from `open' list */
			if (isdead(g, o))
			  luaF_freeupval(L, uv);  /* free upvalue */
			else {
			  unlinkupval(uv);
			  setobj(L, uv.u.value, uv.v);
			  uv.v = uv.u.value;  /* now current value lives here */
			  luaC_linkupval(L, uv);  /* link upvalue into `gcroot' list */
			}
		  }
		}
Exemple #56
0
 public static int tonumber(ref StkId o, TValue n)
 {
     return(((ttype(o) == LUA_TNUMBER || (((o) = luaV_tonumber(o, n)) != null))) ? 1 : 0);
 }
Exemple #57
0
		public static CharPtr SValue(StkId o) { return GetStr(RawTSValue(o)); }
Exemple #58
0
 internal static TValue RB(lua_State L, StkId base_, Instruction i)
 {
     return(base_ + GETARG_B(i));
 }
Exemple #59
0
 public static void api_checkvalidindex(LuaState L, StkId i)
 {
     api_check(L, i != luaO_nilobject);
 }
        /* this function handles only `%d', `%c', %f, %p, and `%s' formats */
        public static CharPtr luaO_pushvfstring(lua_State L, CharPtr fmt, params object[] argp)
        {
            int parm_index = 0;       //FIXME: added, for emulating va_arg(argp, xxx)
            int n          = 0;

            for (;;)
            {
                CharPtr e = strchr(fmt, '%');
                if (e == null)
                {
                    break;
                }
                luaD_checkstack(L, 2);          /* fmt + item */
                pushstr(L, fmt, (uint)(e - fmt));
                switch (e[1])
                {
                case 's': {
                    object  o = argp[parm_index++]; //FIXME: changed
                    CharPtr s = o as CharPtr;       //FIXME: changed
                    if (s == null)                  //FIXME: changed
                    {
                        s = (string)o;              //FIXME: changed
                    }
                    if (s == null)
                    {
                        s = "(null)";
                    }
                    pushstr(L, s, (uint)strlen(s));               //FIXME:changed, (uint)
                    break;
                }

                case 'c': {
                    CharPtr buff = new char[1]; //FIXME:???char->CharPtr
                    buff[0] = (char)(int)argp[parm_index++];
                    pushstr(L, buff, 1);        //FIXME:???&buff
                    break;
                }

                case 'd': {
                    setnvalue(L.top, (int)argp[parm_index++]); StkId.inc(ref L.top);
                    break;
                }

                case 'f': {
                    setnvalue(L.top, (l_uacNumber)argp[parm_index++]); StkId.inc(ref L.top);
                    break;
                }

                case 'p': {
                    CharPtr buff = new char[32]; /* should be enough space for a `%p' */            //FIXME: changed, char buff[4*sizeof(void *) + 8];
                    uint    l    = (uint)sprintf(buff, "0x%08x", argp[parm_index++].GetHashCode()); //FIXME: changed, %p->%08x  //FIXME:changed, (uint)
                    pushstr(L, buff, l);
                    break;
                }

                case '%': {
                    pushstr(L, "%", 1);
                    break;
                }

                default: {
                    luaG_runerror(L,
                                  "invalid option " + LUA_QL("%%%c") + " to " + LUA_QL("lua_pushfstring"),
                                  (e + 1).ToString()); //FIXME: changed, *(e+1)
                    break;                             //FIXME:added
                }
                }
                n  += 2;
                fmt = e + 2;
            }
            luaD_checkstack(L, 1);
            pushstr(L, fmt, (uint)strlen(fmt));       //FIXME:changed, (uint)
            if (n > 0)
            {
                luaV_concat(L, n + 1);
            }
            return(svalue(L.top - 1));
        }