1

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

如果您需要知道我为什么需要它，我需要简化编写 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，但对于 void 情况，我可能会分开JNI_VOID_FUNCTION，以防使用常规方式无法轻松完成。在我的例子中，所有 jni 函数在列表中总是至少有两个 args functionArgs，例如它不能是空列表()。我不必将 functionArgs 用作包含多个参数的单个参数，我也可以这样：

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

无论如何工作......也许我需要某种宏来允许我在某个位置提取一些宏，例如 ARG_1(...) 等，但到目前为止我无法将它全部包装在我的大脑中如何做到这一点.

PS。我记得一些关于使用 c 预处理器的超酷示例，在 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()
4

2 回答 2

3

这是使用 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();
    }
};
于 2012-10-26T22:09:59.430 回答
0

到目前为止，我有一个可能适合作为解决方案的想法。浏览 SO 答案，我找到了一个关于如何计算参数数量的示例。使用这个宏，我可以连接 args 的数量functionArgs并调用一些预定义的宏，例如。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
于 2012-10-26T22:01:19.497 回答