链接和进一步阅读

Question

我试图使用SWIG用可变参数包装C函数，如下所示。

void post(const char *fmt, ...)
{
    char buf[MAXPDSTRING];
    va_list ap;
    t_int arg[8];
    int i;
    va_start(ap, fmt);
    vsnprintf(buf, MAXPDSTRING-1, fmt, ap);
    va_end(ap);
    strcat(buf, "\n");

    dopost(buf);
}

但是当我在Lua中运行该函数时，它只在我使用1个参数时才有效。我无法用以下风格写作。

pd.post("NUM : %d", 123);

我收到以下错误。

Error in post expected 1..1 args, got 2

是否可以使用SWIG用可变参数包装C函数？

我将不胜感激任何帮助。谢谢！

Answer 1

免责声明：不是真的答案，因为我找不到覆盖SWIG参数检查的方法，所以我可以自己处理varargs。这可以通过将我在下面显示的方法与this answer相结合来解决。

链接和进一步阅读

Variable Length Arguments (a.k.a, "The horror. The horror.")
Create va_list dynamically
How do I fill a va_list

普通C包装

我准备了一个示例，如何使用libffi（documentation）将对可变参数Lua函数的调用转换为可变参数C函数。

目前，代码只处理int（需要Lua 5.3），double和const char *个参数。它也可以简单地扩展到更多类型。请记住，此方法非常不安全。使用不受支持的格式将导致分段错误（格式字符串未选中）。例如，编译Lua 5.2并尝试使用整数格式，如此

printf("Hello World! %d %d %d\n", 1, 5, 7)

将导致

Hello World! 0 0 0

如果你很幸运并且它不会对你产生段错误，但是在像valgrind这样的内存调试器中运行程序会发现你正在做一些讨厌的事情。

// clang -Wall -Wextra -Wpedantic -std=c99 -g -I/usr/include/lua5.3 test.c -llua5.3 -lffi

#include <stdio.h>
#include <stdlib.h>

#include <lua.h>
#include <lualib.h>
#include <lauxlib.h>

#include <ffi.h>

static int l_printf(lua_State *L) {
    typedef union {
        int integer;
        double number;
        const char *string;
    } variant;

    int argc = lua_gettop(L);
    variant *argv = malloc(argc * sizeof(variant));

    ffi_cif cif;
    ffi_type **types = malloc(argc * sizeof(ffi_type *));
    void **values = malloc(argc * sizeof(void *));

    for (int i = 0; i < argc; ++i) {
        int j = i + 1;
        switch (lua_type(L, j)) {
        case LUA_TNUMBER:
#if LUA_VERSION_NUM >= 503
            if (lua_isinteger(L, j)) {
                types[i] = &ffi_type_sint;
                argv[i].integer = lua_tointeger(L, j);
                values[i] = &argv[i].integer;
            } else
#endif
            {
                types[i] = &ffi_type_double;
                argv[i].number = lua_tonumber(L, j);
                values[i] = &argv[i].number;
            }
            break;
        case LUA_TSTRING:
            types[i] = &ffi_type_pointer;
            argv[i].string = lua_tostring(L, j);
            values[i] = &argv[i].string;
            break;
        default:
            puts("Unhandled argment type");
            abort();
            break;
        }
    }

    // If preparing the FFI call fails we simply push -1 to indicate
    // that printf failed
    int result = -1;
    if (ffi_prep_cif(&cif, FFI_DEFAULT_ABI, argc, &ffi_type_sint, types) ==
        FFI_OK) {
        ffi_call(&cif, (void (*)())printf, &result, values);
    }

    free(values);
    free(types);
    free(argv);

    lua_pushinteger(L, result);
    return 1;
}

int main(int argc, char *argv[]) {
    if (argc != 2) {
        fprintf(stderr, "Usage: %s <script.lua>\n", argv[0]);
        return 1;
    }

    lua_State *L = luaL_newstate();
    luaL_openlibs(L);

    lua_pushcfunction(L, l_printf);
    lua_setglobal(L, "printf");

    if (luaL_dofile(L, argv[1]) != 0) {
        fprintf(stderr, "lua: %s\n", lua_tostring(L, -1));
        lua_close(L);
        return 1;
    }

    lua_close(L);
}

