LUA的堆栈问题

学习LUA也有一些时日了，个人认为对于LUA中的栈的理解很重要，嗯，写个小文章（真的很小）

如果你看了LUA的文档，那么就应该很清楚LUA与C交互数据时都是用到LUA中所谓的stack。那么当我调用lua_open函数之后栈是什么样的呢？空的（luaopen_base等会往栈上加进一些东西）。那么至于如何操作栈上的数据，我想官方文档上已经说得很清楚了，不过最初我对于栈的顺序有一些迷糊，所以就说说这个。现在假如我有如下的一段代码：

lua_State* L = lua_open();

lua_pushnumber( L, 211 );

lua_pushnumber( L, 2222 );

lua_newtable( L );

lua_close( L );

那么当执行完lua_newtable之后栈上有三个元素，大致就是这样：

211

222

table

现在211是第一个元素，index为1，不过LUA也可以用负数来表示，那么现在他是多少？

index -index value

1 -3 211

2 -2 222

3 -1 table

嗯，很简单，再看看如果我们要设置一个TABLE的值怎么做？文档中说用lua_settable或是lua_rawset（这两者有什么区别应该和这里说的无关），它们参数意义、以及准备工作都一样，-1是值，-2是键值

lua_settable( lua_state*, int )

第一个参数是要操作的脚本环境，第二个则是要操作的表在栈上的位置

一般的写法可能是这样

// 代码A

lua_getglobal( L, "myTable" ); // 获取要设置值的table

lua_pushstring( L, "hp" ); // "hp"在栈上的位置为-1

lua_pushnumber( L, 211 ); // "hp"在栈上的位置变为-2，而211则是-1

lua_settable( L, -3 ); // 值被正确的设置到全局变量（表）的myTable中

如果我是想把hp这个值设置到全局表中呢？一般通过调用lua_setglobal宏

lua_pushnumber( L, 211 );

lua_setglobal( L, "hp" );

就这么简单，不过我们来看看lua_setglobal这个宏

#define lua_setglobal(L,s) \

(lua_pushstring(L, s), lua_insert(L, -2), lua_settable(L, LUA_GLOBALSINDEX))

这么看来实际上我们上面的代码被替换成了

lua_pushnumber( L, 211 );

lua_pushstring( L, "hp" );

lua_insert( L, -2 ); // 这一步看上去或许比较诡异，实际上[来源：GameRes.com]是把-1的值放到lua_insert的第二个参数所指的位置，然后这个位置后面的参数往上移

//这里实际上最终结果就是-1和-2对调，但从逻辑上并不是对调

lua_settable( L, LUA_GLOBALSINDEX ); // 这里为什么不用lua_rawset？我认为是有原因的^@^

将上面的代码与代码A结合起来看，在lua_settable时index值不同，而它做的工作是如果发现index是LUA_GLOBALSINDEX 那么就取出全局表（还有一个LUA_REGISTERINDEX，类似），否则从stack上取元素，当然，这个栈位置取出的不是一个table就会失败。所以代码A中指定的是-3是刚从全局表中取出的myTable表（这里假设他是一个table），上面的代码片段则是取出的全局表。所以lua_settable的index是什么值都可以，只要它指向的是一个table

实际上lua中与c的接口也就主要在栈的操作上，基本上你在写一个lua与C结合的程序时你最最需要做的工作就是明白你当前栈上有什么元素以及它们的位置。我一般会在纸上画出他们的位置，如果你熟了，对于几句在一起有关联的lua调用则可以很快的看出栈的变化。比如

lua_gettable/lua_rawget

lua_pushstring( L, "hp" );

lua_gettable( L, LUA_GLOBALSINDEX );

只看第一句，栈顶是一个字符串，但两句放在一起，最终栈顶是一个全局表上一个名为hp的实际值

lua_pushstring( L, "hp" );

lua_pushnumber( L, 211 );

lua_settable( L, LUA_GLOBALSINDEX );

无论第二句pushnumber还是pushvalue,pushstring什么的，最终这三句执行之后对于栈来说是没有任何变化的，因为lua_settable/lua_rawset会移走-1和-2

