From a9b7950e542e8542f08437e2d87f6ec2133101b6 Mon Sep 17 00:00:00 2001 From: satoren Date: Sat, 6 Aug 2016 04:35:37 +0900 Subject: [PATCH] refactoring C++03 macros --- include/kaguya/another_binding_api.hpp | 9 +- include/kaguya/detail/lua_function_def.hpp | 173 ++++++++------------- include/kaguya/detail/lua_variant_def.hpp | 29 +--- include/kaguya/lua_ref.hpp | 12 +- include/kaguya/lua_ref_function.hpp | 94 +++++------ include/kaguya/metatable.hpp | 37 ++--- include/kaguya/native_function.hpp | 17 +- include/kaguya/native_function_cxx03.hpp | 3 + include/kaguya/object.hpp | 23 +-- include/kaguya/preprocess.hpp | 6 + include/kaguya/utility.hpp | 8 +- include/kaguya/utility_cxx03.hpp | 5 +- 12 files changed, 153 insertions(+), 263 deletions(-) diff --git a/include/kaguya/another_binding_api.hpp b/include/kaguya/another_binding_api.hpp index 6a511d19..c46bb18d 100644 --- a/include/kaguya/another_binding_api.hpp +++ b/include/kaguya/another_binding_api.hpp @@ -141,16 +141,13 @@ namespace kaguya template class_& constructor() { this->template setConstructors(); return *this; } #else -#define KAGUYA_TEMPLATE_PARAMETER(N) + class_& constructor() { this->template setConstructors(); return *this; } + #define KAGUYA_ADD_CON_FN_DEF(N) \ - KAGUYA_TEMPLATE_PARAMETER(N)\ + template\ class_& constructor() { this->template setConstructors(); return *this; } - KAGUYA_ADD_CON_FN_DEF(0) -#undef KAGUYA_TEMPLATE_PARAMETER -#define KAGUYA_TEMPLATE_PARAMETER(N) template KAGUYA_PP_REPEAT_DEF(KAGUYA_FUNCTION_MAX_ARGS, KAGUYA_ADD_CON_FN_DEF) -#undef KAGUYA_TEMPLATE_PARAMETER #undef KAGUYA_ADD_CON_FN_DEF #endif diff --git a/include/kaguya/detail/lua_function_def.hpp b/include/kaguya/detail/lua_function_def.hpp index 32cc70c1..da591d3c 100644 --- a/include/kaguya/detail/lua_function_def.hpp +++ b/include/kaguya/detail/lua_function_def.hpp @@ -97,68 +97,49 @@ namespace kaguya template FunctionResults operator()(Args&&... args); #else -#define KAGUYA_PP_TEMPLATE(N) ,KAGUYA_PP_CAT(typename A,N) -#define KAGUYA_PP_FARG(N) const KAGUYA_PP_CAT(A,N)& KAGUYA_PP_CAT(a,N) -#define KAGUYA_PUSH_ARG_DEF(N) ,KAGUYA_PP_CAT(a,N) #define KAGUYA_CALL_DEF(N) \ - template\ - Result call(KAGUYA_PP_REPEAT_ARG(N,KAGUYA_PP_FARG))\ - {\ - lua_State* state = state_();\ - if (!state)\ + template\ + Result call(KAGUYA_PP_ARG_CR_DEF_REPEAT(N))\ {\ - except::typeMismatchError(state, "is nil");\ - return Result();\ - }\ - int argstart = lua_gettop(state) + 1;\ - push_(state);\ - int argnum = util::push_args(state KAGUYA_PP_REPEAT(N,KAGUYA_PUSH_ARG_DEF));\ - int result = lua_pcall_wrap(state, argnum, LUA_MULTRET);\ - except::checkErrorAndThrow(result, state);\ - return detail::FunctionResultProxy::ReturnValue(state,result, argstart, types::typetag());\ - } + lua_State* state = state_();\ + if (!state)\ + {\ + except::typeMismatchError(state, "is nil");\ + return Result();\ + }\ + int argstart = lua_gettop(state) + 1;\ + push_(state);\ + int argnum = util::push_args(state KAGUYA_PP_ARG_REPEAT_CONCAT(N));\ + int result = lua_pcall_wrap(state, argnum, LUA_MULTRET);\ + except::checkErrorAndThrow(result, state);\ + return detail::FunctionResultProxy::ReturnValue(state,result, argstart, types::typetag());\ + } - KAGUYA_CALL_DEF(0) - KAGUYA_PP_REPEAT_DEF(KAGUYA_FUNCTION_MAX_ARGS, KAGUYA_CALL_DEF) + KAGUYA_CALL_DEF(0); + KAGUYA_PP_REPEAT_DEF(KAGUYA_FUNCTION_MAX_ARGS, KAGUYA_CALL_DEF); -#undef KAGUYA_PUSH_DEF -#undef KAGUYA_PUSH_ARG_DEF -#undef KAGUYA_PP_TEMPLATE #undef KAGUYA_RESUME_DEF -#define KAGUYA_TEMPLATE_PARAMETER(N) -#define KAGUYA_FUNCTION_ARGS_DEF(N) -#define KAGUYA_CALL_ARGS(N) -#define KAGUYA_OP_FN_DEF(N) \ - KAGUYA_TEMPLATE_PARAMETER(N)\ - inline FunctionResults operator()(KAGUYA_FUNCTION_ARGS_DEF(N)); + inline FunctionResults operator()(); - KAGUYA_OP_FN_DEF(0) -#undef KAGUYA_TEMPLATE_PARAMETER -#undef KAGUYA_FUNCTION_ARGS_DEF -#undef KAGUYA_CALL_ARGS -#define KAGUYA_TEMPLATE_PARAMETER(N) template -#define KAGUYA_FUNCTION_ARGS_DEF(N) KAGUYA_PP_REPEAT_ARG(N,KAGUYA_PP_FARG) -#define KAGUYA_CALL_ARGS(N) KAGUYA_PP_REPEAT_ARG(N, KAGUYA_PUSH_ARG_DEF) +#define KAGUYA_OP_FN_DEF(N) \ + template\ + inline FunctionResults operator()(KAGUYA_PP_ARG_CR_DEF_REPEAT(N)); + -#define KAGUYA_PP_TEMPLATE(N) KAGUYA_PP_CAT(typename A,N) -#define KAGUYA_PUSH_ARG_DEF(N) KAGUYA_PP_CAT(a,N) +#define KAGUYA_FUNCTION_ARGS_DEF(N) +#define KAGUYA_CALL_ARGS(N) KAGUYA_PP_ARG_REPEAT(N) - KAGUYA_PP_REPEAT_DEF(KAGUYA_FUNCTION_MAX_ARGS, KAGUYA_OP_FN_DEF) + KAGUYA_PP_REPEAT_DEF(KAGUYA_FUNCTION_MAX_ARGS, KAGUYA_OP_FN_DEF); #undef KAGUYA_OP_FN_DEF -#undef KAGUYA_TEMPLATE_PARAMETER #undef KAGUYA_CALL_ARGS #undef KAGUYA_FUNCTION_ARGS_DEF -#undef KAGUYA_PUSH_ARG_DEF -#undef KAGUYA_PP_TEMPLATE -#undef KAGUYA_PP_FARG #undef KAGUYA_CALL_DEF -#undef KAGUYA_OP_FN_DEF #endif @@ -211,80 +192,50 @@ namespace kaguya template FunctionResults operator()(Args&&... args); #else - -#define KAGUYA_PP_TEMPLATE(N) ,KAGUYA_PP_CAT(typename A,N) -#define KAGUYA_PP_FARG(N) const KAGUYA_PP_CAT(A,N)& KAGUYA_PP_CAT(a,N) -#define KAGUYA_PUSH_ARG_DEF(N) ,KAGUYA_PP_CAT(a,N) - #define KAGUYA_RESUME_DEF(N) \ - template\ - Result resume(KAGUYA_PP_REPEAT_ARG(N,KAGUYA_PP_FARG))\ - {\ - lua_State* state = state_();\ - if (!state)\ + template\ + Result resume(KAGUYA_PP_ARG_CR_DEF_REPEAT(N))\ {\ - except::typeMismatchError(state, "is nil");\ - return Result();\ - }\ - util::ScopedSavedStack save(state);\ - int corStackIndex = pushStackIndex_(state);\ - lua_State* thread = lua_tothread(state, corStackIndex);\ - if (!thread)\ - {\ - except::typeMismatchError(state, "not thread");\ - return Result();\ - }\ - int argstart = 1;\ - if (lua_status(thread) == LUA_YIELD)\ - {\ - argstart = 0;\ - }\ - util::push_args(thread KAGUYA_PP_REPEAT(N, KAGUYA_PUSH_ARG_DEF));\ - int argnum = lua_gettop(thread) - argstart;\ - if (argnum < 0) { argnum = 0; }\ - int result = lua_resume(thread, state, argnum);\ - except::checkErrorAndThrow(result, thread);\ - return detail::FunctionResultProxy::ReturnValue(thread,result, 1, types::typetag());\ - } - - KAGUYA_RESUME_DEF(0) - KAGUYA_PP_REPEAT_DEF(KAGUYA_FUNCTION_MAX_ARGS, KAGUYA_RESUME_DEF) - -#undef KAGUYA_PUSH_DEF -#undef KAGUYA_PUSH_ARG_DEF -#undef KAGUYA_PP_TEMPLATE -#undef KAGUYA_RESUME_DEF - -#define KAGUYA_TEMPLATE_PARAMETER(N) -#define KAGUYA_FUNCTION_ARGS_DEF(N) -#define KAGUYA_CALL_ARGS(N) - -#define KAGUYA_OP_FN_DEF(N) \ - KAGUYA_TEMPLATE_PARAMETER(N)\ - inline FunctionResults operator()(KAGUYA_FUNCTION_ARGS_DEF(N)); + lua_State* state = state_();\ + if (!state)\ + {\ + except::typeMismatchError(state, "is nil");\ + return Result();\ + }\ + util::ScopedSavedStack save(state);\ + int corStackIndex = pushStackIndex_(state);\ + lua_State* thread = lua_tothread(state, corStackIndex);\ + if (!thread)\ + {\ + except::typeMismatchError(state, "not thread");\ + return Result();\ + }\ + int argstart = 1;\ + if (lua_status(thread) == LUA_YIELD)\ + {\ + argstart = 0;\ + }\ + util::push_args(thread KAGUYA_PP_ARG_REPEAT_CONCAT(N));\ + int argnum = lua_gettop(thread) - argstart;\ + if (argnum < 0) { argnum = 0; }\ + int result = lua_resume(thread, state, argnum);\ + except::checkErrorAndThrow(result, thread);\ + return detail::FunctionResultProxy::ReturnValue(thread,result, 1, types::typetag());\ + } - KAGUYA_OP_FN_DEF(0) + KAGUYA_RESUME_DEF(0); + KAGUYA_PP_REPEAT_DEF(KAGUYA_FUNCTION_MAX_ARGS, KAGUYA_RESUME_DEF); -#undef KAGUYA_TEMPLATE_PARAMETER -#undef KAGUYA_FUNCTION_ARGS_DEF -#undef KAGUYA_CALL_ARGS -#define KAGUYA_TEMPLATE_PARAMETER(N) template -#define KAGUYA_FUNCTION_ARGS_DEF(N) KAGUYA_PP_REPEAT_ARG(N,KAGUYA_PP_FARG) -#define KAGUYA_CALL_ARGS(N) KAGUYA_PP_REPEAT_ARG(N, KAGUYA_PUSH_ARG_DEF) +#undef KAGUYA_RESUME_DEF -#define KAGUYA_PP_TEMPLATE(N) KAGUYA_PP_CAT(typename A,N) -#define KAGUYA_PUSH_ARG_DEF(N) KAGUYA_PP_CAT(a,N) + inline FunctionResults operator()(); - KAGUYA_PP_REPEAT_DEF(KAGUYA_FUNCTION_MAX_ARGS, KAGUYA_OP_FN_DEF) -#undef KAGUYA_OP_FN_DEF -#undef KAGUYA_TEMPLATE_PARAMETER +#define KAGUYA_OP_FN_DEF(N) \ + template\ + inline FunctionResults operator()(KAGUYA_PP_ARG_CR_DEF_REPEAT(N)); + + KAGUYA_PP_REPEAT_DEF(KAGUYA_FUNCTION_MAX_ARGS, KAGUYA_OP_FN_DEF); -#undef KAGUYA_CALL_ARGS -#undef KAGUYA_FUNCTION_ARGS_DEF -#undef KAGUYA_PUSH_ARG_DEF -#undef KAGUYA_PP_TEMPLATE -#undef KAGUYA_PP_FARG -#undef KAGUYA_CALL_DEF #undef KAGUYA_OP_FN_DEF #endif diff --git a/include/kaguya/detail/lua_variant_def.hpp b/include/kaguya/detail/lua_variant_def.hpp index b6ae6699..beabba7a 100644 --- a/include/kaguya/detail/lua_variant_def.hpp +++ b/include/kaguya/detail/lua_variant_def.hpp @@ -76,33 +76,14 @@ namespace kaguya #if KAGUYA_USE_CPP11 template FunctionResults operator()(Args&&... args); #else -#define KAGUYA_TEMPLATE_PARAMETER(N) -#define KAGUYA_FUNCTION_ARGS_DEF(N) -#define KAGUYA_PP_FARG(N) const KAGUYA_PP_CAT(A,N)& KAGUYA_PP_CAT(a,N) + inline FunctionResults operator()(); #define KAGUYA_OP_FN_DEF(N) \ - KAGUYA_TEMPLATE_PARAMETER(N)\ - inline FunctionResults operator()(KAGUYA_FUNCTION_ARGS_DEF(N)); + template\ + inline FunctionResults operator()(KAGUYA_PP_ARG_CR_DEF_REPEAT(N)); - KAGUYA_OP_FN_DEF(0) - -#undef KAGUYA_TEMPLATE_PARAMETER -#undef KAGUYA_FUNCTION_ARGS_DEF -#define KAGUYA_TEMPLATE_PARAMETER(N) template -#define KAGUYA_FUNCTION_ARGS_DEF(N) KAGUYA_PP_REPEAT_ARG(N,KAGUYA_PP_FARG) - -#define KAGUYA_PP_TEMPLATE(N) KAGUYA_PP_CAT(typename A,N) -#define KAGUYA_PUSH_ARG_DEF(N) KAGUYA_PP_CAT(a,N) - - KAGUYA_PP_REPEAT_DEF(KAGUYA_FUNCTION_MAX_ARGS, KAGUYA_OP_FN_DEF) -#undef KAGUYA_OP_FN_DEF -#undef KAGUYA_TEMPLATE_PARAMETER - -#undef KAGUYA_FUNCTION_ARGS_DEF -#undef KAGUYA_PUSH_ARG_DEF -#undef KAGUYA_PP_TEMPLATE -#undef KAGUYA_PP_FARG -#undef KAGUYA_CALL_DEF + + KAGUYA_PP_REPEAT_DEF(KAGUYA_FUNCTION_MAX_ARGS, KAGUYA_OP_FN_DEF); #undef KAGUYA_OP_FN_DEF #endif }; diff --git a/include/kaguya/lua_ref.hpp b/include/kaguya/lua_ref.hpp index bf101289..c5239e29 100644 --- a/include/kaguya/lua_ref.hpp +++ b/include/kaguya/lua_ref.hpp @@ -50,18 +50,14 @@ namespace kaguya { return standard::tuple<>(); } - -#define KAGUYA_PP_TEMPLATE(N) KAGUYA_PP_CAT(typename A,N) -#define KAGUYA_PP_TARG(N) KAGUYA_PP_CAT(A,N) + #define KAGUYA_GET_DEF(N) lua_type_traits::get(l, N + startindex - 1) -#define KAGUYA_GET_TUPLE_DEF(N) template\ - inline standard::tuple get_result_impl(lua_State *l,int startindex,types::typetag >)\ +#define KAGUYA_GET_TUPLE_DEF(N) template\ + inline standard::tuple get_result_impl(lua_State *l,int startindex,types::typetag >)\ {\ - return standard::tuple(KAGUYA_PP_REPEAT_ARG(N,KAGUYA_GET_DEF));\ + return standard::tuple(KAGUYA_PP_REPEAT_ARG(N,KAGUYA_GET_DEF));\ } KAGUYA_PP_REPEAT_DEF(KAGUYA_FUNCTION_MAX_TUPLE_SIZE, KAGUYA_GET_TUPLE_DEF) -#undef KAGUYA_PP_TEMPLATE -#undef KAGUYA_PP_TARG #undef KAGUYA_GET_DEF #undef KAGUYA_GET_TUPLE_DEF #endif diff --git a/include/kaguya/lua_ref_function.hpp b/include/kaguya/lua_ref_function.hpp index 68d5b95d..0f60a793 100644 --- a/include/kaguya/lua_ref_function.hpp +++ b/include/kaguya/lua_ref_function.hpp @@ -253,59 +253,53 @@ namespace kaguya #define KAGUYA_TEMPLATE_PARAMETER(N)template #define KAGUYA_FUNCTION_ARGS_DEF(N) #define KAGUYA_CALL_ARGS(N) -#define KAGUYA_PP_FARG(N) const KAGUYA_PP_CAT(A,N)& KAGUYA_PP_CAT(a,N) #define KAGUYA_OP_FN_DEF(N) \ - KAGUYA_TEMPLATE_PARAMETER(N)\ - inline FunctionResults LuaFunctionImpl::operator()(KAGUYA_FUNCTION_ARGS_DEF(N))\ - {\ - return this->template call(KAGUYA_CALL_ARGS(N)); \ - }\ - KAGUYA_TEMPLATE_PARAMETER(N)\ - inline FunctionResults LuaThreadImpl::operator()(KAGUYA_FUNCTION_ARGS_DEF(N))\ - {\ - return this->template resume(KAGUYA_CALL_ARGS(N)); \ - }\ - KAGUYA_TEMPLATE_PARAMETER(N)\ - inline FunctionResults LuaVariantImpl::operator()(KAGUYA_FUNCTION_ARGS_DEF(N))\ - {\ - int t = type();\ - if (t == LUA_TTHREAD)\ - {\ - return this->template resume(KAGUYA_CALL_ARGS(N)); \ - }\ - else if (t == LUA_TFUNCTION)\ - {\ + KAGUYA_TEMPLATE_PARAMETER(N)\ + inline FunctionResults LuaFunctionImpl::operator()(KAGUYA_FUNCTION_ARGS_DEF(N))\ + {\ return this->template call(KAGUYA_CALL_ARGS(N)); \ - }\ - else\ - {\ - except::typeMismatchError(state_(), " is not function or thread");\ - return FunctionResults(state_());\ - }\ - } - - KAGUYA_OP_FN_DEF(0) + }\ + KAGUYA_TEMPLATE_PARAMETER(N)\ + inline FunctionResults LuaThreadImpl::operator()(KAGUYA_FUNCTION_ARGS_DEF(N))\ + {\ + return this->template resume(KAGUYA_CALL_ARGS(N)); \ + }\ + KAGUYA_TEMPLATE_PARAMETER(N)\ + inline FunctionResults LuaVariantImpl::operator()(KAGUYA_FUNCTION_ARGS_DEF(N))\ + {\ + int t = type();\ + if (t == LUA_TTHREAD)\ + {\ + return this->template resume(KAGUYA_CALL_ARGS(N)); \ + }\ + else if (t == LUA_TFUNCTION)\ + {\ + return this->template call(KAGUYA_CALL_ARGS(N)); \ + }\ + else\ + {\ + except::typeMismatchError(state_(), " is not function or thread");\ + return FunctionResults(state_());\ + }\ + } + + KAGUYA_OP_FN_DEF(0); #undef KAGUYA_TEMPLATE_PARAMETER #undef KAGUYA_FUNCTION_ARGS_DEF #undef KAGUYA_CALL_ARGS -#define KAGUYA_TEMPLATE_PARAMETER(N) template template -#define KAGUYA_FUNCTION_ARGS_DEF(N) KAGUYA_PP_REPEAT_ARG(N,KAGUYA_PP_FARG) -#define KAGUYA_CALL_ARGS(N) KAGUYA_PP_REPEAT_ARG(N, KAGUYA_PUSH_ARG_DEF) +#define KAGUYA_TEMPLATE_PARAMETER(N) template template +#define KAGUYA_FUNCTION_ARGS_DEF(N) KAGUYA_PP_ARG_CR_DEF_REPEAT(N) +#define KAGUYA_CALL_ARGS(N) KAGUYA_PP_ARG_REPEAT(N) -#define KAGUYA_PP_TEMPLATE(N) KAGUYA_PP_CAT(typename A,N) -#define KAGUYA_PUSH_ARG_DEF(N) KAGUYA_PP_CAT(a,N) - KAGUYA_PP_REPEAT_DEF(KAGUYA_FUNCTION_MAX_ARGS, KAGUYA_OP_FN_DEF) + KAGUYA_PP_REPEAT_DEF(KAGUYA_FUNCTION_MAX_ARGS, KAGUYA_OP_FN_DEF); #undef KAGUYA_OP_FN_DEF #undef KAGUYA_TEMPLATE_PARAMETER #undef KAGUYA_CALL_ARGS #undef KAGUYA_FUNCTION_ARGS_DEF -#undef KAGUYA_PUSH_ARG_DEF -#undef KAGUYA_PP_TEMPLATE -#undef KAGUYA_PP_FARG #undef KAGUYA_CALL_DEF #undef KAGUYA_OP_FN_DEF #endif @@ -440,14 +434,11 @@ namespace kaguya } #else -#define KAGUYA_PP_TEMPLATE(N) KAGUYA_PP_CAT(typename A,N) -#define KAGUYA_PP_FARG(N) const KAGUYA_PP_CAT(A,N)& KAGUYA_PP_CAT(a,N) -#define KAGUYA_PUSH_ARG_DEF(N) KAGUYA_PP_CAT(a,N) #define KAGUYA_OP_FN_DEF(N) \ - template \ - FunctionResults operator()(KAGUYA_PP_REPEAT_ARG(N,KAGUYA_PP_FARG))\ + template \ + FunctionResults operator()(KAGUYA_PP_ARG_CR_DEF_REPEAT(N))\ {\ - return KAGUYA_DELEGATE_LUAREF(KAGUYA_DELEGATE_FIRST_ARG_C KAGUYA_PP_REPEAT_ARG(N, KAGUYA_PUSH_ARG_DEF));\ + return KAGUYA_DELEGATE_LUAREF(KAGUYA_DELEGATE_FIRST_ARG_C KAGUYA_PP_ARG_REPEAT(N));\ } /** @@ -461,11 +452,13 @@ namespace kaguya } KAGUYA_PP_REPEAT_DEF(KAGUYA_FUNCTION_MAX_ARGS, KAGUYA_OP_FN_DEF) +#undef KAGUYA_OP_FN_DEF + #define KAGUYA_CALL_DEF(N) \ - template \ - Result call(KAGUYA_PP_REPEAT_ARG(N,KAGUYA_PP_FARG))\ + template \ + Result call(KAGUYA_PP_ARG_CR_DEF_REPEAT(N))\ {\ - return KAGUYA_DELEGATE_LUAREF.call(KAGUYA_DELEGATE_FIRST_ARG_C KAGUYA_PP_REPEAT_ARG(N, KAGUYA_PUSH_ARG_DEF));\ + return KAGUYA_DELEGATE_LUAREF.call(KAGUYA_DELEGATE_FIRST_ARG_C KAGUYA_PP_ARG_REPEAT(N));\ } template @@ -475,12 +468,7 @@ namespace kaguya } KAGUYA_PP_REPEAT_DEF(KAGUYA_FUNCTION_MAX_ARGS, KAGUYA_CALL_DEF) -#undef KAGUYA_PP_TEMPLATE -#undef KAGUYA_PP_FARG -#undef KAGUYA_PUSH_ARG_DEF -#undef KAGUYA_OP_FN_DEF #undef KAGUYA_CALL_DEF -#undef KAGUYA_RESUME_DEF #endif #undef KAGUYA_DELEGATE_FIRST_ARG_C diff --git a/include/kaguya/metatable.hpp b/include/kaguya/metatable.hpp index 13eb1ee3..6293abee 100644 --- a/include/kaguya/metatable.hpp +++ b/include/kaguya/metatable.hpp @@ -265,18 +265,17 @@ namespace kaguya addOverloadedFunctions("new", typename ConstructorFunction::type()...); return *this; } -#else -#define KAGUYA_TEMPLATE_PARAMETER(N) template +#else #define KAGUYA_SET_CON_TYPE_DEF(N) typename ConstructorFunction::type() #define KAGUYA_SET_CON_FN_DEF(N) \ - KAGUYA_TEMPLATE_PARAMETER(N)\ - inline UserdataMetatable& setConstructors()\ - {\ - addOverloadedFunctions("new",KAGUYA_PP_REPEAT_ARG(N,KAGUYA_SET_CON_TYPE_DEF));\ - return *this;\ - } - KAGUYA_PP_REPEAT_DEF(KAGUYA_FUNCTION_MAX_OVERLOADS, KAGUYA_SET_CON_FN_DEF) -#undef KAGUYA_TEMPLATE_PARAMETER + template\ + inline UserdataMetatable& setConstructors()\ + {\ + addOverloadedFunctions("new",KAGUYA_PP_REPEAT_ARG(N,KAGUYA_SET_CON_TYPE_DEF));\ + return *this;\ + } + + KAGUYA_PP_REPEAT_DEF(KAGUYA_FUNCTION_MAX_OVERLOADS, KAGUYA_SET_CON_FN_DEF); #undef KAGUYA_SET_CON_FN_DEF #undef KAGUYA_SET_CON_TYPE_DEF @@ -407,11 +406,8 @@ namespace kaguya } #else -#define KAGUYA_PP_TEMPLATE(N) KAGUYA_PP_CAT(typename A,N) -#define KAGUYA_PP_FARG(N) const KAGUYA_PP_CAT(A,N)& KAGUYA_PP_CAT(a,N) -#define KAGUYA_PP_FUNCS(N) KAGUYA_PP_CAT(a,N) -#define KAGUYA_ADD_OVERLOAD_FUNCTION_DEF(N) template\ - inline UserdataMetatable& addOverloadedFunctions(const char* name,KAGUYA_PP_REPEAT_ARG(N,KAGUYA_PP_FARG))\ +#define KAGUYA_ADD_OVERLOAD_FUNCTION_DEF(N) template\ + inline UserdataMetatable& addOverloadedFunctions(const char* name,KAGUYA_PP_ARG_CR_DEF_REPEAT(N))\ {\ if (has_key(name))\ {\ @@ -421,10 +417,8 @@ namespace kaguya member_map_[name] = AnyDataPusher(kaguya::overload(KAGUYA_PP_ARG_REPEAT(N)));\ return *this;\ } - KAGUYA_PP_REPEAT_DEF(KAGUYA_FUNCTION_MAX_OVERLOADS, KAGUYA_ADD_OVERLOAD_FUNCTION_DEF) -#undef KAGUYA_PP_TEMPLATE -#undef KAGUYA_PP_FARG -#undef KAGUYA_PP_FUNCS + + KAGUYA_PP_REPEAT_DEF(KAGUYA_FUNCTION_MAX_OVERLOADS, KAGUYA_ADD_OVERLOAD_FUNCTION_DEF); #undef KAGUYA_ADD_OVERLOAD_FUNCTION_DEF #endif @@ -555,12 +549,11 @@ namespace kaguya } #else -#define KAGUYA_TEMPLATE_PARAMETER(N) template #define KAGUYA_GET_BASE_METATABLE(N) class_userdata::get_metatable(state);\ metabases.setRawField(metabases.size() + 1, LuaTable(state, StackTop())); \ pconverter.add_type_conversion(); #define KAGUYA_MULTIPLE_INHERITANCE_SETBASE_DEF(N) \ - KAGUYA_TEMPLATE_PARAMETER(N)\ + template\ void set_base_metatable(lua_State* state, LuaStackRef& metatable, types::typetag > metatypes)const\ {\ PointerConverter& pconverter = PointerConverter::get(state);\ @@ -571,10 +564,8 @@ namespace kaguya }\ KAGUYA_PP_REPEAT_DEF(KAGUYA_FUNCTION_MAX_TUPLE_SIZE, KAGUYA_MULTIPLE_INHERITANCE_SETBASE_DEF) -#undef KAGUYA_TEMPLATE_PARAMETER #undef KAGUYA_MULTIPLE_INHERITANCE_SETBASE_DEF #undef KAGUYA_GET_BASE_METATABLE -#undef KAGUYA_TYPE_CHECK_REP #endif bool has_key(const std::string& key) diff --git a/include/kaguya/native_function.hpp b/include/kaguya/native_function.hpp index 943cb4e7..f2d5ae1d 100644 --- a/include/kaguya/native_function.hpp +++ b/include/kaguya/native_function.hpp @@ -679,28 +679,19 @@ namespace kaguya } #if KAGUYA_USE_CPP11 - template FunctionInvokerType > overload(Functions... fns) { return FunctionInvokerType >(fntuple::tuple(fns...)); } #else -#define KAGUYA_DEF_TEMPLATE(N) KAGUYA_PP_CAT(typename F,N) -#define KAGUYA_TEMPLATE_ARG_DEF(N) KAGUYA_PP_CAT(F,N) -#define KAGUYA_TUPLE_ARG_DEF(N) KAGUYA_PP_CAT(f,N) -#define KAGUYA_ARG_DEF(N) KAGUYA_PP_CAT(F,N) KAGUYA_PP_CAT(f,N) -#define KAGUYA_FOVERLOAD_DEF(N) template\ - FunctionInvokerType > overload(KAGUYA_PP_REPEAT_ARG(N,KAGUYA_ARG_DEF))\ +#define KAGUYA_FOVERLOAD_DEF(N) template\ + FunctionInvokerType > overload(KAGUYA_PP_ARG_DEF_REPEAT(N))\ {\ - typedef typename fntuple::tuple ttype;\ - return FunctionInvokerType(ttype(KAGUYA_PP_REPEAT_ARG(N,KAGUYA_TUPLE_ARG_DEF)));\ + typedef typename fntuple::tuple ttype;\ + return FunctionInvokerType(ttype(KAGUYA_PP_ARG_REPEAT(N)));\ } KAGUYA_PP_REPEAT_DEF(KAGUYA_FUNCTION_MAX_OVERLOADS, KAGUYA_FOVERLOAD_DEF) -#undef KAGUYA_DEF_TEMPLATE -#undef KAGUYA_TEMPLATE_ARG_DEF -#undef KAGUYA_TUPLE_ARG_DEF -#undef KAGUYA_ARG_DEF #undef KAGUYA_FOVERLOAD_DEF #endif diff --git a/include/kaguya/native_function_cxx03.hpp b/include/kaguya/native_function_cxx03.hpp index 486575f6..c57d4a70 100644 --- a/include/kaguya/native_function_cxx03.hpp +++ b/include/kaguya/native_function_cxx03.hpp @@ -62,6 +62,7 @@ namespace kaguya KAGUYA_CALL_FN_DEF(0); KAGUYA_PP_REPEAT_DEF(KAGUYA_FUNCTION_MAX_ARGS, KAGUYA_CALL_FN_DEF); +#undef KAGUYA_CALL_FN_DEF #undef KAGUYA_CALL_FN_DEF #undef KAGUYA_FUNC_DEF @@ -144,6 +145,7 @@ namespace kaguya KAGUYA_CONSTRUCTOR_CALL_FN_DEF(0); KAGUYA_PP_REPEAT_DEF(KAGUYA_FUNCTION_MAX_ARGS, KAGUYA_CONSTRUCTOR_CALL_FN_DEF); +#undef KAGUYA_CONSTRUCTOR_CALL_FN_DEF template struct ConstructorFunction; @@ -163,6 +165,7 @@ namespace kaguya KAGUYA_F_TO_CONSIG_DEF(0); KAGUYA_PP_REPEAT_DEF(KAGUYA_FUNCTION_MAX_ARGS, KAGUYA_F_TO_CONSIG_DEF); +#undef KAGUYA_F_TO_CONSIG_DEF } using nativefunction::ConstructorFunction; } diff --git a/include/kaguya/object.hpp b/include/kaguya/object.hpp index 1f4a41ac..869f64bf 100644 --- a/include/kaguya/object.hpp +++ b/include/kaguya/object.hpp @@ -64,25 +64,12 @@ namespace kaguya #else ObjectWrapper() : object_() {} - template - ObjectWrapper(const Arg1& v1) : object_(v1) {} - template - ObjectWrapper(const Arg1& v1, const Arg2& v2) : object_(v1, v2) {} - template - ObjectWrapper(const Arg1& v1, const Arg2& v2, const Arg3& v3) : object_(v1, v2, v3) {} - template - ObjectWrapper(const Arg1& v1, const Arg2& v2, const Arg3& v3, const Arg4& v4) : object_(v1, v2, v3, v4) {} - template - ObjectWrapper(const Arg1& v1, const Arg2& v2, const Arg3& v3, const Arg4& v4, const Arg5& v5) : object_(v1, v2, v3, v4, v5) {} - template - ObjectWrapper(const Arg1& v1, const Arg2& v2, const Arg3& v3, const Arg4& v4, const Arg5& v5, const Arg6& v6) : object_(v1, v2, v3, v4, v5, v6) {} - template - ObjectWrapper(const Arg1& v1, const Arg2& v2, const Arg3& v3, const Arg4& v4, const Arg5& v5, const Arg6& v6, const Arg7& v7) : object_(v1, v2, v3, v4, v5, v6, v7) {} - template - ObjectWrapper(const Arg1& v1, const Arg2& v2, const Arg3& v3, const Arg4& v4, const Arg5& v5, const Arg6& v6, const Arg7& v7, const Arg8& v8) : object_(v1, v2, v3, v4, v5, v6, v7, v8) {} - template - ObjectWrapper(const Arg1& v1, const Arg2& v2, const Arg3& v3, const Arg4& v4, const Arg5& v5, const Arg6& v6, const Arg7& v7, const Arg8& v8, const Arg9& v9) : object_(v1, v2, v3, v4, v5, v6, v7, v8, v9) {} +#define KAGUYA_OBJECT_WRAPPER_CONSTRUCTOR_DEF(N) \ + template\ + ObjectWrapper(KAGUYA_PP_ARG_DEF_REPEAT(N)):object_(KAGUYA_PP_ARG_REPEAT(N)){} + KAGUYA_PP_REPEAT_DEF(KAGUYA_FUNCTION_MAX_ARGS, KAGUYA_OBJECT_WRAPPER_CONSTRUCTOR_DEF); +#undef KAGUYA_OBJECT_WRAPPER_CONSTRUCTOR_DEF #endif virtual const std::type_info& type() diff --git a/include/kaguya/preprocess.hpp b/include/kaguya/preprocess.hpp index c32eb7aa..25d48bfa 100644 --- a/include/kaguya/preprocess.hpp +++ b/include/kaguya/preprocess.hpp @@ -20,6 +20,12 @@ #define KAGUYA_PP_ARG_DEF_REPEAT_CONCAT(N) KAGUYA_PP_REPEAT(N, KAGUYA_PP_ARG_DEF_CONCAT_REP) #define KAGUYA_PP_ARG_DEF_REPEAT(N) KAGUYA_PP_REPEAT_ARG(N, KAGUYA_PP_ARG_DEF_REP) +#define KAGUYA_PP_ARG_CR_DEF_CONCAT_REP(N) ,const KAGUYA_PP_CAT(A,N)& KAGUYA_PP_CAT(a,N) +#define KAGUYA_PP_ARG_CR_DEF_REP(N) const KAGUYA_PP_CAT(A,N)& KAGUYA_PP_CAT(a,N) + +#define KAGUYA_PP_ARG_CR_DEF_REPEAT_CONCAT(N) KAGUYA_PP_REPEAT(N, KAGUYA_PP_ARG_CR_DEF_CONCAT_REP) +#define KAGUYA_PP_ARG_CR_DEF_REPEAT(N) KAGUYA_PP_REPEAT_ARG(N, KAGUYA_PP_ARG_CR_DEF_REP) + #define KAGUYA_PP_ARG_CONCAT_REP(N) ,KAGUYA_PP_CAT(a,N) #define KAGUYA_PP_ARG_REP(N) KAGUYA_PP_CAT(a,N) diff --git a/include/kaguya/utility.hpp b/include/kaguya/utility.hpp index db3ff56f..6b030e70 100644 --- a/include/kaguya/utility.hpp +++ b/include/kaguya/utility.hpp @@ -205,19 +205,15 @@ namespace kaguya return 0; } -#define KAGUYA_PP_TEMPLATE(N) KAGUYA_PP_CAT(typename A,N) -#define KAGUYA_PP_FARG(N) const KAGUYA_PP_CAT(A,N)& KAGUYA_PP_CAT(a,N) #define KAGUYA_PUSH_DEF(N) c+=lua_type_traits::push(l, KAGUYA_PP_CAT(a,N)); -#define KAGUYA_PUSH_ARG_DEF(N) template\ - inline int push_args(lua_State *l,KAGUYA_PP_REPEAT_ARG(N,KAGUYA_PP_FARG))\ +#define KAGUYA_PUSH_ARG_DEF(N) template\ + inline int push_args(lua_State *l,KAGUYA_PP_ARG_CR_DEF_REPEAT(N))\ {\ int c =0;\ KAGUYA_PP_REPEAT(N,KAGUYA_PUSH_DEF)\ return c;\ } KAGUYA_PP_REPEAT_DEF(KAGUYA_FUNCTION_MAX_ARGS, KAGUYA_PUSH_ARG_DEF) -#undef KAGUYA_PP_TEMPLATE -#undef KAGUYA_PP_FARG #undef KAGUYA_PUSH_DEF #undef KAGUYA_PUSH_ARG_DEF #endif diff --git a/include/kaguya/utility_cxx03.hpp b/include/kaguya/utility_cxx03.hpp index ecf591d8..c84da510 100644 --- a/include/kaguya/utility_cxx03.hpp +++ b/include/kaguya/utility_cxx03.hpp @@ -88,9 +88,9 @@ namespace kaguya KAGUYA_MEMBER_FUNCTION_SIGNATURE_DEF(0); KAGUYA_PP_REPEAT_DEF(KAGUYA_PP_DEC(KAGUYA_FUNCTION_MAX_ARGS), KAGUYA_MEMBER_FUNCTION_SIGNATURE_DEF); +#undef KAGUYA_MEMBER_FUNCTION_SIGNATURE_DEF KAGUYA_FUNCTION_SIGNATURE_DEF(0); KAGUYA_PP_REPEAT_DEF(KAGUYA_FUNCTION_MAX_ARGS, KAGUYA_FUNCTION_SIGNATURE_DEF); -#undef KAGUYA_MEMBER_FUNCTION_SIGNATURE_DEF #undef KAGUYA_FUNCTION_SIGNATURE_DEF template @@ -118,6 +118,7 @@ namespace kaguya // KAGUYA_TYPE_INDEX_GET_DEF(0); KAGUYA_PP_REPEAT_DEF(KAGUYA_PP_DEC(KAGUYA_FUNCTION_MAX_ARGS), KAGUYA_TYPE_INDEX_GET_DEF); +#undef KAGUYA_TYPE_INDEX_GET_DEF template struct ArgumentType @@ -148,6 +149,7 @@ namespace kaguya KAGUYA_INVOKE_HELPER_DEF(0); KAGUYA_PP_REPEAT_DEF(KAGUYA_FUNCTION_MAX_ARGS, KAGUYA_INVOKE_HELPER_DEF); +#undef KAGUYA_INVOKE_HELPER_DEF } @@ -160,6 +162,7 @@ namespace kaguya KAGUYA_INVOKE_DEF(0); KAGUYA_PP_REPEAT_DEF(KAGUYA_FUNCTION_MAX_ARGS, KAGUYA_INVOKE_DEF); +#undef KAGUYA_INVOKE_DEF }