我使用的wxLua版本信息为wxLua 2.8.7.0 built with wxWidgets 2.8.8，也就是LuaForWindows_v5.1.4-40.exe这个安装包里自带的wxLua。我不知道其他wxWidgets版本里wxListCtrl怎样，但我使用的版本里wxListCtrl是不支持编辑里面的子item的。在我使用的report模式下，子item也就是特定某一行一列的item。

google了一下，发现悲剧地需要自己实现，主要就是自己显示一个wxTextCtrl：

--
-- file: wxListCtrlTextEdit.lua
-- author: Kevin Lynx
-- date: 08.06.2012
--
local EditList = {}

-- get the column by an abs point
function EditList:getColumn(x)
    local cols = self.listctrl:GetColumnCount()
    local cx = 0
    for i = 0, cols - 1 do
        local w = self.listctrl:GetColumnWidth(i)
        if x <= cx + w then return i end
        cx = cx + w
    end
    return -1
end

-- when a mouse down, show a text edit control 
function EditList:onLeftDown(evt)
    if self.editor:IsShown() then
        self:closeEditor()
    end
    local p = evt:GetPoint()
    local row = evt:GetIndex()
    local col = self:getColumn(p.x)
    local rect = wx.wxListCtrlEx.GetSubItemRect(self.listctrl, row, col)
    rect:SetHeight(rect:GetHeight() + 5) -- adjust
    self.editor:SetSize(rect)
    self.editor:Show()
    self.editor:SetValue(wx.wxListCtrlEx.GetItemText(self.listctrl, row, col))
    self.editor:SetFocus()
    self.col = col
    self.row = row
end

function EditList:closeEditor()
    if not self.editor:IsShown() then return end
    self.editor:Hide()
    self.listctrl:SetItem(self.row, self.col, self.editor:GetValue())
end

function EditList:initialize()
    self.editor = wx.wxTextCtrl(self.listctrl, wx.wxID_ANY, "", wx.wxDefaultPosition, wx.wxDefaultSize, wx.wxTE_PROCESS_ENTER + wx.wxTE_RICH2)
    self.editor:Connect(wx.wxEVT_COMMAND_TEXT_ENTER, function () self:closeEditor() end)
    -- not work actually
    self.editor:Connect(wx.wxEVT_COMMAND_KILL_FOCUS, function () self:closeEditor() end)
    self.editor:Hide()
end

function wx.wxListCtrlTextEdit(listctrl)
    local o = {
        listctrl = listctrl,
        editor = nil,
    }
    local editlist = newObject(o, EditList)
    editlist:initialize()
    listctrl:Connect(wx.wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK, function (evt) editlist:onLeftDown(evt) end)
    listctrl:Connect(wx.wxEVT_COMMAND_LIST_ITEM_FOCUSED, function () editlist:closeEditor() end)
    return listctrl
end

其原理就是获取到当前鼠标点击所在的子item位置，然后在此位置显示一个wxEditCtrl即可。以上代码需要依赖我之前写的Lua里实现简单的类-对象中的代码，同时依赖以下针对wxListCtrl的扩展接口：

--
-- file: wxListCtrlExtend.lua
-- author: Kevin Lynx
-- date: 08.07.2012
-- brief: extend some util functions to wx.wxListCtrl
-- 
wx.wxListCtrlEx = {}

function wx.wxListCtrlEx.GetSubItemRect(listctrl, item, col)
    local rect = wx.wxRect()
    listctrl:GetItemRect(item, rect)
    local x = 0
    local w = 0
    for i = 0, col do
        w = listctrl:GetColumnWidth(i)
        x = x + w
    end
    return wx.wxRect(x - w, rect:GetY(), w, rect:GetHeight())
end

function wx.wxListCtrlEx.GetItemText(listctrl, item, col)
    local info = wx.wxListItem()
    info:SetId(item)
    info:SetColumn(col)
    info:SetMask(wx.wxLIST_MASK_TEXT)
    listctrl:GetItem(info)
    return info:GetText()
end

在我看到的wxWidgets官方文档里，其实wxListCtrl已经有GetSubItemRect接口，并且在另一些示例代码里，也看到了GetItemText接口，但是，我使用的版本里没有，所以只好自己写。基于以上，要使用这个可以支持编辑子item的wxListCtrl，可以：

