我们说用Lua可以调用C语言函数，但这并不意味着Lua可以调用所有的C函数。当C语言调用Lua函数时，该函数必须遵循一个简单的规则来传递参数和获取结果。

同样，当Lua调用C函数时，这个C函数也必须遵循某种规则来获取参数和返回结果。此外，当Lua调用C函数时，我们必须注册该函数，即必须以一种恰当的方式为Lua提供该C函数的地址。
Lua调用C函数时，也使用一个与C语言调用Lua函数时相同类型的栈，C函数从栈中获取参数，并将结果压入栈中。
此处的重点在于，这个栈不是一个全局结构；每个函数都有其私有的局部栈。当Lua调用一个C函数时，第一个参数总是位于这个局部栈中索引为1的位置。即使一个C函数调用了Lua代码，而且Lua代码又再次调用了同一个C函数，这些调用每一次都只会看到本次调用自己的私有栈，其中索引为1的位置上就是一个参数。

C函数

先举一个例子，让我们实现一个简化版本的正弦函数，该函数返回某个给定数的正弦值：

1
2
3
4
5

static int l_sin(lua_State *L){
	double d = lua_tonumber(L,1);
	lua_pushnumber(L,sin(d));
	return 1;
}

1

typedef int (*lua_CFunction)(lua_State *L);

1
2

lua_pushcfunction(L,l_sin);
lua_setglobal(L,"mysin");

1
2
3
4
5

static int l_sin(lua_State *L){
	double d = luaL_checknumber(L,1);
	lua_pushnumber(L,sin(d));
	return 1;
}

1

bad argument #1 to 'mysin' (number expected, got string)

一个读取目录的函数

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

#include <dirent.h> #include <errno.h> #include <string.h> #include "lua.h" #include "luaxlib.h" static int l_dir(lua_State *L){ DIR *dir; struct dirent *entry; int i; const char *path = lual_checkstring(L,1); dir = opendir(path); if (dir == NULL){ lua_pushnil(L); lua_pushstring(L,strerror(error)); return 2; } lua_newtable(L); i = 1; while ((entry = readdir(dir)) != NULL){ lua_pushinteger(L,i++); lua_pushstring(L,entry -> d_name); lua_settable(L,3); } closedir(dir); return 1; }

该函数先使用与luaL_checknumber类似的函数luaL_checkstring检查目录路径是否为字符串，然后使用函数opendir打开目录。如果无法打开目录，该函数会返回nil以及一条用函数strerror获取的错误信息。在打开目录后，该函数会创建一张新表，然后用目录中的元素填充这张新表。最后，该函数关闭目录并返回1，在C语言中即表示该函数将其栈顶的值返回给了Lua。
在某些情况中，l_dir的这种实现可能会造成内存泄露。该函数调用的三个Lua函数均可能由于内存不足而失败。这三个函数中的任意一个执行失败都会引发错误，并中断函数l_dir的执行，进而也就无法调用closedir了。

延续

通过lua_pcall和lua_call，一个被Lua调用的C函数也可以回调Lua函数。标准库中有一些函数就是这么做的：table.sort调用了排序函数，string.gsub调用了替换函数，pcall和xpcall以保护模式来调用函数。如果你还记得Lua代码本身就是被C代码调用的，那么你应该知道调用顺序类似于：C调用Lua，Lua又调用了C，C又调用了Lua。
通常，Lua语言可以处理这种调用顺序；毕竟，与C语言的集成是Lua的一大特点。但是，有一种情况下，这种相互调用会有问题，那就是协程。
Lua语言中的每个协程都有自己的栈，其中保存了该协程所挂起调用的信息。具体地说，就是该栈中存储了每一个调用的返回地址、参数及局部变量。对于Lua函数的调用，解释器只需要这个栈即可，我们将其成为软栈。然而，对于C函数的调用，解释器必须使用C语言栈。毕竟，C函数的返回地址是局部变量都位于C语言栈中。
对于解释器来说，拥有多个软栈并不难；然而，ISO C的运行时环境却只能拥有一个内部栈。因此，Lua中的协程不能挂起C函数的执行：如果一个C函数位于从resume到对应yield的调用路径中，那么Lua无法保存C函数的状态以便在下次resume时恢复状态。请考虑如下的示例：

1
2
3
4
5
6

co = coroutine.wrap(function()
	print(pcall(coroutine.yield))
end)
co()

-- false attempt to yield across metamethod/C-call boundary

1
2
3
4
5
6
7
8

