0

我正在使用 Lua 的 C API 来扩展 Lua。在我的模块中，我想使用 填充表luaL_ref，并使用 删除字段luaL_unref。我也希望能够遍历这个表，希望使用lua_next.

遍历表是一个问题，因为luaL_unref. 在 Lua 中，通过赋值来“删除”表字段是很常见的nil（因为未初始化的表字段评估为nil）。该next功能足够聪明，可以跳过nil。我本来希望luaL_unref分配nil给未引用的表字段，但它似乎分配了一个整数。这个整数的值似乎没有记录。

考虑以下代码：

/* tableDump prints a table: */
/* key: value, key: value, ... */

lua_newtable(L);

lua_pushboolean(L, 0);
int ref1 = luaL_ref(L, -2);

lua_pushinteger(L, 7);
int ref2 = luaL_ref(L, -2);

lua_pushstring(L, "test");
int ref3 = luaL_ref(L, -2);

tableDump(L, -1);

luaL_unref(L, -1, ref1);
tableDump(L, -1);

luaL_unref(L, -1, ref3);
tableDump(L, -1);

luaL_unref(L, -1, ref2);
    tableDump(L, -1);

printf("done.\n");

输出：

1:  false,  2:  7,  3:  `test',  
3:  `test',  2:  7,  0:  1,  
3:  1,  2:  7,  0:  3,  
3:  1,  2:  3,  0:  2,  
done.

这里发生了什么？我该如何解决这个问题？是否有一些技巧可以迭代引用并忽略未引用的？我必须停止使用luaL_refandluaL_unref吗？

编辑

首先，感谢您的回复！

也许我问错了问题。

请允许我说得更具体一点。我有一个需要管理许多订阅用户数据的客户端用户数据。订阅由客户端的 subscribe 方法创建。订阅由客户端的取消订阅方法删除。订阅用户数据基本上是一个实现细节，因此它们不会暴露在客户端 API 中。相反，客户端 API 使用订阅引用，因此使用luaL_ref来填充订阅表。

ref = client:sub(channel, func)
cleint:unsub(ref)

这就是问题所在。我希望客户端自动取消订阅 __gc 上的所有剩余订阅（否则用户将收到段错误）。所以看来我需要遍历订阅。我真的在这里滥用 API 吗？有一个更好的方法吗？

4

2 回答 2

3

luaL_ref和luaL_unref函数在 中定义lauxlib.c。他们通过跟踪一个免费的参考列表来工作，他们将其存储在他们正在操作的表中。这些函数都比较短，所以我将它们包括在这里。

LUALIB_API int luaL_ref (lua_State *L, int t) {
  int ref;
  t = abs_index(L, t);
  if (lua_isnil(L, -1)) {
    lua_pop(L, 1);  /* remove from stack */
    return LUA_REFNIL;  /* 'nil' has a unique fixed reference */
  }
  lua_rawgeti(L, t, FREELIST_REF);  /* get first free element */
  ref = (int)lua_tointeger(L, -1);  /* ref = t[FREELIST_REF] */
  lua_pop(L, 1);  /* remove it from stack */
  if (ref != 0) {  /* any free element? */
    lua_rawgeti(L, t, ref);  /* remove it from list */
    lua_rawseti(L, t, FREELIST_REF);  /* (t[FREELIST_REF] = t[ref]) */
  }
  else {  /* no free elements */
    ref = (int)lua_objlen(L, t);
    ref++;  /* create new reference */
  }
  lua_rawseti(L, t, ref);
  return ref;
}

LUALIB_API void luaL_unref (lua_State *L, int t, int ref) {
  if (ref >= 0) {
    t = abs_index(L, t);
    lua_rawgeti(L, t, FREELIST_REF);
    lua_rawseti(L, t, ref);  /* t[ref] = t[FREELIST_REF] */
    lua_pushinteger(L, ref);
    lua_rawseti(L, t, FREELIST_REF);  /* t[FREELIST_REF] = ref */
  }
}

这些函数非常聪明，因为它们不需要额外的存储空间（除了它们正在操作的表之外）。但是，有时不希望将自由引用列表与引用的值存储在同一个表中，例如当需要迭代引用的值时。