list = wx.wxListCtrlTextEdit(wx.wxListCtrl(dialog, wx.wxID_ANY, wx.wxDefaultPosition, wx.wxDefaultSize, wx.wxLC_REPORT))

也就是通过wx.wxListCtrlTextEdit这个函数做下处理，这个函数返回的是本身的wxListCtrl。当然更好的方式是使用继承之类的方式，开发一种新的控件，但在Lua中，针对usedata类型的扩展貌似只能这样了。

最好吐槽下，这个控件扩展其实很恶心。本来我打算当编辑控件失去焦点后就隐藏它，但是往编辑控件上注册KILL_FOCUS事件始终不起作用；我又打算弄个ESC键盘事件去手动取消，但显然wxTextCtrl是不支持键盘事件的。好吧，凑合用了。

原文地址： http://codemacro.com/2012/08/07/edit-item-wxlistctrl/
written by Kevin Lynx  posted at http://codemacro.com

我们使用tolua++手工绑定c/c++接口到lua中，在绑定的接口实现里，就需要取出传入的参数。tolua++中提供了一系列tolua_toxxx函数，例如：

lua_Number tolua_tonumber(lua_State *L, int narg, lua_Number def)
const char *tolua_tostring(lua_State *L, int narg, const char *def)

这些函数都有一个def参数。乍一看，这些函数使用起来很简单。传入lua_State，传入参数在栈中的位置，然后再传一个失败后返回的默认值。

我重点要说的是这里这个失败，按正常程序员的理解，针对lua而言，什么情况下算失败呢？lua语言里函数参数支持不传，此时实参为nil，将nil转换为一个c类型必然失败；参数类型不正确算不算失败？你传一个user data，c里按数字来取，这也算失败。

这么简单的API还需要多纠结什么呢？然后我们浩浩荡荡地写了上百个接口，什么tolua_tostring/tolua_tonumber的使用少说也有500了吧？

然后有一天，服务器宕机了，空指针:

/* 失败返回""，还能省空指针的判断 */
const char *name = tolua_tostring(L, 1, "");
if (name[0] == '\0') { /* 空串总得判断吧 */
 ...
}

跟踪后发现，脚本里传入的是nil，这里的name取出来是NULL，而不是”“（的地址）。然后吐槽了一下这个API，辛苦地修改了所有类似代码，增加对空指针的判断。我没有多想。

故事继续，有一天服务器虽然没宕机，但功能不正常了:

float angle = (float) tolua_tonumber(L, 1, 2 * PI);
...

这个意思是，这个函数的参数1默认是2*PI，什么是默认？lua里某函数参数不传，或传nil就是使用默认。因为不传的话，这个实参本身就是nil。但，tolua_tonumber的行为不是这样的，它的实现真是偷懒:

TOLUA_API lua_Number tolua_tonumber (lua_State* L, int narg, lua_Number def)
{
 return lua_gettop(L)<abs(narg) ? def : lua_tonumber(L,narg);
}
TOLUA_API const char* tolua_tostring (lua_State* L, int narg, const char* def)
{
 return lua_gettop(L)<abs(narg) ? def : lua_tostring(L,narg);
}

意思是，只有当你不传的时候，它才返回默认值，否则就交给lua的API来管，而lua这些API是不支持应用层的默认参数的，对于lua_tonumber错误时就返回0，lua_tostring错误时就返回NULL。

这种其行为和其带来的common sense不一致的API设计，实在让人蛋疼。什么是common sense呢？就像一个UI库里的按钮，我们都知道有click事件，hover事件，UI库的文档甚至都不需要解释什么是click什么是hover，因为大家看到这个东西，就有了共识，无需废话，这就是common sense。就像tolua的这些API，非常普通，大家一看都期待在意外情况下你能返回def值。但它竟然不是。实在不行，你可以模仿lua的check系列函数的实现嘛:

LUALIB_API lua_Number luaL_checknumber (lua_State *L, int narg) {
 lua_Number d = lua_tonumber(L, narg);
 if (d == 0 && !lua_isnumber(L, narg)) /* avoid extra test when d is not 0 */
 tag_error(L, narg, LUA_TNUMBER);
 return d;
}

即，根本不用去检查栈问题，直接在lua_tonumber之后再做包装检查。何况，lua需要你去检查栈吗？当你访问了栈外的元素时，lua会自动返回一个全局常量luaO_nilobject:

static TValue *index2adr(lua_State *L, int idx) {
 ...
 if (o >= L->top) return cast(TValue*, luaO_nilobject);
}

另，程序悲剧也来源于臆想。

传递Lua函数到C/C++中

table.sort(table [,comp])

table.sort(t, comp) -- 直接写函数名
table.sort(t, local_comp) -- 某个局部函数
table.sort(t, function (a, b) xxx end ) -- 临时构造一个匿名函数

function lua_func () xxx end
cfunc(lua_func) -- wrong
cfunc("lua_func") -- right

cfunc(lua_func) -- ok
cfunc(function () xxx end) -- ok
local xxx = function () xxx end
cfunc(xxx) -- ok

function wrap (fn)
    local id = generate_id()
    local fn_s = "__callback_fn"..id
    _G[fn_s] = fn
    return fn_s
end

cfunc(wrap(function () xxx end))
cfunc(const char *fn_name, xxx); -- cfunc的原型

ab(1, 2)

local function create_callback_table (fn, name)
    local t = {}
    t.callback = fn
    setmetatable (t, {__call =  -- 关注__call
        function (func, ...) -- 在t(xx)时，将调用到这个函数
            func.callback (...) -- 真正的回调
            del_callback (name) -- 回调完毕，清除wrap建立的数据
        end })
    return t
end

function wrap (fn)
    local id = generate_func_id() -- 产生唯一的id
    local fn_s = "_callback_fn"..id
    _G[fn_s] = create_callback_table(fn, fn_s) -- _G[fn_s]对应的是一个表
    return fn_s
end

cfunc(print) -- 传入Lua函数

另一个同事在iptux的基础上修改的，结果大概是因为iptux的代码不是那么容易修改，就不了了之了。这个

刚发布的luafeiq功能非常简单，仅支持与飞秋（包括大部分兼容IP messager的IM）进行单聊，群消息的

收发，简易的消息盒子（暂存未读消息）。因为选的库都是跨平台的，所以很容易的luafeiq也是跨平台的，

最主要的是我想在linux下使用。

之所以选用lua，一方面是想练练lua，另一方面则是因为开发效率。前段时间在android下写了些java代码，

用java写代码觉得甚为爽快（当然算不了完美）。这几天写了千把行的lua（也许有3K行，未统计过），

感觉也不错。综合来说，这些高级语言的很多好用的语法特性，例如闭包（closure），垃圾回收，都提高

了不少写代码的速度。当然，lua于我而言也算不上完美的语言。例如我经常因为变量敲错字母，而在运行时

才暴露nil错误。这也许可以通过诸如IDE之类的工具在写代码的时候就给予提示。lua 在遇到一个符号时，

默认地将其处理为全局的。关于这个语法特性早有人提出不爽，只能说大家设计的准则不一样。（在我们

项目里，我直接改写了全局变量的metatable，从而防止策划随意定义全局变量）

再来谈谈实现过程中的一些琐事。因为飞秋也算是IP messager协议的兼容实现，很多通信除了可以使用

抓包软件分析外，还可以直接通过IP messager的源码来了解。所以，基础通信协议的实现过程也比较

简单。飞秋与飞秋之间发送私聊消息是经过加密的。其加密过程也不简单，更重要的是，我并不想浪费太

多时间在这上面。后来发现其实可以通过上线消息里某个标志位表明自己不需要加密。这个标志就是消息头

里的option。上线广播出去的消息里一旦表明自己不加密，那么以后和飞秋通信也就不需要解密了。

发送私聊消息时，消息里会携带一个消息ID。这个ID可以通过任意算法生成，例如直接取time的值。接收到

对方的消息时，需要取出该ID，然后加入回应消息。对方收到回应消息后，就知道自己发送成功。这个过程

算是ip messager在UDP上做的消息可靠验证，过程也比较简单。

群聊消息在之前提到过，是通过UDP多播实现。我们可以接收所有群的消息。如果之前已经处于某个群里，

那么一旦你上线后（广播上线消息），你就可以直接在这个群里发言。但如果你之前不在这个群里，则

可以通过多播一个加入群的消息，然后就可以不请自来地在这个群里发言。详细的消息值和实现都可以从

luafeiq的代码里读到（message_sender.lua）。