根据Lua 5.3进行编译，我们可以运行以下示例：

print(printf("Hello World! %d %d %d\n", 1, 5, 7) .. " bytes written")
print(printf("Hello %d %f World! %s\n", 1, 3.14, "ABC") .. " bytes written")

输出：

Hello World! 1 5 7
19 bytes written
Hello 1 3.140000 World! ABC
28 bytes written

尝试SWIG

我提出了一个可以在SWIG中使用的变体，但假设所有参数都可以转换为string。在这里，我只是声明printf是一个函数，它接受类型string的十个参数（如果你需要更多，只需增加数字）。

%varargs(10, const char * = NULL) printf;
int printf(const char *fmt, ...);

这将使用10个字符串调用printf函数，默认情况下为空（NULL）。因此，我写了action，将每个参数转换为正确的类型（int，double，string）。因为SWIG参数检查器已经对每个参数调用了lua_tostring，所以无论实际的参数类型是什么，对lua_type的调用总是会导致LUA_TSTRING。这就是为什么我使用lua_tointegerx和lua_tonumberx来将字符串转换回原始类型。结合基于后续转换的极低效率，我们给出了一个类似于上面提到的普通C包装器的包装器。

%module printf

%{
#include <ffi.h>
%}

%feature("action") printf {
    typedef union {
        int integer;
        double number;
        const char *string;
    } variant;

    int argc = lua_gettop(L);
    variant *argv = malloc(argc * sizeof(variant));

    ffi_cif cif;
    ffi_type **types = malloc(argc * sizeof(ffi_type *));
    void **values = malloc(argc * sizeof(void *));

    for (int i = 0; i < argc; ++i) {
        int j = i + 1;

        int flag = 0;

        types[i] = &ffi_type_sint;
        argv[i].integer = lua_tointegerx(L, j, &flag);
        values[i] = &argv[i].integer;
        if (flag) { continue; }

        types[i] = &ffi_type_double;
        argv[i].number = lua_tonumberx(L, j, &flag);
        values[i] = &argv[i].number;
        if (flag) { continue; }

        types[i] = &ffi_type_pointer;
        argv[i].string = lua_tostring(L, j);
        values[i] = &argv[i].string;
        if (argv[i].string) { continue; }

        puts("Unhandled argment type");
        abort();
        break;
    }

    // If preparing the FFI call fails we simply push -1 to indicate
    // that printf failed
    result = -1;
    if (ffi_prep_cif(&cif, FFI_DEFAULT_ABI, argc, &ffi_type_sint, types) ==
        FFI_OK) {
        ffi_call(&cif, (void (*)())printf, &result, values);
    }

    free(values);
    free(types);
    free(argv);
};

%varargs(10, const char * = NULL) printf;
int printf(const char *fmt, ...);

swig -lua test.i
clang -Wall -Wextra -Wpedantic -std=c99 -I/usr/include/lua5.3 -fPIC -shared test_wrap.c -o printf.so -llua5.3 -lffi

local printf = require"printf"
printf.printf("Hello %d %f %s World!\n", 1, 3.14, "ABC")

Hello 1 3.140000 ABC World!

结束语

作为最后一点，这是一种在Lua中格式化字符串的非常低效的方法。除了printf函数族之外，我不知道C中的任何可变函数，即它们都执行字符串格式化。使用string.format和函数调用（如

）在Lua中更有效地完成此操作

do_something("Hello %d %f %s World!\n", 1, 3.14, "ABC")

应该简单地避免使用稍微冗长但更强大的

do_something(string.format("Hello %d %f %s World!\n", 1, 3.14, "ABC"))

如何使用SWIG用可变参数包装C函数

1 个答案:

链接和进一步阅读

普通C包装

尝试SWIG

结束语