public static int lua_pcall(lua_State L, int nargs, int nresults, int errfunc)
{
CallS c = new CallS();
int status;
ptrdiff_t func;
lua_lock(L);
api_checknelems(L, nargs + 1);
checkresults(L, nargs, nresults);
if (errfunc == 0)
{
func = 0;
}
else
{
StkId o = index2adr(L, errfunc);
api_checkvalidindex(L, o);
func = savestack(L, o);
}
c.func = L.top - (nargs + 1); /* function to be called */
c.nresults = nresults;
status = luaD_pcall(L, f_call, c, savestack(L, c.func), func);
adjustresults(L, nresults);
lua_unlock(L);
return(status);
}
public static int LuaPCall(LuaState L, int nargs, int nresults, int errfunc)
{
CallS c = new CallS();
int status;
ptrdiff_t func;
LuaLock(L);
CheckNElements(L, nargs + 1);
CheckResults(L, nargs, nresults);
if (errfunc == 0)
{
func = 0;
}
else
{
StkId o = Index2Address(L, errfunc);
CheckValidIndex(L, o);
func = SaveStack(L, o);
}
c.func = L.top - (nargs + 1); /* function to be called */
c.nresults = nresults;
status = LuaDPCall(L, FunctionCall, c, SaveStack(L, c.func), func);
AdjustResults(L, nresults);
LuaUnlock(L);
return(status);
}
ThreadStatus ILuaAPI.PCallK(int numArgs, int numResults, int errFunc,
int context, CSharpFunctionDelegate continueFunc)
{
Utl.ApiCheck(continueFunc == null || !CI.IsLua,
"cannot use continuations inside hooks");
Utl.ApiCheckNumElems(this, numArgs + 1);
Utl.ApiCheck(Status == ThreadStatus.LUA_OK,
"cannot do calls on non-normal thread");
CheckResults(numArgs, numResults);
int func;
if (errFunc == 0)
{
func = 0;
}
else
{
StkId addr;
if (!Index2Addr(errFunc, out addr))
{
Utl.InvalidIndex();
}
func = addr.Index;
}
ThreadStatus status;
CallS c = new CallS();
c.L = this;
c.FuncIndex = Top.Index - (numArgs + 1);
if (continueFunc == null || NumNonYieldable > 0) // no continuation or no yieldable?
{
c.NumResults = numResults;
status = D_PCall(DG_F_Call, ref c, c.FuncIndex, func);
}
else
{
int ciIndex = CI.Index;
CI.ContinueFunc = continueFunc;
CI.Context = context;
CI.ExtraIndex = c.FuncIndex;
CI.OldAllowHook = AllowHook;
CI.OldErrFunc = ErrFunc;
ErrFunc = func;
CI.CallStatus |= CallStatus.CIST_YPCALL;
D_Call(Stack[c.FuncIndex], numResults, true);
CallInfo ci = BaseCI[ciIndex];
ci.CallStatus &= ~CallStatus.CIST_YPCALL;
ErrFunc = ci.OldErrFunc;
status = ThreadStatus.LUA_OK;
}
AdjustResults(numResults);
return(status);
}
public static int lua_pcallk(lua_State L, int nargs, int nresults, int errfunc,
int ctx, lua_CFunction k)
{
CallS c = new CallS();
int status;
ptrdiff_t func;
lua_lock(L);
api_check(L, k == null || isLua(L.ci) == 0,
"cannot use continuations inside hooks");
api_checknelems(L, nargs + 1);
api_check(L, L.status == LUA_OK, "cannot do calls on non-normal thread");
checkresults(L, nargs, nresults);
if (errfunc == 0)
{
func = 0;
}
else
{
StkId o = index2addr(L, errfunc);
api_checkstackindex(L, errfunc, o);
func = savestack(L, o);
}
c.func = L.top - (nargs + 1); /* function to be called */
if (k == null || L.nny > 0) /* no continuation or no yieldable? */
{
c.nresults = nresults; /* do a 'conventional' protected call */
status = luaD_pcall(L, f_call, c, savestack(L, c.func), func);
}
else /* prepare continuation (call is already protected by 'resume') */
{
CallInfo ci = L.ci;
ci.u.c.k = k; /* save continuation */
ci.u.c.ctx = ctx; /* save context */
/* save information for error recovery */
ci.extra = savestack(L, c.func);
ci.u.c.old_allowhook = L.allowhook;
ci.u.c.old_errfunc = L.errfunc;
L.errfunc = func;
/* mark that function may do error recovery */
ci.callstatus |= CIST_YPCALL;
luaD_call(L, c.func, nresults, 1); /* do the call */
ci.callstatus &= (byte)((~CIST_YPCALL) & 0xff);
L.errfunc = ci.u.c.old_errfunc;
status = LUA_OK; /* if it is here, there were no errors */
}
adjustresults(L, nresults);
lua_unlock(L);
return(status);
}
public static int lua_pcall(lua_State L, int nargs, int nresults, int errfunc)
{
CallS c = new CallS();
int status;
ptrdiff_t func;
lua_lock(L);
api_checknelems(L, nargs+1);
checkresults(L, nargs, nresults);
if (errfunc == 0)
func = 0;
else {
StkId o = index2adr(L, errfunc);
api_checkvalidindex(L, o);
func = savestack(L, o);
}
c.func = L.top - (nargs+1); /* function to be called */
c.nresults = nresults;
status = luaD_pcall(L, f_call, c, savestack(L, c.func), func);
adjustresults(L, nresults);
lua_unlock(L);
return status;
}
static void f_call(lua_State L, object ud)
{
CallS c = ud as CallS;
luaD_call(L, c.func, c.nresults, 0);
}
private static void F_Call(ref CallS ud)
{
CallS c = (CallS)ud;
c.L.D_Call(c.L.Stack[c.FuncIndex], c.NumResults, false);
}
ThreadStatus ILuaAPI.PCallK( int numArgs, int numResults, int errFunc,
int context, CSharpFunctionDelegate continueFunc )
{
Utl.ApiCheck( continueFunc == null || !CI.IsLua,
"cannot use continuations inside hooks" );
Utl.ApiCheckNumElems( this, numArgs + 1 );
Utl.ApiCheck( Status == ThreadStatus.LUA_OK,
"cannot do calls on non-normal thread" );
CheckResults( numArgs, numResults );
int func;
if( errFunc == 0 )
func = 0;
else
{
StkId addr;
if( !Index2Addr( errFunc, out addr ) )
Utl.InvalidIndex();
func = addr.Index;
}
ThreadStatus status;
CallS c = new CallS();
c.L = this;
c.FuncIndex = Top.Index - (numArgs + 1);
if( continueFunc == null || NumNonYieldable > 0 ) // no continuation or no yieldable?
{
c.NumResults = numResults;
status = D_PCall( DG_F_Call, ref c, c.FuncIndex, func );
}
else
{
int ciIndex = CI.Index;
CI.ContinueFunc = continueFunc;
CI.Context = context;
CI.ExtraIndex = c.FuncIndex;
CI.OldAllowHook = AllowHook;
CI.OldErrFunc = ErrFunc;
ErrFunc = func;
CI.CallStatus |= CallStatus.CIST_YPCALL;
D_Call( Stack[c.FuncIndex], numResults, true );
CallInfo ci = BaseCI[ciIndex];
ci.CallStatus &= ~CallStatus.CIST_YPCALL;
ErrFunc = ci.OldErrFunc;
status = ThreadStatus.LUA_OK;
}
AdjustResults( numResults );
return status;
}
private static void F_Call(ref CallS ud)
{
CallS c = (CallS)ud;
c.L.D_Call(c.L.Stack[c.FuncIndex], c.NumResults, false);
}
public static int LuaPCall(LuaState L, int nargs, int nresults, int errfunc)
{
CallS c = new CallS();
int status;
ptrdiff_t func;
LuaLock(L);
CheckNElements(L, nargs + 1);
CheckResults(L, nargs, nresults);
if (errfunc == 0)
func = 0;
else
{
StkId o = Index2Address(L, errfunc);
CheckValidIndex(L, o);
func = SaveStack(L, o);
}
c.func = L.top - (nargs + 1); /* function to be called */
c.nresults = nresults;
status = LuaDPCall(L, FunctionCall, c, SaveStack(L, c.func), func);
AdjustResults(L, nresults);
LuaUnlock(L);
return status;
}
static void FunctionCall(LuaState L, object ud)
{
CallS c = ud as CallS;
LuaDCall(L, c.func, c.nresults);
}