在linux下接收windows上的飞秋消息，是需要做字符编码转换的。因为luafeiq使用IUP作为UI库，IUP在

linux下使用GTK作为底层实现，默认全部是UTF8编码。luafeiq里我自己写了个lua库，用于编码转换。

话说IUP作为一个UI库，还是比较不错的。正如其介绍文档里所说，学习曲线低，基本上看一会文档，就可以

直接使用了。luafeiq使用的IUP版本至少需要3.0以上。当初在linux下为了安装IUP3.3，基本花了4个小时

时间，各种奇怪的没多大意义的错误信息。后来换成3.2版本，居然一下子就和谐了，无限怨念。

luafeiq目前放在googlecode的版本，可以说是一个很不负责任的版本。早上我才刚把字符编码转换的代码

调试好。今天已经请假，家里就一台电脑，也就测试不了这个字符编码转换是否真的能正常工作。我在

windows下dump了些字符，看上去能正常功能。明天得回老家过春节，上不了网，索性就提前发布了。

luafeiq项目地址：http://code.google.com/p/luafeiq/

说白了，也就是要让tolua++在生成的代码文件开头插入#include "stdafx.h"。

修改代码其实很简单。tolua++分析pkg文件及生成代码文件其实都是通过lua代码完成的。
在src/bin/lua目录下，或者在源代码里toluabind.c里（把对应的lua代码直接以ASCII码值
复制了过来）即为这些代码。

首先修改package.lua里的classPackage::preamble函数，可以看出该函数会生成一些代码
文件头，模仿着即可写下如下代码：

