programming in lua (9)

归档: lua程序设计 | 标签:

第 27 章,主要介绍 c 语言和 lua 交互的一些技巧。这一章涉及到第 2 部分的一些内容。

数组操作

在 lua 中,数组是一种特殊的 table,除了可以使用 lua_settable() 和 lua_gettable() 等操作 table 的函数外,另外也有一些专门用来操作数组的函数。使用这些有针对性的函数有两个好处:一是性能上的提升,例如我们经常在循环访问数组的所有元素;二是像整数数组,字符串等常见的类型使用一些有针对性的操作会比较方便。

lua 提供了两个函数来访问指定下标的数组元素:

void lua_rawgeti (lua_State *L, int index, int key);
void lua_rawseti (lua_State *L, int index, int key);

其中 index 是 table 在栈中的位置,key 是数组的下标。当 index 为正整数时,

lua_rawgeti(L, index, key);

和下面两个调用等价:

lua_pushnumber(L, key);
lua_rawget(L, index);

因为 lua_pushnumber() 会改变栈顶的位置,如果 index 为负数,那么在调用 lua_rawget() 的时候要注意使用 index-1 而不是 index。

当 index 为正整数时,下面的调用

lua_rawseti(L, index, key);

等价于:

lua_pushnumber(L, key);
lua_insert(L, -2); /* put 'key' below previous value */
lua_rawset(L, index);

下面的例子使用 lua_rawgeti() 遍历一个整型数组,再把数组的每个元素加 5,最后遍历修改后的数组:

int l_iterate(lua_State* l)
{
    int i, n;

    /* 1st arg must be a table */
    luaL_checktype(l, 1, LUA_TTABLE);

    n = lua_objlen(l, 1); /* get size of table */

    for (i = 0; i < n; ++i) {
        int value;

        lua_rawgeti(l, 1, i);
        value = lua_tonumber(l, -1);
        printf("%d -> %d\n", i, value);

        /* change value */
        lua_pushinteger(l, value + 5);
        lua_rawseti(l, 1, i);
    }

    for (i = 0; i < n; ++i) {
        int value;
        lua_rawgeti(l, 1, i);
        value = lua_tonumber(l, -1);
        printf("%d -> %d\n", i, value);
    }

    return 0; /* no result */
}

字符串操作

当 c 函数从 lua 中获取一个字符串变量时要注意两点:一是在访问完字符串后再把它弹出栈,二是不要修改栈里的字符串。

lua 标准 api 提供了两个常用的字符串操作:取子串和字符串连接。例如要把字符串中的某部分传递给 lua 可以使用函数

const char *lua_pushlstring (lua_State *L, const char *s, size_t len);

把从位置 s 起的 len 个字符传给 lua,返回的 const char* 指向 lua 内部的该子串的副本。

要把两个字符串拼接起来可以使用函数

void lua_concat (lua_State *L, int n);

把栈顶的 n 个字符串按照入栈顺序依次拼接起来。函数执行完后会把位于栈顶的 n 个字符串都弹出,然后把结果压入栈。如果 n 为 1 函数什么都不做,如果 n 为 0 则返回一个空串。另外还有一个类似于 sprintf() 的函数

const char *lua_pushfstring (lua_State *L, const char *fmt, ...);

函数把结果压入栈中并且返回指向结果字符串的指针。目前第二个参数 fmt 支持的格式只有“%%”,“%s”,“%d”,“%f”,“%c”,不支持宽度或精度控制。

当处理少量字符串时上面两个函数显得很方便,但是要处理大量字符串时,使用上面的函数一个接一个地处理效率很低,因为 lua 需要不断地申请和释放内存,还有在两块内存间复制中间结果的字符串。在 lua 辅助函数库里提供了一种两层的 buffer 机制:第一层类似于普通的 IO 缓冲区,即先把零散的字符串收集起来,填满缓冲区后一次性地把缓冲区传给下一层;第二层使用了 lua_concat() 和在 11.6 节介绍过的栈算法把字符串拼接起来。下面看看 lstrlib.c 中 string.upper() 的实现:

static int str_upper (lua_State *L) {
  size_t l;
  size_t i;
  luaL_Buffer b;
  const char *s = luaL_checklstr(L, 1, &l);
  luaL_buffinit(L, &b);
  for (i = 0; i < l; i++)
    luaL_addchar(&b, toupper((unsigned char)(s[i])));
  luaL_pushresult(&b);
  return 1;
}

函数先定义了一个 luaL_Buffer 类型 b,然后使用函数

void luaL_buffinit (lua_State *L, luaL_Buffer *B);

来初始化这个变量。在 luaL_Buffer 中保存了 L 的位置,所以在后续调用中不必把 L 作为参数。lua 提供了一系列的 luaL_add* 函数来向 luaL_Buffer 中添加数据:

void luaL_addchar    (luaL_Buffer *B, char c);
void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l);
void luaL_addstring  (luaL_Buffer *B, const char *s);

最后使用

void luaL_pushresult (luaL_Buffer *B);

清理 luaL_Buffer 并且把最终结果放入栈顶。使用这些函数我们不需担心内存的分配和释放,字符串是否越界等,并且也很高效。

在使用 luaL_Buffer 时要注意一个细节。当往 luaL_Buffer 中放东西时,一些中间变量可能会被保存在对应的 lua_State 的栈中,因此在使用过程中栈顶位置可能会变化。在使用 luaL_Buffer 的过程中(即往其中放了一些东西,但是还没最后执行 luaL_pushresult())也可以调用其它函数:

luaL_addchar(&b, 'c');
/* do something else */
luaL_addstring(&b, "ccc");

但是当需要再次使用 luaL_add* 函数往 luaL_Buffer 中添加内容时,必须把栈恢复到上一次调用 luaL_add* 的状态。但是有一种情况不能利用上面的函数实现:将 lua 函数返回的内容放到 luaL_Buffer 中。例如要把 lua 函数中返回的字符串放到 luaL_Buffer 中,在执行 luaL_addstring() 前你不能把这个字符串弹出栈,如果不把字符串弹出栈又不能对 luaL_Buffer 进行操作(因为返回的字符串在栈顶,已经改变了栈的状态)。当然这种情况可以先把字符串复制一份,然后把字符串弹出,再调用 luaL_addstring() 把字符串放到 luaL_Buffer 中,但是这样的做法太繁琐了。于是 lua 提供了另一个函数

void luaL_addvalue (luaL_Buffer *B);

用来把栈顶的字符串或数值放到 luaL_Buffer 中。

在 c 函数中保存 lua 状态

在 c 语言中有些变量会被很多函数使用,这些变量通常会被声明为全局变量。但是对于用于 lua 函数库中的数据类型来说使用 c 风格的全局变量却不是那么方便,一是因为 c 语言中找不到一个可以表示所有 lua 变量的通用类型,二是这样的变量不能用于多个 lua_State 中。

lua 中有 3 种方法保存非局部数据:全局变量,函数环境(function environments,参考第 14 章),非局部变量(non-local variables,就是闭包里的那种变量)。lua 提供的 c 函数库也提供了 3 种方法:registry(真麻烦,不知道该翻译成什么),环境(environments),和非局部变量(upvalues,和 non-local variables 是一个意思)。

registry 是一个只能在 c 环境中访问的全局 table,能被若干个模块共享。如果需要保存私有变量,应该使用 environments。像 lua 函数一样,每个 c 函数可以有自己的 environment table,但是在一个模块中的所有 c 函数一般都共享一个 environment table。另外每个 c 函数也可以有 upvalue,就像 lua 中的闭包一样(不过 5.2 中已经去掉了 environments)。

registry

registry 只能使用一个“伪索引”——LUA_REGISTRYINDEX,来访问其中的内容。伪索引就像栈索引一样,不过它所指向的内容并不在栈中。大部分的栈操作函数都能使用 LUA_REGISTRYINDEX,除了一些只在栈内部进行操作的函数如 lua_insert() 和 lua_remove() 等(个人理解为,数据的源和目的都默认为栈,即栈-栈,而不是从用户环境-栈或栈-用户环境,因为 LUA_REGISTRYINDEX 指向的内容实际并不存在栈里)。例如要从栈里获取关键字为“key”的内容:

lua_getfield(L, LUA_REGISTRYINDEX, "Key");