总之，对于栈的变化，在看一个函数的文档时先看它参数又需要栈上那些位置的元素并正确设置栈上的值，看清楚他会取栈上那些位置的元素作为这个lua api调用的使用并为之把正确的值放到栈上，最后注意函数完成之后会清除/移走那些位置的元素，我想应该就没什么问题了

///-----------------

近来研究Lua这个东西，官网为http://www.lua.org/

主要的目的是通过lua来对短信发送过来的业务报文转换为业务系统支持的格式，设计的思想是Lua进行业务报文的转换，报文的通讯采用c实现，因为要通过C实现SGIP协议报文的封装和到后台业务的转换。

C调用Lua函数

1. 首先要进行Lua的初始化，这个主要是lua_open和luaL_openlibs函数
2. 然后是解析并编译lua的代码，这个主要是luaL_dofile函数
3. 解析好之后使用lua_getglobal指明要调用的lua函数
4. 如果有lua函数的参数，通过使用lua_pushstring函数传递参数
5. 最后调用lua_pcall进行lua函数的调用
6. 调用完成之后采用lua_tonumber类函数可以获取到函数的返回结果

Lua调用C函数

1. 在Lua中调用C的函数，该函数必须进行注册，这个通过lua_register这个函数来完成
2. 在Lua中调用注册的函数，会调用上面注册的函数（类似于回调），所有的处理在这个函数里面
3. 这个函数里面可以使用lua_tostring类函数来获取函数的参数
4. 如果有返回值，通过lua_pushnumber这个函数来返回。

参考的代码

下面的这个代码是用来将联通的短信进行报文的转换，同时对Lua注册了一个SendSms函数用来可以在Lua中发送短信。

#include <lua.h>

#include <lauxlib.h>

#include <lualib.h>

#define cutil_log_error printf

#define cutil_log_debug printf

/**

* LuaSendSms

* 当Lua里面调用SendSms函数时候会触发该函数

*/

static int LuaSendSms(lua_State *L)

{

char *pszPhone = "";

char *pszMessage = "";

// 读取并判读参数

if(lua_gettop(L) != 2)

{

lua_pushstring(L, "Incorrect argument number!");

lua_error(L);

}

if(!lua_isnumber(L, 1) || !lua_isstring(L, 2))

{

lua_pushstring(L, "Incorrect argument!");

lua_error(L);

}

pszPhone = lua_tostring(L, 1);

pszMessage = lua_tostring(L, 2);

// 发送消息 TODO

cutil_log_debug("Send Message %s to %s.\n", pszMessage, pszPhone);

// 返回结果

lua_pushnumber(L, 0);

// 只有一个返回结果

return 1;

}

/**

* LuaProcessSms

* 调用Lua里面的LuaMain函数进行消息的处理

*/

static int LuaProcessSms(lua_State *L, char *pszPhone, char *pszMessage)

{

int nRet;

char *pszRetInfo;

cutil_log_debug("process phone %s message %s\n", pszPhone, pszMessage);

// 调用函数和参数

lua_getglobal(L, "LuaMain");

lua_pushstring(L, pszPhone);

lua_pushstring(L, pszMessage);

if(nRet = lua_pcall(L, 2, 2, 0))

{

cutil_log_error("lua_pcall error ret %d error '%s'. phone %s message %s\n",

nRet, lua_tostring(L, -1), pszPhone, pszMessage);

lua_settop(L, 0);

return -1;

}

// 判读返回参数合法性

if(lua_gettop(L) != 2)

{

cutil_log_error("Incorrect return number. %d phone %s message %s\n",

lua_gettop(L), pszPhone, pszMessage);

lua_settop(L, 0);

return -1;

}

if(!lua_isnumber(L, 1) || !lua_isstring(L, 2))

{

cutil_log_error("Incorrect return. arg1 %s arg2 %s phone %s message %s\n",

lua_tostring(L, 1), lua_tostring(L, 2),

pszPhone, pszMessage);

lua_settop(L, 0);

return -1;

}

// 获取并处理返回信息 TODO

nRet = lua_tonumber(L, 1);

pszRetInfo = strdup(lua_tostring(L, 2));

lua_settop(L, 0);

cutil_log_debug("Ret %d Info %s\n", nRet, pszRetInfo);

if(nRet != 0)

{

cutil_log_error("process info error phone %s message %s ret %d info %s\n",

pszPhone, pszMessage, nRet, pszRetInfo);

free(pszRetInfo);

return -1;

}

free(pszRetInfo);

return 0;

}

