如何编写包装C variadic函数的动态加载程序？

Question

为了避免在运行时取决于库，我编写了一个动态加载程序，该加载程序使用 dlopen / dlsym 在运行时形成库。

要在构建时间链接，我使用包装函数，这些功能将 dlsym 设置的功能指针调用。

我遇到了variadic函数的问题，那里似乎没有一种动态加载功能并将其转发为变异参数的方法。

有没有办法编写支持不支持varargs的包装库……

• 取决于知道variadic参数的数量或以哨兵值结束参数。
• 通过更改调用variadic函数的代码（在这种情况下我无法控制）来依赖于解决问题的工作。

似乎可以支持这一点，但是大多数现有的答案都表明，在我的用例中，以不实际的方式解决问题。

对于上下文，我包装的功能签名是：

struct wl_proxy *wl_proxy_marshal_flags(
        struct wl_proxy *proxy,
        uint32_t opcode,
        const struct wl_interface *interface,
        uint32_t version,
        uint32_t flags,
        ...);

此功能通过生成的代码调用（请参阅 Wayland-Scanner ），尽管我宁愿不专门提出这个问题。

---

请注意，已经提出了类似的问题，例如：

• 如何在c
• forwhard c 中的variadic函数调用

，但他们建议在我的用例中使用 vfprintf 诸如使用 vfprintf 。

Answer 1

通常的方法是使variadic函数仅在真实函数上以 va_list 作为参数作为界面。此模式（这是 fprintf 和 vfprintf 在标准库中工作的方式），通过使用 va_list 。

在这里您可以写：

struct wl_proxy *vwl_proxy_marshal_flags(
        struct wl_proxy *proxy,
        uint32_t opcode,
        const struct wl_interface *interface,
        uint32_t version,
        uint32_t flags,
        va_list params) {
    // actual code
    ...
}
struct wl_proxy *wl_proxy_marshal_flags(
        struct wl_proxy *proxy,
        uint32_t opcode,
        const struct wl_interface *interface,
        uint32_t version,
        uint32_t flags,
        ...) {
    va_list params
    va_start(params, flags);
    struct wl_proxy *cr = vwl_proxy_marshal_flags(proxy, opcode,
        interface, version, flags, params);
    va_end(params);
    return cr;
}

Answer 2

假设variadic参数列表中的所有项目均为相同的类型，那么您可以使用此技巧：

将实际函数实现为非variadic的函数，占据数组和大小。以及任意数量的非广播论点。示例：

void actual_func (int this, double that, size_t argc, int argv[argc])
{
  printf("this:%d that:%f\n", this, that);
  for(size_t i=0; i<argc; i++)
    printf("%d ", argv[i]);
}

此处此和 可以是任何类型的任何参数，与示例中的固定参数相对应。 argc 和 argv 分别是大小和数组。

然后，我们可以编写一个variadic宏来将variadic调用转换为一个普通函数调用：

#define COUNT_ARGS(...) ( sizeof((int[]){__VA_ARGS__}) / sizeof(int) )
#define func(this,that,...) actual_func(this, that, COUNT_ARGS(__VA_ARGS__), (int[]){__VA_ARGS__})

辅助宏 count_args 计算variadic项目的数量 - 它们都必须是 int 或它行不通。这给出了数组大小。然后，以变色的参数初始化了以复合文字形式的临时数组，然后传递给该函数。完整的示例：

#include <stdio.h>

void actual_func (int this, double that, size_t argc, int argv[argc])
{
  printf("this:%d that:%f\n", this, that);
  for(size_t i=0; i<argc; i++)
    printf("%d ", argv[i]);
}

#define COUNT_ARGS(...) ( sizeof((int[]){__VA_ARGS__}) / sizeof(int) )
#define func(this,that,...) actual_func(this,that,COUNT_ARGS(__VA_ARGS__),(int[]){__VA_ARGS__})

int main (void) 
{
  func(1, 1.0f, 1, 2, 3);
}

这与整数分配具有相同的类型安全性，含义是SO-SO，但它比Variadic函数更安全。

Answer 3

坏消息：我认为没有一个通用（与平台无关的）解决方案。

好消息：Wayland的开发人员似乎已经想到了这个问题，这就是为什么他们创建了 _array _ 函数，例如 Wayland-client-core.h ：

struct wl_proxy *
wl_proxy_marshal_flags(struct wl_proxy *proxy, uint32_t opcode,
                       const struct wl_interface *interface,
                       uint32_t version,
                       uint32_t flags, ...);

struct wl_proxy *
wl_proxy_marshal_array_flags(struct wl_proxy *proxy, uint32_t opcode,
                             const struct wl_interface *interface,
                             uint32_t version,
                             uint32_t flags,
                             union wl_argument *args);

以前的函数调用后者的函数：

WL_EXPORT struct wl_proxy *
wl_proxy_marshal_flags(struct wl_proxy *proxy, uint32_t opcode,
                       const struct wl_interface *interface, uint32_t version,
                       uint32_t flags, ...)
{
        union wl_argument args[WL_CLOSURE_MAX_ARGS];
        va_list ap;

        va_start(ap, flags);
        wl_argument_from_va_list(proxy->object.interface->methods[opcode].signature,
                                 args, WL_CLOSURE_MAX_ARGS, ap);
        va_end(ap);

        return wl_proxy_marshal_array_flags(proxy, opcode, interface, version, flags, args);
}