registry 也是一个普通的 table,因此可以使用任何值(除了 nil)作为索引。但是因为所有的 c 模块都使用同一个 registry,所以选择索引的时候要注意冲突,使用字符串是一个比较好的选择,并且可以选择一些不常用的前缀。另一个选择是一个 128 bit 的 uuid。

另外不能使用整数作为索引,因为这些整数是为引用系统(reference system)保留的。引用系统的作用是让用户往 registry 里添加数据的时候不需指定索引。例如

int r = luaL_ref(L, LUA_REGISTRYINDEX);

表示从栈里弹出栈顶的数据并把它放到 registry 中,引用系统为这个数据选择了一个索引并将其作为返回值,这个索引被称为引用(reference)。

因为在 c 环境中不能使用指针指向 lua 中的数据,我们可以使用引用来代替指针的功能。将引用指向的数据压入栈顶可以这样:

lua_rawgeti(L, LUA_REGISTRYINDEX, r);

要释放引用及其所关联的值使用函数

luaL_unref(L, LUA_REGISTRYINDEX, r);

nil 仍然被看作是一个特殊的值,如果为 nil 创建一个引用,lua_ref() 会返回一个 LUA_REFNIL 的常量;但是如果使用

lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_REFNIL);

则会向栈顶放入一个 nil 值。

还有一个常量 LUA_NOREF,表示无效的引用。任何想获取这个引用关联的值都会返回 nil,释放这个引用相当于什么都不做。

在 c 环境中可以使用变量的内存地址作为 registry 的索引(在第 28 章中有详细讲解)。

environments

这部分不看了,因为 5.2 中 c 函数不再有 environments。

upvalues

在 c 环境中也可以创建类似 lua 中的闭包:

#include <stdio.h>

#include <lua.h>
#include <lauxlib.h>
#include <lualib.h>

static int anon_ret_func(lua_State* l)
{
    int val = lua_tointeger(l, lua_upvalueindex(1));
    lua_pushinteger(l, ++val); /* new value */
    lua_pushvalue(l, -1); /* duplicate it */
    lua_replace(l, lua_upvalueindex(1)); /* update upvalue */
    return 1; /* return new value */
}

static int l_counter(lua_State* l)
{
    lua_pushinteger(l, 5);
    lua_pushcclosure(l, anon_ret_func, 1);
    return 1;
}

int main(void)
{
    lua_State* l;

    l = luaL_newstate();
    luaL_openlibs(l);

    lua_pushcfunction(l, l_counter);
    lua_setglobal(l, "counter");

    if (luaL_loadfile(l, "./closure.lua") != 0) {
        fprintf(stderr, "luaL_loadfile err: %s.\n", lua_tostring(l, -1));
        goto end;
    }

    if (lua_pcall(l, 0, 0, 0) != 0)
        fprintf(stderr, "lua_pcall err: %s.\n", lua_tostring(l, -1));

end:
    lua_close(l);
    return 0;
}

下面是上面 c 程序所使用的 lua 脚本:

f = counter()
print(f())
print(f())
print(f())

print ("------------------------------")

g = counter()
print(g())
print(g())

上面的 c 程序所定义的闭包函数 l_counter() 相当于下面的 lua 闭包函数 counter():

function counter ()
    local i = 5
    return function ()
        i = i + 1
        return i
    end
end

anon_ret_func() 就是上面返回的匿名函数。c 环境中的 upvalue 只能通过一个“伪索引”来访问,这个“伪索引”可以通过宏 lua_upvalueindex() 来获得,其中宏的参数是 upvalue 入栈的顺序。如果所访问的 upvalue 不存在或者访问的位置超出栈内元素的个数,使用 lua_type() 会获得一个 LUA_TNONE 的类型。

anon_ret_func() 先取得 upvalue 的值,然后把修改后的 upvalue 替换掉原来的值,最后把新的 upvalue 值返回(对照对应的 lua 程序来理解会比较容易)。函数

void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n);

创建一个闭包,其中 n 表示 upvalue 的个数,这些 upvalue 需要预先压入栈中。完成后函数把所有的 upvalue 弹出栈,并且把匿名函数留在栈中(因为这个函数是返回值)。

发表于 2012年7月28日
本文目前尚无任何评论.

发表评论

XHTML: 您可以使用这些标签: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <s> <strike> <strong>