Question

我需要编写一个自动生成函数的宏，该函数将所有参数转发给另一个（成员）函数。

如果您需要知道我为什么需要它，我需要简化JNI胶水的编写。我会省略其他原因，为什么我需要这样做，我只是提到我不能使用boost（虽然，我可能会删掉所需的部分并从boost转换为我自己的宏）;我还检查了一些其他的库（jace等），但没有找到任何符合我需要的东西。

简而言之，这是JNI函数的示例：

class TestClass
{
    void nativeTest(JNIEnv *, jobject, jint, jboolean)
    {
        ...
    }

    static TestClass* getPeer(JNIEnv *, jobject obj)
    {
        ...
    }
}

JNIEXPORT void JNICALL Java_com_noname_media_TestClass_nativeTest(
    JNIEnv *env, jobject obj, jint i, jboolean b
)
{
    TestClass* peer = TestClass::getPeer(env, obj, i, b);
    if(peer)
        return peer->nativeTest(env, obj, i, b);
    return;
}

现在，我想编写一些JNI_FUNCTION宏来自动生成所有Java_com_noname_media_TestClass_nativeTest。经过一番思考，我想我能做到这样的事情：

#define JNI_FUNCTION(functionName, functionReturn, functionArgs) \
JNIEXPORT functionReturn JNICALL                                 \
  Java_com_noname_media_TestClass##functionName(**WTF**)         \
{
        TestClass* peer = TestClass::getPeer(**WTF**);
        if(peer)
            return peer->functionName(**WTF**);
        return;
}

然后，要使用JNI_FUNCTION，我可以这样做：

JNI_FUNCTION(nativeTest, void, (JNIEnv *, jobject, jint, jboolean));

问题是我不知道如何“破解”函数参数，因为我需要为functionArgs列表中的每个条目添加自动编号的参数名称。

其他陷阱：返回类型可以是某种类型或无效，但对于void case，我可能有单独的JNI_VOID_FUNCTION，以防使用常规方法无法轻松完成。在我的情况下，所有jni函数在functionArgs列表中始终至少有两个args，例如它不能是空列表()。我不必将functionArgs用作包含多个参数的单个参数，我也可以这样做：

#define JNI_FUNCTION(functionName, functionReturn, ...)

无论什么有用......也许我需要一些允许我在某个位置提取某些宏的宏，比如ARG_1（...）等，但到目前为止，我无法将其全部包含在脑中这样做。

PS。我记得一些关于c-preprocessor使用的超酷例子，在SO中有很好的解释，但现在找不到它们，如果你有书签，也许我只需要查看它们。

修改基本上，诀窍是为每个参数添加自动编号的名称，然后按原样将它们传递给成员函数。我需要这样做的原因是因为最重要的是我用预处理器做了一些其他的自动生成。简而言之，这个宏实际上将用于一组类似的宏（类似于ATL / WTL）：

JNI_TABLE_BEGIN(ClassName)
  JNI_FUNCTION(native1, void, (JNIEnv *, jobject, jint))
  JNI_FUNCTION(native2, void, (JNIEnv *, jobject, jint))
  JNI_FUNCTION(native3, jint, (JNIEnv *, jobject))
JNI_TABLE_END()

Answer 1

以下是使用Boost.Preprocessor Sequences的解决方案：

#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/seq/size.hpp>
#include <boost/preprocessor/seq/enum.hpp>
#include <boost/preprocessor/list/append.hpp>
#include <boost/preprocessor/seq/for_each_i.hpp>
#include <boost/preprocessor/control/expr_if.hpp>
#include <boost/preprocessor/comparison/equal.hpp>
#include <boost/preprocessor/facilities/expand.hpp>

#define RET_TYPE_void 1)(1
#define IS_NOT_VOID(type) BOOST_PP_EQUAL(BOOST_PP_SEQ_SIZE((BOOST_PP_CAT(RET_TYPE_,type))),1)

#define JNI_PARAMS(r, data, i, elem) (elem p##i)
#define JNI_ARGS_PASS(r, data, i, elem) (p##i)

