Lua 基础之 Lua 程序

野性酷女 2022-06-12 14:42 311阅读 0赞

# lua 调用 c 函数 #

lua 调用 c 函数与 c 调用 lua 函数一样，都是通过 CAPI 和一个栈来实现，lua 调用 c 函数有以下几个步骤  
1. 在 c 代码中定义函数  
lau.h 中定义了要注册到 lua 中的 c 函数的原型，虽然我测试的时候不使用这个原型也不会出错，但还是要遵循规范比较好  
`int FunctionName(lua_State* L)`  
返回值表示此函数有几个返回值，lua 执行完些函数之后根据这个返回值就知道需要从栈中取几个返回值，而 lua\_State\* 参数使得 c 函数内可以使用 CAPI 来操作栈，与 lua 交互  
c 函数的实现流程：  
（1）从栈中取函数的参数。lua 调用 c 函数之前会把参数压入栈中，每个 c 函数都有一个独立的私有栈，所以函数第一个参数在栈中的索引是 1。  
（2）实现函数功能。  
（3）把返回值逐个压入栈中，第一个返回值最先压入，也就是在栈底；把结果压入栈之前不用手动清除栈中原来的参数和函数，lua 会自动帮我们清除。  
（4）返回一个整数表示该函数有几个返回值。  
2. 把 c 函数注册到 lua 环境，在 lua 中创建一个全局变量保存这个函数  
使用 `lua_pushcfunction(L, c_fun_name)` 把函数压入栈中  
使用 `lua_setglobal(L, l_fun_name)` 把函数赋给一个全局变量  
3. 在 lua 程序中使用上面创建的全局变量了

*main.c*

#include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <math.h>
    #include "lua.h"
    #include "lualib.h"
    #include "lauxlib.h"
    
    int sayHello(lua_State* L)
    {
        printf("hello world in c!\n");
        return 0;
    }
    
    int l_sin(lua_State* L)
    {
        //double angle = lua_tonumber(L, 1);
        double angle = luaL_checknumber(L, 1);
        lua_pushnumber(L, sin(angle));
        return 1;
    }
    
    int main(void)
    {
        lua_State* L = luaL_newstate();
        luaL_openlibs(L);
    
        lua_pushcfunction(L, sayHello);
        lua_setglobal(L, "c_say_hello");
    
        lua_pushcfunction(L, l_sin);
        lua_setglobal(L, "c_sin");
    
        int error = luaL_loadfile(L, "main.lua") | lua_pcall(L, 0, 0, 0);
        if (error != 0)
        {
            printf("main.lua run error!\n");
        }
    
        system("pause");
        return 0;
    }

加载 main.lua 之前先把两个 c 函数 *sayHello* 和 *l\_sin* 注册到 lua 环境中，然后再加载运行 main.lua 文件，这时 lua 环境中已经有两个全局变量 *c\_say\_hello* 和 *c\_sin* 了，main.lua 中的代码块直接使用这两个全局函数就不会找不到了

*main.lua*

print "hello world in lua!"
    
    c_say_hello()
    
    print("PI = 3.14")
    local angle
    repeat
        angle = tonumber(io.read())
        local s, c = c_sin(angle)
        print(string.format("sin(%g) = %.2f cos(%g) = %.2f", angle, s, angle, c))
    until angle == -1

# c 模块 #

我们已经知道了如何在执行 lua 代码块之前注册 c 函数，但前面的程序还是一个 c 程序，只不过实现了 lua 调 c 而已。如果我们想要在使用 lua 解释器来运行 lua 代码时能够让 lua 调用 c 函数，那就得事先将 c 函数导出来。将要导出的 c 函数导出为一个模块，lua 代码可以像加载 lua 模块一样加载这个模块；lua 不仅能加载以 *.lua* 为后缀的 lua 文件，还能加载以 *.dll* 或 *.so* 为后缀的二进制文件，我们就是要将 c 函数导出为 *.dll* 或 *.so* 的动态链接库。

导出 c 函数模块的流程（以 windows 下导出 dll 为例）：  
1. 定义要导出给 lua 调用的 c 函数，加上 *static* 定义成私有的，因为这些函数的注册在模块内部完成，不需要模块外部访问  
2. 把这些 c 函数组织成一个数组，类型为 const luaL\_Reg\[\]，同样为私有的  
3. 定义一个外部函数，将所有 c 函数注册到 lua 环境，这个函数是外部调用的接口，lua 通过这个函数来注册上面组织的所有函数。为了让外部模块能够访问到这个函数，函数除了要 定义成公有之外，还需要将函数导出，*dll* 导出函数的方式是在函数前面加上 *\_\_declspec(dllexport)*  
**注册 c 函数：**  
**lua 5.1:** `luaL_register(L, "mylib", mylib)`  
**lua 5.2:** `luaL_newlib(L, mylib)` 等价于

luaL_checkversion(L);
    lua_newlibtable(L, mylib);
    lua_setfuncs(L, mylib, 0);

其中 luaL\_checkversion 函数会导致在 lua 解释器程序中无法加载正常 c 模块，会出现 *multiple Lua VMs detected* 错误，这是打开了两个 lua 环境造成的；所以如果要导出供纯 lua 程序使用的 c 模块，要把 luaL\_checkversion 这条语句去掉，即不要直接使用 luaL\_newlib 函数

下面用实例演示一下整个过程，创建一个 c 动态链接库程序，这个链接库注册了一个 *clib* 模块，然后分别在 lua 解释器和 c 程序中使用这个模块

## 新建一个动态链接库项目 ##

使用 visual studio 创建一个控制台项目 clib，勾选 dll 项目选项和空项目选项。新建一个文件 *lib.c*

#include "lua.h"
    #include "lualib.h"
    #include "lauxlib.h"
    
    //定义私有C函数
    static int sayHello(lua_State* L)
    {
        printf("hello world!\n");
        lua_pushstring(L, "hello world!\n");
        return 1;
    }
    
    //定义私有函数数组
    static const struct luaL_Reg myLibs[] = 
    {
        {
       "sayHello",sayHello},
        {NULL,NULL}
    };
    
    //定义外部函数
    __declspec(dllexport) int luaopen_clib(lua_State* L)
    {
        //5.1
        //luaL_register(L, "myLibs", myLibs); 
    
        //5.2
        //luaL_newlib(L, myLibs);
        luaL_newlibtable(L, myLibs);
        luaL_setfuncs(L, myLibs, 0);
    
        return 1;
    }

然后编译项目就会生成一个 clib.dll，这个文件就可以直接在 lua 程序中加载使用了。但如果要在 c 项目中使用的话，还需要创建一个头文件 lib.h，不然的话 c 项目在使用时会找不到导出的外部函数

#pragma once
    #include "lua.h"
    __declspec(dllexport) int luaopen_clib(lua_State* L);

## 在 lua 解释器中使用 c 模块 ##

把上面导出的 clib.dll 库文件放入到 lua 程序运行时的 cpath 中去，然后在 lua 代码中直接使用 require 加载模块名即可，加载后要使用一个变量来保存模块生成的 table

local clib = require("clib")
    
    print(clib.sayHello())

程序到这里就可以运行测试一下了，但运行之后很可能会崩溃，主要有下面几点方要注意：

> 1、注册的模块名和 dll 文件名要保持一致，因为 require 函数是根据名字找到 dll 文件，再从 dll 文件中加载同名的模块
> 
> 2、require 函数会自动在模块内查找函数 luaopen\_模块名，然后运行这个函数完成注册工作，因此模块定义的外部函数名并不是可以随便起的，而是必须使用 luaopen\_模块名，比如上面的 `luaopen_clib`，其注册的模块名就是 clib
> 
> 3、`__declspec(dllexport)` 是必须的
> 
> 4、 导出 c 模块的时候需要用到 lua 链接库，如果直接链接静态链接库，则生成的 c 模块 dll 文件比较大，可直接加载；如果是链接静态链接库的 lib 文件，则生成的 c 模块 dll 文件比较小，但不能直接加载，需要把 lua.dll 跟这个 dll 放在一起

## 在 c 程序中使用 c 模块 ##

我们也可以在 c 程序中打开一个 lua 环境，然后加载上面的 c 模块到 lua 环境，最后执行 lua 代码块，让 lua 代码调用 c 函数。这种方法其实跟最上面讲的 `lua 调用 c 函数` 一样，不同的是前面都是一个函数一个函数手动注册，而现在是通过一个外部模块批量注册所有函数。使用 lua\_requiref 在 c 程序中加载 c 模块完成函数注册，函数原型如下  
`luaL_requiref(lua_State, "模块名", 模块外部接口, 1);`

#include "lib.h"
    #include "lualib.h"
    #include "lauxlib.h"
    
    int main()
    {
        lua_State* L = luaL_newstate();
    
        //打开默认模块
        luaL_openlibs(L);
    
        //打开自定义模块
        luaL_requiref(L, "clib", luaopen_clib, 1); //1
    
        char buff[] = "clib.sayHello()";
        if (luaL_loadbuffer(L, buff, strlen(buff), 0))
        {
            printf("error load");
        }
    
        if (lua_pcall(L, 0, 0, 0))
        {
            printf("error run");
        }
    
        lua_close(L);
    
        getchar();
        return 0;
    }