/**

* LuaInit

* 初始化Lua库，并注册一个SendSms函数

*/

static lua_State *LuaInit()

{

lua_State *L = lua_open();

if(L == NULL)

{

cutil_log_error("Init the lua library error\n");

return NULL;

}

luaL_openlibs(L);

/* register our function */

lua_register(L, "SendSms", LuaSendSms);

return L;

}

int main()

{

int i;

lua_State *L;

L = LuaInit();

if (luaL_dofile(L, "sms.lua"))

error(L, "cannot run configuration file: %s",

lua_tostring(L, -1));

for(i = 0; i < 1; i ++)

LuaProcessSms(L, "13988227711", "测试消息");

lua_close(L);

}

下面是参考的Lua程序

-- 函数名称必须为LuaMain

-- 函数里面可以调用SendSms进行消息发送，第一个参数是手机号码，第二个参数是内容

-- 函数的参数有两个phone是手机号码 message是接收到的短信内容

-- 返回参数有两个 第一个是返回值0表示成功，其他失败，第二个是要求发送的内容

function LuaMain(phone, message)

print("phone ", phone, "message", message)

SendSms('13988221133', '你好')

return 0,'KZCZ函数的参数有两个phone是手机号码 message是接收到的短信内容'

end

-- 这个里面可以有全局的代码，不过建议不要编写

-- 全局的代码会在LuaMain函数之前运行

-------------

lua与C交互中堆栈 (1)

发布时间：2010.07.13 15:30 来源：赛迪网 作者：萧萧

【赛迪网讯】1. 堆栈

当在Lua和C之间交换数据时我们面临着两个问题：动态与静态类型系统的不匹配和自动与手动内存管理的不一致。

在Lua中，我们写下a[k]=v时，k和v可以有几种不同的类型（由于metatables的存在，a也可能有不同的类型）。如果我们想在C中提供类似的操作，无论怎样，操作表的函数(settable)必定有一个固定的类型。我们将需要几十个不同的函数来完成这一个的操作（三个参数的类型的每一种组合都需要一个函数）。

我们可以在C中声明一些union类型来解决这个问题，我们称之为lua_Value，它能够描述所有类型的Lua值。然后，我们就可以这样声明settable

void lua_settable (lua_Value a, lua_Value k, lua_Value v);

这个解决方案有两个缺点。第一，要将如此复杂的类型映射到其它语言可能很困难；Lua不仅被设计为与C/C++易于交互，Java,Fortran以及类似的语言也一样。第二，Lua负责垃圾回收：如果我们将Lua值保存在C变量中，Lua引擎没有办法了解这种用法；它可能错误地认为某个值为垃圾并收集他。

因此，Lua API没有定义任何类似lua_Value的类型。替代的方案，它用一个抽象的栈在Lua与C之间交换值。栈中的每一条记录都可以保存任何Lua值。无论你何时想要从Lua请求一个值（比如一个全局变量的值），调用Lua，被请求的值将会被压入栈。无论你何时想要传递一个值给Lua，首先将这个值压入栈，然后调用Lua（这个值将被弹出）。我们仍然需要一个不同的函数将每种C类型压入栈和一个不同函数从栈上取值（译注：只是取出不是弹出），但是我们避免了组合式的爆炸（combinatorial explosion）。另外，因为栈是由Lua来管理的，垃圾回收器知道那个值正在被C使用。几乎所有的API函数都用到了栈。正如我们在第一个例子中所看到的，luaL_loadbuffer把它的结果留在了栈上（被编译的chunk或一条错误信息）；lua_pcall从栈上获取要被调用的函数并把任何临时的错误信息放在这里。

Lua以一个严格的LIFO规则（后进先出；也就是说，始终存取栈顶）来操作栈。当你调用Lua时，它只会改变栈顶部分。你的Ｃ代码却有更多的自由；更明确的来讲，你可以查询栈上的任何元素，甚至是在任何一个位置插入和删除元素。

1.1 压入元素

