LUA源码分析八:小总结,完整分析dofile的过程和堆栈
关于一些语法包装的问题不涉及（可见前面某篇），主要对堆栈排列上的分析。
一路跟调到static void f_parser (lua_State *L, void *ud)函数，堆栈记录如下：
+ L->top 0x003950e8:当前指针
+ L->stack 0x003950a8
+ L->base 0x003950b8
+ L->ci 0x00398e08
跟调到Proto *luaY_parser函数中。该函数主要进行了语法解析，FuncState的建立，最后返回结构体
Proto。里面具体怎么解析语法等我们都不需要关系，我们只需要关注哪些结果被压入了堆栈。
Proto *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff, const char *name) {
struct LexState lexstate;
struct FuncState funcstate;
lexstate.buff = buff;
/*
不涉及堆栈，只是设置lexstate的一些参数
*/
luaX_setinput(L, &lexstate, z, luaS_new(L, name));
/*
会在top上压入2个值，Proto(表示函数属性)和一张表。
L->top排列如下：
L->top 0x003950e8:funcstate->h
L->top 0x003950f8:luaF_newproto(L)
*/
open_func(&lexstate, &funcstate);
funcstate.f->is_vararg = VARARG_ISVARARG; /* main func. is always vararg */
luaX_next(&lexstate); /* read first token */
chunk(&lexstate);
check(&lexstate, TK_EOS);
/*
将之前压入的2个值退出，堆栈恢复为
+ L->top 0x003950e8
*/
close_func(&lexstate);
lua_assert(funcstate.prev == NULL);
lua_assert(funcstate.f->nups == 0);
lua_assert(lexstate.fs == NULL);
return funcstate.f;
}
return上层函数f_parser，继续跟入：
static void f_parser (lua_State *L, void *ud) {
int i;
Proto *tf;
Closure *cl;
struct SParser *p = cast(struct SParser *, ud);
int c = luaZ_lookahead(p->z);
luaC_checkGC(L);
tf = ((c == LUA_SIGNATURE[0]) ? luaU_undump : luaY_parser)(L, p->z,
&p->buff, p->name);
/*
根据返回回来的函数属性新建一个closure,tf->nups表示多少个upvalues。
并且将tf设置回cl,初始化好upvalues值等
*/
cl = luaF_newLclosure(L, tf->nups, hvalue(gt(L)));
cl->l.p = tf;
for (i = 0; i < tf->nups; i++) /* initialize eventual upvalues */
cl->l.upvals[i] = luaF_newupval(L);
setclvalue(L, L->top, cl);
/*
改变了L->top
L->top 0x003950e8:cl,
cl地址为 0x00473780
*/
incr_top(L);
}
一路返回，断点到最初的luaL_loadfile中，该函数最后执行了一句lua_remove(L, fnameindex);
清除了一些参数(不影响到子调用的压栈)，现在top里面排列如下：
+ L->top 0x003950d8：cl包
+ L->top 0x003950e8：当前指针
+ L->stack 0x003950a8
+ L->base 0x003950b8
+ L->ci 0x00398e08
根据宏
#define luaL_dofile(L, fn) \ (luaL_loadfile(L, fn) || lua_pcall(L, 0, LUA_MULTRET, 0))
接下来调用lua_pcall函数:
LUA_API int lua_pcall (lua_State *L, int nargs, int nresults, int errfunc) {
struct CallS c;
/*
nargs为0，这段地址算出来为0x003950d8，
也就是我们上文创建的cl包
*/
c.func = L->top - (nargs+1); /* function to be called */
c.nresults = nresults;
/*
savestack算的是c.func和L->stack的差值。
0x003950d8-0x003950a8=48
*/
status = luaD_pcall(L, f_call, &c, savestack(L, c.func), func);
adjustresults(L, nresults);
lua_unlock(L);
return status;
}
跟入luaD_pcall->luaD_rawrunprotected->f_call->luaD_call->luaD_precall
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 */
/*
savestack算的是c.func和L->stack的差值。
0x003950d8-0x003950a8=48
*/
funcr = savestack(L, func);
cl = &clvalue(func)->l;
L->ci->savedpc = L->savedpc;
if (!cl->isC) { /* Lua function? prepare its call */
CallInfo *ci;
StkId st, base;
//取出函数属性
Proto *p = cl->p;
luaD_checkstack(L, p->maxstacksize);
//？？为什么不直接用func呢？
func = restorestack(L, funcr);
if (!p->is_vararg) { /* no varargs? */
base = func + 1;
if (L->top > base + p->numparams)
L->top = base + p->numparams;
}
else { /* vararg function */
/*
因为不带参数，所以base返回L->top，姑且是这个值
*/
int nargs = cast_int(L->top - func) - 1;
base = adjust_varargs(L, p, nargs);
func = restorestack(L, funcr); /* previous call may change the stack */
}
/*
设置好ci的堆栈
ci->func=0x003950d8
ci->base=0x003950e8
ci->top= 0x00395108
L->savedpc=0x00473860 编译出来的虚拟指令
*/
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 = p->code; /* starting point */
ci->tailcalls = 0;
ci->nresults = nresults;
/*
清空ci需要的堆栈
*/
for (st = L->top; st < ci->top; st++)
setnilvalue(st);
/*
L->top=0x00395108
*/
L->top = ci->top;
if (L->hookmask & LUA_MASKCALL) {
L->savedpc++; /* hooks assume 'pc' is already incremented */
luaD_callhook(L, LUA_HOOKCALL, -1);
L->savedpc--; /* correct 'pc' */
}
return PCRLUA;
}
}
跟入执行luaV_execute,根据 L->savedpc获取执行码
先获取环境表
case OP_GETGLOBAL: {
TValue g;
TValue *rb = KBx(i);
sethvalue(L, &g, cl->env);
lua_assert(ttisstring(rb));
Protect(luaV_gettable(L, &g, rb, ra));
continue;
}
再
case OP_LOADK: {
setobj2s(L, ra, KBx(i));
continue;
}
前面两个的具体意义都可以先不管，最后的调用.如果ci里有多个函数需要执行，则返回值为
PCRC,从下一指令的ci设置完毕，即可马上调用
case 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 = pc;
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 */
}
}
}
跟调到最后的luaD_precall.上文已经分析过luaD_precall，不同的是if (!cl->isC)的判断。上文中
为lua function,此次为C function
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->savedpc = L->savedpc;
if (!cl->isC) { /* Lua function? prepare its call */
}
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的环境。要执行的起始栈地址为要执行的函数+1，栈顶为L->top+LUA_MINSTACK
ci->func:0x003950e8
L->base:0x003950f8
ci->top:0x00395248
*/
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)
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 {
/*
整理CI的下一次行为.默认结尾时压入一条return的虚拟指令
*/
luaD_poscall(L, L->top - n);
return PCRC;
}
}
}