考虑使用已经有的dll，要写wrapper，使得在lua中能调用dll里的函数，嗯，参考《Programming in lua》，然后仿写luars232。
一、函数定义
先分析一个函数的写法，其它函数类似：
/*
* error, written_len = port:write(data [, timeout_ms])
*/
static int lua_port_write(lua_State *L)
{
int ret = 0;
int argc = 0;
unsigned int timeout = 0;
unsigned int wlen = 0;
size_t len = 0;
const char *data;
struct rs232_port_t *p = NULL;
p = *(struct rs232_port_t**) luaL_checkudata(L, 1, MODULE_NAMESPACE);
lua_remove(L, 1);
if (p == NULL || !rs232_port_open(p)) {
lua_pushinteger(L, RS232_ERR_PORT_CLOSED);
lua_pushinteger(L, 0);
return 2;
}
argc = lua_gettop(L);
switch (argc) {
case 1: {
data = luaL_checklstring(L, 1, &len);
ret = rs232_write(p, (unsigned char*) data, (unsigned int) len, &wlen);
break;
}
case 2:
data = luaL_checklstring(L, 1, &len);
timeout = (unsigned int) luaL_checknumber(L, 2);
ret = rs232_write_timeout(p, (unsigned char*) data, (unsigned int) len, &wlen, timeout);
break;
default:
lua_pushinteger(L, RS232_ERR_CONFIG);
lua_pushinteger(L, 0);
return 2;
}
lua_pushinteger(L, ret);
lua_pushinteger(L, wlen);
return 2;
}
1、传给函数的参数是lua_State *L。用PIL的说法，lua是使用一个virtual stack来和C之间交换数据的。这一stack里的每一个element都是lua中的一个value，比如number、string、nil这些。为了方便，我们是可以用index来取用这些element的。取用element时，正的index表示它的绝对位置（1开始），即直接使用正1，我们就可以取到最早压入的数；负的index表示它相对堆顶的偏移量（offset），注意，stack的top是我们最后压入stack的那个element。如果有n个element，那么，用-1取到的就是最后被压入stack的element，和使用n取到的是同一个element。另外需留意，这里是从index1开始，根据PIL的说法，lua每次调用一个C函数，都会给他分配一个新的堆，第一个压入的是函数名，然后是第一个参数，依次类推。。。
2、我们看到的是一个void *luaL_checkudata (lua_State *L, int narg, const char *tname)的调用，在PLI 28.2找到它的描述。它是和metable密切相关的函数，我们可以检查给定index位置的element是不是tname类型的。如果是，它会返回这个element的地址，所以这里的赋值是赋给指针的；如果不是，它会抛出一个错误（注，据说以前是返回NULL，具体不详）。关于这里的tname，后面会介绍到，这里只需要知道我们使用这个tname可以找到某个metatable，这个关联是在我们注册C函数到lua时产生的。
3、接下来是void lua_remove (lua_State *L, int index)调用，因为我们已经拿到了port句柄的地址，所以，我们可以把这一个element抛掉了。这个element为最早压入，所以用index=1.
4、下面有个判断，P==NULL或者是使用rs232_open来打开端口无效，则执行这里的操作，调用的是void lua_pushinteger (lua_State *L, lua_Integer n)。调用push来压一个integer到堆顶，是为了返回参数给lua。这个和后面的return不同，return是给lua解释器看的，而我们调用lua函数的返回值是从堆L中取的，或者说，压进去的element就是我们在lua中看得到的返回值。
5、接下来的int lua_gettop (lua_State *L)，是查看L中还有几个element。如果是有0个，那么这个stack为empety。这里为了检查调用这个函数时传过来几个参数。
6、这里的switch根据剩余几个element来做出选择，事实上，这里就是我们要在lua中传给这个函数几个参数。从下面的判断来看，可以是1个或2个。如果是1个参数，这个参数就是data；如果是2个参数，第一个是data，第二个是timeout。这里调用const char *luaL_checkstring (lua_State *L, int narg)，取出L中第几个element（第几个被压入stack，lua中调用函数时参数的顺序），取之前要先判断这个element是不是一个string，并以string的形式把这个element拿出来。
7、另外，留意到，这个函数里都是renturn 2。不知道为什么，翻PIL再找答案。
二、声明各函数的注册关系
这里主要是从下面的struct luaL_reg 型变量声明开始的：
static luaL_reg port_methods[] = {
{ "__tostring", lua_port_tostring },
{ "__gc", lua_port_close },
{ "read", lua_port_read },
{ "write", lua_port_write },
{ "close", lua_port_close },
{ "flush", lua_port_flush },
{ "device", lua_port_device },
{ "fd", lua_port_fd },
/* baud */
{ "baud_rate", lua_port_get_baud },
{ "baud_rate_tostring", lua_port_get_strbaud },
{ "set_baud_rate", lua_port_set_baud },
/* data */
{ "data_bits", lua_port_get_data },
{ "data_bits_tostring", lua_port_get_strdata },
{ "set_data_bits", lua_port_set_data },
/* stop */
{ "stop_bits", lua_port_get_stop },
{ "stop_bits_tostring", lua_port_get_strstop },
{ "set_stop_bits", lua_port_set_stop },
/* parity */
{ "parity", lua_port_get_parity },
{ "parity_tostring", lua_port_get_strparity },
{ "set_parity", lua_port_set_parity },
/* flow */
{ "flow_control", lua_port_get_flow },
{ "flow_control_tostring", lua_port_get_strflow },
{ "set_flow_control", lua_port_set_flow },
/* dtr */
{ "dtr", lua_port_get_dtr },
{ "dtr_tostring", lua_port_get_strdtr },
{ "set_dtr", lua_port_set_dtr },
/* rts */
{ "rts", lua_port_get_rts },
{ "rts_tostring", lua_port_get_strrts },
{ "set_rts", lua_port_set_rts },
{ NULL, NULL }
};
PIL里面提到，已经有定义一个变量类型如下：
typedef struct luaL_Reg {
const char *name;
lua_CFunction func;
} luaL_Reg;
所以，这里是定义了一个luaL_reg类型的数组，该数组的内容有巴拉巴拉个函数以及他们对应的在lua中的函数名，这些函数就是我们前面定义的如lua_port_write()之类的。应该叫注册关系还是什么？
还提到，其实，这个数组是给下面这个函数用的：
void luaL_register (lua_State *L,
const char *libname,
const luaL_Reg *l);
这个函数的执行是分情况的，这里只是简单翻译文档，我也没明白：
1、这个函数打开了一个library。
2、如果libname是NULL，那么，这个函数就按照数组l中的对应关系，把所有函数注册到堆L顶部的table中。
3、如果libname不为NULL，那么，这个函数就会先创建一个以libname那么为变量名的table，这个table会是一个全局变量，并且把这个table当做是package.loaded[libname]的值，然后，他会按照数组l中的对应关系，把所有函数注册到堆L顶部的table中。
4、如果libname变量本身就是一个table，或者package.loaded[libname]中有一个table，那么它会复用这个table，而不是重新创建一个。
这里还有定义另一个数组，也是给后面用的：
static luaL_reg port_functions[] = {
{ "open", lua_port_open },
{ "error_tostring", lua_port_strerror },
{ NULL, NULL }
};
不过，理解luaL_register的动作的话，还得靠分析后面的代码。
三、注册到lua
下面这句是创建一个metatable：
static void create_metatables(lua_State *L, const char *name, const luaL_reg *methods)
{
luaL_newmetatable(L, name);
lua_pushvalue(L, -1);
lua_setfield(L, -2, "__index");
luaL_register(L, NULL, methods);
}
1、调用int luaL_newmetatable (lua_State *L, const char *tname)，PIL讲，如果在L的注册关系中已经有了一个以tname为名的key，那么直接return 0；否则的话，创建一个表作为userdata的metatable，把它添加到注册关系中，然后返回1。不管怎么样，它都会把最后那个以tname为key的注册项的内容push到L顶上。
2、调用void lua_pushvalue (lua_State *L, int index)，这个调用是copy了指定index处element的value到堆顶。所以，这里是做了一个刚才我们创建的metatable的copy。
3、调用void lua_setfield (lua_State *L, int index, const char *k)，手册说这个函数是执行了类似于t[k]=value的操作，这里的table t是位置index处的table，v就是在堆顶的那个element的value。而且lua_setfield会先把堆顶的element给pop出来。那么，在这里，它做的事就是给我们刚创建的metatable添加了一个member，member的key是“__index”,value是它自己的地址？
4、这个呢，就是我们前面遇到过的luaL_register了，因为libname的位置为NULL，而且我们的堆顶位置现在是一个table，即刚创建的metatable，所以，这句在这里就是按照methods对应的注册关系，把所有函数注册到metatable。
然后完了是定义了一个函数，内容如下：
RS232_LIB int luaopen_luars232(lua_State *L);
RS232_LIB int luaopen_luars232(lua_State *L)
{
int i;
create_metatables(L, MODULE_NAMESPACE, port_methods);
luaL_register(L, MODULE_NAMESPACE, port_functions);
for (i = 0; luars232_ulong_consts[i].name != NULL; i++) {
lua_pushstring(L, luars232_ulong_consts[i].name);
lua_pushnumber(L, luars232_ulong_consts[i].value);
lua_settable(L, -3);
}
lua_pushstring(L, MODULE_VERSION);
lua_setfield(L, -2, "_VERSION");
lua_pushstring(L, MODULE_BUILD);
lua_setfield(L, -2, "_BUILD");
lua_pushstring(L, MODULE_TIMESTAMP);
lua_setfield(L, -2, "_TIMESTAMP");
lua_pushstring(L, MODULE_COPYRIGHT);
lua_setfield(L, -2, "_COPYRIGHT");
DBG("[*] luaopen_luars232(Version: ‘%s‘ Build: ‘%s‘ TimeStamp: ‘%s‘)\n",
MODULE_VERSION, MODULE_BUILD, MODULE_TIMESTAMP);
return 0;
}
这个函数是唯一一个需要外部访问的函数，RS232_LIB事实上是一个宏定义，需要给生成dll的编译器用的：
#define RS232_LIB __declspec(dllexport)
那来看看这个函数做了些什么：
1、create_metatables，也就是我们上面分析的那个函数做的事情。MODULE_NAMESPACE的定义是"luars232"，即在表luars232中创建了一个metatable，然后按照port_methods中对应关系，把那些函数注册到metatable中。
2、然后，直接按照port_functions的对应关系，把两个函数注册到表“luars232”中，这两个函数是不依赖于port存在的，而上面metatable中定义的是和port相关的操作。
3、接下来是lua_pushstring、lua_pushnumber和void lua_settable (lua_State *L, int index)。前两个好理解，往堆里压入一个string和一个number。lua_settable的话，手册里说，它会执行t[k]=v的操作，t是index指向的element，v是堆上index为-1的element，k是index为-2的element；执行这个调用的话，会把k和v都先从堆上pop出来，也就是执行完这个调用，原来index=-3的element成为了堆顶。在这里，index=-3的element是那边的metatable。
这句留着自己看的：比如，RS232_BAUND_300，我们在lua中使用这个变量的时候，我们传给dll的是"RS232_BAUD_300"这个字符串，然后dll会去处理好这个字符串。
=======================get in===================
看书看到这里，做了个很头疼的决定，11点了，是去睡觉还是继续看？因为明天就是周末了，所以我决定继续把它看完。嗯！
因为lua_setfiled涉及另一个问题，所以在这里展开下。这里的field是什么？其实就是指某个table的一个register项，我们前面定义过的luaL_reg型数组里的一项。
还是理解不能，所以了解了另一个用得比较多的调用void lua_getfield (lua_State *L, int index, const char *k)。一个例子是，lua_getfield(L, LUA_GLOBALSINDEX, "f")，它需要在LUA_GLOBALSINDEX定位的table中，找到名为f的注册项，然后把f放在堆的顶部；这句可以用来找注册到全局变量里的某个function。这个怎么理解？比如我们在lua中调用了某个函数 ：
a = f("how", t.x, 14)
这一句调用实际上等于下面的C语言过程：
lua_getfield(L, LUA_GLOBALSINDEX, "f"); /* function to be called */
lua_pushstring(L, "how"); /* 1st argument */
lua_getfield(L, LUA_GLOBALSINDEX, "t"); /* table to be indexed */
lua_getfield(L, -1, "x"); /* push result of t.x (2nd arg) */
lua_remove(L, -2); /* remove ‘t‘ from the stack */
lua_pushinteger(L, 14); /* 3rd argument */
lua_call(L, 3, 1); /* call ‘f‘ with 3 arguments and 1 result */
lua_setfield(L, LUA_GLOBALSINDEX, "a"); /* set global ‘a‘ */
这里的第一句是调用lua_getfield在全局变量里找到f，然后把function f的地址放到堆顶，接着把第一个参数也就是string “how”压到堆顶，继续再调用lua_getfield找到table t并放到堆顶，再用lua_getfield从table t中找到name是x的注册项并把它的value放到堆顶，取出t.x之后应该是把刚拿出来的table t给移走，接着再压入下一个参数“14”。自此，函数，以及参数都被压进了stack，然后调用lua_call(L, 3, 1)来执行函数。嗯，我们的重点在最后一句，lua_setfield，new一个变量a出来，把堆顶的element给push出来并把它的value给a，然后再把变量a注册到LUA_GLOBALSINDEX去。
====================get out==================================