API有一系列压栈的函数，它将每种可以用C来描述的Lua类型压栈：空值（nil）用lua_pushnil，数值型（double）用lua_pushnumber，布尔型（在C中用整数表示）用lua_pushboolean，任意的字符串（char*类型，允许包含”字符）用lua_pushlstring，C语言风格（以”结束）的字符串（const char*）用lua_pushstring：

void lua_pushnil (lua_State *L);
    void lua_pushboolean (lua_State *L, int bool);
    void lua_pushnumber (lua_State *L, double n);
    void lua_pushlstring (lua_State *L, const char *s, size_t length);
    void lua_pushstring (lua_State *L, const char *s);

同样也有将C函数和userdata值压入栈的函数，稍后会讨论到它们。

Lua中的字符串不是以零为结束符的；它们依赖于一个明确的长度，因此可以包含任意的二进制数据。将字符串压入串的正式函数是lua_pushlstring，它要求一个明确的长度作为参数。对于以零结束的字符串，你可以用lua_pushstring（它用strlen来计算字符串长度）。Lua从来不保持一个指向外部字符串（或任何其它对象，除了C函数——它总是静态指针）的指针。对于它保持的所有字符串，Lua要么做一份内部的拷贝要么重新利用已经存在的字符串。因此，一旦这些函数返回之后你可以自由的修改或是释放你的缓冲区。

无论你何时压入一个元素到栈上，你有责任确保在栈上有空间来做这件事情。记住，你现在是C程序员；Lua不会宠着你。当Lua在起始以及在Lua调用C的时候，栈上至少有20个空闲的记录（lua.h中的LUA_MINSTACK宏定义了这个常量）。对于多数普通的用法栈是足够的，所以通常我们不必去考虑它。无论如何，有些任务或许需要更多的栈空间（如，调用一个不定参数数目的函数）。在这种情况下，或许你需要调用下面这个函数：

int lua_checkstack (lua_State *L, int sz);它检测栈上是否有足够你需要的空间（稍后会有关于它更多的信息）。

1.2 查询元素

API用索引来访问栈中的元素。在栈中的第一个元素（也就是第一个被压入栈的）有索引1，下一个有索引2，以此类推。我们也可以用栈顶作为参照来存取元素，利用负索引。在这种情况下，-1指出栈顶元素（也就是最后被压入的），-2指出它的前一个元素，以此类推。例如，调用lua_tostring(L, -1)以字符串的形式返回栈顶的值。我们下面将看到，在某些场合使用正索引访问栈比较方便，另外一些情况下，使用负索引访问栈更方便。

API提供了一套lua_is*函数来检查一个元素是否是一个指定的类型，*可以是任何Lua类型。因此有lua_isnumber,lua_isstring,lua_istable以及类似的函数。所有这些函数都有同样的原型：int lua_is… (lua_State *L, int index);

lua_isnumber和lua_isstring函数不检查这个值是否是指定的类型，而是看它是否能被转换成指定的那种类型。例如，任何数字类型都满足lua_isstring。

还有一个lua_type函数，它返回栈中元素的类型。（lua_is*中的有些函数实际上是用了这个函数定义的宏）在lua.h头文件中，每种类型都被定义为一个常量：LUA_TNIL、LUA_TBOOLEAN、LUA_TNUMBER、LUA_TSTRING、LUA_TTABLE、LUA_TFUNCTION、LUA_TUSERDATA以及LUA_TTHREAD。这个函数主要被用在与一个switch语句联合使用。当我们需要真正的检查字符串和数字类型时它也是有用的

为了从栈中获得值，这里有lua_to*函数：
    int lua_toboolean (lua_State *L, int index);
    double lua_tonumber (lua_State *L, int index);
    const char * lua_tostring (lua_State *L, int index);
    size_t lua_strlen (lua_State *L, int index);

即使给定的元素的类型不正确，调用上面这些函数也没有什么问题。在这种情况下，lua_toboolean、lua_tonumber和lua_strlen返回0，其他函数返回NULL。由于ANSI C没有提供有效的可以用来判断错误发生数字值，所以返回的0是没有什么用处的。对于其他函数而言，我们一般不需要使用对应的lua_is*函数：我们只需要调用lua_is*，测试返回结果是否为NULL即可。

