建议去看《Lua程序设计》24-28章，里面详细介绍了Lua和C语言之间的通信原理，多看函数是怎么调用的，就会理解了虚拟栈是怎么操作的，以下是我看完后的总结。

Lua和C语言之间的通信原理：虚拟栈

Lua库中没有定义任何全局变量，他将所有的状态都保存在动态结构lua_State中

为什么要用栈来储存数据而不是定义类似于lua_Value的类型呢

1. lua_Value很难将复杂的类型映射到其他语言中
2. Lua引擎无法搜索出一个保存在C变量中的lua table, 会认为这个table是垃圾并回收它

作用：可以解决C语言与lua语言之间的差异：

1. Lua要求垃圾回收而C语言要求显式释放内存
2. Lua使用动态类型而C语言使用静态类型

栈的基本操作：

• 传值给lua: 先将值压入栈，再调用Lua API, 将其值从栈中弹出
• 从lua中拿值: 调用Lua API，将指定值压入栈中

栈的操作规则：

• 严格按照LIFO（last in first out，先进后出）
• 调用Lua时，Lua只会改变栈的顶部；C代码对此栈可以查询删除插入中间元素

栈的操作函数

• 基础操作函数：

luaL_newstate：用于创建一个新环境或状态;// lua_State *L = luaL_newstate(); 

luaL_openlibs: 辅助库函数可以打开所有的标准库;

luaL_loadbuff: 编译用户输入的每行内容并将编译后的程序块压入栈中

lua_pcall: 将程序块从栈中弹出，并在保护模式下进行，成功返回0，若执行发生错误则会向栈中压入一条错误消息

lua_tostring: 可获取栈中的错误消息

lua_pop: 将程序块从栈中弹出删除

• 压入元素：每个C类型，lua都有对应的压入函数: lua_pushnumber, lua_pushboolean, lua_pushinteger, lua_pushstring...

需要确保栈中有足够的空间，一般是20个空闲的槽（由MINSTACK定义）

• 查询元素：API使用索引来引用栈中的元素，第一个压入栈的是1，最后一个压入栈的是-1，以此类推

一般跟着类型检测函数: lua_isnumber, lua_istable etc.

或者是类型转换函数: lua_tonumber, lua_tostring etc.

• 对栈的增加查询删除操作函数：

lua_gettop (lua_State * L): 返回栈中元素的个数

lua_settop (lua_State * L, int index): 修改栈中元素的数量；如果比以前的多则从nil补充

lua_pushvalue (lua_State * L, int index): 将指定索引的值副本压入栈中

lua_remove (lua_State * L, int index): 将指定索引的值移除

lua_insert (lua_State * L, int index): 将指定索引的位置上开辟新元素，再将栈顶元素移到该位置

lua_replace (lua_State * L, int index): 弹出栈顶值，并将该值设置到指定的索引上

API中的错误处理：

用lua_pcall来调用Lua代码，在保护模式下运行。如果发生了内存分配错误，lua_pcall会返回错误代码

当C函数检测出一个错误时，应该调用lua_error。此函数会清理Lua中所有需要清理的东西，然后跳转回发起执行的那个lua_pcall, 并附上一条错误消息

C转Lua Table操作

将C语言的struct转变成Lua的table

设置table, 将字段名和字段值压入栈中，并调用lua_settable创建table
void setfield(lua_State* L, const char* key, int value)
    lua_pushstring(L, key)
    lua_pushnumber(L, value/MAX_COLOR);
    lua_settable(L, -3)
}

ColorTable("GREEN", 1, 0, 0) -> background = GREEN = {r = 1, g = 0, b = 0}

struct ColorTable{
　　char* name;
　　int red;
　　int green;
}

void setColor(lua_State* L, struct ColorTable *c){
    lua_newTable(L)
    setfield(L, 'r', c->red);
    setfield(L, 'g', c->green);
    lua_setglobal(L, c->name);
}

拿Lua table里的值: background = {r = 1, g = 0, b = 0}

lua_setglobal(L, "background")
if lua_istable(L, -1){
    red = lua_getfield(L, 'r');
    green = lua_getfield(L, 'g');
　　 blue = lua_getfield(L, 'b');
} 

从C调用Lua函数

流程：

1. 函数压入栈
2. 参数压入栈
3. lua_pcall进行函数调用
4. 弹出返回值

// lua file
function add(x, y)
　　return x+y
end

