luajit ffi 总结 <转载>

发表于   |     |    阅读次数

Lua 是一种语法简单，上手快的语言，虽然原生库比较少，但是可以方便的和 C 语言互相调用，常被用于脚本嵌入到 C 程序中。如 Redis 中可以加载 Lua 脚本，作用类似于存储过程，Nginx 中 lua-nginx-module 模块更是将 Lua 的这种特性发挥到极致。

使用 Lua 如何调用 C 的函数，个人认为是每一个 Lua 开发者必学的内容。Lua 调用 C 程序有两种方法，一种是使用 lua C API，另一种方法就是使用 luajit 提供的 ffi 库来调用 C 程序。本文主要是对 luajit ffi 的研究总结。

#luajit ffi

luajit 和 lua 一样，是可以直接安装在操作系统中的，相关介绍直接参考官网 luajit。个人测试效果来看，luajit 的执行效率远高于 lua，大概是 8 倍左右。openresty 的 lua-nginx-module 模块就是将 luajit 集成到了 Nginx 中，实现在 Nginx 中执行 Lua 脚本

luajit ffi 是 luajit 提供给 Luaer 使用 Lua 调用 C 函数的 Lua 库，使用该库，Luaer 不用再去操作复杂的 Lua 栈来粘合两种程序代码，luajit ffi 官方资料。

##引入 luajit ffi 库

local ffi = require("ffi")

#在 Lua 中调用 C 函数

和 lua 的 C API 一样，Lua 调用 C 函数，需要将 C 函数编译成链接库。区别在于 C API 查找 C 的 Lua 库是在 package.cpath 路径下进行查找，而这些库函数使用 Lua 栈接口进行编写。而 luajit 对于 C 链接库的引用遵从于普通 C 库的引用方式，先在 /usr/lib(/usr/lib64)，/lib(/lib64) 目录下查找，再到用户自定义的 LD_LIBRARY_PATH 下查找。

本节涉及接口：

 ffi.cdef[[c_function define]]
ffi.C
ffi.load(name [,global])

  • 调用 C 标准库函数

    对于 C 标准库函数引用，需要引入函数，函数声明

    ffi.cdef[[c_function define]]

    调用 C 函数

    ffi.C.c_function

    如：

    local ffi = require("ffi")

ffi.cdef[[
    int printf(const char *fmt, ...);
    int strcasecmp(const char *s1, const char *s2);
]]

ffi.C.printf("Hello %s!\n", "world")
ret = ffi.C.strcasecmp("Hello", "hello")
print(ret)
ret = ffi.C.strcasecmp("Hello", "hello1")
print(ret)

    输出结果

    [root@AlexWoo-CentOS lua]# luajit ffic.lua 
Hello world!
0
-49

  • 调用自定义的 C 函数

    调用自定义的 C 函数，首先要将自定义的 C 函数编译成链接库

    [root@AlexWoo-CentOS lua]# cat ffimyc.c 
int add(int x, int y)
{
    return x + y;
}
[root@AlexWoo-CentOS lua]# gcc -g -o libffimyc.so -fpic -shared ffimyc.c

  • 调用 C 标准库函数

    调用 C 标准库函数，需要在 Lua 中引入相应的库

    ffi.load(name [,global])

    这里第二个参数如果为 true，则该库被引入全局命名空间，这里使用 ffi.load 需要注意两点：

    1. 链接库文件必须在 C 的动态链接库查找路径中，否则会报类似错误：

      luajit: ffimyc.lua:3: libffimyc.so: cannot open shared object file: No such file or directory

      引入方法：

       export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:your_lib_path

在 Linux 下，库函数名的查找与 C 程序查找动态链接库相同，如上面我生成的动态链接库文件为 libffimyc.so，我在 ffi.load 中的 name 为 ffimyc

      调用自己的函数，可以直接使用 ffi.load 返回的变量调用，下面我们看一个简单的例子：

      local ffi = require('ffi')
myc = ffi.load('ffimyc')

ffi.cdef[[
    int add(int x, int y);
]]

ret = myc.add(1, 20)
print(ret)

      输出结果

      [root@AlexWoo-CentOS lua]# luajit ffimyc.lua
21

    2. 使用 ffi.C 调用自定义的 C 函数

      上面的例子中，是不能直接使用 ffi.C 来调用 add 函数的，那么怎么用 ffi.C 来调用 add 函数，对，就是 ffi.load 时，第二个参数置为 true，将库加载为全局命名空间。示例：

      local ffi = require('ffi')

ffi.load('ffimyc', true)

ffi.cdef[[
    int add(int x, int y);
]]

ret = ffi.C.add(1, 10)
print(ret)

      输出结果

      [root@AlexWoo-CentOS lua]# luajit ffimyc.lua
11

      本节小结

      在 lua 中调用 C 函数，需要使用 ffi.cdef 对 C 函数进行声明

      对于 C 标准库函数，已在全局命名空间，直接可以使用 ffi.C.函数名(函数参数…) 来调用函数

      对于自定义的 C 函数，需要将其先编译成链接库，并将链接库所在路径加入到 LD_LIBRARY_PATH 中，需要使用 ffi.load 载入链接库

      如果 ffi.load 第二个参数不填写，链接库以私有空间方式链入 Lua 脚本，使用时需要用 ffi.load 的返回值对函数进行调用

      如果 ffi.load 第二个参数设置为 true，可以使用 ffi.C 直接调用，调用方法同 C 标准库函数的调用

Lua 处理 cdata 对象

上面对 Lua 如何调用 C 函数进行了小结，但是光能调用 C 函数是远远不够的，我们还需要对 C 的变量，变量类型进行处理。本节将对这部分进行探讨。

C 类型转化为 Lua 中的 ctype

C 类型转化为 Lua ctype，使用 ffi.typeof，该函数返回一个 ctype 变量类型

ctype = ffi.typeof(ct)

示例：

local ffi = require('ffi')

ffi.cdef[[
    struct s1 {
        int a;
         int b;
    };
    typedef struct {
        int c;
            int d;
    } s2;
    union u {
           int a;
        long b;
        float c;
    };
    enum e {
            Male,
        Female
    };
]]

print(ffi.typeof("int8_t"))
print(ffi.typeof("uint8_t"))
print(ffi.typeof("int16_t"))
print(ffi.typeof("uint16_t"))
print(ffi.typeof("int32_t"))
print(ffi.typeof("uint32_t"))
print(ffi.typeof("int64_t"))
print(ffi.typeof("uint64_t"))
print(ffi.typeof("double"))
print(ffi.typeof("float"))
print(ffi.typeof("bool"))
print(ffi.typeof("struct s1"))
print(ffi.typeof("s2"))
print(ffi.typeof("union u"))
print(ffi.typeof("enum e"))
print(ffi.typeof("struct s1*"))
print(ffi.typeof("struct s1[]"))

输出：

[root@AlexWoo-CentOS lua]# luajit ffit.lua 
ctype<char>
ctype<unsigned char>
ctype<short>
ctype<unsigned short>
ctype<int>
ctype<unsigned int>
ctype<int64_t>
ctype<uint64_t>
ctype<double>
ctype<float>
ctype<bool>
ctype<struct s1>
ctype<struct 98>
ctype<union u>
ctype<enum e>
ctype<struct s1 *>
ctype<struct s1 []>

创建并初始化 cdata 对象

使用 ctype 有以下两种构造 Lua C 对象的方法

cdata = ffi.new(ct [,nelem] [,init...])
cdata = ctype([nelem,] [init...])

基本类型 cdata 对象

首先是一个 C 的函数，我们使用构造的 cadata 对象来调用该函数：

int add(int x, int y)
{
    return x+y;
}

直接调用

local ffi = require('ffi')
local t = ffi.load("t", true)

ffi.cdef[[
    int add(int x, int y);
]]

print(t.add(10, 11))

执行结果

[root@AlexWoo-CentOS lua]# luajit ffit.lua 
21

这种方法仅限于基本类型，lua 会将其基本类型转换为 cdata 的基本类型

使用 ffi.new 构造

local ffi = require('ffi')
local t = ffi.load("t", true)

ffi.cdef[[
    int add(int x, int y);
]]