Lua_tostring函数返回一个指向字符串的内部拷贝的指针。你不能修改它（使你想起那里有一个const）。只要这个指针对应的值还在栈内，Lua会保证这个指针一直有效。当一个C函数返回后，Lua会清理他的栈，所以，有一个原则：永远不要将指向Lua字符串的指针保存到访问他们的外部函数中。

Lua_string返回的字符串结尾总会有一个字符结束标志0，但是字符串中间也可能包含0，lua_strlen返回字符串的实际长度。特殊情况下，假定栈顶的值是一个字符串，下面的断言(assert)总是有效的：

const char *s = lua_tostring(L, -1);
    size_t l = lua_strlen(L, -1);
    assert(s[l] == ”);
    assert(strlen(s) <= l);

1.3 其他堆栈操作

除开上面所提及的C与堆栈交换值的函数外，API也提供了下列函数来完成通常的堆栈维护工作：

int lua_gettop (lua_State *L);
    void lua_settop (lua_State *L, int index);
    void lua_pushvalue (lua_State *L, int index);
    void lua_remove (lua_State *L, int index);
    void lua_insert (lua_State *L, int index);
    void lua_replace (lua_State *L, int index);

函数lua_gettop返回堆栈中的元素个数，它也是栈顶元素的索引。注意一个负数索引-x对应于正数索引gettop-x+1。lua_settop设置栈顶（也就是堆栈中的元素个数）为一个指定的值。如果开始的栈顶高于新的栈顶，顶部的值被丢弃。否则，为了得到指定的大小这个函数压入相应个数的空值（nil）到栈上。特别的，lua_settop(L,0)清空堆栈。你也可以用负数索引作为调用lua_settop的参数；那将会设置栈顶到指定的索引。利用这种技巧，API提供了下面这个宏，它从堆栈中弹出n个元素：#define lua_pop(L,n) lua_settop(L, -(n)-1)

函数lua_pushvalue压入堆栈上指定索引的一个抟贝到栈顶；lua_remove移除指定索引位置的元素，并将其上面所有的元素下移来填补这个位置的空白；lua_insert移动栈顶元素到指定索引的位置，并将这个索引位置上面的元素全部上移至栈顶被移动留下的空隔；最后，lua_replace从栈顶弹出元素值并将其设置到指定索引位置，没有任何移动操作。注意到下面的操作对堆栈没有任何影响： lua_settop(L, -1); lua_insert(L, -1);

为了说明这些函数的用法，这里有一个有用的帮助函数，它dump整个堆栈的内容：

static void stackDump (lua_State *L) {
        int i;
        int top = lua_gettop(L);
        for (i = 1; i <= top; i++) {
        int t = lua_type(L, i);
        switch (t) {

        case LUA_TSTRING:
            printf(”`%s’”, lua_tostring(L, i));
            break;

        case LUA_TBOOLEAN:
            printf(lua_toboolean(L, i) ? “true” : “false”);
            break;

        case LUA_TNUMBER:
            printf(”%g”, lua_tonumber(L, i));
            break;

        default:
            printf(”%s”, lua_typename(L, t));
            break;

        }
        printf(” “);
    }
    printf(”\n”);
}

这个函数从栈底到栈顶遍历了整个堆栈，依照每个元素自己的类型打印出其值。它用引号输出字符串；以%g的格式输出数字；对于其它值（table，函数，等等）它仅仅输出它们的类型（lua_typename转换一个类型码到类型名）。

下面的函数利用stackDump更进一步的说明了API堆栈的操作。

static void stackDump (lua_State *L) {
…
}

int main (void) {
    lua_State *L = lua_open();
    lua_pushboolean(L, 1);
    lua_pushnumber(L, 10);
    lua_pushnil(L); lua_pushstring(L, “hello”);
    stackDump(L);
  lua_pushvalue(L, -4);
    stackDump(L);
    lua_replace(L, 3);
    stackDump(L);
   
    lua_settop(L, 6);
    stackDump(L);
     lua_remove(L, -3);
    stackDump(L);
     lua_settop(L, -5);
    stackDump(L);
    lua_close(L);
    return 0;
}