static int luaB_pcall(lua_State *L){
	int status;
	luaL_checkany(L,1);
	status = lua_pcall(L,lua_gettop(L) - 1, LUA_MULTRET,0);
	lua_pushboolean(L,(status == LUA_OK));
	lua_insert(L,1);
	return lua_gettop(L);
}

使用延续实现pcall

1 2 3 4 5 6 7 8 9 10 11 12 13

static int finishpcall (lua_State *L, int status, intptr_t ctx){ (void)ctx; status = (status != LUA_OK && status != LUA_YIELD); lua_pushboolean (L,(status == 0 )); lua_insert(L,1); return lua_gettop(L); } static int luaB_pcall(lua_State *L){ int status; luaL_checkany(L,1); status = lua_pcall(L,lua_gettop(L) - 1, LUA_MULTERT,0,0,finishpcall); return finsihpcall(L,status,0); }

与Lua5.1中的版本相比，上述实现有三个重要的不同点：首先，新版本用lua_pcallk替换了lua_pcall；其次，新版本在调用完lua_pcallk后把完成的状态传给了新的辅助函数finishpcall；第三，lua_pcallk返回的状态除了LUA_OK或者一个错误外，还可以是LUA_YIELD。
如果没有发生yield，那么lua_pcallk的行为与lua_pcall的行为完全一样。但是，如果发生yield，情况则大不相同。如果一个被原来lua_pcall调用的函数想要yield，那么Lua5.3会像Lua5.1版本一样引发错误。但当被新的lua_pcallk调用的函数yield时，则不会出现发生错误：Lua会做一个长跳转并且丢弃C语言栈中有关luaB_pcall的元素，但是会在协程软栈中保存传递给函数lua_pcallk的延续函数的引用。后来，当解释器发现应该返回到luaB_pcall时，它就会调用延续函数。
当发生错误时，延续函数finishpcall也可能会被调用。与原来的luaB_pcall不同，finishpcall不能获取lua_pcallk所返回的值。因此，finishpcall通过额外的参数status获取这个结果。当没有错误时，status是LUA_YIELD而不是LUA_OK，因此延续函数可以检查它是如何被调用的。当发生错误时，status还是原来的错误码。
除了调用的状态，延续函数还接收一个上下文。lua_pcallk的第5个参数是一个任意的整型数，这个参数被当做延续函数的最后一个参数来传递。这个值允许原来的函数直接向延续函数传递某些任意的信息。
Lua5.3的延续体系是一种为了支持yield而设计的精巧机制，但它也不是万能的。某些C函数可能会需要它们的延续传递相当多的上下文。例如，table.sort将C语言栈用于递归，而string.gsub则必须跟踪捕获，还要跟踪和一个用于存放部分结果的缓冲区。虽然这些函数能以”yieldbale”的方式重写，但与增加的复杂性和性能损失相比，这样做似乎并不值得。

C模块

Lua模块就是一个代码段，其中定义了一些Lua函数并将其存储在恰当的地方。为Lua编写的C语言模块可以模仿这种行为。除了C函数的定义外，C模块还必须定义一个特殊的函数，这个特殊的函数相当于Lua库中的主代码段，用于注册模块中所有的C函数，并将它们存储在恰当的地方。与Lua的主代码段一样，这个函数还应该初始化模块中所有需要初始化的其他东西。
Lua通过注册过程感知到C函数。一旦一个C函数用Lua表示和存储，Lua就会通过对其地址的直接引用来调用它。换句话说，一旦一个C函数完成注册，Lua调用它时就不再依赖于其函数名、包的位置以及可见性规则。通常，一个C模块中只有一个用于打开库的公共函数；其他所有的函数都是私有的，在C语言中被声明为static。
当我们使用C函数来扩展Lua程序时，将代码设计为一个C模块是个不错的想法。因为即使我们现在只想注册一个函数，但迟早总会需要其他的函数。通常，辅助库为这项工作提供了一个辅助函数。宏luaL_newlib接收一个由C函数及其对应函数名组成的数组，并将这些函数注册到一个新表中。举个例子，假设我们要用之前定义的函数l_dir创建一个库。首先，必须定义这库函数：

1
2
3

static int l_dir(lua_State *L){
	同前
}

1
2
3
4

static const struct luaL_Reg mylib[] = {
	{"dir",l_dir},
	{NULL,NULL}
};

1
2
3
4

int luaopen_mylib(lua_State *L){
	luaL_newlib(L,mylib);
	return 1;
}

1

local mylib = requrire "mylib"