亚弥's Blog

c = require('c')                 
                                 
co = coroutine.create(function() 
  print('coroutine yielding')    
  c.callback(function()          
    coroutine.yield()            
  end)                           
  print('coroutine resumed')     
end)                             
                                 
coroutine.resume(co)             
coroutine.resume(co)             
                                 
print('the end')                 

local c = require 'c'

#include<stdio.h>                                        
#include<stdlib.h>                                       
#include<lua.h>                                          
#include<lualib.h>                                       
#include<lauxlib.h>                                      
                                                         
static int c_callback(lua_State *L){                     
  int ret = lua_pcall(L, 0, 0, 0);                       
  if(ret){                                               
    fprintf(stderr, "Error: %s\n", lua_tostring(L, -1)); 
    lua_pop(L, 1);                                       
    exit(1);                                             
  }                                                      
  return 0;                                              
}                                                        
                                                         
static const luaL_Reg c[] = {                            
  {"callback", c_callback},                              
  {NULL, NULL}                                           
};                                                       
                                                         
LUALIB_API int luaopen_c (lua_State *L) {                
  luaL_register(L, "c", c);                              
  return 1;                                              
}                                                        

#include<stdio.h>                                                     
#include<stdlib.h>                                                    
                                                                      
#define LUA_LIB /* 告诉Lua，这是一个LIB文件 */                        
#include<lua.h>                                                       
#include<lualib.h>                                                    
#include<lauxlib.h>                                                   
                                                                      
static int c_cont(lua_State *L) {                                     
  /* 这里什么都不用做：因为你的原函数里面就没做什么 */                
  return 0;                                                           
}                                                                     
                                                                      
static int c_callback(lua_State *L){                                  
  /* 使用 lua_pcallk，而不是lua_pcall */                              
  int ret = lua_pcallk(L, 0, 0, 0, 0, c_cont);                        
  if(ret) {                                                           
    fprintf(stderr, "Error: %s\n", lua_tostring(L, -1));              
    lua_pop(L, 1);                                                    
    exit(1);                                                          
  }                                                                   
  /* 因为你这里什么都没做，所以c_cont里面才什么都没有。如果这里需要做 
   * 什么东西，将所有内容挪到c_cont里面去，然后在这里简单地调用       
   * return c_cont(L);                                                
   * 即可。                                                           
   */                                                                 
  return 0;                                                           
}                                                                     
                                                                      
static const luaL_Reg c[] = {                                         
  {"callback", c_callback},                                           
  {NULL, NULL}                                                        
};                                                                    
                                                                      
LUALIB_API int luaopen_c (lua_State *L) {                             
  /* 使用新的 luaL_newlib 函数 */                                     
  luaL_newlib(L, c);                                                  
  return 1;                                                           
}                                                                     

lua  -- co.lua     
coroutine yielding 
coroutine resumed  
the end            

function do_login(server)                                                 
    server:login(function(data)                                           
        -- 错误处理先不管，假设有一个全局处理错误的机制（后面会提到，实际 
        -- 上就是newtry/protect机制）                                     
        server:get_player_info(function(data)                             
            player:move_to(data.x, data.y)                                
        end)                                                              
    end, "username", "password")                                          
end                                                                       

function d_login(server)                  
    server:login("username", "password")  
    local data = server:get_player_info() 
    player:move_to(data.x, data.y)        
end                                       

local current                                          
function server:login(name, password)                  
    assert(not current, "already send login message!") 
    server:callback_login(function(data)               
        local cur = current                            
        current = nil                                  
        coroutine.resume(cur, data)                    
    end, name, password)                               
    current = coroutine.running()                      
    coroutine.yield()                                  
end                                                    

function coroutinize(f, reenter_errmsg)     
    local current                           
    return function(...)                    
        assert(not current, reenter_errmsg) 
        f(function(...)                     
            local cur = current             
            current = nil                   
            coroutine.resume(cur, ...)      
        end, ...)                           
        current = coroutine.running()       
        coroutine.yield()                   
    end                                     
end                                         

undefined = {}                              
-- 指定一个全局变量存在，但不指向任何地方： 
a = undefined                               
-- 判断这个全局变量是否不指向任何地方：     
if a == undefine then ... end               
-- 彻底删除这个变量：                       
a = nil                                     

local a = true           
repeat a = false until a 

for line in configfile do                 
    if string.sub(line, 1, 1) == '#' then 
        goto next                         
    end                                   
    parse_config(line)                    
    ::next::                              
end                                       

local i                           
repeat                            
    if i == 5 then                
        goto next                 
    end                           
    local j = i * i               
    print("i = "..i..", j = "..j) 
    i = i + 1                     
    ::next::                      
until i == 10                     

lua  -- "noname\2013-01-03-1.lua"                                                        
lua: noname\2013-01-03-1.lua:10: <goto next> at line 4 jumps into the scope of local 'j' 
shell returned 1                                                                         
Hit any key to close this window...