我已经写了luaX_ref并luaX_unref解决了这个问题。它们的工作方式几乎与 and 相同luaL_ref，luaL_unref只是它们将免费参考列表存储在单独的表中，l用于list。（对于我的项目，我将它们放在单独的源文件中，并根据需要包含它们。我不建议修改lauxlib.c。）

static int abs_index(lua_State * L, int i){
  return i > 0 || i <= LUA_REGISTRYINDEX ? i : lua_gettop(L) + i + 1;
}

LUALIB_API int luaX_ref(lua_State *L, int t, int l){
  int ref;
  t = abs_index(L, t);
  l = abs_index(L, l);
  if(lua_isnil(L, -1)){
    lua_pop(L, 1); /* remove from stack */
    return LUA_REFNIL; /* 'nil' has a unique fixed reference */
  }
  lua_rawgeti(L, l, FREELIST_REF); /* get first free element */
  ref = (int) lua_tointeger(L, -1); /* ref = l[FREELIST_REF] */
  lua_pop(L, 1); /* remove it from stack */
  if(ref != 0){ /* any free element? */
    lua_rawgeti(L, l, ref); /* remove it from list */
    lua_rawseti(L, l, FREELIST_REF); /* (l[FREELIST_REF] = l[ref]) */
  }else{ /* no free elements */
    ref = (int)lua_objlen(L, l);
    ref++; /* create new reference */
  }
  lua_pushboolean(L, 1);
  lua_rawseti(L, l, ref); /* l[ref] = true */
  lua_rawseti(L, t, ref); /* t[ref] = value */
  return ref;
}

LUALIB_API void luaX_unref(lua_State *L, int t, int l, int ref){
  if(ref >= 0){
    t = abs_index(L, t);
    l = abs_index(L, l);
    lua_rawgeti(L, l, FREELIST_REF);
    lua_rawseti(L, l, ref);  /* l[ref] = l[FREELIST_REF] */
    lua_pushinteger(L, ref);
    lua_rawseti(L, l, FREELIST_REF);  /* l[FREELIST_REF] = ref */
    lua_pushnil(L);
    lua_rawseti(L, t, ref); /* t[ref] = nil */
  }
}

现在看看用法：

lua_newtable(L); /* 1 */
lua_newtable(L); /* 2 */

lua_pushboolean(L, 0);
int ref1 = luaX_ref(L, 1, 2);

lua_pushinteger(L, 7);
int ref2 = luaX_ref(L, 1, 2);

lua_pushstring(L, "test");
int ref3 = luaX_ref(L, 1, 2);

tableDump(L, 1);
tableDump(L, 2);

luaX_unref(L, 1, 2, ref1);
tableDump(L, 1);
tableDump(L, 2);

luaX_unref(L, 1, 2, ref3);
tableDump(L, 1);
tableDump(L, 2);

luaX_unref(L, 1, 2, ref2);
tableDump(L, 1);
tableDump(L, 2);

printf("done.\n");

输出：

1:  false,  2:  7,  3:  `test',
1:  true,  2:  true,  3:  true,
2:  7,  3:  `test',
3:  true,  2:  true,  0:  1,
2:  7,
3:  1,  2:  true,  0:  3,

3:  1,  2:  3,  0:  2,
done.
于 2012-10-09T01:37:17.563 回答
2

为了“确保它返回的键的唯一性”，luaL_ref必须维护一个已使用和随后luaL_unref删除的键的列表。看起来这个列表从开始t[0]并一直持续到索引链导致 a nil。此列表与活动参考保存在同一个表中。

如果您想像 Nicol 所观察到的那样继续“滥用 API”，并且依赖于实现定义的行为，您可以按照这个链接列表查看在迭代表时键是否是已删除的引用。或者为了避免依赖于实现定义的行为并提高性能，您可以保留一个单独的已删除引用表并在迭代表时跳过它们，尽管您需要忽略t[0].

如果您确实需要迭代引用，则最好完全使用不同的机制。您可以简单地将所有引用/值对放在一个单独的表中，并将单独表中的值设置为nil删除引用时的值。然后你可以简单地迭代单独的表。

于 2012-10-07T19:41:08.080 回答