// C++
lua_getglobalname(L, 'add') 1. 把lua函数压入栈
lua_pushnumber(L, x) 2. 把参数压入栈
lua_pushnumber(L, y)
if (lua_pcall(L, 2, 1, 0) != 0) 3. 用lua_pcall进行函数调用
　　error(L, "wrong function: %s", lua_tostring(L, -1));
if(!lua_isnumber(L, -1) // 验证返回值
　　error(L, "must return number");
z = lua_tonumber(L, -1);
lua_pop(L, -1); 4. 将返回值从栈中弹出
return z; 

从Lua调用C函数

所有注册到Lua中的函数都具有相同的原型：typedef int (*lua_Cfunction) (lua_State* L); 仅有一个参数且为Lua的状态

// 将要在Lua中调用的C函数add()
static int add(luaState* L)
{
    int x = lua_tonumber(L, 1);
　　int y = lua_tonumber(L, 2);
　　lua_pushnumber(L, x+y)
　　return L;
}

lua使用C函数前必须先注册这个函数
lua_pushcfunction(L, add); // 压入C函数类型的值
lua_setglobal(L, "myAdd"); // 将该值赋予全局变量myAdd

之后就可以在lua中直接调用myAdd(x, y)

数组操作

数组操作函数：

• lua_rawgeti(lua_State* L, int index, int key)，相当于：

1. 1. lua_pushnumber(L, key);
   2. lua_rawget(L, index);

• lua_rawseti(lua_State* L, int index, int key)，相当于：

1. 1. lua_pushnumber(L, key);
   2. lua_insert(L, -2,); // key放在前一个元素下面，因为前一个元素为赋值value
   3. lua_rawset(L, t);

• index表示table在栈中的位置，key表示元素在table的位置

例子：一个变换函数在C中，对lua table里的值应用了一个给定函数

int turnMap(lua_State* L)
{
    luaL_checkType(L, 1, LUA_TABLE);
    luaL_checkType(L, 2, LUA_TFUNCTION);
    int n = lua_objlen(L, 1)
    for(int i = 1; i <=n; i++)
    {
        lua_pushvalue(L, 2);// 将索引位置的拷贝值压入栈顶，也就是f
        lua_rawgetti(L, 1, i); // 压入t[i]
        lua_call(L, 1, 1); // 调用 f(t[i])，结果压入栈顶
        lua_rawseti(L, 1, i); // t[i] = 结果
    }

    return 0;
}　　

upvalue

类似于C语言中的静态变量机制，只在一个特定的函数里可见

关键函数：

• lua_pushclosure(lua_State* L, lua_function* function, int number): 第二个参数是基础函数，第三个参数是upvalue的数量
  • upvalue的初始化必须是在创建closure之前
  • 每个closure可以有不同的upvalue
  • 一个函数可以创建多个closure
• lua_upvalueindex(int index): 生成upvalue的伪索引，可以像其他栈索引一样使用，不同的是它不在栈上
  • index不能为负数

示例1：不断增加的counter

static int count(lua_State* L)
{
    int val = lua_tointeger(L, lua_upvalueindex(1)); //拿到第一个也是唯一一个upvalue
    lua_pushinteger(L, ++val);
    lua_pushvalue(L, -1); // 复制结果压入栈中
    lua_replace(L, lua_upvalueindex(1)); // 更新upvalue
    return 1
}
int newCount(lua_State* L)
{
    lua_pushnumber(L, 0); // 设置upvalue的初始值为0
    lua_pushclosure(L, &count, 1) // 创建closure，建立该函数与upvalue之间的联系
 }

示例2：upvalue实现tuple

tuple_new是用于创建tuple的函数，由于参数已经在栈中，所以只需要将这些参数作为upvalue，并调用lua_pushcclosure来创建基于t_tuple的closure即可。数组tuplelib和luaopen_tuple是创建库的标准代码，tuple库中只有new函数

关键函数：

• luaL_Reg: 数组元素结构，有两个字段，一个字符串和一个函数指针
  • 必须以NULL, NULL结尾代表结束
• luaL_register(lua_State* L, string functionName, const struct luaL_Reg* lib)：根据给定的名字“functionName”创建一个table，并用数组lib中的信息填充这个table
  • 函数返回时会把这个table留在栈中
• luaL_opint(lua_State* L, int index, int num): 类似于luaL_checkint, 但它允许参数为null，若不存在则返回默认值（0）
• lua_isnone(lua_State* L, lua_upvalueindex(int i)): 用于测试upvalue是否存在
• lua_argcheck(lua_State* L, bool condition, int index, string errMsg): 用于检测condition是否满足，若不满足则返回error message

tuple的使用
x = tuple.new(10, 'a', {}, 3)
print(x(1)) // 10

int luaopen_tuple(lua_State* L)
{
    luaL_register(L, "tuple", tuplelib); // 给tuple注册函数列表
    return 1;
}

static const struct luaL_Reg tuplelib[] = 
{
    {"new", tuple_new},
    {NULL, NULL}, //必须以null结尾
}；

int tuple_new(lua_State* L)
{
    lua_pushcclosure(L, t_tuple, lua_gettop(L); // 创建closure，参数的个数为upvalue的数量
    return 1;
}

int t_tuple(lua_State* L)
{
    int op = luaL_opint(L, 1, 0);
　　 if (op == 0)
　　 {
　　　　// 遍历所有的upvalue并压入栈中
　　　　for(int i = 1; !lua_isnone(L, lua_upvalueindex(i)); i++)
　　　　{
　　　　　　lua_pushvalue(L, lua_upvalueindex(i);
　　　　}
　　　　return i - 1; // return upvalue的数量
　　 }
　　 else
　　 {
　　　　luaL_argcheck(L, op > 0, 1, "out of range");
　　　　if (lua_isnone(L, lua_upvalueindex(op)) // 无此字段
　　　　　　return 0;
　　　　lua_pushvalue(L, lua_upvalueindex(op);
　　　　return 1;
　　 }
}

元表

 一种辨别不同类型的userdata的方法是为每种类型创建一个唯一的元表，每当得到一个userdata，就检查它是否拥有正确的元表

• luaL_setmetatable: 创建一个新的table作为元表，并将其压入栈顶，然后将这个table与注册表中的指定名称关联起来
• luaL_getmetatable：在注册表中搜索与tname关联的元表

面对对象的操作

local metaarray = getmetatable(array.new(1))
metaarray.--index = metaarray // 当a时userdata时是没有size key的，因此lua会通过a元表的--index，找到自己本身metaarray，然后再找到size
metaarray.size = array.size
static const struct luaL_Reg arraylib_m [] = {
{"--newindex", setarray}, //元方法 将a:setarray(i, 0) 变成 a[i] = 0
{"--index", getarray}, //将a:get(i) 变成 a[i]
{"--len", getsize},
{NULL, NULL}
}

luaL_register(L, NULL, arraylib_m): 以NULL作为库名，是不会创建任何用于储存函数的table，而是以栈顶的table作为存储函数的table

这样就可以直接调用metaarray.getarray(10)

Reference:

1. 《Lua程序设计》第24-28章