ti = ffi.typeof("int")
a = ffi.new(ti, 10)
b = ffi.new("int", 11)
print(type(a), type(b))
print(t.add(a, b))

执行结果

[root@AlexWoo-CentOS lua]# luajit ffit.lua 
cdata   cdata
21

这里如果执行 print(ffi.typeof(“int”))，结果就是 ctype，因此这里 ffi.new 的第一个参数直接填为 “int” 与传入一个 ctype 的类型对象是等价的

使用类型对象构造

local ffi = require('ffi')
local t = ffi.load("t", true)

ffi.cdef[[
    int add(int x, int y);
]]

ti = ffi.typeof("int")
a = ti(10)
b = ti(11)
print(t.add(a, b))

执行结果

[root@AlexWoo-CentOS lua]# luajit ffit.lua 
21

基本类型指针 cdata 对象

首先是一个 C 的函数，我们使用构造的 cadata 对象来调用该函数：

int addp(int *x, int *y)
{
    return *x+*y;
}

这里构造指针对象可以使用 ffi.new 和 类型构造两种方法，下面只以一种进行举例，其它举一反三

local ffi = require('ffi')
local t = ffi.load("t", true)

ffi.cdef[[
    int add(int x, int y);
    int addp(int *x, int *y);
]]

a = ffi.new("int[1]", {10})
b = ffi.new("int[1]", {10})
print(t.addp(a, b))

执行结果

[root@AlexWoo-CentOS lua]# luajit ffit.lua 
21

没有将 Lua 原生类型直接转换为指针类型的方法(至少我没找到)，这里使用的是将 Lua 的 table 转为只有一个元素的数组，并将数组当作指针类型参数传入addp中。

结构类型 cdata 对象

首先是一个 C 程序，我们使用构造的 cadata 对象来调用该函数：

#include <stdio.h>

struct constr_t {
    int a;
    int b;
    struct innerstr {
        int x;
        int y;
    } c;
};

void print_constr_t(struct constr_t t)
{
    printf("a:%d\n", t.a);
    printf("b:%d\n", t.b);
    printf("c.x:%d\n", t.c.x);
    printf("c.y:%d\n", t.c.y);
}

Lua 程序

local ffi = require('ffi')
local t = ffi.load("t", true)

ffi.cdef[[
    struct constr_t {
        int a;
        int b;
        struct innerstr {
            int x;
            int y;
        } c;
    };
    void print_constr_t(struct constr_t t);
]]

a = ffi.new("struct constr_t", {1, 2, {10, 11}})
t.print_constr_t(a)

执行结果

[root@AlexWoo-CentOS lua]# luajit ffit.lua 
a:1
b:2
c.x:10
c.y:11

这里我们看到构造一个 C 的结构类型与基本类型的方法基本类似，唯一区别就是需要使用 table 来进行构造，table 的层次结构与 C 的结构的层次必须符合

结构类型指针 cdata 对象

在日常使用中，对于结构体，我们更常使用的是指针。和基本类型指针 cdata 对象不同，可以直接使用与结构类型 cdata 对象相同的方式来构造结构类型指针的 cdata 对象

C 程序

#include <stdio.h>

struct constr_t {
    int a;
    int b;
    struct innerstr {
        int x;
        int y;
    } c;
};

void print_pconstr_t(struct constr_t *t)
{
    printf("a:%d\n", t->a);
    printf("b:%d\n", t->b);
    printf("c.x:%d\n", t->c.x);
    printf("c.y:%d\n", t->c.y);
}

Lua 程序

local ffi = require('ffi')
local t = ffi.load("t", true)

ffi.cdef[[
    struct constr_t {
        int a;
        int b;
        struct innerstr {
            int x;
            int y;
        } c;
    };
    void print_pconstr_t(struct constr_t *t);
]]

a = ffi.new("struct constr_t", {1, 2, {10, 11}})
t.print_pconstr_t(a)

执行结果

[root@AlexWoo-CentOS lua]# luajit ffit.lua 
a:1
b:2
c.x:10
c.y:11

字符串 cdata 对象

可以使用 Lua string 对象来初始化字符串 cdata 对象

C 程序

void print(const char *s)
{
    printf("%s\n", s);
}