#define JNI_FUNCTION(functionName, functionReturn, PARAMS ) \
JNIEXPORT functionReturn JNICALL \
    Java_com_noname_media_TestClass##functionName(BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_FOR_EACH_I(JNI_PARAMS,_,PARAMS)))  \
{ \
    TestClass* peer = TestClass::getPeer(BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_FOR_EACH_I(JNI_ARGS_PASS,_,PARAMS))); \
    if(peer) \
        BOOST_PP_EXPR_IF(IS_NOT_VOID(functionReturn),return) peer->functionName(BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_FOR_EACH_I(JNI_ARGS_PASS,_,PARAMS))); \
    BOOST_PP_EXPR_IF(IS_NOT_VOID(functionReturn),return functionReturn();) \
} \
/**/

JNI_FUNCTION(nativeTest, void, (jobject)(jint)(jboolean))

扩展为：

JNIEXPORT void JNICALL
Java_com_noname_media_TestClassnativeTest(jobject p0, jint p1, jboolean p2)
{
    TestClass* peer = TestClass::getPeer(p0, p1, p2);
    if(peer)
        peer->nativeTest(p0, p1, p2);
}

所以，你的例子将成为：

#define JNI_TABLE_BEGIN(name) class name { public:
#define JNI_TABLE_END() };

JNI_TABLE_BEGIN(ClassName)
  JNI_FUNCTION(native1, void, (JNIEnv *)(jobject)(jint) )
  JNI_FUNCTION(native2, void, (JNIEnv *)(jobject)(jint) )
  JNI_FUNCTION(native3, jint, (JNIEnv *)(jobject) )
JNI_TABLE_END()

它扩展为：

class ClassName
{
public:
    JNIEXPORT void JNICALL
    Java_com_noname_media_TestClassnative1(JNIEnv * p0, jobject p1, jint p2)
    {
        TestClass* peer = TestClass::getPeer(p0, p1, p2);
        if(peer)
            peer->native1(p0, p1, p2);
    }
    JNIEXPORT void JNICALL
    Java_com_noname_media_TestClassnative2(JNIEnv * p0, jobject p1, jint p2)
    {
        TestClass* peer = TestClass::getPeer(p0, p1, p2);
        if(peer)
            peer->native2(p0, p1, p2);
    }
    JNIEXPORT jint JNICALL
    Java_com_noname_media_TestClassnative3(JNIEnv * p0, jobject p1)
    {
        TestClass* peer = TestClass::getPeer(p0, p1);
        if(peer)
            return peer->native3(p0, p1);
        return jint();
    }
};

Answer 2

到目前为止，我有一个可能适合作为解决方案的想法。通过SO回答我found an example on how to count number of arguments。使用这个宏我可以连接functionArgs的args计数并调用一些预定义的宏，例如。 JNI_FUNCTION_5在args列表中占用5个args。我只需要能够从 VA_ARGS 列表中提取一些参数。像__VA_ARG_N（num）。

这样的宏

这是从__VA_ARGS__中提取一些参数的方法：

#define ARG_REST(arg, ...) __VA_ARGS__
#define ARG0(arg0, ...) arg0
#define ARG1(...) ARG0(ARG_REST(__VA_ARGS__))
#define ARG2(...) ARG1(ARG_REST(__VA_ARGS__))
... etc.

然后我编写了一个特殊的宏来生成列表参数类型对或仅参数。

所以，最终，我设法做到了：

JNI_FUNCTION(void, nativeSetOrientation, (JNIEnv *, jobject, jint, jboolean));
JNI_FUNCTION(void, nativeStartRecording, (JNIEnv *, jobject, jstring, jint));

修复的唯一问题是为void returnType 添加特殊处理，如下所示：

    if(peer)
        IS_NOT_VOID(returnType, return) peer->functionName(**WTF**);
    IS_NOT_VOID(returnType, return returnType();)

IS_NOT_VOID应该执行此操作：

#define IS_NOT_VOID(type, expr) if(type == void) expr

即

IS_NOT_VOID(void, return void();) -> expands to nothing
IS_NOT_VOID(int, return int();) -> expands to return int();

知道怎么做得好吗？除了迭代所有可能类型的明显解决方案，并为可以传递给JNI函数的所有类型创建30个定义。像这样：

#define _IF_NOT_VOID(type, expr) _IF_NOT_VOID##type(expr)
#define _IF_NOT_VOIDvoid(expr) //void type...
#define _IF_NOT_VOIDjboolean(expr) expr
#define _IF_NOT_VOIDjbyte(expr) expr
#define _IF_NOT_VOIDjchar(expr) expr

使用c-preprocessor自动生成函数转发器

2 个答案: