因为实习需要用到lua所以最近在学习lua，在学习过程中我使用C++与lua做交互。正常来说，如果lua要调用C++的函数，C++需要返回一个整数，这个整数的值是这个C++函数需要返回给lua调用的值的个数。这样的做法才是正确的，只是我突然间想了下，如果我返回一个不正确的值会怎样呢?于是我这么做了，然后数据如预料之中变得很不正常。然后我又在想，为什么我返回不正确的值lua会得到这样的数据呢。于是我开始了lua的C源码分析。其实就是给自己挖了个大坑23333，然后我又是属于那种有问题没解决心里仿佛有块石头压着的那种人。没办法，只好硬着头皮上了。
一、问题建立
实验代码：
main.cpp
#include <iostream>
#include <string>
#include "lua.hpp"
#include "Utils.hpp"
int CGetPow(lua_State *l)
{
lua_pushstring(l, "hello");
lua_pushstring(l, "world");
StackDump(l);
return 2;
}
int main(int argc, const char *argv[])
{
using namespace std;
int error,error1,error2;
string fname;
fname = argv[1];
lua_State *L = luaL_newstate();
luaL_openlibs(L);
lua_pushstring(L, "fuck");
lua_pushcfunction(L, CGetPow);
lua_setglobal(L, "pow");
error1 = luaL_loadfile(L, fname.c_str());
error2 = lua_pcall(L, 0, 0, 0);
error = error1 || error2;
if (error)
{
std::cout << fname << std::endl;
fprintf(stderr, "%s\n", lua_tostring(L, -1));
lua_pop(L, 1);
}
lua_close(L);
return 0;
}
StackDump的作用是打印栈上的内容：
void StackDump(lua_State *l)
{
int top = lua_gettop(l);
std::cout << "Stack: ";
for (int i = 1; i <= top; i++)
{
int t = lua_type(l, i);
switch (t)
{
case LUA_TSTRING:
std::cout << "‘" << lua_tostring(l, i) << "‘";
break;
case LUA_TBOOLEAN:
std::cout << lua_toboolean(l, i) ? "true" : "false";
break;
case LUA_TNUMBER:
std::cout << lua_tonumber(l, i);
break;
default:
std::cout << lua_typename(l, t);
break;
}
std::cout << "\t";
}
std::cout << std::endl;
}
test.lua
print(pow(2,3))--这句是最主要的，下面三个输出只是为了对比函数而已
print("print",print)
print("pow",pow)
print("test.lua",debug.getinfo(1, "f").func)
现在，CGetPow返回的整数是2，而函数中push的内容也的确只有两个，所以，它会很正常的返回"hellow"和"world"内容，输出：
如上图所示，print(pow(2,3))的输出是 hello world（下面三行还没用到，可以先无视）。
然后第一次，把CGetPow的返回改为5，它会输出：
这时候输出变成了function：xxxxx 2 3 hello world，第一个function:xxxxxx可以由下面的函数对照发现是pow函数，也就是CGetPow，从这时候看好像看起来还是栈结构，虽然它返回来我们不需要的参数2和3和正在CGetPow函数.
第二次，把CGetPow的返回改为8，输出为：
由函数对照发现，输出在重复：fuck，加载test.lua生成的函数，print函数。这时候它的输出又不像一个栈结构了，因为2,3，hello，world不见了。为什么会这样呢？lua是怎么push值到栈中的，怎么从栈中取值的，函数调用到底干了什么？我决定通过分析lua的c源码来弄明白这些问题。
二、源码分析
1、lua_State和栈的初始化
lua_State由lua_newstate创建：
LUA_API lua_State *lua_newstate (lua_Alloc f, void *ud) {
int i;
lua_State *L;
global_State *g;
//LG由传进来的f进行分配，其中就已经包含了lua_State
LG *l = cast(LG *, (*f)(ud, NULL, LUA_TTHREAD, sizeof(LG)));
if (l == NULL) return NULL;
//从LG中取出要返回的lua_State
L = &l->l.l;
g = &l->g;
L->next = NULL;
L->tt = LUA_TTHREAD;
g->currentwhite = bitmask(WHITE0BIT);
L->marked = luaC_white(g);
preinit_thread(L, g);
g->frealloc = f;
g->ud = ud;
g->mainthread = L;
g->seed = makeseed(L);
g->gcrunning = 0; /* no GC while building state */
g->GCestimate = 0;
g->strt.size = g->strt.nuse = 0;
g->strt.hash = NULL;
setnilvalue(&g->l_registry);
g->panic = NULL;
g->version = NULL;
g->gcstate = GCSpause;
g->gckind = KGC_NORMAL;
g->allgc = g->finobj = g->tobefnz = g->fixedgc = NULL;
g->sweepgc = NULL;
g->gray = g->grayagain = NULL;
g->weak = g->ephemeron = g->allweak = NULL;
g->twups = NULL;
g->totalbytes = sizeof(LG);
g->GCdebt = 0;
g->gcfinnum = 0;
g->gcpause = LUAI_GCPAUSE;
g->gcstepmul = LUAI_GCMUL;
for (i=0; i < LUA_NUMTAGS; i++) g->mt[i] = NULL;
if (luaD_rawrunprotected(L, f_luaopen, NULL) != LUA_OK) {
/* memory allocation error: free partial state */
close_state(L);
L = NULL;
}
return L;
}
展开lua_rawrunprotected
int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud) {
......
LUAI_TRY(L, &lj,
(*f)(L, ud);
);
......
}
发现调用了传进来的f_luaopen函数，追踪这个函数
static void f_luaopen (lua_State *L, void *ud) {
......
stack_init(L, L); /* init stack */
......
}
由作者注释可知stack_init是初始化栈的函数，找到这个函数的实现
static void stack_init (lua_State *L1, lua_State *L) {
int i; CallInfo *ci;
/* initialize stack array */
L1->stack = luaM_newvector(L, BASIC_STACK_SIZE, TValue);
L1->stacksize = BASIC_STACK_SIZE;
for (i = 0; i < BASIC_STACK_SIZE; i++)
setnilvalue(L1->stack + i); /* erase new stack */
L1->top = L1->stack;
L1->stack_last = L1->stack + L1->stacksize - EXTRA_STACK;
/* initialize first ci */
ci = &L1->base_ci;
ci->next = ci->previous = NULL;
ci->callstatus = 0;
ci->func = L1->top;
setnilvalue(L1->top++); /* ‘function‘ entry for this ‘ci‘ */
ci->top = L1->top + LUA_MINSTACK;
L1->ci = ci;
}
分析得知：lua_State由luaM_newvector初始化并返回一个基地址给L1->stack，栈的大小为40（由BASIC_STACK_SIZE的宏定义得到），然后初始化把栈上的值全设置为nil，设置栈最后一个元素的地址L1->stack_last，初始化当前调用信息L1->ci，把lua_State的top设置为第一个栈上的第二个空元素（第一个是空元素已经被用作ci了，所以不能使用），设置ci的top（其实相当于ci作为栈基，然后ci这个栈的长度为LUA_MINSTACK，也就是20，在这个栈中push时不能超过这个长度，除非重新设置栈长度）。
2、lua从栈中取数据和往栈中push数据
首先是取数据，这里用lua_tointegerx作例子
LUA_API lua_Integer lua_tointegerx (lua_State *L, int idx, int *pisnum) {
lua_Integer res;
//重点是这句，TValue是lua中用的最多的数据结构，index2addr则是根据传入的栈索引从栈取出数据
const TValue *o = index2addr(L, idx);
int isnum = tointeger(o, &res);
if (!isnum)
res = 0; /* call to ‘tointeger‘ may change ‘n‘ even if it fails */
if (pisnum) *pisnum = isnum;
return res;
}
查看TValue的数据结构
//Value是具体的值，tt_则是定义好的数据类型，数据类型在lua中也是使用宏定义设置的
#define TValuefields Value value_; int tt_
typedef struct lua_TValue {
TValuefields;
} TValue;
展开index2addr的实现：
static TValue *index2addr (lua_State *L, int idx) {
//当前调用函数的信息
CallInfo *ci = L->ci;
if (idx > 0) {
//在栈基(这里的栈基不是指整个lua_State的栈基，而是当前调用函数信息的栈基，也可以简单理解成就是当前函数在栈中的地址)基础上加上传进来的索引获取到正确的数据
TValue *o = ci->func + idx;
//下面是检测数据正确性
api_check(L, idx <= ci->top - (ci->func + 1), "unacceptable index");
if (o >= L->top) return NONVALIDVALUE;
//返回获取到的数据
else return o;
}
......
}
通过index2addr从栈中获取到数据，然后在根据tt_获取到数据类型，得到对应的值。lua_tolstring,lua_toboolean等基本都是这样从栈中取数据。
然后是向栈中push数据。这里以lua_pushinteger做例子：
#define api_incr_top(L) {L->top++; api_check(L, L->top <= L->ci->top, "stack overflow");}
#define setivalue(obj,x) \
{ TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_TNUMINT); }
LUA_API void lua_pushinteger (lua_State *L, lua_Integer n) {
lua_lock(L);
setivalue(L->top, n);
api_incr_top(L);
lua_unlock(L);
}
这里所做的操作显示把L->top指向的空元素设置为想要设置的元素，然后再把L->top只向下一个空元素，期间同样会涉及到向栈推元素需要做的安全性检查。push其他类型元素的操作也和这个操作原理一样。
3、函数的调用
通常我们在C中调用函数，会先push要调用的函数，然后再按顺序push参数，最后使用lua_pcall指定lua_state,参数个数以及返回个数。先来分析源码
//lua_pcall是个宏定义，展开后是lua_pcallk()
#define lua_pcall(L,n,r,f) lua_pcallk(L, (n), (r), (f), 0, NULL)
//看看lua_pcallk的实现，代码太多，只展示要说明的
LUA_API int lua_pcallk (lua_State *L, int nargs, int nresults, int errfunc,
lua_KContext ctx, lua_KFunction k) {
struct CallS c;
int status;
ptrdiff_t func;
lua_lock(L);
//检查正确性
api_check(L, k == NULL || !isLua(L->ci),
"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);
//errfunc为0代表没指定错误处理函数
if (errfunc == 0)
func = 0;
else {
......
}
//c.func通过栈的运算获得，是要调用的函数在栈上的位置
c.func = L->top - (nargs+1); /* function to be called */
//k为空代表没有延续
if (k == NULL || L->nny > 0) { /* no continuation or no yieldable? */
//设置返回结果个数
c.nresults = nresults; /* do a ‘conventional‘ protected call */
//luaD_pcall才是重点，在这里传进去了f_call函数
status = luaD_pcall(L, f_call, &c, savestack(L, c.func), func);
}
else { /* prepare continuation (call is already protected by ‘resume‘) */
......
}
//调整栈顶位置
adjustresults(L, nresults);
lua_unlock(L);
return status;
}
//展开luaD_pcall
int luaD_pcall (lua_State *L, Pfunc func, void *u,
ptrdiff_t old_top, ptrdiff_t ef) {
......
//在这里调用了上一步传进来的f_call函数
status = luaD_rawrunprotected(L, func, u);
......
}
//继续展开f_call函数
static void f_call (lua_State *L, void *ud) {
struct CallS *c = cast(struct CallS *, ud);
//f_call里有调用了luaD_callnoyield函数
luaD_callnoyield(L, c->func, c->nresults);
}
//展开luaD_callnoyield函数
void luaD_callnoyield (lua_State *L, StkId func, int nResults) {
L->nny++;
//好吧，继续看看这个
luaD_call(L, func, nResults);
L->nny--;
}
void luaD_call (lua_State *L, StkId func, int nResults) {
if (++L->nCcalls >= LUAI_MAXCCALLS)
stackerror(L);
//重点函数：luaD_precall，展开之
if (!luaD_precall(L, func, nResults)) /* is a Lua function? */
luaV_execute(L); /* call it */
L->nCcalls--;
}
int luaD_precall (lua_State *L, StkId func, int nresults) {
lua_CFunction f;
CallInfo *ci;
switch (ttype(func)) {
case LUA_TCCL: /* C closure */
f = clCvalue(func)->f;
goto Cfunc;
case LUA_TLCF: /* light C function */
f = fvalue(func);
Cfunc: {
//n是c函数中返回的值
int n; /* number of returns */
//栈检查，这个没细看，都是些检查安全性的东西
checkstackp(L, LUA_MINSTACK, func); /* ensure minimum stack size */
//创建并初始化新的调用函数信息，并进入新的函数
ci = next_ci(L); /* now ‘enter‘ new function */
ci->nresults = nresults;
ci->func = func;
ci->top = L->top + LUA_MINSTACK;
lua_assert(ci->top <= L->stack_last);
ci->callstatus = 0;
if (L->hookmask & LUA_MASKCALL)
luaD_hook(L, LUA_HOOKCALL, -1);
lua_unlock(L);
//终于来了！！妈的调用来调用去的你终于执行到了真正要执行的函数了啊！C函数的返回值赋给了n。
n = (*f)(L); /* do the actual call */
lua_lock(L);
api_checknelems(L, n);
//这个函数也很重要，就是把执行函数后push进来的值重新放置到正确的位置,L->top-n是指第一个元素，n是指有多少个元素
luaD_poscall(L, ci, L->top - n, n);
return 1;
}
//这里只说明c函数部分，其他lua函数等部分的原理都是差不多的。
......
}
}
//展开luaD_poscall
int luaD_poscall (lua_State *L, CallInfo *ci, StkId firstResult, int nres) {
StkId res;
int wanted = ci->nresults;
......
//res指向当前调用函数在栈中的位置
res = ci->func; /* res == final position of 1st result */
//通过调用函数信息链回到上一个调用函数信息中
L->ci = ci->previous; /* back to caller */
/* move results to proper place */
//moveresults真正执行移动元素的操作
return moveresults(L, firstResult, res, nres, wanted);
}
//展开moveresults
static int moveresults (lua_State *L, const TValue *firstResult, StkId res,
int nres, int wanted) {
switch (wanted) { /* handle typical cases separately */
//不需要返回则不需要转移
case 0: break; /* nothing to move */
//需要一个元素，只转移第一个元素
case 1: { /* one result needed */
if (nres == 0) /* no results? */
firstResult = luaO_nilobject; /* adjust with nil */
setobjs2s(L, res, firstResult); /* move it to proper place */
break;
}
//如同print函数这些需要所有返回值的则调用这个，转移所有元素
case LUA_MULTRET: {
int i;
//遍历nres个元素并转移到新位置，可以发现转移元素实际上使用到了setobjs2s()
for (i = 0; i < nres; i++) /* move all results to correct place */
setobjs2s(L, res + i, firstResult + i);
//重新设置栈顶
L->top = res + nres;
return 0; /* wanted == LUA_MULTRET */
}
default: {
int i;
if (wanted <= nres) { /* enough results? */
for (i = 0; i < wanted; i++) /* move wanted results to correct place */
setobjs2s(L, res + i, firstResult + i);
}
else { /* not enough results; use all of them plus nils */
for (i = 0; i < nres; i++) /* move all results to correct place */
setobjs2s(L, res + i, firstResult + i);
for (; i < wanted; i++) /* complete wanted number of results */
setnilvalue(res + i);
}
break;
}
}
//重设置栈顶
L->top = res + wanted; /* top points after the last result */
return 1;
}
//展开setobjs2s
//发现原来又是宏定义
#define setobjs2s setob
//还是宏定义，原来就是直接把obj2的值赋给了obj1而已
#define setobj(L,obj1,obj2) \
{ TValue *io1=(obj1); *io1 = *(obj2); (void)L; checkliveness(L,io1); }
OK～到这里，就基本上明白了整个函数调用流程以及在流程中的栈变化了。
三、得出结论
为什么当CGetPow的返回值为5的时候它看起来还像是个栈结构，但是返回值为8的时候却会重复fuck 编译test.lua得出的函数 print这三个呢？
解：
因为在调用print(pow(2,3))中，栈中的结构为1:nil（已通过实验确定这是最初的lua_state的ci->func），2：fuck， 3：function（加载test.lua得到的函数），4：print函数，5：pow函数，6：参数2，7：参数3.
当push了"hello"和"world“后，栈结构多了8：”hello“，9：”world“。
然后如果这时候返回值为5，移动栈元素时会从L->top-5（当前的top在索引10上）的元素开始，移动5个元素到从当前函数（pow）在栈中的位置开始的位置上。也就是说把从第5个索引开始的5个元素转移到从pow函数所在位置开始的新位置，所以实际上栈的元素是没有变动过的。所以当调用第4个索引位置上的print输出他们的时候，输出结果为：pow 2 3 hello world。
然后当返回值为8时，移动栈元素时会从L->top-8，也就是索引2开始把8个元素转移到pow函数所在位置开始的新位置后。这里就会出现一个现象，因为2->5,3->6,4->7，所以实际上现在第5索引上的元素为最开始第2个索引上的元素，所以5->8后，第8索引上的元素为fuck，同理6->9实际上是3->9，7->10实际上是4->10，这就导致了print输出时一直重复fuck test.lua编译出来的函数 print这3个元素。
至此问题解决，并且还对lua的认识增加了许多。就是看lua的宏定义看得我脑壳疼了一天。233333
原文地址：https://www.cnblogs.com/winsons/p/10806824.html