if flags['I'] then
   output( '#include "..flags['I'] )
end

从上下文代码可以看出flags是个全局变量，保存了命令行参数。

然后修改tolua.c代码文件，让其往lua环境里传入命令行参数：

case 'I':setfield(L,t,"I",argv[++i];break;

本来，这样修改后基本就可以让tolua++支持通过命令行指定是否插入预编译头：
tolua++ -o test.cpp -H test.h -I stdafx.h test.pkg

不过事情并非很顺利，通过开启TOLUA_SCRIPT_RUN宏来让tolua++通过src/bin/lua下的lua
代码来完成功能，结果后来发现basic.lua似乎有问题。无奈之下，只好用winhex之类的工
具把修改过的package.lua转换为unsigned char B[]置于toluabind.c里，即可正常处理。

很早前在折腾挂起LUA脚本支持时，接触到lua_yield这个函数。lua manual中给的解释是：

This function should only be called as the return expression of a C function。

而这个函数一般是在一个注册到LUA环境中的C函数里被调用。lua_CFunction要求的原型里
，函数的返回值必须返回要返回到LUA脚本中的值的个数。也就是说，在一个不需要挂起的
lua_CFunction实现里，也就是一个不需要return lua_yield(...的实现里，我应该return
一个返回值个数。

但是为什么调用lua_yield就必须放在return表达式里？当时很天真，没去深究，反正发现
不按照lua manual里说的做就是不行。而且关键是，lua manual就不告诉你为什么。

最近突然就想到这个问题，决定去搞清楚这个问题。侯捷说了，源码面前了无秘密。我甚至
在看代码之前，还琢磨着LUA是不是操作了堆栈（系统堆栈）之类的东西。结果随便跟了下
代码真的让我很汗颜。有时候人犯傻了真的是一个悲剧。诺简单的一个问题会被人搞得很神
秘：

解释执行调用一个注册进LUA的lua_CFunction是在ldo.c里的luaD_precall函数里，有如下
代码：

    n = (*curr_func(L)->c.f)(L);  /* do the actual call */
    lua_lock(L);
    if (n < 0)  /* yielding? */
      return PCRYIELD;
    else {
      luaD_poscall(L, L->top - n);
      return PCRC;
    }

多的我就不说了，别人注释写得很清楚了，注册进去的lua_CFunction如果返回值小于0，这
个函数就向上层返回PCRYIELD，从名字就可看出是告诉上层需要YIELD。再找到lua_yield函
数的实现，恰好该函数就返回-1。

要再往上层跟，会到lvm.c里luaV_execute函数，看起来应该就是虚拟机在解释执行指令：

      case OP_CALL: {
        int b = GETARG_B(i);
        int nresults = GETARG_C(i) - 1;
        if (b != 0) L->top = ra+b;  /* else previous instruction set top */
        L->savedpc = pc;
        switch (luaD_precall(L, ra, nresults)) {
          case PCRLUA: {
            nexeccalls++;
            goto reentry;  /* restart luaV_execute over new Lua function */
          }
          case PCRC: {
            /* it was a C function (`precall' called it); adjust results */
            if (nresults >= 0) L->top = L->ci->top;
            base = L->base;
            continue;

对于PCRYIELD返回值，直接忽略处理了。

需求

    受WOW的影响，LUA越来越多地被应用于游戏中。脚本被用于游戏中主要用于策划编写游戏规则相关。实际运用中，
我们会将很多宿主语言函数绑定到LUA脚本中，使脚本可以更多地控制程序运行。例如我们可以绑定NPCDialog之类的函数
到LUA中，然后策划便可以在脚本里控制游戏中弹出的NPC对话框。
    我们现在面临这样的需求：对于宿主程序而言，某些功能是不能阻塞程序逻辑的（对于游戏程序尤其如此），但是为
了方便策划，我们又需要让脚本看起来被阻塞了。用NPCDialog举个例子，在脚本中有如下代码 ：

    ret = NPCDialog( "Hello bitch" )
    if ret == OK then print("OK") end

    对于策划而言，NPCDialog应该是阻塞的，除非玩家操作此对话框，点击OK或者关闭，不然该函数不会返回。而对于
宿主程序C++而言，我们如何实现这个函数呢：

    static int do_npc_dialog( lua_State *L )
    {
        const char *content = lua_tostring( L, -1 );
       
        lua_pushnumber( ret );
        return 1;
    }

    显然，该函数不能阻塞，否则它会阻塞整个游戏线程，这对于服务器而言是不可行的。但是如果该函数立即返回，那
么它并没有收集到玩家对于那个对话框的操作。
    综上，我们要做的是，让脚本感觉某个操作阻塞，但事实上宿主程序并没有阻塞。

事件机制

    一个最简单的实现（对于C程序员而言也许也是优美的），就是使用事件机制。我们将对话框的操作结果作为一个事件。
脚本里事实上没有哪个函数是阻塞的。为了处理一些“阻塞”函数的处理结果，脚本向宿主程序注册事件处理器（同GUI事件
处理其实是一样的），例如脚本可以这样：

    function onEvent( ret )
        if ret == OK then print("OK") end
    end
    -- register event handler
    SetEventHandler( "onEvent" )
    NPCDialog("Hello bitch")

    宿主程序保存事件处理器onEvent函数名，当玩家操作了对话框后，宿主程序回调脚本中的onEvent，完成操作。
    事实上我相信有很多人确实是这么做的。这样做其实就是把一个顺序执行的代码流，分成了很多块。但是对于sleep
这样的脚本调用呢？例如：

    --do job A
    sleep(10)
    --do job B
    sleep(10)
    --do job C
   

    那么采用事件机制将可能会把代码分解为：

    function onJobA
        --do job A
        SetEventHandlerB("onJobB")
        sleep(10)
    end
    function onJobB
        --do job B
        SetEventHandlerC("onJobC")
    end
    function onJobC
        --do job C
    end
    -- script starts here
    SetEventHandlerA( "onJobA" )
    sleep(10)

    代码看起来似乎有点难看了，最重要的是它不易编写，策划估计会抓狂的。我想，对于非专业程序员而言，程序的
顺序执行可能理解起来更为容易。

SOLVE IT

    我们的解决方案，其实只有一句话：当脚本执行到阻塞操作时（如NPCDialog），挂起脚本，当宿主程序某个操作完
成时，让脚本从之前的挂起点继续执行。
    这不是一种假想的功能。我在刚开始实现这个功能之前，以为LUA不支持这个功能。我臆想着如下的操作：
    脚本：
    ret = NPCDialog("Hello bitch")
    if ret == 0 then print("OK") end
    宿主程序：

    static int do_npc_dialog( lua_State *L )
    {
       
        lua_suspend_script( L );
       
    }

    某个地方某个操作完成了：
    lua_resume_script( L );
    当我实现了这个功能后，我猛然发现，实际情况和我这里想的差不多（有点汗颜）。

认识Coroutine

    coroutine是LUA中类似线程的东西，但是它其实和fiber更相似。也就是说，它是一种非抢占式的线程，它的切换取决
于任务本身，也就是取决你，你决定它们什么时候发生切换。建议你阅读lua manual了解更多。
    coroutine支持的典型操作有：lua_yield, lua_resume，也就是我们需要的挂起和继续执行。
    lua_State似乎就是一个coroutine，或者按照LUA文档中的另一种说法，就是一个thread。我这里之所以用’似乎‘是
因为我自己也无法确定，我只能说，lua_State看起来就是一个coroutine。
    LUA提供lua_newthread用于手工创建一个coroutine，然后将新创建的coroutine放置于堆栈顶，如同其他new出来的
对象一样。网上有帖子说lua_newthread创建的东西与脚本里调用coroutine.create创建出来的东西不一样，但是根据我
的观察来看，他们是一样的。lua_newthread返回一个lua_State对象，所以从这里可以看出，“lua_State看起来就是一个
coroutine”。另外，网上也有人说创建新的coroutine代价很大，但是，一个lua_State的代价能有多大？当然，我没做过
测试，不敢多言。
    lua_yield用于挂起一个coroutine，不过该函数只能用于coroutine内部，看看它的参数就知道了。
    lua_resume用于启动一个coroutine，它可以用于coroutine没有运行时启动之，也可以用于coroutine挂起时重新启动
之。lua_resume在两种情况下返回：coroutine挂起或者执行完毕，否则lua_resume不返回。
    lua_yield和lua_resume对应于脚本函数：coroutine.yield和coroutine.resume，建议你写写脚本程序感受下coroutine，
例如：

    function main()
        print("main start")
        coroutine.yield()
        print("main end")
    end
    co=coroutine.create( main );
    coroutine.resume(co)

REALLY SOLVE IT

    你可能会想到，我们为脚本定义一个main，然后在宿主程序里lua_newthread创建一个coroutine，然后将main放进去，
当脚本调用宿主程序的某个’阻塞‘操作时，宿主程序获取到之前创建的coroutine，然后yield之。当操作完成时，再resume
之。
    事实上方法是对的，但是没有必要再创建一个coroutine。如之前所说，一个lua_State看上去就是一个coroutine，
而恰好，我们始终都会有一个lua_State。感觉上，这个lua_State就像是main coroutine。（就像你的主线程）
    思路就是这样，因为具体实现时，还是有些问题，所以我罗列每个步骤的代码。
    初始lua_State时如你平时所做：

    lua_State *L = lua_open();
    luaopen_base( L );

    注册脚本需要的宿主程序函数到L里：

    lua_pushcfunction( L, sleep );
    lua_setglobal( L, "my_sleep" );

    载入脚本文件并执行时稍微有点不同：

    luaL_loadfile( L, "test.lua" );
lua_resume( L, 0 ); /**//* 调用resume */

    在你的’阻塞‘函数里需要挂起coroutine：

    return lua_yield( L, 0 );

    注意，lua_yield函数非常特别，它必须作为return语句被调用，否则会调用失败，具体原因我也不清楚。而在这里，
它作为lua_CFunction的返回值，会不会引发错误？因为lua_CFunction约定返回值为该函数对于脚本而言的返回值个数。
实际情况是，我看到的一些例子里都这样安排lua_yield，所以i do what they do。

    在这个操作完成后（如玩家操作了那个对话框），宿主程序需要唤醒coroutine：

    lua_resume( L, 0 );

    大致步骤就这些。如果你要单独创建新的lua_State，反而会搞得很麻烦，我开始就是那样的做的，总是实现不了自己
预想中的效果。

相关下载：
    例子程序中，我给了一个sleep实现。脚本程序调用sleep时将被挂起，宿主程序不断检查当前时间，当时间到时，resume
挂起的coroutine。下载例子

8.13补充

   可能有时候，我们提供给脚本的函数需要返回一些值给脚本，例如NPCDialog返回操作结果，我们只需要在宿主程序里lua_resume

之前push返回值即可，当然，需要设置lua_resume第二个参数为返回值个数。

2.9.2010
    lua_yield( L, nResults )第二个参数指定返回给lua_resume的值个数。如下：

   lua_pushnumber( L, 3 );
   return lua_yield( L, 1 );
 ..
   int ret = lua_resume( L, 0 );
   if( ret == LUA_YIELD )
   {
         lua_Number r = luaL_checknumber( L, -1 );
   }