Lua 程序

local ffi = require('ffi')
local t = ffi.load("t", true)

ffi.cdef[[
    void print(const char *s);
]]

a = ffi.new("const char*", "Hello World")
t.print(a)

执行结果

[root@AlexWoo-CentOS lua]# luajit ffit.lua 
Hello World

注意对字符串，ffi.new 第一个参数只能是 const char 、const char[size] 或 char[size]，不能是 char ，const char[?] 等类型

使用 cdata 对象

本节将探讨在 Lua 中怎么使用 cdata 对象

C 程序

#include <stdio.h>

struct constr_t {
    int a;
    int b;
    struct innerstr {
        int x;
        int y;
    } c;
};

void print_pconstr_t(struct constr_t *t)
{
    printf("a:%d\n", t->a);
    printf("b:%d\n", t->b);
    printf("c.x:%d\n", t->c.x);
    printf("c.y:%d\n", t->c.y);
}

int print_i(int x)
{
    printf("x: %d\n", x);
}

int print_pi(int *px)
{
    printf("px: %d\n", *px);
}

void print(const char *s)
{
    printf("%s\n", s);
}

Lua 程序

local ffi = require('ffi')
local t = ffi.load("t", true)

ffi.cdef[[
    struct constr_t {
        int a;
        int b;
        struct innerstr {
            int x;
            int y;
        } c;
    };
    void print_pconstr_t(struct constr_t *t);
    int print_i(int x);
    int print_pi(int *px);
    void print(const char *s);
]]

ti = ffi.new("int", 10)
tpi = ffi.new("int[1]", {20})

ts = ffi.new("struct constr_t", {1, 2, {3, 4}})

tcstr = ffi.new("const char*", "Hello World")
tstr = ffi.new("char[11]", "Hello World")

t.print_i(ti)
--t.print_pi(ti) --luajit: ffit.lua:29: bad argument #1 to 'print_pi' (cannot convert 'int' to 'int *')

--t.print_i(tpi) --luajit: ffit.lua:31: bad argument #1 to 'print_i' (cannot convert 'int [1]' to 'int')
t.print_pi(tpi)

t.print_pconstr_t(ts)

t.print(tcstr)
t.print(tstr)

–对基本类型操作

ti = 100 --change tpi to number
tpi[0] = 21
--tpi=22 --change tpi to number
--tpi[1] = 2000 --luajit: ffit.lua:44: attempt to index global 'tpi' (a number value)
print(type(ti), type(tpi))
t.print_i(ti)
t.print_pi(tpi)

–对 struct 类型操作

ts.b = 100
ts.c.y = 1000
print(type(ts))
t.print_pconstr_t(ts)

–对字符串类型操作

--tcstr[2] = 32 --luajit: ffit.lua:54: attempt to write to constant location
tstr[2] = 32
t.print(tstr)

t.print("Hello Lua")

执行结果

[root@AlexWoo-CentOS lua]# luajit ffit.lua 
x: 10
px: 20
a:1
b:2
c.x:3
c.y:4
Hello World
Hello World
number  cdata
x: 100
px: 21
cdata    
a:1
b:100
c.x:3
c.y:1000
Hello World
Hello Lua

从上面的例子可以看出，对基本类型，实际上不需要将其转为 cdata 类型；对于基本类型指针，操作方式与数组类似，在 Lua 中可当作 table 数组进行处理；对结构类型，在 Lua 中可当作 table 字典进行处理；对字符串，在 Lua 中可当作 table 数组进行处理

本节小结

Lua 可以使用 ffi.new 初始化一个 cdata 对象，也可以使用 ffi.typeof 生成的类型来初始化一个 cdata 对象

对于基本类型和字符串类型，没有必要将其转为 cdata 对象，其可以作为参数传入 C 函数中。也可以接收 C 函数的返回值

对于基本类型指针对象，可以使用单元素数组进行初始化，可以使用数组元素赋值的方式改变其中的值

对于结构类型，可以传入 C 指针参数，也可以传入 C 普通参数。对结构类型的操作，与 table 的字典操作类似

原文出自: http://blog.csdn.net/alexwoo0501/article/details/50636785