From 6d879f571aab3321377265df7e9ed557cade2cb4 Mon Sep 17 00:00:00 2001 From: ThePhD Date: Sat, 23 Sep 2017 20:26:03 -0400 Subject: [PATCH] add code to steal guts and grab stuff from other frameworks. --- .clang-format | 2 +- docs/source/api/stack.rst | 56 +- docs/source/safety.rst | 9 +- docs/source/tutorial/customization.rst | 2 +- docs/source/tutorial/existing.rst | 12 +- docs/source/usertypes.rst | 2 + examples/interop/kaguya.cpp | 128 + examples/interop/kaguya.hpp | 11907 +++++++++++++++++++++++ sol/stack_check.hpp | 19 +- sol/stack_core.hpp | 7 + sol/stack_get.hpp | 18 +- 11 files changed, 12151 insertions(+), 11 deletions(-) create mode 100644 examples/interop/kaguya.cpp create mode 100644 examples/interop/kaguya.hpp diff --git a/.clang-format b/.clang-format index f99f7e1e..a3289bcc 100644 --- a/.clang-format +++ b/.clang-format @@ -77,7 +77,7 @@ SpaceInEmptyParentheses: false SpacesInAngles: false SpacesInParentheses: false SpacesInSquareBrackets: false -MaxEmptyLinesToKeep: 1 +MaxEmptyLinesToKeep: 3 # OCD SortUsingDeclarations: true diff --git a/docs/source/api/stack.rst b/docs/source/api/stack.rst index 06af4c20..b71f10d9 100644 --- a/docs/source/api/stack.rst +++ b/docs/source/api/stack.rst @@ -235,7 +235,10 @@ This is an SFINAE-friendly struct that is meant to expose static function ``push template static bool check ( lua_State* L, int index, Handler&& handler, record& tracking ) { // if the object in the Lua stack at index is a T, return true - if ( ... ) return true; + if ( ... ) { + tracking.use(1); // or however many you use + return true; + } // otherwise, call the handler function, // with the required 5 arguments, then return false // @@ -244,8 +247,57 @@ This is an SFINAE-friendly struct that is meant to expose static function ``push } }; -This is an SFINAE-friendly struct that is meant to expose static function ``check`` that returns the number of things pushed onto the stack. The default implementation simply checks whether the expected type passed in through the template is equal to the type of the object at the specified index in the Lua stack. The default implementation for types which are considered ``userdata`` go through a myriad of checks to support checking if a type is *actually* of type ``T`` or if its the base class of what it actually stored as a userdata in that index. Down-casting from a base class to a more derived type is, unfortunately, impossible to do. +This is an SFINAE-friendly struct that is meant to expose static function ``check`` that returns whether or not a type at a given index is what its supposed to be. The default implementation simply checks whether the expected type passed in through the template is equal to the type of the object at the specified index in the Lua stack. The default implementation for types which are considered ``userdata`` go through a myriad of checks to support checking if a type is *actually* of type ``T`` or if its the base class of what it actually stored as a userdata in that index. Down-casting from a base class to a more derived type is, unfortunately, impossible to do. + +.. code-block:: cpp + :caption: struct: userdata_checker + :name: userdata_checker + + template + struct userdata_checker { + template + static bool check ( lua_State* L, int index, type indextype, Handler&& handler, record& tracking ) { + // implement custom checking here for a userdata: + // if it doesn't match, return "false" and regular + // sol userdata checks will kick in + return false; + // returning true will skip sol's + // default checks + } + }; + +This is an SFINAE-friendly struct that is meant to expose a function ``check=`` that returns ``true`` if a type meets some custom userdata specifiction, and ``false`` if it does not. The default implementation just returns ``false`` to let the original sol2 handlers take care of everything. If you want to implement your own usertype checking; e.g., for messing with ``toLua`` or ``OOLua`` or ``kaguya`` or some other libraries. Note that the library must have a with a :doc:`memory compatible layout` if you **want to specialize this checker method but not the subsequent getter method**. You can specialize it as shown in the `interop examples`_. + +.. note:: + You must turn it on with ``SOL_ENABLE_INTEROP``, as described in the :ref:`config and safety section`. + +.. code-block:: cpp + :caption: struct: userdata_getter + :name: userdata_getter + + template + struct userdata_getter { + static std::pair get ( lua_State* L, int index, void* unadjusted_pointer, record& tracking ) { + // implement custom getting here for non-sol2 userdatas: + // if it doesn't match, return "false" and regular + // sol userdata checks will kick in + return { false, nullptr }; + } + }; + +This is an SFINAE-friendly struct that is meant to expose a function ``get`` that returns ``true`` and an adjusted pointer if a type meets some custom userdata specifiction (from, say, another library or an internal framework). The default implementation just returns ``{ false, nullptr }`` to let the original sol2 getter take care of everything. If you want to implement your own usertype getter; e.g., for messing with ``kaguya`` or some other libraries. You can specialize it as shown in the `interop examples`_. + +.. note:: + + You do NOT need to use this method in particular if the :doc:`memory layout` is compatible. (For example, ``toLua`` stores userdata in a sol2-compatible way.) + + +.. note:: + + You must turn it on with ``SOL_ENABLE_INTEROP``, as described in the :ref:`config and safety section`. + .. _lua_CFunction: http://www.Lua.org/manual/5.3/manual.html#lua_CFunction .. _Lua stack works in general: https://www.lua.org/pil/24.2.html .. _calling C functions works: https://www.lua.org/pil/26.html +.. _interop example: https://github.com/ThePhD/sol2/blob/develop/examples/interop diff --git a/docs/source/safety.rst b/docs/source/safety.rst index c8169961..3c764539 100644 --- a/docs/source/safety.rst +++ b/docs/source/safety.rst @@ -13,6 +13,13 @@ Note that you can obtain safety with regards to functions you bind by using the ``SOL_USE_BOOST`` triggers the following change: * Attempts to use ``boost::optional`` instead of sol's own ``optional`` +``SOL_ENABLE_INTEROP`` triggers the following change: + * Allows the use of ``extensible`` to be used with ``userdata_checker`` and ``userdata_getter`` to retrieve non-sol usertypes + - Particularly enables non-sol usertypes to be used in overloads + - See the :ref:`stack dcoumentation` for details + * May come with a slight performance penalty: only recommended for those stuck with non-sol libraries that still need to leverage some of sol's power + * **Not** turned on by default under any settings: *this MUST be turned on manually* + ``SOL_SAFE_USERTYPE`` triggers the following change: * If the userdata to a usertype function is nil, will trigger an error instead of letting things go through and letting the system segfault/crash * Turned on by default with clang++, g++ and VC++ if a basic check for building in debug mode is detected @@ -31,7 +38,7 @@ Note that you can obtain safety with regards to functions you bind by using the ``SOL_NO_CHECK_NUMBER_PRECISION`` triggers the following changes: * If ``SOL_CHECK_ARGUMENTS`` is defined, turns off number precision and integer precision fitting when pushing numbers into sol2 - * **Not** turned on by default under any settings: *thus MUSt be turned on manually* + * **Not** turned on by default under any settings: *this MUST be turned on manually* ``SOL_CHECK_ARGUMENTS`` triggers the following changes: * ``sol::stack::get`` (used everywhere) defaults to using ``sol::stack::check_get`` and dereferencing the argument. It uses ``sol::type_panic`` as the handler if something goes wrong diff --git a/docs/source/tutorial/customization.rst b/docs/source/tutorial/customization.rst index d17379bf..4643c2ba 100644 --- a/docs/source/tutorial/customization.rst +++ b/docs/source/tutorial/customization.rst @@ -119,4 +119,4 @@ You can make something pushable into Lua, but not get-able in the same way if yo In general, this is fine since most getters/checkers only use 1 stack point. But, if you're doing more complex nested classes, it would be useful to use ``tracking.last`` to understand how many stack indices the last getter/checker operation did and increment it by ``index + tracking.last`` after using a ``stack::check<..>( L, index, tracking)`` call. -You can read more about the structs themselves :ref:`over on the API page for stack`, and if there's something that goes wrong or you have anymore questions, please feel free to drop a line on the Github Issues page or send an e-mail! \ No newline at end of file +You can read more about the structs themselves :ref:`over on the API page for stack`, and if there's something that goes wrong or you have anymore questions, please feel free to drop a line on the Github Issues page or send an e-mail! diff --git a/docs/source/tutorial/existing.rst b/docs/source/tutorial/existing.rst index fe1948bb..c0a80005 100644 --- a/docs/source/tutorial/existing.rst +++ b/docs/source/tutorial/existing.rst @@ -8,14 +8,17 @@ If you're already using lua and you just want to use ``sol`` in some places, you :caption: using state_view :name: state-view-snippet - void something_in_my_system (lua_State* L) { + int something_in_my_system (lua_State* L) { // start using Sol with a pre-existing system sol::state_view lua(L); // non-owning lua.script("print('bark bark bark!')"); - sol::table expected_table(L); // get the table off the top of the stack - // start using it... + // get the table off the top of the stack + sol::table expected_table(L, -1); + // start using it... + + return 0; // or whatever you require of working with a raw function } :doc:`sol::state_view<../api/state>` is exactly like ``sol::state``, but it doesn't manage the lifetime of a ``lua_State*``. Therefore, you get all the goodies that come with a ``sol::state`` without any of the ownership implications. Sol has no initialization components that need to deliberately remain alive for the duration of the program. It's entirely self-containing and uses lua's garbage collectors and various implementation techniques to require no state C++-side. After you do that, all of the power of `Sol` is available to you, and then some! @@ -26,8 +29,11 @@ You may also want to call ``require`` and supply a string of a script file or so Remember that Sol can be as lightweight as you want it: almost all of Sol's Lua types take the ``lua_State*`` argument and then a second ``int index`` stack index argument, meaning you can use :doc:`tables<../api/table>`, :doc:`lua functions<../api/function>`, :doc:`coroutines<../api/coroutine>`, and other reference-derived objects that expose the proper constructor for your use. You can also set :doc:`usertypes<../api/usertype>` and other things you need without changing your entire architecture in one go. +You can even customize it to `work with an external Lua wrapper/framework/library`_. + Note that you can also make non-standard pointer and reference types with custom reference counting and such also play nice with the system. See :doc:`unique_usertype_traits\<../api/unique_usertype_traits>` to see how! Custom types is also mentioned in the :doc:`customization tutorial`. There are a few things that creating a ``sol::state`` does for you. You can read about it :ref:`in the sol::state docs` and call those functions directly if you need them. .. _create a DLL that loads some Lua module: https://github.com/ThePhD/sol2/tree/develop/examples/require_dll_example +.. _work with an external Lua library: https://github.com/ThePhD/sol2/tree/develop/examples/interop diff --git a/docs/source/usertypes.rst b/docs/source/usertypes.rst index c6d01b58..5353ebb3 100644 --- a/docs/source/usertypes.rst +++ b/docs/source/usertypes.rst @@ -24,6 +24,8 @@ The examples folder also has a number of really great examples for you to see. T - Extend them using the :doc:`sol::unique_usertype\ traits` - This allows for custom smart pointers, special pointers, custom handles and others to be given certain handling semantics to ensure proper RAII with Lua's garbage collection * (Advanced) You can override the iteration function for Lua 5.2 and above (LuaJIT does not have the capability) `as shown in the pairs example`_ +* (Advanced) Interop with ``toLua``, ``kaguya``, ``OOLua``, ``LuaBind``, ``luwra``, and all other existing libraries by using the stack API's ``sol::stack::userdata_checker`` and ``sol::stack::userdata_getter`` :ref:`extension points` + - Must turn on ``SOL_ENABLE_INTEROP``, as defined in the :ref:`configuration and safety documentation`, to use * Please note that the colon is necessary to "automatically" pass the ``this``/``self`` argument to Lua methods - ``obj:method_name()`` is how you call "member" methods in Lua - It is purely syntactic sugar that passes the object name as the first argument to the ``method_name`` function diff --git a/examples/interop/kaguya.cpp b/examples/interop/kaguya.cpp new file mode 100644 index 00000000..434949ea --- /dev/null +++ b/examples/interop/kaguya.cpp @@ -0,0 +1,128 @@ +#define SOL_CHECK_ARGUMENTS 1 +#define SOL_ENABLE_INTEROP 1 // MUST be defined to use interop features +#include + +#include "kaguya.hpp" + +#include +#include + +// kaguya code lifted from README.md, +// written by satoren: +// https://github.com/satoren/kaguya +// Copyright satoren +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +struct ABC { + ABC() + : v_(0) { + } + ABC(int value) + : v_(value) { + } + int value() const { + return v_; + } + void setValue(int v) { + v_ = v; + } + void overload1() { + std::cout << "call overload1" << std::endl; + } + void overload2(int) { + std::cout << "call overload2" << std::endl; + } + +private: + int v_; +}; + +namespace sol { +namespace stack { + template + struct userdata_checker> { + template + static bool check(lua_State* L, int index, type index_type, Handler&& handler, record& tracking) { + // just marking unused parameters for no compiler warnings + (void)index_type; + (void)handler; + // using 1 element + tracking.use(1); + // use kaguya's own detail wrapper check to see if it's correct + bool is_correct_type = kaguya::detail::object_wrapper_type_check(L, index); + return is_correct_type; + } + }; + + template + struct userdata_getter> { + static std::pair get(lua_State* L, int index, void* unadjusted_pointer, record& tracking) { + // you may not need to specialize this method every time: + // some libraries are compatible with sol2's layout + + // kaguya's storage of data is incompatible with sol's + // it stores the data directly in the pointer, not a pointer inside of the `void*` + // therefore, leave the raw userdata pointer as-is, + // if it's of the right type + if (!kaguya::detail::object_wrapper_type_check(L, index)) { + return { false, nullptr }; + } + // using 1 element + tracking.use(1); + kaguya::ObjectWrapperBase* base = kaguya::object_wrapper(L, index); + return { true, static_cast(base->get()) }; + } + }; +} +} // namespace sol::stack + +void register_sol_stuff(lua_State* L) { + // grab raw state and put into state_view + // state_view is cheap to construct + sol::state_view lua(L); + // bind and set up your things: everything is entirely self-contained + lua["f"] = sol::overload( + [](ABC& from_kaguya) { + std::cout << "calling 1-argument version with kaguya-created ABC {" << from_kaguya.value() << "}" << std::endl; + }, + [](ABC& from_kaguya, int second_arg) { + std::cout << "calling 2-argument version with kaguya-created ABC {" << from_kaguya.value() << "} and integer argument of " << second_arg << std::endl; + }); +} + +void check_with_sol(lua_State* L) { + sol::state_view lua(L); + ABC& obj = lua["obj"]; + (void)obj; + assert(obj.value() == 24); +} + +int main(int, char* []) { + + std::cout << "=== interop example (kaguya) ===" << std::endl; + std::cout << "(code lifted from kaguya's README examples: https://github.com/satoren/kaguya)" << std::endl; + + kaguya::State state; + + state["ABC"].setClass(kaguya::UserdataMetatable() + .setConstructors() + .addFunction("get_value", &ABC::value) + .addFunction("set_value", &ABC::setValue) + .addOverloadedFunctions("overload", &ABC::overload1, &ABC::overload2) + .addStaticFunction("nonmemberfun", [](ABC* self, int) { return 1; })); + + + register_sol_stuff(state.state()); + + state.dostring(R"( +obj = ABC.new(24) +f(obj) -- call 1 argument version +f(obj, 5) -- call 2 argument version +)"); + + check_with_sol(state.state()); + + return 0; +} \ No newline at end of file diff --git a/examples/interop/kaguya.hpp b/examples/interop/kaguya.hpp new file mode 100644 index 00000000..7e6f12a7 --- /dev/null +++ b/examples/interop/kaguya.hpp @@ -0,0 +1,11907 @@ +#ifndef KAGUYA_LUABINDING_HPP_INCLUDED +#define KAGUYA_LUABINDING_HPP_INCLUDED +// Copyright satoren +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + + +// Copyright satoren +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include +extern "C" { +#include +#include +#include +} + +#ifndef KAGUYA_USE_CPP11 +#if defined(__cpp_decltype) || __cplusplus >= 201103L || \ + (defined(_MSC_VER) && _MSC_VER >= 1800) +#define KAGUYA_USE_CPP11 1 +#else +#define KAGUYA_USE_CPP11 0 +#endif +#endif + +#if KAGUYA_USE_CPP11 +#include +#include +#include +#include +#include +#include +#include +#else +#include +#include +#include +#include +#include +#include +#include +#endif + +#ifndef KAGUYA_NO_USERDATA_TYPE_CHECK +#define KAGUYA_NO_USERDATA_TYPE_CHECK 0 +#endif + +//If you want use registered class by kaguya between multiple shared library, +//please switch to 1 for KAGUYA_SUPPORT_MULTIPLE_SHARED_LIBRARY and KAGUYA_NAME_BASED_TYPE_CHECK +#ifndef KAGUYA_SUPPORT_MULTIPLE_SHARED_LIBRARY +#define KAGUYA_SUPPORT_MULTIPLE_SHARED_LIBRARY 0 +#endif + +#ifndef KAGUYA_NAME_BASED_TYPE_CHECK +#define KAGUYA_NAME_BASED_TYPE_CHECK KAGUYA_SUPPORT_MULTIPLE_SHARED_LIBRARY +#endif + +#ifndef KAGUYA_USE_RVALUE_REFERENCE +#if KAGUYA_USE_CPP11 +#define KAGUYA_USE_RVALUE_REFERENCE 1 +#else +#define KAGUYA_USE_RVALUE_REFERENCE 0 +#endif +#endif + +#ifdef KAGUYA_NO_VECTOR_AND_MAP_TO_TABLE +#define KAGUYA_NO_STD_VECTOR_TO_TABLE +#define KAGUYA_NO_STD_MAP_TO_TABLE +#endif + +#if !KAGUYA_USE_CPP11 +#ifndef KAGUYA_FUNCTION_MAX_ARGS +///! max argumeent number for binding function. this define used C++03 only. +#define KAGUYA_FUNCTION_MAX_ARGS 9 +#endif + +#ifndef KAGUYA_FUNCTION_MAX_TUPLE_SIZE +///! this define used C++03 only. +#define KAGUYA_FUNCTION_MAX_TUPLE_SIZE 9 +#endif + +#ifndef KAGUYA_FUNCTION_MAX_OVERLOADS +#define KAGUYA_FUNCTION_MAX_OVERLOADS 9 +#endif + +#endif + +#ifndef KAGUYA_CLASS_MAX_BASE_CLASSES +#define KAGUYA_CLASS_MAX_BASE_CLASSES 9 +#endif + +#ifndef KAGUYA_USE_CXX_ABI_DEMANGLE +#if defined(__GNUC__) || defined(__clang__) +#define KAGUYA_USE_CXX_ABI_DEMANGLE 1 +#else +#define KAGUYA_USE_CXX_ABI_DEMANGLE 0 +#endif +#endif + +#ifndef KAGUYA_USE_SHARED_LUAREF +#define KAGUYA_USE_SHARED_LUAREF 0 +#endif + +#ifndef KAGUYA_NOEXCEPT +#if KAGUYA_USE_CPP11 && (!defined(_MSC_VER) || _MSC_VER >= 1900) +#define KAGUYA_NOEXCEPT noexcept +#else +#define KAGUYA_NOEXCEPT throw() +#endif +#endif + +#ifndef KAGUYA_DEPRECATED_FEATURE +#if __cplusplus >= 201402L && defined(__has_cpp_attribute) +#if __has_cpp_attribute(deprecated) +// C++ standard depecated +#define KAGUYA_DEPRECATED_FEATURE(MSG) [[deprecated(MSG)]] +#endif +#endif +#endif +#ifndef KAGUYA_DEPRECATED_FEATURE +#if defined(_MSC_VER) +// MSVC depecated +#define KAGUYA_DEPRECATED_FEATURE(MSG) __declspec(deprecated(MSG)) +#elif defined(__GNUC__) || defined(__clang__) +#define KAGUYA_DEPRECATED_FEATURE(MSG) __attribute__((deprecated)) +#else +#define KAGUYA_DEPRECATED_FEATURE(MSG) +#endif + +#endif + +#define KAGUYA_UNUSED(V) (void)(V) + +namespace kaguya { +#if defined(_MSC_VER) && _MSC_VER <= 1500 +typedef unsigned char uint8_t; +typedef int int32_t; +typedef long long int64_t; +#endif + +namespace standard { +#if KAGUYA_USE_CPP11 +using namespace std; +#define KAGUYA_STATIC_ASSERT static_assert + +#else +using namespace boost; +#define KAGUYA_STATIC_ASSERT BOOST_STATIC_ASSERT_MSG +#endif +} + +#if LUA_VERSION_NUM > 502 +typedef lua_Integer luaInt; +#else +typedef int32_t luaInt; +#endif +} +// Copyright satoren +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + + +#include +#include +#include +#include +#include +#include + +// Copyright satoren +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + + +#include + +// Copyright satoren +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + + +#include +#include + +// Copyright satoren +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include + +namespace kaguya { +/// @addtogroup optional +/// @{ + +struct bad_optional_access : std::exception {}; +struct nullopt_t {}; + +/// @brief self implement for std::optional(C++17 feature). +template class optional { + typedef void (optional::*bool_type)() const; + void this_type_does_not_support_comparisons() const {} + +public: + optional() : value_(0){}; + optional(nullopt_t) : value_(0){}; + optional(const optional &other) : value_(0) { + if (other) { + value_ = new (&storage_) T(other.value()); + } + } + optional(const T &value) { value_ = new (&storage_) T(value); } + + ~optional() { destruct(); } + optional &operator=(nullopt_t) { + destruct(); + return *this; + } + optional &operator=(const optional &other) { + if (other) { + *this = other.value(); + } else { + destruct(); + } + return *this; + } + optional &operator=(const T &value) { + if (value_) { + *value_ = value; + } else { + value_ = new (&storage_) T(value); + } + return *this; + } + +#if KAGUYA_USE_CPP11 + optional(optional &&other) : value_(0) { + if (other) { + value_ = new (&storage_) T(std::move(other.value())); + } + } + optional(T &&value) { value_ = new (&storage_) T(std::move(value)); } + optional &operator=(optional &&other) { + if (other) { + *this = std::move(other.value()); + } else { + destruct(); + } + return *this; + } + optional &operator=(T &&value) { + if (value_) { + *value_ = std::move(value); + } else { + value_ = new (&storage_) T(std::move(value)); + } + return *this; + } +#endif + + operator bool_type() const { + this_type_does_not_support_comparisons(); + return value_ != 0 ? &optional::this_type_does_not_support_comparisons : 0; + } + T &value() { + if (value_) { + return *value_; + } + throw bad_optional_access(); + } + const T &value() const { + if (value_) { + return *value_; + } + throw bad_optional_access(); + } + +#if KAGUYA_USE_CPP11 + template T value_or(U &&default_value) const { + if (value_) { + return *value_; + } + return default_value; + } +#else + template T value_or(const U &default_value) const { + if (value_) { + return *value_; + } + return default_value; + } +#endif + const T *operator->() const { + assert(value_); + return value_; + } + T *operator->() { + assert(value_); + return value_; + } + const T &operator*() const { + assert(value_); + return *value_; + } + T &operator*() { + assert(value_); + return *value_; + } + +private: + void destruct() { + if (value_) { + value_->~T(); + value_ = 0; + } + } + + typename standard::aligned_storage< + sizeof(T), standard::alignment_of::value>::type storage_; + + T *value_; +}; + +/// @brief specialize optional for reference. +/// sizeof(optional) == sizeof(T*) +template class optional { + typedef void (optional::*bool_type)() const; + void this_type_does_not_support_comparisons() const {} + +public: + optional() : value_(0){}; + optional(nullopt_t) : value_(0){}; + + optional(const optional &other) : value_(other.value_) {} + optional(T &value) : value_(&value) {} + + ~optional() {} + optional &operator=(nullopt_t) { + value_ = 0; + return *this; + } + optional &operator=(const optional &other) { + value_ = other.value_; + return *this; + } + optional &operator=(T &value) { + value_ = &value; + return *this; + } + operator bool_type() const { + this_type_does_not_support_comparisons(); + return value_ != 0 ? &optional::this_type_does_not_support_comparisons : 0; + } + T &value() { + if (value_) { + return *value_; + } + throw bad_optional_access(); + } + const T &value() const { + if (value_) { + return *value_; + } + throw bad_optional_access(); + } + +#if KAGUYA_USE_CPP11 + T &value_or(T &default_value) const { + if (value_) { + return *value_; + } + return default_value; + } +#else + T &value_or(T &default_value) const { + if (value_) { + return *value_; + } + return default_value; + } +#endif + + const T *operator->() const { + assert(value_); + return value_; + } + T *operator->() { + assert(value_); + return value_; + } + const T &operator*() const { + assert(value_); + return *value_; + } + T &operator*() { + assert(value_); + return *value_; + } + +private: + T *value_; +}; + +/// @name relational operators +/// @brief +///@{ +template +bool operator==(const optional &lhs, const optional &rhs) { + if (bool(lhs) != bool(rhs)) { + return false; + } + if (bool(lhs) == false) { + return true; + } + return lhs.value() == rhs.value(); +} +template +bool operator!=(const optional &lhs, const optional &rhs) { + return !(lhs == rhs); +} +template +bool operator<(const optional &lhs, const optional &rhs) { + if (!bool(rhs)) { + return false; + } + if (!bool(lhs)) { + return true; + } + return lhs.value() < rhs.value(); +} +template +bool operator<=(const optional &lhs, const optional &rhs) { + return !(rhs < lhs); +} +template +bool operator>(const optional &lhs, const optional &rhs) { + return rhs < lhs; +} +template +bool operator>=(const optional &lhs, const optional &rhs) { + return !(lhs < rhs); +} +/// @} + +/// @} +} +// Copyright satoren +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + + +#include +#include +#include + + +namespace kaguya { +namespace traits { +using standard::integral_constant; +using standard::true_type; +using standard::false_type; +using standard::remove_reference; +using standard::remove_pointer; +using standard::remove_const; +using standard::remove_volatile; +using standard::remove_cv; +using standard::is_function; +using standard::is_floating_point; +using standard::is_integral; +using standard::is_enum; +using standard::is_convertible; +using standard::is_same; +using standard::is_arithmetic; +using standard::is_union; +using standard::is_class; +using standard::is_pointer; +using standard::is_lvalue_reference; +using standard::is_const; +using standard::is_void; +#if KAGUYA_USE_CPP11 +using std::enable_if; +#else +template +struct enable_if : boost::enable_if_c {}; +#endif + +class Helper {}; +/// @brief Check if T_Mem is a member object of a type. That is true if it is +/// not a member function +/// Required as MSVC throws a COMDAT error when using is_member_object_pointer +template struct is_object { + typedef typename standard::is_member_function_pointer::type + NotResult; + enum { value = !NotResult::value }; +}; + +/// @brief Similar to std::decay but also removes const and volatile modifiers +/// if T is neither an array nor a function +template struct decay { +private: + ///@ If T is a reference type, the type referrered to by T. Otherwise, T. + typedef typename standard::remove_reference::type U; + +public: + typedef typename standard::conditional< + standard::is_array::value, typename standard::remove_extent::type *, + typename standard::conditional< + is_function::value, typename standard::add_pointer::type, + typename standard::remove_cv::type>::type>::type type; +}; + +/// @brief Trait class that identifies whether T is a const reference type. +template struct is_const_reference : false_type {}; +template struct is_const_reference : true_type {}; + +/// @brief Obtains the type T without top-level const and reference. +template struct remove_const_and_reference { + /// @brief If T is const or reference, the same type as T but with the const + /// reference removed.Otherwise, T + typedef T type; +}; +/// @brief Obtains the type T without top-level const and reference. +template struct remove_const_and_reference { + /// @brief If T is const or reference, the same type as T but with the const + /// reference removed.Otherwise, T + typedef T type; +}; +/// @brief Obtains the type T without top-level const and reference. +template struct remove_const_and_reference { + /// @brief If T is const or reference, the same type as T but with the const + /// reference removed.Otherwise, T + typedef T type; +}; +/// @brief Obtains the type T without top-level const and reference. +template struct remove_const_and_reference { + /// @brief If T is const or reference, the same type as T but with the const + /// reference removed.Otherwise, T + typedef T type; +}; + +/// @brief Obtains the type T without top-level const reference. +template struct remove_const_reference { + /// @brief If T is const reference, the same type as T but with the const + /// reference removed.Otherwise, T + typedef T type; +}; +/// @brief Obtains the type T without top-level const reference. +template struct remove_const_reference { + /// @brief If T is const reference, the same type as T but with the const + /// reference removed.Otherwise, T + typedef T type; +}; + +/// @brief Trait class that identifies whether T is a std::vector type. +template struct is_std_vector : false_type {}; +template +struct is_std_vector > : true_type {}; + +/// @brief Trait class that identifies whether T is a std::map type. +template struct is_std_map : false_type {}; +template +struct is_std_map > : true_type {}; +} + +/// @addtogroup lua_type_traits + +/// @ingroup lua_type_traits +/// @brief If you want to customize the conversion to type of lua yourself , +/// implement specialize of this class +template struct lua_type_traits { + typedef void Registerable; + + typedef typename traits::decay::type NCRT; + typedef const NCRT &get_type; + typedef optional opt_type; + typedef const NCRT &push_type; + + static bool checkType(lua_State *l, int index); + static bool strictCheckType(lua_State *l, int index); + + static get_type get(lua_State *l, int index); + static opt_type opt(lua_State *l, int index) KAGUYA_NOEXCEPT; + static int push(lua_State *l, push_type v); +#if KAGUYA_USE_RVALUE_REFERENCE + static int push(lua_State *l, NCRT &&v); +#endif +}; + +/// @brief Trait class that identifies whether T is a userdata type. +template +struct is_usertype : traits::false_type {}; +template +struct is_usertype::Registerable> + : traits::true_type {}; + +/// @brief Trait class that identifies whether T is a registerable by +/// UserdataMetatable. +template struct is_registerable : is_usertype {}; +} +// Copyright satoren +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include +#include +#include +#include + +// Copyright satoren +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +#include + +#if KAGUYA_USE_CXX_ABI_DEMANGLE +#include +#endif + +// Copyright satoren +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + + +namespace kaguya { +// for lua version compatibility +namespace compat { +#if LUA_VERSION_NUM >= 503 +inline int lua_rawgetp_rtype(lua_State *L, int idx, const void *ptr) { + return lua_rawgetp(L, idx, ptr); +} +inline int lua_rawget_rtype(lua_State *L, int idx) { + return lua_rawget(L, idx); +} +inline int lua_getfield_rtype(lua_State *L, int idx, const char *k) { + return lua_getfield(L, idx, k); +} +inline int lua_gettable_rtype(lua_State *L, int idx) { + return lua_gettable(L, idx); +} +#elif LUA_VERSION_NUM == 502 +inline int lua_rawgetp_rtype(lua_State *L, int idx, const void *ptr) { + lua_rawgetp(L, idx, ptr); + return lua_type(L, -1); +} +#elif LUA_VERSION_NUM < 502 +enum LUA_OPEQ { LUA_OPEQ, LUA_OPLT, LUA_OPLE }; +inline int lua_compare(lua_State *L, int index1, int index2, int op) { + switch (op) { + case LUA_OPEQ: + return lua_equal(L, index1, index2); + case LUA_OPLT: + return lua_lessthan(L, index1, index2); + case LUA_OPLE: + return lua_equal(L, index1, index2) || lua_lessthan(L, index1, index2); + default: + return 0; + } +} + +inline void lua_pushglobaltable(lua_State *L) { + lua_pushvalue(L, LUA_GLOBALSINDEX); +} +inline size_t lua_rawlen(lua_State *L, int index) { + int type = lua_type(L, index); + if (type != LUA_TSTRING && type != LUA_TTABLE && type != LUA_TUSERDATA && + type != LUA_TLIGHTUSERDATA) { + return 0; + } + return lua_objlen(L, index); +} + +inline int lua_resume(lua_State *L, lua_State *from, int nargs) { + KAGUYA_UNUSED(from); + return ::lua_resume(L, nargs); +} +inline int lua_absindex(lua_State *L, int idx) { + return (idx > 0 || (idx <= LUA_REGISTRYINDEX)) ? idx + : lua_gettop(L) + 1 + idx; +} +inline int lua_rawgetp_rtype(lua_State *L, int idx, const void *ptr) { + int absidx = lua_absindex(L, idx); + lua_pushlightuserdata(L, (void *)ptr); + lua_rawget(L, absidx); + return lua_type(L, -1); +} +inline void lua_rawsetp(lua_State *L, int idx, const void *ptr) { + int absidx = lua_absindex(L, idx); + lua_pushvalue(L, -1); + lua_pushlightuserdata(L, (void *)ptr); + lua_replace(L, -3); + lua_rawset(L, absidx); +} +inline void luaL_requiref(lua_State *L, const char *modname, + lua_CFunction openf, int glb) { + + lua_pushcfunction(L, openf); + lua_pushstring(L, modname); + lua_call(L, 1, 1); + + if (glb) { + lua_pushvalue(L, -1); + lua_setglobal(L, modname); + } +} +inline lua_Number lua_tonumberx(lua_State *L, int index, int *isnum) { + if (isnum) { + *isnum = lua_isnumber(L, index); + } + return lua_tonumber(L, index); +} +#endif +#if LUA_VERSION_NUM < 503 +inline void lua_seti(lua_State *L, int index, lua_Integer n) { + int absidx = lua_absindex(L, index); + lua_pushvalue(L, -1); + lua_pushinteger(L, n); + lua_replace(L, -3); + lua_rawset(L, absidx); +} +inline int lua_geti(lua_State *L, int index, lua_Integer i) { + int absidx = lua_absindex(L, index); + lua_pushinteger(L, i); + lua_rawget(L, absidx); + return lua_type(L, -1); +} +inline int lua_getfield_rtype(lua_State *L, int idx, const char *k) { + lua_getfield(L, idx, k); + return lua_type(L, -1); +} +inline int lua_gettable_rtype(lua_State *L, int idx) { + lua_gettable(L, idx); + return lua_type(L, -1); +} +inline int lua_rawget_rtype(lua_State *L, int idx) { + lua_rawget(L, idx); + return lua_type(L, -1); +} +#endif +#if LUA_VERSION_NUM < 501 +void lua_createtable(lua_State *L, int narr, int nrec) { lua_newtable(L); } +#endif +} + +using namespace compat; +} + +// for c++03 implement + +#define KAGUYA_VA_ARG(...) __VA_ARGS__ + +#define KAGUYA_PP_CAT(F, B) F##B + +// generated by generate_preprocess_macro.py + +#define KAGUYA_PP_REPEAT0(MACRO) +#define KAGUYA_PP_REPEAT1(MACRO) KAGUYA_PP_REPEAT0(MACRO) MACRO(1) +#define KAGUYA_PP_REPEAT2(MACRO) KAGUYA_PP_REPEAT1(MACRO) MACRO(2) +#define KAGUYA_PP_REPEAT3(MACRO) KAGUYA_PP_REPEAT2(MACRO) MACRO(3) +#define KAGUYA_PP_REPEAT4(MACRO) KAGUYA_PP_REPEAT3(MACRO) MACRO(4) +#define KAGUYA_PP_REPEAT5(MACRO) KAGUYA_PP_REPEAT4(MACRO) MACRO(5) +#define KAGUYA_PP_REPEAT6(MACRO) KAGUYA_PP_REPEAT5(MACRO) MACRO(6) +#define KAGUYA_PP_REPEAT7(MACRO) KAGUYA_PP_REPEAT6(MACRO) MACRO(7) +#define KAGUYA_PP_REPEAT8(MACRO) KAGUYA_PP_REPEAT7(MACRO) MACRO(8) +#define KAGUYA_PP_REPEAT9(MACRO) KAGUYA_PP_REPEAT8(MACRO) MACRO(9) +#define KAGUYA_PP_REPEAT10(MACRO) KAGUYA_PP_REPEAT9(MACRO) MACRO(10) +#define KAGUYA_PP_REPEAT11(MACRO) KAGUYA_PP_REPEAT10(MACRO) MACRO(11) +#define KAGUYA_PP_REPEAT12(MACRO) KAGUYA_PP_REPEAT11(MACRO) MACRO(12) +#define KAGUYA_PP_REPEAT13(MACRO) KAGUYA_PP_REPEAT12(MACRO) MACRO(13) +#define KAGUYA_PP_REPEAT14(MACRO) KAGUYA_PP_REPEAT13(MACRO) MACRO(14) +#define KAGUYA_PP_REPEAT15(MACRO) KAGUYA_PP_REPEAT14(MACRO) MACRO(15) +#define KAGUYA_PP_REPEAT16(MACRO) KAGUYA_PP_REPEAT15(MACRO) MACRO(16) +#define KAGUYA_PP_REPEAT17(MACRO) KAGUYA_PP_REPEAT16(MACRO) MACRO(17) +#define KAGUYA_PP_REPEAT18(MACRO) KAGUYA_PP_REPEAT17(MACRO) MACRO(18) +#define KAGUYA_PP_REPEAT19(MACRO) KAGUYA_PP_REPEAT18(MACRO) MACRO(19) +#define KAGUYA_PP_REPEAT20(MACRO) KAGUYA_PP_REPEAT19(MACRO) MACRO(20) +#define KAGUYA_PP_REPEAT21(MACRO) KAGUYA_PP_REPEAT20(MACRO) MACRO(21) +#define KAGUYA_PP_REPEAT22(MACRO) KAGUYA_PP_REPEAT21(MACRO) MACRO(22) +#define KAGUYA_PP_REPEAT23(MACRO) KAGUYA_PP_REPEAT22(MACRO) MACRO(23) +#define KAGUYA_PP_REPEAT24(MACRO) KAGUYA_PP_REPEAT23(MACRO) MACRO(24) +#define KAGUYA_PP_REPEAT25(MACRO) KAGUYA_PP_REPEAT24(MACRO) MACRO(25) +#define KAGUYA_PP_REPEAT26(MACRO) KAGUYA_PP_REPEAT25(MACRO) MACRO(26) +#define KAGUYA_PP_REPEAT27(MACRO) KAGUYA_PP_REPEAT26(MACRO) MACRO(27) +#define KAGUYA_PP_REPEAT28(MACRO) KAGUYA_PP_REPEAT27(MACRO) MACRO(28) +#define KAGUYA_PP_REPEAT29(MACRO) KAGUYA_PP_REPEAT28(MACRO) MACRO(29) +#define KAGUYA_PP_REPEAT30(MACRO) KAGUYA_PP_REPEAT29(MACRO) MACRO(30) +#define KAGUYA_PP_REPEAT31(MACRO) KAGUYA_PP_REPEAT30(MACRO) MACRO(31) +#define KAGUYA_PP_REPEAT32(MACRO) KAGUYA_PP_REPEAT31(MACRO) MACRO(32) +#define KAGUYA_PP_REPEAT33(MACRO) KAGUYA_PP_REPEAT32(MACRO) MACRO(33) +#define KAGUYA_PP_REPEAT34(MACRO) KAGUYA_PP_REPEAT33(MACRO) MACRO(34) +#define KAGUYA_PP_REPEAT35(MACRO) KAGUYA_PP_REPEAT34(MACRO) MACRO(35) +#define KAGUYA_PP_REPEAT36(MACRO) KAGUYA_PP_REPEAT35(MACRO) MACRO(36) +#define KAGUYA_PP_REPEAT37(MACRO) KAGUYA_PP_REPEAT36(MACRO) MACRO(37) +#define KAGUYA_PP_REPEAT38(MACRO) KAGUYA_PP_REPEAT37(MACRO) MACRO(38) +#define KAGUYA_PP_REPEAT39(MACRO) KAGUYA_PP_REPEAT38(MACRO) MACRO(39) +#define KAGUYA_PP_REPEAT40(MACRO) KAGUYA_PP_REPEAT39(MACRO) MACRO(40) +#define KAGUYA_PP_REPEAT41(MACRO) KAGUYA_PP_REPEAT40(MACRO) MACRO(41) +#define KAGUYA_PP_REPEAT42(MACRO) KAGUYA_PP_REPEAT41(MACRO) MACRO(42) +#define KAGUYA_PP_REPEAT43(MACRO) KAGUYA_PP_REPEAT42(MACRO) MACRO(43) +#define KAGUYA_PP_REPEAT44(MACRO) KAGUYA_PP_REPEAT43(MACRO) MACRO(44) +#define KAGUYA_PP_REPEAT45(MACRO) KAGUYA_PP_REPEAT44(MACRO) MACRO(45) +#define KAGUYA_PP_REPEAT46(MACRO) KAGUYA_PP_REPEAT45(MACRO) MACRO(46) +#define KAGUYA_PP_REPEAT47(MACRO) KAGUYA_PP_REPEAT46(MACRO) MACRO(47) +#define KAGUYA_PP_REPEAT48(MACRO) KAGUYA_PP_REPEAT47(MACRO) MACRO(48) +#define KAGUYA_PP_REPEAT49(MACRO) KAGUYA_PP_REPEAT48(MACRO) MACRO(49) +#define KAGUYA_PP_REPEAT50(MACRO) KAGUYA_PP_REPEAT49(MACRO) MACRO(50) +#define KAGUYA_PP_REPEAT51(MACRO) KAGUYA_PP_REPEAT50(MACRO) MACRO(51) +#define KAGUYA_PP_REPEAT52(MACRO) KAGUYA_PP_REPEAT51(MACRO) MACRO(52) +#define KAGUYA_PP_REPEAT53(MACRO) KAGUYA_PP_REPEAT52(MACRO) MACRO(53) +#define KAGUYA_PP_REPEAT54(MACRO) KAGUYA_PP_REPEAT53(MACRO) MACRO(54) +#define KAGUYA_PP_REPEAT55(MACRO) KAGUYA_PP_REPEAT54(MACRO) MACRO(55) +#define KAGUYA_PP_REPEAT56(MACRO) KAGUYA_PP_REPEAT55(MACRO) MACRO(56) +#define KAGUYA_PP_REPEAT57(MACRO) KAGUYA_PP_REPEAT56(MACRO) MACRO(57) +#define KAGUYA_PP_REPEAT58(MACRO) KAGUYA_PP_REPEAT57(MACRO) MACRO(58) +#define KAGUYA_PP_REPEAT59(MACRO) KAGUYA_PP_REPEAT58(MACRO) MACRO(59) +#define KAGUYA_PP_REPEAT60(MACRO) KAGUYA_PP_REPEAT59(MACRO) MACRO(60) +#define KAGUYA_PP_REPEAT61(MACRO) KAGUYA_PP_REPEAT60(MACRO) MACRO(61) +#define KAGUYA_PP_REPEAT62(MACRO) KAGUYA_PP_REPEAT61(MACRO) MACRO(62) +#define KAGUYA_PP_REPEAT63(MACRO) KAGUYA_PP_REPEAT62(MACRO) MACRO(63) +#define KAGUYA_PP_REPEAT64(MACRO) KAGUYA_PP_REPEAT63(MACRO) MACRO(64) +#define KAGUYA_PP_REPEAT65(MACRO) KAGUYA_PP_REPEAT64(MACRO) MACRO(65) +#define KAGUYA_PP_REPEAT66(MACRO) KAGUYA_PP_REPEAT65(MACRO) MACRO(66) +#define KAGUYA_PP_REPEAT67(MACRO) KAGUYA_PP_REPEAT66(MACRO) MACRO(67) +#define KAGUYA_PP_REPEAT68(MACRO) KAGUYA_PP_REPEAT67(MACRO) MACRO(68) +#define KAGUYA_PP_REPEAT69(MACRO) KAGUYA_PP_REPEAT68(MACRO) MACRO(69) +#define KAGUYA_PP_REPEAT70(MACRO) KAGUYA_PP_REPEAT69(MACRO) MACRO(70) +#define KAGUYA_PP_REPEAT71(MACRO) KAGUYA_PP_REPEAT70(MACRO) MACRO(71) +#define KAGUYA_PP_REPEAT72(MACRO) KAGUYA_PP_REPEAT71(MACRO) MACRO(72) +#define KAGUYA_PP_REPEAT73(MACRO) KAGUYA_PP_REPEAT72(MACRO) MACRO(73) +#define KAGUYA_PP_REPEAT74(MACRO) KAGUYA_PP_REPEAT73(MACRO) MACRO(74) +#define KAGUYA_PP_REPEAT75(MACRO) KAGUYA_PP_REPEAT74(MACRO) MACRO(75) +#define KAGUYA_PP_REPEAT76(MACRO) KAGUYA_PP_REPEAT75(MACRO) MACRO(76) +#define KAGUYA_PP_REPEAT77(MACRO) KAGUYA_PP_REPEAT76(MACRO) MACRO(77) +#define KAGUYA_PP_REPEAT78(MACRO) KAGUYA_PP_REPEAT77(MACRO) MACRO(78) +#define KAGUYA_PP_REPEAT79(MACRO) KAGUYA_PP_REPEAT78(MACRO) MACRO(79) +#define KAGUYA_PP_REPEAT80(MACRO) KAGUYA_PP_REPEAT79(MACRO) MACRO(80) +#define KAGUYA_PP_REPEAT81(MACRO) KAGUYA_PP_REPEAT80(MACRO) MACRO(81) +#define KAGUYA_PP_REPEAT82(MACRO) KAGUYA_PP_REPEAT81(MACRO) MACRO(82) +#define KAGUYA_PP_REPEAT83(MACRO) KAGUYA_PP_REPEAT82(MACRO) MACRO(83) +#define KAGUYA_PP_REPEAT84(MACRO) KAGUYA_PP_REPEAT83(MACRO) MACRO(84) +#define KAGUYA_PP_REPEAT85(MACRO) KAGUYA_PP_REPEAT84(MACRO) MACRO(85) +#define KAGUYA_PP_REPEAT86(MACRO) KAGUYA_PP_REPEAT85(MACRO) MACRO(86) +#define KAGUYA_PP_REPEAT87(MACRO) KAGUYA_PP_REPEAT86(MACRO) MACRO(87) +#define KAGUYA_PP_REPEAT88(MACRO) KAGUYA_PP_REPEAT87(MACRO) MACRO(88) +#define KAGUYA_PP_REPEAT89(MACRO) KAGUYA_PP_REPEAT88(MACRO) MACRO(89) +#define KAGUYA_PP_REPEAT90(MACRO) KAGUYA_PP_REPEAT89(MACRO) MACRO(90) +#define KAGUYA_PP_REPEAT91(MACRO) KAGUYA_PP_REPEAT90(MACRO) MACRO(91) +#define KAGUYA_PP_REPEAT92(MACRO) KAGUYA_PP_REPEAT91(MACRO) MACRO(92) +#define KAGUYA_PP_REPEAT93(MACRO) KAGUYA_PP_REPEAT92(MACRO) MACRO(93) +#define KAGUYA_PP_REPEAT94(MACRO) KAGUYA_PP_REPEAT93(MACRO) MACRO(94) +#define KAGUYA_PP_REPEAT95(MACRO) KAGUYA_PP_REPEAT94(MACRO) MACRO(95) +#define KAGUYA_PP_REPEAT96(MACRO) KAGUYA_PP_REPEAT95(MACRO) MACRO(96) +#define KAGUYA_PP_REPEAT97(MACRO) KAGUYA_PP_REPEAT96(MACRO) MACRO(97) +#define KAGUYA_PP_REPEAT98(MACRO) KAGUYA_PP_REPEAT97(MACRO) MACRO(98) +#define KAGUYA_PP_REPEAT99(MACRO) KAGUYA_PP_REPEAT98(MACRO) MACRO(99) +#define KAGUYA_PP_REPEAT100(MACRO) KAGUYA_PP_REPEAT99(MACRO) MACRO(100) +#define KAGUYA_PP_REPEAT101(MACRO) KAGUYA_PP_REPEAT100(MACRO) MACRO(101) +#define KAGUYA_PP_REPEAT102(MACRO) KAGUYA_PP_REPEAT101(MACRO) MACRO(102) +#define KAGUYA_PP_REPEAT103(MACRO) KAGUYA_PP_REPEAT102(MACRO) MACRO(103) +#define KAGUYA_PP_REPEAT104(MACRO) KAGUYA_PP_REPEAT103(MACRO) MACRO(104) +#define KAGUYA_PP_REPEAT105(MACRO) KAGUYA_PP_REPEAT104(MACRO) MACRO(105) +#define KAGUYA_PP_REPEAT106(MACRO) KAGUYA_PP_REPEAT105(MACRO) MACRO(106) +#define KAGUYA_PP_REPEAT107(MACRO) KAGUYA_PP_REPEAT106(MACRO) MACRO(107) +#define KAGUYA_PP_REPEAT108(MACRO) KAGUYA_PP_REPEAT107(MACRO) MACRO(108) +#define KAGUYA_PP_REPEAT109(MACRO) KAGUYA_PP_REPEAT108(MACRO) MACRO(109) +#define KAGUYA_PP_REPEAT110(MACRO) KAGUYA_PP_REPEAT109(MACRO) MACRO(110) +#define KAGUYA_PP_REPEAT111(MACRO) KAGUYA_PP_REPEAT110(MACRO) MACRO(111) +#define KAGUYA_PP_REPEAT112(MACRO) KAGUYA_PP_REPEAT111(MACRO) MACRO(112) +#define KAGUYA_PP_REPEAT113(MACRO) KAGUYA_PP_REPEAT112(MACRO) MACRO(113) +#define KAGUYA_PP_REPEAT114(MACRO) KAGUYA_PP_REPEAT113(MACRO) MACRO(114) +#define KAGUYA_PP_REPEAT115(MACRO) KAGUYA_PP_REPEAT114(MACRO) MACRO(115) +#define KAGUYA_PP_REPEAT116(MACRO) KAGUYA_PP_REPEAT115(MACRO) MACRO(116) +#define KAGUYA_PP_REPEAT117(MACRO) KAGUYA_PP_REPEAT116(MACRO) MACRO(117) +#define KAGUYA_PP_REPEAT118(MACRO) KAGUYA_PP_REPEAT117(MACRO) MACRO(118) +#define KAGUYA_PP_REPEAT119(MACRO) KAGUYA_PP_REPEAT118(MACRO) MACRO(119) +#define KAGUYA_PP_REPEAT120(MACRO) KAGUYA_PP_REPEAT119(MACRO) MACRO(120) +#define KAGUYA_PP_REPEAT121(MACRO) KAGUYA_PP_REPEAT120(MACRO) MACRO(121) +#define KAGUYA_PP_REPEAT122(MACRO) KAGUYA_PP_REPEAT121(MACRO) MACRO(122) +#define KAGUYA_PP_REPEAT123(MACRO) KAGUYA_PP_REPEAT122(MACRO) MACRO(123) +#define KAGUYA_PP_REPEAT124(MACRO) KAGUYA_PP_REPEAT123(MACRO) MACRO(124) +#define KAGUYA_PP_REPEAT125(MACRO) KAGUYA_PP_REPEAT124(MACRO) MACRO(125) +#define KAGUYA_PP_REPEAT126(MACRO) KAGUYA_PP_REPEAT125(MACRO) MACRO(126) +#define KAGUYA_PP_REPEAT127(MACRO) KAGUYA_PP_REPEAT126(MACRO) MACRO(127) +#define KAGUYA_PP_REPEAT128(MACRO) KAGUYA_PP_REPEAT127(MACRO) MACRO(128) +#define KAGUYA_PP_REPEAT129(MACRO) KAGUYA_PP_REPEAT128(MACRO) MACRO(129) +#define KAGUYA_PP_REPEAT130(MACRO) KAGUYA_PP_REPEAT129(MACRO) MACRO(130) +#define KAGUYA_PP_REPEAT131(MACRO) KAGUYA_PP_REPEAT130(MACRO) MACRO(131) +#define KAGUYA_PP_REPEAT132(MACRO) KAGUYA_PP_REPEAT131(MACRO) MACRO(132) +#define KAGUYA_PP_REPEAT133(MACRO) KAGUYA_PP_REPEAT132(MACRO) MACRO(133) +#define KAGUYA_PP_REPEAT134(MACRO) KAGUYA_PP_REPEAT133(MACRO) MACRO(134) +#define KAGUYA_PP_REPEAT135(MACRO) KAGUYA_PP_REPEAT134(MACRO) MACRO(135) +#define KAGUYA_PP_REPEAT136(MACRO) KAGUYA_PP_REPEAT135(MACRO) MACRO(136) +#define KAGUYA_PP_REPEAT137(MACRO) KAGUYA_PP_REPEAT136(MACRO) MACRO(137) +#define KAGUYA_PP_REPEAT138(MACRO) KAGUYA_PP_REPEAT137(MACRO) MACRO(138) +#define KAGUYA_PP_REPEAT139(MACRO) KAGUYA_PP_REPEAT138(MACRO) MACRO(139) +#define KAGUYA_PP_REPEAT140(MACRO) KAGUYA_PP_REPEAT139(MACRO) MACRO(140) +#define KAGUYA_PP_REPEAT141(MACRO) KAGUYA_PP_REPEAT140(MACRO) MACRO(141) +#define KAGUYA_PP_REPEAT142(MACRO) KAGUYA_PP_REPEAT141(MACRO) MACRO(142) +#define KAGUYA_PP_REPEAT143(MACRO) KAGUYA_PP_REPEAT142(MACRO) MACRO(143) +#define KAGUYA_PP_REPEAT144(MACRO) KAGUYA_PP_REPEAT143(MACRO) MACRO(144) +#define KAGUYA_PP_REPEAT145(MACRO) KAGUYA_PP_REPEAT144(MACRO) MACRO(145) +#define KAGUYA_PP_REPEAT146(MACRO) KAGUYA_PP_REPEAT145(MACRO) MACRO(146) +#define KAGUYA_PP_REPEAT147(MACRO) KAGUYA_PP_REPEAT146(MACRO) MACRO(147) +#define KAGUYA_PP_REPEAT148(MACRO) KAGUYA_PP_REPEAT147(MACRO) MACRO(148) +#define KAGUYA_PP_REPEAT149(MACRO) KAGUYA_PP_REPEAT148(MACRO) MACRO(149) +#define KAGUYA_PP_REPEAT150(MACRO) KAGUYA_PP_REPEAT149(MACRO) MACRO(150) +#define KAGUYA_PP_REPEAT151(MACRO) KAGUYA_PP_REPEAT150(MACRO) MACRO(151) +#define KAGUYA_PP_REPEAT152(MACRO) KAGUYA_PP_REPEAT151(MACRO) MACRO(152) +#define KAGUYA_PP_REPEAT153(MACRO) KAGUYA_PP_REPEAT152(MACRO) MACRO(153) +#define KAGUYA_PP_REPEAT154(MACRO) KAGUYA_PP_REPEAT153(MACRO) MACRO(154) +#define KAGUYA_PP_REPEAT155(MACRO) KAGUYA_PP_REPEAT154(MACRO) MACRO(155) +#define KAGUYA_PP_REPEAT156(MACRO) KAGUYA_PP_REPEAT155(MACRO) MACRO(156) +#define KAGUYA_PP_REPEAT157(MACRO) KAGUYA_PP_REPEAT156(MACRO) MACRO(157) +#define KAGUYA_PP_REPEAT158(MACRO) KAGUYA_PP_REPEAT157(MACRO) MACRO(158) +#define KAGUYA_PP_REPEAT159(MACRO) KAGUYA_PP_REPEAT158(MACRO) MACRO(159) +#define KAGUYA_PP_REPEAT160(MACRO) KAGUYA_PP_REPEAT159(MACRO) MACRO(160) +#define KAGUYA_PP_REPEAT161(MACRO) KAGUYA_PP_REPEAT160(MACRO) MACRO(161) +#define KAGUYA_PP_REPEAT162(MACRO) KAGUYA_PP_REPEAT161(MACRO) MACRO(162) +#define KAGUYA_PP_REPEAT163(MACRO) KAGUYA_PP_REPEAT162(MACRO) MACRO(163) +#define KAGUYA_PP_REPEAT164(MACRO) KAGUYA_PP_REPEAT163(MACRO) MACRO(164) +#define KAGUYA_PP_REPEAT165(MACRO) KAGUYA_PP_REPEAT164(MACRO) MACRO(165) +#define KAGUYA_PP_REPEAT166(MACRO) KAGUYA_PP_REPEAT165(MACRO) MACRO(166) +#define KAGUYA_PP_REPEAT167(MACRO) KAGUYA_PP_REPEAT166(MACRO) MACRO(167) +#define KAGUYA_PP_REPEAT168(MACRO) KAGUYA_PP_REPEAT167(MACRO) MACRO(168) +#define KAGUYA_PP_REPEAT169(MACRO) KAGUYA_PP_REPEAT168(MACRO) MACRO(169) +#define KAGUYA_PP_REPEAT170(MACRO) KAGUYA_PP_REPEAT169(MACRO) MACRO(170) +#define KAGUYA_PP_REPEAT171(MACRO) KAGUYA_PP_REPEAT170(MACRO) MACRO(171) +#define KAGUYA_PP_REPEAT172(MACRO) KAGUYA_PP_REPEAT171(MACRO) MACRO(172) +#define KAGUYA_PP_REPEAT173(MACRO) KAGUYA_PP_REPEAT172(MACRO) MACRO(173) +#define KAGUYA_PP_REPEAT174(MACRO) KAGUYA_PP_REPEAT173(MACRO) MACRO(174) +#define KAGUYA_PP_REPEAT175(MACRO) KAGUYA_PP_REPEAT174(MACRO) MACRO(175) +#define KAGUYA_PP_REPEAT176(MACRO) KAGUYA_PP_REPEAT175(MACRO) MACRO(176) +#define KAGUYA_PP_REPEAT177(MACRO) KAGUYA_PP_REPEAT176(MACRO) MACRO(177) +#define KAGUYA_PP_REPEAT178(MACRO) KAGUYA_PP_REPEAT177(MACRO) MACRO(178) +#define KAGUYA_PP_REPEAT179(MACRO) KAGUYA_PP_REPEAT178(MACRO) MACRO(179) +#define KAGUYA_PP_REPEAT180(MACRO) KAGUYA_PP_REPEAT179(MACRO) MACRO(180) +#define KAGUYA_PP_REPEAT181(MACRO) KAGUYA_PP_REPEAT180(MACRO) MACRO(181) +#define KAGUYA_PP_REPEAT182(MACRO) KAGUYA_PP_REPEAT181(MACRO) MACRO(182) +#define KAGUYA_PP_REPEAT183(MACRO) KAGUYA_PP_REPEAT182(MACRO) MACRO(183) +#define KAGUYA_PP_REPEAT184(MACRO) KAGUYA_PP_REPEAT183(MACRO) MACRO(184) +#define KAGUYA_PP_REPEAT185(MACRO) KAGUYA_PP_REPEAT184(MACRO) MACRO(185) +#define KAGUYA_PP_REPEAT186(MACRO) KAGUYA_PP_REPEAT185(MACRO) MACRO(186) +#define KAGUYA_PP_REPEAT187(MACRO) KAGUYA_PP_REPEAT186(MACRO) MACRO(187) +#define KAGUYA_PP_REPEAT188(MACRO) KAGUYA_PP_REPEAT187(MACRO) MACRO(188) +#define KAGUYA_PP_REPEAT189(MACRO) KAGUYA_PP_REPEAT188(MACRO) MACRO(189) +#define KAGUYA_PP_REPEAT190(MACRO) KAGUYA_PP_REPEAT189(MACRO) MACRO(190) +#define KAGUYA_PP_REPEAT191(MACRO) KAGUYA_PP_REPEAT190(MACRO) MACRO(191) +#define KAGUYA_PP_REPEAT192(MACRO) KAGUYA_PP_REPEAT191(MACRO) MACRO(192) +#define KAGUYA_PP_REPEAT193(MACRO) KAGUYA_PP_REPEAT192(MACRO) MACRO(193) +#define KAGUYA_PP_REPEAT194(MACRO) KAGUYA_PP_REPEAT193(MACRO) MACRO(194) +#define KAGUYA_PP_REPEAT195(MACRO) KAGUYA_PP_REPEAT194(MACRO) MACRO(195) +#define KAGUYA_PP_REPEAT196(MACRO) KAGUYA_PP_REPEAT195(MACRO) MACRO(196) +#define KAGUYA_PP_REPEAT197(MACRO) KAGUYA_PP_REPEAT196(MACRO) MACRO(197) +#define KAGUYA_PP_REPEAT198(MACRO) KAGUYA_PP_REPEAT197(MACRO) MACRO(198) +#define KAGUYA_PP_REPEAT199(MACRO) KAGUYA_PP_REPEAT198(MACRO) MACRO(199) +#define KAGUYA_PP_REPEAT200(MACRO) KAGUYA_PP_REPEAT199(MACRO) MACRO(200) +#define KAGUYA_PP_REPEAT201(MACRO) KAGUYA_PP_REPEAT200(MACRO) MACRO(201) +#define KAGUYA_PP_REPEAT202(MACRO) KAGUYA_PP_REPEAT201(MACRO) MACRO(202) +#define KAGUYA_PP_REPEAT203(MACRO) KAGUYA_PP_REPEAT202(MACRO) MACRO(203) +#define KAGUYA_PP_REPEAT204(MACRO) KAGUYA_PP_REPEAT203(MACRO) MACRO(204) +#define KAGUYA_PP_REPEAT205(MACRO) KAGUYA_PP_REPEAT204(MACRO) MACRO(205) +#define KAGUYA_PP_REPEAT206(MACRO) KAGUYA_PP_REPEAT205(MACRO) MACRO(206) +#define KAGUYA_PP_REPEAT207(MACRO) KAGUYA_PP_REPEAT206(MACRO) MACRO(207) +#define KAGUYA_PP_REPEAT208(MACRO) KAGUYA_PP_REPEAT207(MACRO) MACRO(208) +#define KAGUYA_PP_REPEAT209(MACRO) KAGUYA_PP_REPEAT208(MACRO) MACRO(209) +#define KAGUYA_PP_REPEAT210(MACRO) KAGUYA_PP_REPEAT209(MACRO) MACRO(210) +#define KAGUYA_PP_REPEAT211(MACRO) KAGUYA_PP_REPEAT210(MACRO) MACRO(211) +#define KAGUYA_PP_REPEAT212(MACRO) KAGUYA_PP_REPEAT211(MACRO) MACRO(212) +#define KAGUYA_PP_REPEAT213(MACRO) KAGUYA_PP_REPEAT212(MACRO) MACRO(213) +#define KAGUYA_PP_REPEAT214(MACRO) KAGUYA_PP_REPEAT213(MACRO) MACRO(214) +#define KAGUYA_PP_REPEAT215(MACRO) KAGUYA_PP_REPEAT214(MACRO) MACRO(215) +#define KAGUYA_PP_REPEAT216(MACRO) KAGUYA_PP_REPEAT215(MACRO) MACRO(216) +#define KAGUYA_PP_REPEAT217(MACRO) KAGUYA_PP_REPEAT216(MACRO) MACRO(217) +#define KAGUYA_PP_REPEAT218(MACRO) KAGUYA_PP_REPEAT217(MACRO) MACRO(218) +#define KAGUYA_PP_REPEAT219(MACRO) KAGUYA_PP_REPEAT218(MACRO) MACRO(219) +#define KAGUYA_PP_REPEAT220(MACRO) KAGUYA_PP_REPEAT219(MACRO) MACRO(220) +#define KAGUYA_PP_REPEAT221(MACRO) KAGUYA_PP_REPEAT220(MACRO) MACRO(221) +#define KAGUYA_PP_REPEAT222(MACRO) KAGUYA_PP_REPEAT221(MACRO) MACRO(222) +#define KAGUYA_PP_REPEAT223(MACRO) KAGUYA_PP_REPEAT222(MACRO) MACRO(223) +#define KAGUYA_PP_REPEAT224(MACRO) KAGUYA_PP_REPEAT223(MACRO) MACRO(224) +#define KAGUYA_PP_REPEAT225(MACRO) KAGUYA_PP_REPEAT224(MACRO) MACRO(225) +#define KAGUYA_PP_REPEAT226(MACRO) KAGUYA_PP_REPEAT225(MACRO) MACRO(226) +#define KAGUYA_PP_REPEAT227(MACRO) KAGUYA_PP_REPEAT226(MACRO) MACRO(227) +#define KAGUYA_PP_REPEAT228(MACRO) KAGUYA_PP_REPEAT227(MACRO) MACRO(228) +#define KAGUYA_PP_REPEAT229(MACRO) KAGUYA_PP_REPEAT228(MACRO) MACRO(229) +#define KAGUYA_PP_REPEAT230(MACRO) KAGUYA_PP_REPEAT229(MACRO) MACRO(230) +#define KAGUYA_PP_REPEAT231(MACRO) KAGUYA_PP_REPEAT230(MACRO) MACRO(231) +#define KAGUYA_PP_REPEAT232(MACRO) KAGUYA_PP_REPEAT231(MACRO) MACRO(232) +#define KAGUYA_PP_REPEAT233(MACRO) KAGUYA_PP_REPEAT232(MACRO) MACRO(233) +#define KAGUYA_PP_REPEAT234(MACRO) KAGUYA_PP_REPEAT233(MACRO) MACRO(234) +#define KAGUYA_PP_REPEAT235(MACRO) KAGUYA_PP_REPEAT234(MACRO) MACRO(235) +#define KAGUYA_PP_REPEAT236(MACRO) KAGUYA_PP_REPEAT235(MACRO) MACRO(236) +#define KAGUYA_PP_REPEAT237(MACRO) KAGUYA_PP_REPEAT236(MACRO) MACRO(237) +#define KAGUYA_PP_REPEAT238(MACRO) KAGUYA_PP_REPEAT237(MACRO) MACRO(238) +#define KAGUYA_PP_REPEAT239(MACRO) KAGUYA_PP_REPEAT238(MACRO) MACRO(239) +#define KAGUYA_PP_REPEAT240(MACRO) KAGUYA_PP_REPEAT239(MACRO) MACRO(240) +#define KAGUYA_PP_REPEAT241(MACRO) KAGUYA_PP_REPEAT240(MACRO) MACRO(241) +#define KAGUYA_PP_REPEAT242(MACRO) KAGUYA_PP_REPEAT241(MACRO) MACRO(242) +#define KAGUYA_PP_REPEAT243(MACRO) KAGUYA_PP_REPEAT242(MACRO) MACRO(243) +#define KAGUYA_PP_REPEAT244(MACRO) KAGUYA_PP_REPEAT243(MACRO) MACRO(244) +#define KAGUYA_PP_REPEAT245(MACRO) KAGUYA_PP_REPEAT244(MACRO) MACRO(245) +#define KAGUYA_PP_REPEAT246(MACRO) KAGUYA_PP_REPEAT245(MACRO) MACRO(246) +#define KAGUYA_PP_REPEAT247(MACRO) KAGUYA_PP_REPEAT246(MACRO) MACRO(247) +#define KAGUYA_PP_REPEAT248(MACRO) KAGUYA_PP_REPEAT247(MACRO) MACRO(248) +#define KAGUYA_PP_REPEAT249(MACRO) KAGUYA_PP_REPEAT248(MACRO) MACRO(249) +#define KAGUYA_PP_REPEAT250(MACRO) KAGUYA_PP_REPEAT249(MACRO) MACRO(250) +#define KAGUYA_PP_REPEAT251(MACRO) KAGUYA_PP_REPEAT250(MACRO) MACRO(251) +#define KAGUYA_PP_REPEAT252(MACRO) KAGUYA_PP_REPEAT251(MACRO) MACRO(252) +#define KAGUYA_PP_REPEAT253(MACRO) KAGUYA_PP_REPEAT252(MACRO) MACRO(253) +#define KAGUYA_PP_REPEAT254(MACRO) KAGUYA_PP_REPEAT253(MACRO) MACRO(254) +#define KAGUYA_PP_REPEAT(COUNT, MACRO) \ + KAGUYA_PP_CAT(KAGUYA_PP_REPEAT, COUNT)(MACRO) + +#define KAGUYA_PP_REPEAT_DEF0(MACRO) +#define KAGUYA_PP_REPEAT_DEF1(MACRO) KAGUYA_PP_REPEAT_DEF0(MACRO) MACRO(1) +#define KAGUYA_PP_REPEAT_DEF2(MACRO) KAGUYA_PP_REPEAT_DEF1(MACRO) MACRO(2) +#define KAGUYA_PP_REPEAT_DEF3(MACRO) KAGUYA_PP_REPEAT_DEF2(MACRO) MACRO(3) +#define KAGUYA_PP_REPEAT_DEF4(MACRO) KAGUYA_PP_REPEAT_DEF3(MACRO) MACRO(4) +#define KAGUYA_PP_REPEAT_DEF5(MACRO) KAGUYA_PP_REPEAT_DEF4(MACRO) MACRO(5) +#define KAGUYA_PP_REPEAT_DEF6(MACRO) KAGUYA_PP_REPEAT_DEF5(MACRO) MACRO(6) +#define KAGUYA_PP_REPEAT_DEF7(MACRO) KAGUYA_PP_REPEAT_DEF6(MACRO) MACRO(7) +#define KAGUYA_PP_REPEAT_DEF8(MACRO) KAGUYA_PP_REPEAT_DEF7(MACRO) MACRO(8) +#define KAGUYA_PP_REPEAT_DEF9(MACRO) KAGUYA_PP_REPEAT_DEF8(MACRO) MACRO(9) +#define KAGUYA_PP_REPEAT_DEF10(MACRO) KAGUYA_PP_REPEAT_DEF9(MACRO) MACRO(10) +#define KAGUYA_PP_REPEAT_DEF11(MACRO) KAGUYA_PP_REPEAT_DEF10(MACRO) MACRO(11) +#define KAGUYA_PP_REPEAT_DEF12(MACRO) KAGUYA_PP_REPEAT_DEF11(MACRO) MACRO(12) +#define KAGUYA_PP_REPEAT_DEF13(MACRO) KAGUYA_PP_REPEAT_DEF12(MACRO) MACRO(13) +#define KAGUYA_PP_REPEAT_DEF14(MACRO) KAGUYA_PP_REPEAT_DEF13(MACRO) MACRO(14) +#define KAGUYA_PP_REPEAT_DEF15(MACRO) KAGUYA_PP_REPEAT_DEF14(MACRO) MACRO(15) +#define KAGUYA_PP_REPEAT_DEF16(MACRO) KAGUYA_PP_REPEAT_DEF15(MACRO) MACRO(16) +#define KAGUYA_PP_REPEAT_DEF17(MACRO) KAGUYA_PP_REPEAT_DEF16(MACRO) MACRO(17) +#define KAGUYA_PP_REPEAT_DEF18(MACRO) KAGUYA_PP_REPEAT_DEF17(MACRO) MACRO(18) +#define KAGUYA_PP_REPEAT_DEF19(MACRO) KAGUYA_PP_REPEAT_DEF18(MACRO) MACRO(19) +#define KAGUYA_PP_REPEAT_DEF20(MACRO) KAGUYA_PP_REPEAT_DEF19(MACRO) MACRO(20) +#define KAGUYA_PP_REPEAT_DEF21(MACRO) KAGUYA_PP_REPEAT_DEF20(MACRO) MACRO(21) +#define KAGUYA_PP_REPEAT_DEF22(MACRO) KAGUYA_PP_REPEAT_DEF21(MACRO) MACRO(22) +#define KAGUYA_PP_REPEAT_DEF23(MACRO) KAGUYA_PP_REPEAT_DEF22(MACRO) MACRO(23) +#define KAGUYA_PP_REPEAT_DEF24(MACRO) KAGUYA_PP_REPEAT_DEF23(MACRO) MACRO(24) +#define KAGUYA_PP_REPEAT_DEF25(MACRO) KAGUYA_PP_REPEAT_DEF24(MACRO) MACRO(25) +#define KAGUYA_PP_REPEAT_DEF26(MACRO) KAGUYA_PP_REPEAT_DEF25(MACRO) MACRO(26) +#define KAGUYA_PP_REPEAT_DEF27(MACRO) KAGUYA_PP_REPEAT_DEF26(MACRO) MACRO(27) +#define KAGUYA_PP_REPEAT_DEF28(MACRO) KAGUYA_PP_REPEAT_DEF27(MACRO) MACRO(28) +#define KAGUYA_PP_REPEAT_DEF29(MACRO) KAGUYA_PP_REPEAT_DEF28(MACRO) MACRO(29) +#define KAGUYA_PP_REPEAT_DEF30(MACRO) KAGUYA_PP_REPEAT_DEF29(MACRO) MACRO(30) +#define KAGUYA_PP_REPEAT_DEF31(MACRO) KAGUYA_PP_REPEAT_DEF30(MACRO) MACRO(31) +#define KAGUYA_PP_REPEAT_DEF32(MACRO) KAGUYA_PP_REPEAT_DEF31(MACRO) MACRO(32) +#define KAGUYA_PP_REPEAT_DEF33(MACRO) KAGUYA_PP_REPEAT_DEF32(MACRO) MACRO(33) +#define KAGUYA_PP_REPEAT_DEF34(MACRO) KAGUYA_PP_REPEAT_DEF33(MACRO) MACRO(34) +#define KAGUYA_PP_REPEAT_DEF35(MACRO) KAGUYA_PP_REPEAT_DEF34(MACRO) MACRO(35) +#define KAGUYA_PP_REPEAT_DEF36(MACRO) KAGUYA_PP_REPEAT_DEF35(MACRO) MACRO(36) +#define KAGUYA_PP_REPEAT_DEF37(MACRO) KAGUYA_PP_REPEAT_DEF36(MACRO) MACRO(37) +#define KAGUYA_PP_REPEAT_DEF38(MACRO) KAGUYA_PP_REPEAT_DEF37(MACRO) MACRO(38) +#define KAGUYA_PP_REPEAT_DEF39(MACRO) KAGUYA_PP_REPEAT_DEF38(MACRO) MACRO(39) +#define KAGUYA_PP_REPEAT_DEF40(MACRO) KAGUYA_PP_REPEAT_DEF39(MACRO) MACRO(40) +#define KAGUYA_PP_REPEAT_DEF41(MACRO) KAGUYA_PP_REPEAT_DEF40(MACRO) MACRO(41) +#define KAGUYA_PP_REPEAT_DEF42(MACRO) KAGUYA_PP_REPEAT_DEF41(MACRO) MACRO(42) +#define KAGUYA_PP_REPEAT_DEF43(MACRO) KAGUYA_PP_REPEAT_DEF42(MACRO) MACRO(43) +#define KAGUYA_PP_REPEAT_DEF44(MACRO) KAGUYA_PP_REPEAT_DEF43(MACRO) MACRO(44) +#define KAGUYA_PP_REPEAT_DEF45(MACRO) KAGUYA_PP_REPEAT_DEF44(MACRO) MACRO(45) +#define KAGUYA_PP_REPEAT_DEF46(MACRO) KAGUYA_PP_REPEAT_DEF45(MACRO) MACRO(46) +#define KAGUYA_PP_REPEAT_DEF47(MACRO) KAGUYA_PP_REPEAT_DEF46(MACRO) MACRO(47) +#define KAGUYA_PP_REPEAT_DEF48(MACRO) KAGUYA_PP_REPEAT_DEF47(MACRO) MACRO(48) +#define KAGUYA_PP_REPEAT_DEF49(MACRO) KAGUYA_PP_REPEAT_DEF48(MACRO) MACRO(49) +#define KAGUYA_PP_REPEAT_DEF50(MACRO) KAGUYA_PP_REPEAT_DEF49(MACRO) MACRO(50) +#define KAGUYA_PP_REPEAT_DEF51(MACRO) KAGUYA_PP_REPEAT_DEF50(MACRO) MACRO(51) +#define KAGUYA_PP_REPEAT_DEF52(MACRO) KAGUYA_PP_REPEAT_DEF51(MACRO) MACRO(52) +#define KAGUYA_PP_REPEAT_DEF53(MACRO) KAGUYA_PP_REPEAT_DEF52(MACRO) MACRO(53) +#define KAGUYA_PP_REPEAT_DEF54(MACRO) KAGUYA_PP_REPEAT_DEF53(MACRO) MACRO(54) +#define KAGUYA_PP_REPEAT_DEF55(MACRO) KAGUYA_PP_REPEAT_DEF54(MACRO) MACRO(55) +#define KAGUYA_PP_REPEAT_DEF56(MACRO) KAGUYA_PP_REPEAT_DEF55(MACRO) MACRO(56) +#define KAGUYA_PP_REPEAT_DEF57(MACRO) KAGUYA_PP_REPEAT_DEF56(MACRO) MACRO(57) +#define KAGUYA_PP_REPEAT_DEF58(MACRO) KAGUYA_PP_REPEAT_DEF57(MACRO) MACRO(58) +#define KAGUYA_PP_REPEAT_DEF59(MACRO) KAGUYA_PP_REPEAT_DEF58(MACRO) MACRO(59) +#define KAGUYA_PP_REPEAT_DEF60(MACRO) KAGUYA_PP_REPEAT_DEF59(MACRO) MACRO(60) +#define KAGUYA_PP_REPEAT_DEF61(MACRO) KAGUYA_PP_REPEAT_DEF60(MACRO) MACRO(61) +#define KAGUYA_PP_REPEAT_DEF62(MACRO) KAGUYA_PP_REPEAT_DEF61(MACRO) MACRO(62) +#define KAGUYA_PP_REPEAT_DEF63(MACRO) KAGUYA_PP_REPEAT_DEF62(MACRO) MACRO(63) +#define KAGUYA_PP_REPEAT_DEF64(MACRO) KAGUYA_PP_REPEAT_DEF63(MACRO) MACRO(64) +#define KAGUYA_PP_REPEAT_DEF65(MACRO) KAGUYA_PP_REPEAT_DEF64(MACRO) MACRO(65) +#define KAGUYA_PP_REPEAT_DEF66(MACRO) KAGUYA_PP_REPEAT_DEF65(MACRO) MACRO(66) +#define KAGUYA_PP_REPEAT_DEF67(MACRO) KAGUYA_PP_REPEAT_DEF66(MACRO) MACRO(67) +#define KAGUYA_PP_REPEAT_DEF68(MACRO) KAGUYA_PP_REPEAT_DEF67(MACRO) MACRO(68) +#define KAGUYA_PP_REPEAT_DEF69(MACRO) KAGUYA_PP_REPEAT_DEF68(MACRO) MACRO(69) +#define KAGUYA_PP_REPEAT_DEF70(MACRO) KAGUYA_PP_REPEAT_DEF69(MACRO) MACRO(70) +#define KAGUYA_PP_REPEAT_DEF71(MACRO) KAGUYA_PP_REPEAT_DEF70(MACRO) MACRO(71) +#define KAGUYA_PP_REPEAT_DEF72(MACRO) KAGUYA_PP_REPEAT_DEF71(MACRO) MACRO(72) +#define KAGUYA_PP_REPEAT_DEF73(MACRO) KAGUYA_PP_REPEAT_DEF72(MACRO) MACRO(73) +#define KAGUYA_PP_REPEAT_DEF74(MACRO) KAGUYA_PP_REPEAT_DEF73(MACRO) MACRO(74) +#define KAGUYA_PP_REPEAT_DEF75(MACRO) KAGUYA_PP_REPEAT_DEF74(MACRO) MACRO(75) +#define KAGUYA_PP_REPEAT_DEF76(MACRO) KAGUYA_PP_REPEAT_DEF75(MACRO) MACRO(76) +#define KAGUYA_PP_REPEAT_DEF77(MACRO) KAGUYA_PP_REPEAT_DEF76(MACRO) MACRO(77) +#define KAGUYA_PP_REPEAT_DEF78(MACRO) KAGUYA_PP_REPEAT_DEF77(MACRO) MACRO(78) +#define KAGUYA_PP_REPEAT_DEF79(MACRO) KAGUYA_PP_REPEAT_DEF78(MACRO) MACRO(79) +#define KAGUYA_PP_REPEAT_DEF80(MACRO) KAGUYA_PP_REPEAT_DEF79(MACRO) MACRO(80) +#define KAGUYA_PP_REPEAT_DEF81(MACRO) KAGUYA_PP_REPEAT_DEF80(MACRO) MACRO(81) +#define KAGUYA_PP_REPEAT_DEF82(MACRO) KAGUYA_PP_REPEAT_DEF81(MACRO) MACRO(82) +#define KAGUYA_PP_REPEAT_DEF83(MACRO) KAGUYA_PP_REPEAT_DEF82(MACRO) MACRO(83) +#define KAGUYA_PP_REPEAT_DEF84(MACRO) KAGUYA_PP_REPEAT_DEF83(MACRO) MACRO(84) +#define KAGUYA_PP_REPEAT_DEF85(MACRO) KAGUYA_PP_REPEAT_DEF84(MACRO) MACRO(85) +#define KAGUYA_PP_REPEAT_DEF86(MACRO) KAGUYA_PP_REPEAT_DEF85(MACRO) MACRO(86) +#define KAGUYA_PP_REPEAT_DEF87(MACRO) KAGUYA_PP_REPEAT_DEF86(MACRO) MACRO(87) +#define KAGUYA_PP_REPEAT_DEF88(MACRO) KAGUYA_PP_REPEAT_DEF87(MACRO) MACRO(88) +#define KAGUYA_PP_REPEAT_DEF89(MACRO) KAGUYA_PP_REPEAT_DEF88(MACRO) MACRO(89) +#define KAGUYA_PP_REPEAT_DEF90(MACRO) KAGUYA_PP_REPEAT_DEF89(MACRO) MACRO(90) +#define KAGUYA_PP_REPEAT_DEF91(MACRO) KAGUYA_PP_REPEAT_DEF90(MACRO) MACRO(91) +#define KAGUYA_PP_REPEAT_DEF92(MACRO) KAGUYA_PP_REPEAT_DEF91(MACRO) MACRO(92) +#define KAGUYA_PP_REPEAT_DEF93(MACRO) KAGUYA_PP_REPEAT_DEF92(MACRO) MACRO(93) +#define KAGUYA_PP_REPEAT_DEF94(MACRO) KAGUYA_PP_REPEAT_DEF93(MACRO) MACRO(94) +#define KAGUYA_PP_REPEAT_DEF95(MACRO) KAGUYA_PP_REPEAT_DEF94(MACRO) MACRO(95) +#define KAGUYA_PP_REPEAT_DEF96(MACRO) KAGUYA_PP_REPEAT_DEF95(MACRO) MACRO(96) +#define KAGUYA_PP_REPEAT_DEF97(MACRO) KAGUYA_PP_REPEAT_DEF96(MACRO) MACRO(97) +#define KAGUYA_PP_REPEAT_DEF98(MACRO) KAGUYA_PP_REPEAT_DEF97(MACRO) MACRO(98) +#define KAGUYA_PP_REPEAT_DEF99(MACRO) KAGUYA_PP_REPEAT_DEF98(MACRO) MACRO(99) +#define KAGUYA_PP_REPEAT_DEF100(MACRO) KAGUYA_PP_REPEAT_DEF99(MACRO) MACRO(100) +#define KAGUYA_PP_REPEAT_DEF101(MACRO) KAGUYA_PP_REPEAT_DEF100(MACRO) MACRO(101) +#define KAGUYA_PP_REPEAT_DEF102(MACRO) KAGUYA_PP_REPEAT_DEF101(MACRO) MACRO(102) +#define KAGUYA_PP_REPEAT_DEF103(MACRO) KAGUYA_PP_REPEAT_DEF102(MACRO) MACRO(103) +#define KAGUYA_PP_REPEAT_DEF104(MACRO) KAGUYA_PP_REPEAT_DEF103(MACRO) MACRO(104) +#define KAGUYA_PP_REPEAT_DEF105(MACRO) KAGUYA_PP_REPEAT_DEF104(MACRO) MACRO(105) +#define KAGUYA_PP_REPEAT_DEF106(MACRO) KAGUYA_PP_REPEAT_DEF105(MACRO) MACRO(106) +#define KAGUYA_PP_REPEAT_DEF107(MACRO) KAGUYA_PP_REPEAT_DEF106(MACRO) MACRO(107) +#define KAGUYA_PP_REPEAT_DEF108(MACRO) KAGUYA_PP_REPEAT_DEF107(MACRO) MACRO(108) +#define KAGUYA_PP_REPEAT_DEF109(MACRO) KAGUYA_PP_REPEAT_DEF108(MACRO) MACRO(109) +#define KAGUYA_PP_REPEAT_DEF110(MACRO) KAGUYA_PP_REPEAT_DEF109(MACRO) MACRO(110) +#define KAGUYA_PP_REPEAT_DEF111(MACRO) KAGUYA_PP_REPEAT_DEF110(MACRO) MACRO(111) +#define KAGUYA_PP_REPEAT_DEF112(MACRO) KAGUYA_PP_REPEAT_DEF111(MACRO) MACRO(112) +#define KAGUYA_PP_REPEAT_DEF113(MACRO) KAGUYA_PP_REPEAT_DEF112(MACRO) MACRO(113) +#define KAGUYA_PP_REPEAT_DEF114(MACRO) KAGUYA_PP_REPEAT_DEF113(MACRO) MACRO(114) +#define KAGUYA_PP_REPEAT_DEF115(MACRO) KAGUYA_PP_REPEAT_DEF114(MACRO) MACRO(115) +#define KAGUYA_PP_REPEAT_DEF116(MACRO) KAGUYA_PP_REPEAT_DEF115(MACRO) MACRO(116) +#define KAGUYA_PP_REPEAT_DEF117(MACRO) KAGUYA_PP_REPEAT_DEF116(MACRO) MACRO(117) +#define KAGUYA_PP_REPEAT_DEF118(MACRO) KAGUYA_PP_REPEAT_DEF117(MACRO) MACRO(118) +#define KAGUYA_PP_REPEAT_DEF119(MACRO) KAGUYA_PP_REPEAT_DEF118(MACRO) MACRO(119) +#define KAGUYA_PP_REPEAT_DEF120(MACRO) KAGUYA_PP_REPEAT_DEF119(MACRO) MACRO(120) +#define KAGUYA_PP_REPEAT_DEF121(MACRO) KAGUYA_PP_REPEAT_DEF120(MACRO) MACRO(121) +#define KAGUYA_PP_REPEAT_DEF122(MACRO) KAGUYA_PP_REPEAT_DEF121(MACRO) MACRO(122) +#define KAGUYA_PP_REPEAT_DEF123(MACRO) KAGUYA_PP_REPEAT_DEF122(MACRO) MACRO(123) +#define KAGUYA_PP_REPEAT_DEF124(MACRO) KAGUYA_PP_REPEAT_DEF123(MACRO) MACRO(124) +#define KAGUYA_PP_REPEAT_DEF125(MACRO) KAGUYA_PP_REPEAT_DEF124(MACRO) MACRO(125) +#define KAGUYA_PP_REPEAT_DEF126(MACRO) KAGUYA_PP_REPEAT_DEF125(MACRO) MACRO(126) +#define KAGUYA_PP_REPEAT_DEF127(MACRO) KAGUYA_PP_REPEAT_DEF126(MACRO) MACRO(127) +#define KAGUYA_PP_REPEAT_DEF128(MACRO) KAGUYA_PP_REPEAT_DEF127(MACRO) MACRO(128) +#define KAGUYA_PP_REPEAT_DEF129(MACRO) KAGUYA_PP_REPEAT_DEF128(MACRO) MACRO(129) +#define KAGUYA_PP_REPEAT_DEF130(MACRO) KAGUYA_PP_REPEAT_DEF129(MACRO) MACRO(130) +#define KAGUYA_PP_REPEAT_DEF131(MACRO) KAGUYA_PP_REPEAT_DEF130(MACRO) MACRO(131) +#define KAGUYA_PP_REPEAT_DEF132(MACRO) KAGUYA_PP_REPEAT_DEF131(MACRO) MACRO(132) +#define KAGUYA_PP_REPEAT_DEF133(MACRO) KAGUYA_PP_REPEAT_DEF132(MACRO) MACRO(133) +#define KAGUYA_PP_REPEAT_DEF134(MACRO) KAGUYA_PP_REPEAT_DEF133(MACRO) MACRO(134) +#define KAGUYA_PP_REPEAT_DEF135(MACRO) KAGUYA_PP_REPEAT_DEF134(MACRO) MACRO(135) +#define KAGUYA_PP_REPEAT_DEF136(MACRO) KAGUYA_PP_REPEAT_DEF135(MACRO) MACRO(136) +#define KAGUYA_PP_REPEAT_DEF137(MACRO) KAGUYA_PP_REPEAT_DEF136(MACRO) MACRO(137) +#define KAGUYA_PP_REPEAT_DEF138(MACRO) KAGUYA_PP_REPEAT_DEF137(MACRO) MACRO(138) +#define KAGUYA_PP_REPEAT_DEF139(MACRO) KAGUYA_PP_REPEAT_DEF138(MACRO) MACRO(139) +#define KAGUYA_PP_REPEAT_DEF140(MACRO) KAGUYA_PP_REPEAT_DEF139(MACRO) MACRO(140) +#define KAGUYA_PP_REPEAT_DEF141(MACRO) KAGUYA_PP_REPEAT_DEF140(MACRO) MACRO(141) +#define KAGUYA_PP_REPEAT_DEF142(MACRO) KAGUYA_PP_REPEAT_DEF141(MACRO) MACRO(142) +#define KAGUYA_PP_REPEAT_DEF143(MACRO) KAGUYA_PP_REPEAT_DEF142(MACRO) MACRO(143) +#define KAGUYA_PP_REPEAT_DEF144(MACRO) KAGUYA_PP_REPEAT_DEF143(MACRO) MACRO(144) +#define KAGUYA_PP_REPEAT_DEF145(MACRO) KAGUYA_PP_REPEAT_DEF144(MACRO) MACRO(145) +#define KAGUYA_PP_REPEAT_DEF146(MACRO) KAGUYA_PP_REPEAT_DEF145(MACRO) MACRO(146) +#define KAGUYA_PP_REPEAT_DEF147(MACRO) KAGUYA_PP_REPEAT_DEF146(MACRO) MACRO(147) +#define KAGUYA_PP_REPEAT_DEF148(MACRO) KAGUYA_PP_REPEAT_DEF147(MACRO) MACRO(148) +#define KAGUYA_PP_REPEAT_DEF149(MACRO) KAGUYA_PP_REPEAT_DEF148(MACRO) MACRO(149) +#define KAGUYA_PP_REPEAT_DEF150(MACRO) KAGUYA_PP_REPEAT_DEF149(MACRO) MACRO(150) +#define KAGUYA_PP_REPEAT_DEF151(MACRO) KAGUYA_PP_REPEAT_DEF150(MACRO) MACRO(151) +#define KAGUYA_PP_REPEAT_DEF152(MACRO) KAGUYA_PP_REPEAT_DEF151(MACRO) MACRO(152) +#define KAGUYA_PP_REPEAT_DEF153(MACRO) KAGUYA_PP_REPEAT_DEF152(MACRO) MACRO(153) +#define KAGUYA_PP_REPEAT_DEF154(MACRO) KAGUYA_PP_REPEAT_DEF153(MACRO) MACRO(154) +#define KAGUYA_PP_REPEAT_DEF155(MACRO) KAGUYA_PP_REPEAT_DEF154(MACRO) MACRO(155) +#define KAGUYA_PP_REPEAT_DEF156(MACRO) KAGUYA_PP_REPEAT_DEF155(MACRO) MACRO(156) +#define KAGUYA_PP_REPEAT_DEF157(MACRO) KAGUYA_PP_REPEAT_DEF156(MACRO) MACRO(157) +#define KAGUYA_PP_REPEAT_DEF158(MACRO) KAGUYA_PP_REPEAT_DEF157(MACRO) MACRO(158) +#define KAGUYA_PP_REPEAT_DEF159(MACRO) KAGUYA_PP_REPEAT_DEF158(MACRO) MACRO(159) +#define KAGUYA_PP_REPEAT_DEF160(MACRO) KAGUYA_PP_REPEAT_DEF159(MACRO) MACRO(160) +#define KAGUYA_PP_REPEAT_DEF161(MACRO) KAGUYA_PP_REPEAT_DEF160(MACRO) MACRO(161) +#define KAGUYA_PP_REPEAT_DEF162(MACRO) KAGUYA_PP_REPEAT_DEF161(MACRO) MACRO(162) +#define KAGUYA_PP_REPEAT_DEF163(MACRO) KAGUYA_PP_REPEAT_DEF162(MACRO) MACRO(163) +#define KAGUYA_PP_REPEAT_DEF164(MACRO) KAGUYA_PP_REPEAT_DEF163(MACRO) MACRO(164) +#define KAGUYA_PP_REPEAT_DEF165(MACRO) KAGUYA_PP_REPEAT_DEF164(MACRO) MACRO(165) +#define KAGUYA_PP_REPEAT_DEF166(MACRO) KAGUYA_PP_REPEAT_DEF165(MACRO) MACRO(166) +#define KAGUYA_PP_REPEAT_DEF167(MACRO) KAGUYA_PP_REPEAT_DEF166(MACRO) MACRO(167) +#define KAGUYA_PP_REPEAT_DEF168(MACRO) KAGUYA_PP_REPEAT_DEF167(MACRO) MACRO(168) +#define KAGUYA_PP_REPEAT_DEF169(MACRO) KAGUYA_PP_REPEAT_DEF168(MACRO) MACRO(169) +#define KAGUYA_PP_REPEAT_DEF170(MACRO) KAGUYA_PP_REPEAT_DEF169(MACRO) MACRO(170) +#define KAGUYA_PP_REPEAT_DEF171(MACRO) KAGUYA_PP_REPEAT_DEF170(MACRO) MACRO(171) +#define KAGUYA_PP_REPEAT_DEF172(MACRO) KAGUYA_PP_REPEAT_DEF171(MACRO) MACRO(172) +#define KAGUYA_PP_REPEAT_DEF173(MACRO) KAGUYA_PP_REPEAT_DEF172(MACRO) MACRO(173) +#define KAGUYA_PP_REPEAT_DEF174(MACRO) KAGUYA_PP_REPEAT_DEF173(MACRO) MACRO(174) +#define KAGUYA_PP_REPEAT_DEF175(MACRO) KAGUYA_PP_REPEAT_DEF174(MACRO) MACRO(175) +#define KAGUYA_PP_REPEAT_DEF176(MACRO) KAGUYA_PP_REPEAT_DEF175(MACRO) MACRO(176) +#define KAGUYA_PP_REPEAT_DEF177(MACRO) KAGUYA_PP_REPEAT_DEF176(MACRO) MACRO(177) +#define KAGUYA_PP_REPEAT_DEF178(MACRO) KAGUYA_PP_REPEAT_DEF177(MACRO) MACRO(178) +#define KAGUYA_PP_REPEAT_DEF179(MACRO) KAGUYA_PP_REPEAT_DEF178(MACRO) MACRO(179) +#define KAGUYA_PP_REPEAT_DEF180(MACRO) KAGUYA_PP_REPEAT_DEF179(MACRO) MACRO(180) +#define KAGUYA_PP_REPEAT_DEF181(MACRO) KAGUYA_PP_REPEAT_DEF180(MACRO) MACRO(181) +#define KAGUYA_PP_REPEAT_DEF182(MACRO) KAGUYA_PP_REPEAT_DEF181(MACRO) MACRO(182) +#define KAGUYA_PP_REPEAT_DEF183(MACRO) KAGUYA_PP_REPEAT_DEF182(MACRO) MACRO(183) +#define KAGUYA_PP_REPEAT_DEF184(MACRO) KAGUYA_PP_REPEAT_DEF183(MACRO) MACRO(184) +#define KAGUYA_PP_REPEAT_DEF185(MACRO) KAGUYA_PP_REPEAT_DEF184(MACRO) MACRO(185) +#define KAGUYA_PP_REPEAT_DEF186(MACRO) KAGUYA_PP_REPEAT_DEF185(MACRO) MACRO(186) +#define KAGUYA_PP_REPEAT_DEF187(MACRO) KAGUYA_PP_REPEAT_DEF186(MACRO) MACRO(187) +#define KAGUYA_PP_REPEAT_DEF188(MACRO) KAGUYA_PP_REPEAT_DEF187(MACRO) MACRO(188) +#define KAGUYA_PP_REPEAT_DEF189(MACRO) KAGUYA_PP_REPEAT_DEF188(MACRO) MACRO(189) +#define KAGUYA_PP_REPEAT_DEF190(MACRO) KAGUYA_PP_REPEAT_DEF189(MACRO) MACRO(190) +#define KAGUYA_PP_REPEAT_DEF191(MACRO) KAGUYA_PP_REPEAT_DEF190(MACRO) MACRO(191) +#define KAGUYA_PP_REPEAT_DEF192(MACRO) KAGUYA_PP_REPEAT_DEF191(MACRO) MACRO(192) +#define KAGUYA_PP_REPEAT_DEF193(MACRO) KAGUYA_PP_REPEAT_DEF192(MACRO) MACRO(193) +#define KAGUYA_PP_REPEAT_DEF194(MACRO) KAGUYA_PP_REPEAT_DEF193(MACRO) MACRO(194) +#define KAGUYA_PP_REPEAT_DEF195(MACRO) KAGUYA_PP_REPEAT_DEF194(MACRO) MACRO(195) +#define KAGUYA_PP_REPEAT_DEF196(MACRO) KAGUYA_PP_REPEAT_DEF195(MACRO) MACRO(196) +#define KAGUYA_PP_REPEAT_DEF197(MACRO) KAGUYA_PP_REPEAT_DEF196(MACRO) MACRO(197) +#define KAGUYA_PP_REPEAT_DEF198(MACRO) KAGUYA_PP_REPEAT_DEF197(MACRO) MACRO(198) +#define KAGUYA_PP_REPEAT_DEF199(MACRO) KAGUYA_PP_REPEAT_DEF198(MACRO) MACRO(199) +#define KAGUYA_PP_REPEAT_DEF200(MACRO) KAGUYA_PP_REPEAT_DEF199(MACRO) MACRO(200) +#define KAGUYA_PP_REPEAT_DEF201(MACRO) KAGUYA_PP_REPEAT_DEF200(MACRO) MACRO(201) +#define KAGUYA_PP_REPEAT_DEF202(MACRO) KAGUYA_PP_REPEAT_DEF201(MACRO) MACRO(202) +#define KAGUYA_PP_REPEAT_DEF203(MACRO) KAGUYA_PP_REPEAT_DEF202(MACRO) MACRO(203) +#define KAGUYA_PP_REPEAT_DEF204(MACRO) KAGUYA_PP_REPEAT_DEF203(MACRO) MACRO(204) +#define KAGUYA_PP_REPEAT_DEF205(MACRO) KAGUYA_PP_REPEAT_DEF204(MACRO) MACRO(205) +#define KAGUYA_PP_REPEAT_DEF206(MACRO) KAGUYA_PP_REPEAT_DEF205(MACRO) MACRO(206) +#define KAGUYA_PP_REPEAT_DEF207(MACRO) KAGUYA_PP_REPEAT_DEF206(MACRO) MACRO(207) +#define KAGUYA_PP_REPEAT_DEF208(MACRO) KAGUYA_PP_REPEAT_DEF207(MACRO) MACRO(208) +#define KAGUYA_PP_REPEAT_DEF209(MACRO) KAGUYA_PP_REPEAT_DEF208(MACRO) MACRO(209) +#define KAGUYA_PP_REPEAT_DEF210(MACRO) KAGUYA_PP_REPEAT_DEF209(MACRO) MACRO(210) +#define KAGUYA_PP_REPEAT_DEF211(MACRO) KAGUYA_PP_REPEAT_DEF210(MACRO) MACRO(211) +#define KAGUYA_PP_REPEAT_DEF212(MACRO) KAGUYA_PP_REPEAT_DEF211(MACRO) MACRO(212) +#define KAGUYA_PP_REPEAT_DEF213(MACRO) KAGUYA_PP_REPEAT_DEF212(MACRO) MACRO(213) +#define KAGUYA_PP_REPEAT_DEF214(MACRO) KAGUYA_PP_REPEAT_DEF213(MACRO) MACRO(214) +#define KAGUYA_PP_REPEAT_DEF215(MACRO) KAGUYA_PP_REPEAT_DEF214(MACRO) MACRO(215) +#define KAGUYA_PP_REPEAT_DEF216(MACRO) KAGUYA_PP_REPEAT_DEF215(MACRO) MACRO(216) +#define KAGUYA_PP_REPEAT_DEF217(MACRO) KAGUYA_PP_REPEAT_DEF216(MACRO) MACRO(217) +#define KAGUYA_PP_REPEAT_DEF218(MACRO) KAGUYA_PP_REPEAT_DEF217(MACRO) MACRO(218) +#define KAGUYA_PP_REPEAT_DEF219(MACRO) KAGUYA_PP_REPEAT_DEF218(MACRO) MACRO(219) +#define KAGUYA_PP_REPEAT_DEF220(MACRO) KAGUYA_PP_REPEAT_DEF219(MACRO) MACRO(220) +#define KAGUYA_PP_REPEAT_DEF221(MACRO) KAGUYA_PP_REPEAT_DEF220(MACRO) MACRO(221) +#define KAGUYA_PP_REPEAT_DEF222(MACRO) KAGUYA_PP_REPEAT_DEF221(MACRO) MACRO(222) +#define KAGUYA_PP_REPEAT_DEF223(MACRO) KAGUYA_PP_REPEAT_DEF222(MACRO) MACRO(223) +#define KAGUYA_PP_REPEAT_DEF224(MACRO) KAGUYA_PP_REPEAT_DEF223(MACRO) MACRO(224) +#define KAGUYA_PP_REPEAT_DEF225(MACRO) KAGUYA_PP_REPEAT_DEF224(MACRO) MACRO(225) +#define KAGUYA_PP_REPEAT_DEF226(MACRO) KAGUYA_PP_REPEAT_DEF225(MACRO) MACRO(226) +#define KAGUYA_PP_REPEAT_DEF227(MACRO) KAGUYA_PP_REPEAT_DEF226(MACRO) MACRO(227) +#define KAGUYA_PP_REPEAT_DEF228(MACRO) KAGUYA_PP_REPEAT_DEF227(MACRO) MACRO(228) +#define KAGUYA_PP_REPEAT_DEF229(MACRO) KAGUYA_PP_REPEAT_DEF228(MACRO) MACRO(229) +#define KAGUYA_PP_REPEAT_DEF230(MACRO) KAGUYA_PP_REPEAT_DEF229(MACRO) MACRO(230) +#define KAGUYA_PP_REPEAT_DEF231(MACRO) KAGUYA_PP_REPEAT_DEF230(MACRO) MACRO(231) +#define KAGUYA_PP_REPEAT_DEF232(MACRO) KAGUYA_PP_REPEAT_DEF231(MACRO) MACRO(232) +#define KAGUYA_PP_REPEAT_DEF233(MACRO) KAGUYA_PP_REPEAT_DEF232(MACRO) MACRO(233) +#define KAGUYA_PP_REPEAT_DEF234(MACRO) KAGUYA_PP_REPEAT_DEF233(MACRO) MACRO(234) +#define KAGUYA_PP_REPEAT_DEF235(MACRO) KAGUYA_PP_REPEAT_DEF234(MACRO) MACRO(235) +#define KAGUYA_PP_REPEAT_DEF236(MACRO) KAGUYA_PP_REPEAT_DEF235(MACRO) MACRO(236) +#define KAGUYA_PP_REPEAT_DEF237(MACRO) KAGUYA_PP_REPEAT_DEF236(MACRO) MACRO(237) +#define KAGUYA_PP_REPEAT_DEF238(MACRO) KAGUYA_PP_REPEAT_DEF237(MACRO) MACRO(238) +#define KAGUYA_PP_REPEAT_DEF239(MACRO) KAGUYA_PP_REPEAT_DEF238(MACRO) MACRO(239) +#define KAGUYA_PP_REPEAT_DEF240(MACRO) KAGUYA_PP_REPEAT_DEF239(MACRO) MACRO(240) +#define KAGUYA_PP_REPEAT_DEF241(MACRO) KAGUYA_PP_REPEAT_DEF240(MACRO) MACRO(241) +#define KAGUYA_PP_REPEAT_DEF242(MACRO) KAGUYA_PP_REPEAT_DEF241(MACRO) MACRO(242) +#define KAGUYA_PP_REPEAT_DEF243(MACRO) KAGUYA_PP_REPEAT_DEF242(MACRO) MACRO(243) +#define KAGUYA_PP_REPEAT_DEF244(MACRO) KAGUYA_PP_REPEAT_DEF243(MACRO) MACRO(244) +#define KAGUYA_PP_REPEAT_DEF245(MACRO) KAGUYA_PP_REPEAT_DEF244(MACRO) MACRO(245) +#define KAGUYA_PP_REPEAT_DEF246(MACRO) KAGUYA_PP_REPEAT_DEF245(MACRO) MACRO(246) +#define KAGUYA_PP_REPEAT_DEF247(MACRO) KAGUYA_PP_REPEAT_DEF246(MACRO) MACRO(247) +#define KAGUYA_PP_REPEAT_DEF248(MACRO) KAGUYA_PP_REPEAT_DEF247(MACRO) MACRO(248) +#define KAGUYA_PP_REPEAT_DEF249(MACRO) KAGUYA_PP_REPEAT_DEF248(MACRO) MACRO(249) +#define KAGUYA_PP_REPEAT_DEF250(MACRO) KAGUYA_PP_REPEAT_DEF249(MACRO) MACRO(250) +#define KAGUYA_PP_REPEAT_DEF251(MACRO) KAGUYA_PP_REPEAT_DEF250(MACRO) MACRO(251) +#define KAGUYA_PP_REPEAT_DEF252(MACRO) KAGUYA_PP_REPEAT_DEF251(MACRO) MACRO(252) +#define KAGUYA_PP_REPEAT_DEF253(MACRO) KAGUYA_PP_REPEAT_DEF252(MACRO) MACRO(253) +#define KAGUYA_PP_REPEAT_DEF254(MACRO) KAGUYA_PP_REPEAT_DEF253(MACRO) MACRO(254) +#define KAGUYA_PP_REPEAT_DEF(COUNT, MACRO) \ + KAGUYA_PP_CAT(KAGUYA_PP_REPEAT_DEF, COUNT)(MACRO) + +#define KAGUYA_PP_REVERSE_REPEAT0(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT1(MACRO) \ + MACRO(1) KAGUYA_PP_REVERSE_REPEAT0(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT2(MACRO) \ + MACRO(2) KAGUYA_PP_REVERSE_REPEAT1(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT3(MACRO) \ + MACRO(3) KAGUYA_PP_REVERSE_REPEAT2(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT4(MACRO) \ + MACRO(4) KAGUYA_PP_REVERSE_REPEAT3(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT5(MACRO) \ + MACRO(5) KAGUYA_PP_REVERSE_REPEAT4(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT6(MACRO) \ + MACRO(6) KAGUYA_PP_REVERSE_REPEAT5(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT7(MACRO) \ + MACRO(7) KAGUYA_PP_REVERSE_REPEAT6(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT8(MACRO) \ + MACRO(8) KAGUYA_PP_REVERSE_REPEAT7(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT9(MACRO) \ + MACRO(9) KAGUYA_PP_REVERSE_REPEAT8(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT10(MACRO) \ + MACRO(10) KAGUYA_PP_REVERSE_REPEAT9(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT11(MACRO) \ + MACRO(11) KAGUYA_PP_REVERSE_REPEAT10(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT12(MACRO) \ + MACRO(12) KAGUYA_PP_REVERSE_REPEAT11(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT13(MACRO) \ + MACRO(13) KAGUYA_PP_REVERSE_REPEAT12(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT14(MACRO) \ + MACRO(14) KAGUYA_PP_REVERSE_REPEAT13(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT15(MACRO) \ + MACRO(15) KAGUYA_PP_REVERSE_REPEAT14(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT16(MACRO) \ + MACRO(16) KAGUYA_PP_REVERSE_REPEAT15(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT17(MACRO) \ + MACRO(17) KAGUYA_PP_REVERSE_REPEAT16(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT18(MACRO) \ + MACRO(18) KAGUYA_PP_REVERSE_REPEAT17(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT19(MACRO) \ + MACRO(19) KAGUYA_PP_REVERSE_REPEAT18(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT20(MACRO) \ + MACRO(20) KAGUYA_PP_REVERSE_REPEAT19(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT21(MACRO) \ + MACRO(21) KAGUYA_PP_REVERSE_REPEAT20(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT22(MACRO) \ + MACRO(22) KAGUYA_PP_REVERSE_REPEAT21(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT23(MACRO) \ + MACRO(23) KAGUYA_PP_REVERSE_REPEAT22(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT24(MACRO) \ + MACRO(24) KAGUYA_PP_REVERSE_REPEAT23(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT25(MACRO) \ + MACRO(25) KAGUYA_PP_REVERSE_REPEAT24(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT26(MACRO) \ + MACRO(26) KAGUYA_PP_REVERSE_REPEAT25(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT27(MACRO) \ + MACRO(27) KAGUYA_PP_REVERSE_REPEAT26(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT28(MACRO) \ + MACRO(28) KAGUYA_PP_REVERSE_REPEAT27(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT29(MACRO) \ + MACRO(29) KAGUYA_PP_REVERSE_REPEAT28(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT30(MACRO) \ + MACRO(30) KAGUYA_PP_REVERSE_REPEAT29(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT31(MACRO) \ + MACRO(31) KAGUYA_PP_REVERSE_REPEAT30(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT32(MACRO) \ + MACRO(32) KAGUYA_PP_REVERSE_REPEAT31(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT33(MACRO) \ + MACRO(33) KAGUYA_PP_REVERSE_REPEAT32(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT34(MACRO) \ + MACRO(34) KAGUYA_PP_REVERSE_REPEAT33(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT35(MACRO) \ + MACRO(35) KAGUYA_PP_REVERSE_REPEAT34(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT36(MACRO) \ + MACRO(36) KAGUYA_PP_REVERSE_REPEAT35(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT37(MACRO) \ + MACRO(37) KAGUYA_PP_REVERSE_REPEAT36(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT38(MACRO) \ + MACRO(38) KAGUYA_PP_REVERSE_REPEAT37(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT39(MACRO) \ + MACRO(39) KAGUYA_PP_REVERSE_REPEAT38(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT40(MACRO) \ + MACRO(40) KAGUYA_PP_REVERSE_REPEAT39(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT41(MACRO) \ + MACRO(41) KAGUYA_PP_REVERSE_REPEAT40(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT42(MACRO) \ + MACRO(42) KAGUYA_PP_REVERSE_REPEAT41(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT43(MACRO) \ + MACRO(43) KAGUYA_PP_REVERSE_REPEAT42(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT44(MACRO) \ + MACRO(44) KAGUYA_PP_REVERSE_REPEAT43(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT45(MACRO) \ + MACRO(45) KAGUYA_PP_REVERSE_REPEAT44(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT46(MACRO) \ + MACRO(46) KAGUYA_PP_REVERSE_REPEAT45(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT47(MACRO) \ + MACRO(47) KAGUYA_PP_REVERSE_REPEAT46(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT48(MACRO) \ + MACRO(48) KAGUYA_PP_REVERSE_REPEAT47(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT49(MACRO) \ + MACRO(49) KAGUYA_PP_REVERSE_REPEAT48(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT50(MACRO) \ + MACRO(50) KAGUYA_PP_REVERSE_REPEAT49(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT51(MACRO) \ + MACRO(51) KAGUYA_PP_REVERSE_REPEAT50(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT52(MACRO) \ + MACRO(52) KAGUYA_PP_REVERSE_REPEAT51(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT53(MACRO) \ + MACRO(53) KAGUYA_PP_REVERSE_REPEAT52(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT54(MACRO) \ + MACRO(54) KAGUYA_PP_REVERSE_REPEAT53(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT55(MACRO) \ + MACRO(55) KAGUYA_PP_REVERSE_REPEAT54(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT56(MACRO) \ + MACRO(56) KAGUYA_PP_REVERSE_REPEAT55(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT57(MACRO) \ + MACRO(57) KAGUYA_PP_REVERSE_REPEAT56(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT58(MACRO) \ + MACRO(58) KAGUYA_PP_REVERSE_REPEAT57(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT59(MACRO) \ + MACRO(59) KAGUYA_PP_REVERSE_REPEAT58(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT60(MACRO) \ + MACRO(60) KAGUYA_PP_REVERSE_REPEAT59(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT61(MACRO) \ + MACRO(61) KAGUYA_PP_REVERSE_REPEAT60(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT62(MACRO) \ + MACRO(62) KAGUYA_PP_REVERSE_REPEAT61(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT63(MACRO) \ + MACRO(63) KAGUYA_PP_REVERSE_REPEAT62(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT64(MACRO) \ + MACRO(64) KAGUYA_PP_REVERSE_REPEAT63(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT65(MACRO) \ + MACRO(65) KAGUYA_PP_REVERSE_REPEAT64(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT66(MACRO) \ + MACRO(66) KAGUYA_PP_REVERSE_REPEAT65(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT67(MACRO) \ + MACRO(67) KAGUYA_PP_REVERSE_REPEAT66(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT68(MACRO) \ + MACRO(68) KAGUYA_PP_REVERSE_REPEAT67(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT69(MACRO) \ + MACRO(69) KAGUYA_PP_REVERSE_REPEAT68(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT70(MACRO) \ + MACRO(70) KAGUYA_PP_REVERSE_REPEAT69(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT71(MACRO) \ + MACRO(71) KAGUYA_PP_REVERSE_REPEAT70(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT72(MACRO) \ + MACRO(72) KAGUYA_PP_REVERSE_REPEAT71(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT73(MACRO) \ + MACRO(73) KAGUYA_PP_REVERSE_REPEAT72(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT74(MACRO) \ + MACRO(74) KAGUYA_PP_REVERSE_REPEAT73(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT75(MACRO) \ + MACRO(75) KAGUYA_PP_REVERSE_REPEAT74(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT76(MACRO) \ + MACRO(76) KAGUYA_PP_REVERSE_REPEAT75(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT77(MACRO) \ + MACRO(77) KAGUYA_PP_REVERSE_REPEAT76(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT78(MACRO) \ + MACRO(78) KAGUYA_PP_REVERSE_REPEAT77(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT79(MACRO) \ + MACRO(79) KAGUYA_PP_REVERSE_REPEAT78(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT80(MACRO) \ + MACRO(80) KAGUYA_PP_REVERSE_REPEAT79(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT81(MACRO) \ + MACRO(81) KAGUYA_PP_REVERSE_REPEAT80(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT82(MACRO) \ + MACRO(82) KAGUYA_PP_REVERSE_REPEAT81(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT83(MACRO) \ + MACRO(83) KAGUYA_PP_REVERSE_REPEAT82(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT84(MACRO) \ + MACRO(84) KAGUYA_PP_REVERSE_REPEAT83(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT85(MACRO) \ + MACRO(85) KAGUYA_PP_REVERSE_REPEAT84(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT86(MACRO) \ + MACRO(86) KAGUYA_PP_REVERSE_REPEAT85(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT87(MACRO) \ + MACRO(87) KAGUYA_PP_REVERSE_REPEAT86(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT88(MACRO) \ + MACRO(88) KAGUYA_PP_REVERSE_REPEAT87(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT89(MACRO) \ + MACRO(89) KAGUYA_PP_REVERSE_REPEAT88(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT90(MACRO) \ + MACRO(90) KAGUYA_PP_REVERSE_REPEAT89(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT91(MACRO) \ + MACRO(91) KAGUYA_PP_REVERSE_REPEAT90(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT92(MACRO) \ + MACRO(92) KAGUYA_PP_REVERSE_REPEAT91(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT93(MACRO) \ + MACRO(93) KAGUYA_PP_REVERSE_REPEAT92(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT94(MACRO) \ + MACRO(94) KAGUYA_PP_REVERSE_REPEAT93(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT95(MACRO) \ + MACRO(95) KAGUYA_PP_REVERSE_REPEAT94(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT96(MACRO) \ + MACRO(96) KAGUYA_PP_REVERSE_REPEAT95(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT97(MACRO) \ + MACRO(97) KAGUYA_PP_REVERSE_REPEAT96(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT98(MACRO) \ + MACRO(98) KAGUYA_PP_REVERSE_REPEAT97(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT99(MACRO) \ + MACRO(99) KAGUYA_PP_REVERSE_REPEAT98(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT100(MACRO) \ + MACRO(100) KAGUYA_PP_REVERSE_REPEAT99(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT101(MACRO) \ + MACRO(101) KAGUYA_PP_REVERSE_REPEAT100(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT102(MACRO) \ + MACRO(102) KAGUYA_PP_REVERSE_REPEAT101(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT103(MACRO) \ + MACRO(103) KAGUYA_PP_REVERSE_REPEAT102(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT104(MACRO) \ + MACRO(104) KAGUYA_PP_REVERSE_REPEAT103(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT105(MACRO) \ + MACRO(105) KAGUYA_PP_REVERSE_REPEAT104(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT106(MACRO) \ + MACRO(106) KAGUYA_PP_REVERSE_REPEAT105(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT107(MACRO) \ + MACRO(107) KAGUYA_PP_REVERSE_REPEAT106(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT108(MACRO) \ + MACRO(108) KAGUYA_PP_REVERSE_REPEAT107(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT109(MACRO) \ + MACRO(109) KAGUYA_PP_REVERSE_REPEAT108(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT110(MACRO) \ + MACRO(110) KAGUYA_PP_REVERSE_REPEAT109(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT111(MACRO) \ + MACRO(111) KAGUYA_PP_REVERSE_REPEAT110(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT112(MACRO) \ + MACRO(112) KAGUYA_PP_REVERSE_REPEAT111(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT113(MACRO) \ + MACRO(113) KAGUYA_PP_REVERSE_REPEAT112(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT114(MACRO) \ + MACRO(114) KAGUYA_PP_REVERSE_REPEAT113(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT115(MACRO) \ + MACRO(115) KAGUYA_PP_REVERSE_REPEAT114(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT116(MACRO) \ + MACRO(116) KAGUYA_PP_REVERSE_REPEAT115(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT117(MACRO) \ + MACRO(117) KAGUYA_PP_REVERSE_REPEAT116(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT118(MACRO) \ + MACRO(118) KAGUYA_PP_REVERSE_REPEAT117(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT119(MACRO) \ + MACRO(119) KAGUYA_PP_REVERSE_REPEAT118(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT120(MACRO) \ + MACRO(120) KAGUYA_PP_REVERSE_REPEAT119(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT121(MACRO) \ + MACRO(121) KAGUYA_PP_REVERSE_REPEAT120(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT122(MACRO) \ + MACRO(122) KAGUYA_PP_REVERSE_REPEAT121(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT123(MACRO) \ + MACRO(123) KAGUYA_PP_REVERSE_REPEAT122(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT124(MACRO) \ + MACRO(124) KAGUYA_PP_REVERSE_REPEAT123(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT125(MACRO) \ + MACRO(125) KAGUYA_PP_REVERSE_REPEAT124(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT126(MACRO) \ + MACRO(126) KAGUYA_PP_REVERSE_REPEAT125(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT127(MACRO) \ + MACRO(127) KAGUYA_PP_REVERSE_REPEAT126(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT128(MACRO) \ + MACRO(128) KAGUYA_PP_REVERSE_REPEAT127(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT129(MACRO) \ + MACRO(129) KAGUYA_PP_REVERSE_REPEAT128(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT130(MACRO) \ + MACRO(130) KAGUYA_PP_REVERSE_REPEAT129(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT131(MACRO) \ + MACRO(131) KAGUYA_PP_REVERSE_REPEAT130(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT132(MACRO) \ + MACRO(132) KAGUYA_PP_REVERSE_REPEAT131(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT133(MACRO) \ + MACRO(133) KAGUYA_PP_REVERSE_REPEAT132(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT134(MACRO) \ + MACRO(134) KAGUYA_PP_REVERSE_REPEAT133(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT135(MACRO) \ + MACRO(135) KAGUYA_PP_REVERSE_REPEAT134(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT136(MACRO) \ + MACRO(136) KAGUYA_PP_REVERSE_REPEAT135(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT137(MACRO) \ + MACRO(137) KAGUYA_PP_REVERSE_REPEAT136(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT138(MACRO) \ + MACRO(138) KAGUYA_PP_REVERSE_REPEAT137(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT139(MACRO) \ + MACRO(139) KAGUYA_PP_REVERSE_REPEAT138(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT140(MACRO) \ + MACRO(140) KAGUYA_PP_REVERSE_REPEAT139(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT141(MACRO) \ + MACRO(141) KAGUYA_PP_REVERSE_REPEAT140(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT142(MACRO) \ + MACRO(142) KAGUYA_PP_REVERSE_REPEAT141(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT143(MACRO) \ + MACRO(143) KAGUYA_PP_REVERSE_REPEAT142(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT144(MACRO) \ + MACRO(144) KAGUYA_PP_REVERSE_REPEAT143(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT145(MACRO) \ + MACRO(145) KAGUYA_PP_REVERSE_REPEAT144(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT146(MACRO) \ + MACRO(146) KAGUYA_PP_REVERSE_REPEAT145(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT147(MACRO) \ + MACRO(147) KAGUYA_PP_REVERSE_REPEAT146(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT148(MACRO) \ + MACRO(148) KAGUYA_PP_REVERSE_REPEAT147(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT149(MACRO) \ + MACRO(149) KAGUYA_PP_REVERSE_REPEAT148(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT150(MACRO) \ + MACRO(150) KAGUYA_PP_REVERSE_REPEAT149(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT151(MACRO) \ + MACRO(151) KAGUYA_PP_REVERSE_REPEAT150(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT152(MACRO) \ + MACRO(152) KAGUYA_PP_REVERSE_REPEAT151(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT153(MACRO) \ + MACRO(153) KAGUYA_PP_REVERSE_REPEAT152(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT154(MACRO) \ + MACRO(154) KAGUYA_PP_REVERSE_REPEAT153(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT155(MACRO) \ + MACRO(155) KAGUYA_PP_REVERSE_REPEAT154(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT156(MACRO) \ + MACRO(156) KAGUYA_PP_REVERSE_REPEAT155(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT157(MACRO) \ + MACRO(157) KAGUYA_PP_REVERSE_REPEAT156(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT158(MACRO) \ + MACRO(158) KAGUYA_PP_REVERSE_REPEAT157(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT159(MACRO) \ + MACRO(159) KAGUYA_PP_REVERSE_REPEAT158(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT160(MACRO) \ + MACRO(160) KAGUYA_PP_REVERSE_REPEAT159(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT161(MACRO) \ + MACRO(161) KAGUYA_PP_REVERSE_REPEAT160(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT162(MACRO) \ + MACRO(162) KAGUYA_PP_REVERSE_REPEAT161(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT163(MACRO) \ + MACRO(163) KAGUYA_PP_REVERSE_REPEAT162(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT164(MACRO) \ + MACRO(164) KAGUYA_PP_REVERSE_REPEAT163(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT165(MACRO) \ + MACRO(165) KAGUYA_PP_REVERSE_REPEAT164(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT166(MACRO) \ + MACRO(166) KAGUYA_PP_REVERSE_REPEAT165(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT167(MACRO) \ + MACRO(167) KAGUYA_PP_REVERSE_REPEAT166(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT168(MACRO) \ + MACRO(168) KAGUYA_PP_REVERSE_REPEAT167(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT169(MACRO) \ + MACRO(169) KAGUYA_PP_REVERSE_REPEAT168(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT170(MACRO) \ + MACRO(170) KAGUYA_PP_REVERSE_REPEAT169(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT171(MACRO) \ + MACRO(171) KAGUYA_PP_REVERSE_REPEAT170(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT172(MACRO) \ + MACRO(172) KAGUYA_PP_REVERSE_REPEAT171(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT173(MACRO) \ + MACRO(173) KAGUYA_PP_REVERSE_REPEAT172(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT174(MACRO) \ + MACRO(174) KAGUYA_PP_REVERSE_REPEAT173(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT175(MACRO) \ + MACRO(175) KAGUYA_PP_REVERSE_REPEAT174(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT176(MACRO) \ + MACRO(176) KAGUYA_PP_REVERSE_REPEAT175(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT177(MACRO) \ + MACRO(177) KAGUYA_PP_REVERSE_REPEAT176(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT178(MACRO) \ + MACRO(178) KAGUYA_PP_REVERSE_REPEAT177(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT179(MACRO) \ + MACRO(179) KAGUYA_PP_REVERSE_REPEAT178(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT180(MACRO) \ + MACRO(180) KAGUYA_PP_REVERSE_REPEAT179(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT181(MACRO) \ + MACRO(181) KAGUYA_PP_REVERSE_REPEAT180(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT182(MACRO) \ + MACRO(182) KAGUYA_PP_REVERSE_REPEAT181(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT183(MACRO) \ + MACRO(183) KAGUYA_PP_REVERSE_REPEAT182(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT184(MACRO) \ + MACRO(184) KAGUYA_PP_REVERSE_REPEAT183(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT185(MACRO) \ + MACRO(185) KAGUYA_PP_REVERSE_REPEAT184(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT186(MACRO) \ + MACRO(186) KAGUYA_PP_REVERSE_REPEAT185(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT187(MACRO) \ + MACRO(187) KAGUYA_PP_REVERSE_REPEAT186(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT188(MACRO) \ + MACRO(188) KAGUYA_PP_REVERSE_REPEAT187(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT189(MACRO) \ + MACRO(189) KAGUYA_PP_REVERSE_REPEAT188(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT190(MACRO) \ + MACRO(190) KAGUYA_PP_REVERSE_REPEAT189(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT191(MACRO) \ + MACRO(191) KAGUYA_PP_REVERSE_REPEAT190(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT192(MACRO) \ + MACRO(192) KAGUYA_PP_REVERSE_REPEAT191(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT193(MACRO) \ + MACRO(193) KAGUYA_PP_REVERSE_REPEAT192(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT194(MACRO) \ + MACRO(194) KAGUYA_PP_REVERSE_REPEAT193(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT195(MACRO) \ + MACRO(195) KAGUYA_PP_REVERSE_REPEAT194(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT196(MACRO) \ + MACRO(196) KAGUYA_PP_REVERSE_REPEAT195(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT197(MACRO) \ + MACRO(197) KAGUYA_PP_REVERSE_REPEAT196(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT198(MACRO) \ + MACRO(198) KAGUYA_PP_REVERSE_REPEAT197(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT199(MACRO) \ + MACRO(199) KAGUYA_PP_REVERSE_REPEAT198(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT200(MACRO) \ + MACRO(200) KAGUYA_PP_REVERSE_REPEAT199(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT201(MACRO) \ + MACRO(201) KAGUYA_PP_REVERSE_REPEAT200(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT202(MACRO) \ + MACRO(202) KAGUYA_PP_REVERSE_REPEAT201(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT203(MACRO) \ + MACRO(203) KAGUYA_PP_REVERSE_REPEAT202(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT204(MACRO) \ + MACRO(204) KAGUYA_PP_REVERSE_REPEAT203(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT205(MACRO) \ + MACRO(205) KAGUYA_PP_REVERSE_REPEAT204(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT206(MACRO) \ + MACRO(206) KAGUYA_PP_REVERSE_REPEAT205(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT207(MACRO) \ + MACRO(207) KAGUYA_PP_REVERSE_REPEAT206(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT208(MACRO) \ + MACRO(208) KAGUYA_PP_REVERSE_REPEAT207(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT209(MACRO) \ + MACRO(209) KAGUYA_PP_REVERSE_REPEAT208(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT210(MACRO) \ + MACRO(210) KAGUYA_PP_REVERSE_REPEAT209(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT211(MACRO) \ + MACRO(211) KAGUYA_PP_REVERSE_REPEAT210(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT212(MACRO) \ + MACRO(212) KAGUYA_PP_REVERSE_REPEAT211(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT213(MACRO) \ + MACRO(213) KAGUYA_PP_REVERSE_REPEAT212(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT214(MACRO) \ + MACRO(214) KAGUYA_PP_REVERSE_REPEAT213(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT215(MACRO) \ + MACRO(215) KAGUYA_PP_REVERSE_REPEAT214(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT216(MACRO) \ + MACRO(216) KAGUYA_PP_REVERSE_REPEAT215(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT217(MACRO) \ + MACRO(217) KAGUYA_PP_REVERSE_REPEAT216(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT218(MACRO) \ + MACRO(218) KAGUYA_PP_REVERSE_REPEAT217(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT219(MACRO) \ + MACRO(219) KAGUYA_PP_REVERSE_REPEAT218(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT220(MACRO) \ + MACRO(220) KAGUYA_PP_REVERSE_REPEAT219(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT221(MACRO) \ + MACRO(221) KAGUYA_PP_REVERSE_REPEAT220(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT222(MACRO) \ + MACRO(222) KAGUYA_PP_REVERSE_REPEAT221(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT223(MACRO) \ + MACRO(223) KAGUYA_PP_REVERSE_REPEAT222(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT224(MACRO) \ + MACRO(224) KAGUYA_PP_REVERSE_REPEAT223(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT225(MACRO) \ + MACRO(225) KAGUYA_PP_REVERSE_REPEAT224(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT226(MACRO) \ + MACRO(226) KAGUYA_PP_REVERSE_REPEAT225(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT227(MACRO) \ + MACRO(227) KAGUYA_PP_REVERSE_REPEAT226(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT228(MACRO) \ + MACRO(228) KAGUYA_PP_REVERSE_REPEAT227(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT229(MACRO) \ + MACRO(229) KAGUYA_PP_REVERSE_REPEAT228(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT230(MACRO) \ + MACRO(230) KAGUYA_PP_REVERSE_REPEAT229(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT231(MACRO) \ + MACRO(231) KAGUYA_PP_REVERSE_REPEAT230(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT232(MACRO) \ + MACRO(232) KAGUYA_PP_REVERSE_REPEAT231(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT233(MACRO) \ + MACRO(233) KAGUYA_PP_REVERSE_REPEAT232(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT234(MACRO) \ + MACRO(234) KAGUYA_PP_REVERSE_REPEAT233(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT235(MACRO) \ + MACRO(235) KAGUYA_PP_REVERSE_REPEAT234(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT236(MACRO) \ + MACRO(236) KAGUYA_PP_REVERSE_REPEAT235(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT237(MACRO) \ + MACRO(237) KAGUYA_PP_REVERSE_REPEAT236(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT238(MACRO) \ + MACRO(238) KAGUYA_PP_REVERSE_REPEAT237(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT239(MACRO) \ + MACRO(239) KAGUYA_PP_REVERSE_REPEAT238(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT240(MACRO) \ + MACRO(240) KAGUYA_PP_REVERSE_REPEAT239(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT241(MACRO) \ + MACRO(241) KAGUYA_PP_REVERSE_REPEAT240(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT242(MACRO) \ + MACRO(242) KAGUYA_PP_REVERSE_REPEAT241(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT243(MACRO) \ + MACRO(243) KAGUYA_PP_REVERSE_REPEAT242(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT244(MACRO) \ + MACRO(244) KAGUYA_PP_REVERSE_REPEAT243(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT245(MACRO) \ + MACRO(245) KAGUYA_PP_REVERSE_REPEAT244(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT246(MACRO) \ + MACRO(246) KAGUYA_PP_REVERSE_REPEAT245(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT247(MACRO) \ + MACRO(247) KAGUYA_PP_REVERSE_REPEAT246(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT248(MACRO) \ + MACRO(248) KAGUYA_PP_REVERSE_REPEAT247(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT249(MACRO) \ + MACRO(249) KAGUYA_PP_REVERSE_REPEAT248(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT250(MACRO) \ + MACRO(250) KAGUYA_PP_REVERSE_REPEAT249(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT251(MACRO) \ + MACRO(251) KAGUYA_PP_REVERSE_REPEAT250(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT252(MACRO) \ + MACRO(252) KAGUYA_PP_REVERSE_REPEAT251(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT253(MACRO) \ + MACRO(253) KAGUYA_PP_REVERSE_REPEAT252(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT254(MACRO) \ + MACRO(254) KAGUYA_PP_REVERSE_REPEAT253(MACRO) +#define KAGUYA_PP_REVERSE_REPEAT(COUNT, MACRO) \ + KAGUYA_PP_CAT(KAGUYA_PP_REVERSE_REPEAT, COUNT)(MACRO) + +#define KAGUYA_PP_REPEAT_ARG0(MACRO) +#define KAGUYA_PP_REPEAT_ARG1(MACRO) MACRO(1) +#define KAGUYA_PP_REPEAT_ARG2(MACRO) KAGUYA_PP_REPEAT_ARG1(MACRO), MACRO(2) +#define KAGUYA_PP_REPEAT_ARG3(MACRO) KAGUYA_PP_REPEAT_ARG2(MACRO), MACRO(3) +#define KAGUYA_PP_REPEAT_ARG4(MACRO) KAGUYA_PP_REPEAT_ARG3(MACRO), MACRO(4) +#define KAGUYA_PP_REPEAT_ARG5(MACRO) KAGUYA_PP_REPEAT_ARG4(MACRO), MACRO(5) +#define KAGUYA_PP_REPEAT_ARG6(MACRO) KAGUYA_PP_REPEAT_ARG5(MACRO), MACRO(6) +#define KAGUYA_PP_REPEAT_ARG7(MACRO) KAGUYA_PP_REPEAT_ARG6(MACRO), MACRO(7) +#define KAGUYA_PP_REPEAT_ARG8(MACRO) KAGUYA_PP_REPEAT_ARG7(MACRO), MACRO(8) +#define KAGUYA_PP_REPEAT_ARG9(MACRO) KAGUYA_PP_REPEAT_ARG8(MACRO), MACRO(9) +#define KAGUYA_PP_REPEAT_ARG10(MACRO) KAGUYA_PP_REPEAT_ARG9(MACRO), MACRO(10) +#define KAGUYA_PP_REPEAT_ARG11(MACRO) KAGUYA_PP_REPEAT_ARG10(MACRO), MACRO(11) +#define KAGUYA_PP_REPEAT_ARG12(MACRO) KAGUYA_PP_REPEAT_ARG11(MACRO), MACRO(12) +#define KAGUYA_PP_REPEAT_ARG13(MACRO) KAGUYA_PP_REPEAT_ARG12(MACRO), MACRO(13) +#define KAGUYA_PP_REPEAT_ARG14(MACRO) KAGUYA_PP_REPEAT_ARG13(MACRO), MACRO(14) +#define KAGUYA_PP_REPEAT_ARG15(MACRO) KAGUYA_PP_REPEAT_ARG14(MACRO), MACRO(15) +#define KAGUYA_PP_REPEAT_ARG16(MACRO) KAGUYA_PP_REPEAT_ARG15(MACRO), MACRO(16) +#define KAGUYA_PP_REPEAT_ARG17(MACRO) KAGUYA_PP_REPEAT_ARG16(MACRO), MACRO(17) +#define KAGUYA_PP_REPEAT_ARG18(MACRO) KAGUYA_PP_REPEAT_ARG17(MACRO), MACRO(18) +#define KAGUYA_PP_REPEAT_ARG19(MACRO) KAGUYA_PP_REPEAT_ARG18(MACRO), MACRO(19) +#define KAGUYA_PP_REPEAT_ARG20(MACRO) KAGUYA_PP_REPEAT_ARG19(MACRO), MACRO(20) +#define KAGUYA_PP_REPEAT_ARG21(MACRO) KAGUYA_PP_REPEAT_ARG20(MACRO), MACRO(21) +#define KAGUYA_PP_REPEAT_ARG22(MACRO) KAGUYA_PP_REPEAT_ARG21(MACRO), MACRO(22) +#define KAGUYA_PP_REPEAT_ARG23(MACRO) KAGUYA_PP_REPEAT_ARG22(MACRO), MACRO(23) +#define KAGUYA_PP_REPEAT_ARG24(MACRO) KAGUYA_PP_REPEAT_ARG23(MACRO), MACRO(24) +#define KAGUYA_PP_REPEAT_ARG25(MACRO) KAGUYA_PP_REPEAT_ARG24(MACRO), MACRO(25) +#define KAGUYA_PP_REPEAT_ARG26(MACRO) KAGUYA_PP_REPEAT_ARG25(MACRO), MACRO(26) +#define KAGUYA_PP_REPEAT_ARG27(MACRO) KAGUYA_PP_REPEAT_ARG26(MACRO), MACRO(27) +#define KAGUYA_PP_REPEAT_ARG28(MACRO) KAGUYA_PP_REPEAT_ARG27(MACRO), MACRO(28) +#define KAGUYA_PP_REPEAT_ARG29(MACRO) KAGUYA_PP_REPEAT_ARG28(MACRO), MACRO(29) +#define KAGUYA_PP_REPEAT_ARG30(MACRO) KAGUYA_PP_REPEAT_ARG29(MACRO), MACRO(30) +#define KAGUYA_PP_REPEAT_ARG31(MACRO) KAGUYA_PP_REPEAT_ARG30(MACRO), MACRO(31) +#define KAGUYA_PP_REPEAT_ARG32(MACRO) KAGUYA_PP_REPEAT_ARG31(MACRO), MACRO(32) +#define KAGUYA_PP_REPEAT_ARG33(MACRO) KAGUYA_PP_REPEAT_ARG32(MACRO), MACRO(33) +#define KAGUYA_PP_REPEAT_ARG34(MACRO) KAGUYA_PP_REPEAT_ARG33(MACRO), MACRO(34) +#define KAGUYA_PP_REPEAT_ARG35(MACRO) KAGUYA_PP_REPEAT_ARG34(MACRO), MACRO(35) +#define KAGUYA_PP_REPEAT_ARG36(MACRO) KAGUYA_PP_REPEAT_ARG35(MACRO), MACRO(36) +#define KAGUYA_PP_REPEAT_ARG37(MACRO) KAGUYA_PP_REPEAT_ARG36(MACRO), MACRO(37) +#define KAGUYA_PP_REPEAT_ARG38(MACRO) KAGUYA_PP_REPEAT_ARG37(MACRO), MACRO(38) +#define KAGUYA_PP_REPEAT_ARG39(MACRO) KAGUYA_PP_REPEAT_ARG38(MACRO), MACRO(39) +#define KAGUYA_PP_REPEAT_ARG40(MACRO) KAGUYA_PP_REPEAT_ARG39(MACRO), MACRO(40) +#define KAGUYA_PP_REPEAT_ARG41(MACRO) KAGUYA_PP_REPEAT_ARG40(MACRO), MACRO(41) +#define KAGUYA_PP_REPEAT_ARG42(MACRO) KAGUYA_PP_REPEAT_ARG41(MACRO), MACRO(42) +#define KAGUYA_PP_REPEAT_ARG43(MACRO) KAGUYA_PP_REPEAT_ARG42(MACRO), MACRO(43) +#define KAGUYA_PP_REPEAT_ARG44(MACRO) KAGUYA_PP_REPEAT_ARG43(MACRO), MACRO(44) +#define KAGUYA_PP_REPEAT_ARG45(MACRO) KAGUYA_PP_REPEAT_ARG44(MACRO), MACRO(45) +#define KAGUYA_PP_REPEAT_ARG46(MACRO) KAGUYA_PP_REPEAT_ARG45(MACRO), MACRO(46) +#define KAGUYA_PP_REPEAT_ARG47(MACRO) KAGUYA_PP_REPEAT_ARG46(MACRO), MACRO(47) +#define KAGUYA_PP_REPEAT_ARG48(MACRO) KAGUYA_PP_REPEAT_ARG47(MACRO), MACRO(48) +#define KAGUYA_PP_REPEAT_ARG49(MACRO) KAGUYA_PP_REPEAT_ARG48(MACRO), MACRO(49) +#define KAGUYA_PP_REPEAT_ARG50(MACRO) KAGUYA_PP_REPEAT_ARG49(MACRO), MACRO(50) +#define KAGUYA_PP_REPEAT_ARG51(MACRO) KAGUYA_PP_REPEAT_ARG50(MACRO), MACRO(51) +#define KAGUYA_PP_REPEAT_ARG52(MACRO) KAGUYA_PP_REPEAT_ARG51(MACRO), MACRO(52) +#define KAGUYA_PP_REPEAT_ARG53(MACRO) KAGUYA_PP_REPEAT_ARG52(MACRO), MACRO(53) +#define KAGUYA_PP_REPEAT_ARG54(MACRO) KAGUYA_PP_REPEAT_ARG53(MACRO), MACRO(54) +#define KAGUYA_PP_REPEAT_ARG55(MACRO) KAGUYA_PP_REPEAT_ARG54(MACRO), MACRO(55) +#define KAGUYA_PP_REPEAT_ARG56(MACRO) KAGUYA_PP_REPEAT_ARG55(MACRO), MACRO(56) +#define KAGUYA_PP_REPEAT_ARG57(MACRO) KAGUYA_PP_REPEAT_ARG56(MACRO), MACRO(57) +#define KAGUYA_PP_REPEAT_ARG58(MACRO) KAGUYA_PP_REPEAT_ARG57(MACRO), MACRO(58) +#define KAGUYA_PP_REPEAT_ARG59(MACRO) KAGUYA_PP_REPEAT_ARG58(MACRO), MACRO(59) +#define KAGUYA_PP_REPEAT_ARG60(MACRO) KAGUYA_PP_REPEAT_ARG59(MACRO), MACRO(60) +#define KAGUYA_PP_REPEAT_ARG61(MACRO) KAGUYA_PP_REPEAT_ARG60(MACRO), MACRO(61) +#define KAGUYA_PP_REPEAT_ARG62(MACRO) KAGUYA_PP_REPEAT_ARG61(MACRO), MACRO(62) +#define KAGUYA_PP_REPEAT_ARG63(MACRO) KAGUYA_PP_REPEAT_ARG62(MACRO), MACRO(63) +#define KAGUYA_PP_REPEAT_ARG64(MACRO) KAGUYA_PP_REPEAT_ARG63(MACRO), MACRO(64) +#define KAGUYA_PP_REPEAT_ARG65(MACRO) KAGUYA_PP_REPEAT_ARG64(MACRO), MACRO(65) +#define KAGUYA_PP_REPEAT_ARG66(MACRO) KAGUYA_PP_REPEAT_ARG65(MACRO), MACRO(66) +#define KAGUYA_PP_REPEAT_ARG67(MACRO) KAGUYA_PP_REPEAT_ARG66(MACRO), MACRO(67) +#define KAGUYA_PP_REPEAT_ARG68(MACRO) KAGUYA_PP_REPEAT_ARG67(MACRO), MACRO(68) +#define KAGUYA_PP_REPEAT_ARG69(MACRO) KAGUYA_PP_REPEAT_ARG68(MACRO), MACRO(69) +#define KAGUYA_PP_REPEAT_ARG70(MACRO) KAGUYA_PP_REPEAT_ARG69(MACRO), MACRO(70) +#define KAGUYA_PP_REPEAT_ARG71(MACRO) KAGUYA_PP_REPEAT_ARG70(MACRO), MACRO(71) +#define KAGUYA_PP_REPEAT_ARG72(MACRO) KAGUYA_PP_REPEAT_ARG71(MACRO), MACRO(72) +#define KAGUYA_PP_REPEAT_ARG73(MACRO) KAGUYA_PP_REPEAT_ARG72(MACRO), MACRO(73) +#define KAGUYA_PP_REPEAT_ARG74(MACRO) KAGUYA_PP_REPEAT_ARG73(MACRO), MACRO(74) +#define KAGUYA_PP_REPEAT_ARG75(MACRO) KAGUYA_PP_REPEAT_ARG74(MACRO), MACRO(75) +#define KAGUYA_PP_REPEAT_ARG76(MACRO) KAGUYA_PP_REPEAT_ARG75(MACRO), MACRO(76) +#define KAGUYA_PP_REPEAT_ARG77(MACRO) KAGUYA_PP_REPEAT_ARG76(MACRO), MACRO(77) +#define KAGUYA_PP_REPEAT_ARG78(MACRO) KAGUYA_PP_REPEAT_ARG77(MACRO), MACRO(78) +#define KAGUYA_PP_REPEAT_ARG79(MACRO) KAGUYA_PP_REPEAT_ARG78(MACRO), MACRO(79) +#define KAGUYA_PP_REPEAT_ARG80(MACRO) KAGUYA_PP_REPEAT_ARG79(MACRO), MACRO(80) +#define KAGUYA_PP_REPEAT_ARG81(MACRO) KAGUYA_PP_REPEAT_ARG80(MACRO), MACRO(81) +#define KAGUYA_PP_REPEAT_ARG82(MACRO) KAGUYA_PP_REPEAT_ARG81(MACRO), MACRO(82) +#define KAGUYA_PP_REPEAT_ARG83(MACRO) KAGUYA_PP_REPEAT_ARG82(MACRO), MACRO(83) +#define KAGUYA_PP_REPEAT_ARG84(MACRO) KAGUYA_PP_REPEAT_ARG83(MACRO), MACRO(84) +#define KAGUYA_PP_REPEAT_ARG85(MACRO) KAGUYA_PP_REPEAT_ARG84(MACRO), MACRO(85) +#define KAGUYA_PP_REPEAT_ARG86(MACRO) KAGUYA_PP_REPEAT_ARG85(MACRO), MACRO(86) +#define KAGUYA_PP_REPEAT_ARG87(MACRO) KAGUYA_PP_REPEAT_ARG86(MACRO), MACRO(87) +#define KAGUYA_PP_REPEAT_ARG88(MACRO) KAGUYA_PP_REPEAT_ARG87(MACRO), MACRO(88) +#define KAGUYA_PP_REPEAT_ARG89(MACRO) KAGUYA_PP_REPEAT_ARG88(MACRO), MACRO(89) +#define KAGUYA_PP_REPEAT_ARG90(MACRO) KAGUYA_PP_REPEAT_ARG89(MACRO), MACRO(90) +#define KAGUYA_PP_REPEAT_ARG91(MACRO) KAGUYA_PP_REPEAT_ARG90(MACRO), MACRO(91) +#define KAGUYA_PP_REPEAT_ARG92(MACRO) KAGUYA_PP_REPEAT_ARG91(MACRO), MACRO(92) +#define KAGUYA_PP_REPEAT_ARG93(MACRO) KAGUYA_PP_REPEAT_ARG92(MACRO), MACRO(93) +#define KAGUYA_PP_REPEAT_ARG94(MACRO) KAGUYA_PP_REPEAT_ARG93(MACRO), MACRO(94) +#define KAGUYA_PP_REPEAT_ARG95(MACRO) KAGUYA_PP_REPEAT_ARG94(MACRO), MACRO(95) +#define KAGUYA_PP_REPEAT_ARG96(MACRO) KAGUYA_PP_REPEAT_ARG95(MACRO), MACRO(96) +#define KAGUYA_PP_REPEAT_ARG97(MACRO) KAGUYA_PP_REPEAT_ARG96(MACRO), MACRO(97) +#define KAGUYA_PP_REPEAT_ARG98(MACRO) KAGUYA_PP_REPEAT_ARG97(MACRO), MACRO(98) +#define KAGUYA_PP_REPEAT_ARG99(MACRO) KAGUYA_PP_REPEAT_ARG98(MACRO), MACRO(99) +#define KAGUYA_PP_REPEAT_ARG100(MACRO) KAGUYA_PP_REPEAT_ARG99(MACRO), MACRO(100) +#define KAGUYA_PP_REPEAT_ARG101(MACRO) \ + KAGUYA_PP_REPEAT_ARG100(MACRO), MACRO(101) +#define KAGUYA_PP_REPEAT_ARG102(MACRO) \ + KAGUYA_PP_REPEAT_ARG101(MACRO), MACRO(102) +#define KAGUYA_PP_REPEAT_ARG103(MACRO) \ + KAGUYA_PP_REPEAT_ARG102(MACRO), MACRO(103) +#define KAGUYA_PP_REPEAT_ARG104(MACRO) \ + KAGUYA_PP_REPEAT_ARG103(MACRO), MACRO(104) +#define KAGUYA_PP_REPEAT_ARG105(MACRO) \ + KAGUYA_PP_REPEAT_ARG104(MACRO), MACRO(105) +#define KAGUYA_PP_REPEAT_ARG106(MACRO) \ + KAGUYA_PP_REPEAT_ARG105(MACRO), MACRO(106) +#define KAGUYA_PP_REPEAT_ARG107(MACRO) \ + KAGUYA_PP_REPEAT_ARG106(MACRO), MACRO(107) +#define KAGUYA_PP_REPEAT_ARG108(MACRO) \ + KAGUYA_PP_REPEAT_ARG107(MACRO), MACRO(108) +#define KAGUYA_PP_REPEAT_ARG109(MACRO) \ + KAGUYA_PP_REPEAT_ARG108(MACRO), MACRO(109) +#define KAGUYA_PP_REPEAT_ARG110(MACRO) \ + KAGUYA_PP_REPEAT_ARG109(MACRO), MACRO(110) +#define KAGUYA_PP_REPEAT_ARG111(MACRO) \ + KAGUYA_PP_REPEAT_ARG110(MACRO), MACRO(111) +#define KAGUYA_PP_REPEAT_ARG112(MACRO) \ + KAGUYA_PP_REPEAT_ARG111(MACRO), MACRO(112) +#define KAGUYA_PP_REPEAT_ARG113(MACRO) \ + KAGUYA_PP_REPEAT_ARG112(MACRO), MACRO(113) +#define KAGUYA_PP_REPEAT_ARG114(MACRO) \ + KAGUYA_PP_REPEAT_ARG113(MACRO), MACRO(114) +#define KAGUYA_PP_REPEAT_ARG115(MACRO) \ + KAGUYA_PP_REPEAT_ARG114(MACRO), MACRO(115) +#define KAGUYA_PP_REPEAT_ARG116(MACRO) \ + KAGUYA_PP_REPEAT_ARG115(MACRO), MACRO(116) +#define KAGUYA_PP_REPEAT_ARG117(MACRO) \ + KAGUYA_PP_REPEAT_ARG116(MACRO), MACRO(117) +#define KAGUYA_PP_REPEAT_ARG118(MACRO) \ + KAGUYA_PP_REPEAT_ARG117(MACRO), MACRO(118) +#define KAGUYA_PP_REPEAT_ARG119(MACRO) \ + KAGUYA_PP_REPEAT_ARG118(MACRO), MACRO(119) +#define KAGUYA_PP_REPEAT_ARG120(MACRO) \ + KAGUYA_PP_REPEAT_ARG119(MACRO), MACRO(120) +#define KAGUYA_PP_REPEAT_ARG121(MACRO) \ + KAGUYA_PP_REPEAT_ARG120(MACRO), MACRO(121) +#define KAGUYA_PP_REPEAT_ARG122(MACRO) \ + KAGUYA_PP_REPEAT_ARG121(MACRO), MACRO(122) +#define KAGUYA_PP_REPEAT_ARG123(MACRO) \ + KAGUYA_PP_REPEAT_ARG122(MACRO), MACRO(123) +#define KAGUYA_PP_REPEAT_ARG124(MACRO) \ + KAGUYA_PP_REPEAT_ARG123(MACRO), MACRO(124) +#define KAGUYA_PP_REPEAT_ARG125(MACRO) \ + KAGUYA_PP_REPEAT_ARG124(MACRO), MACRO(125) +#define KAGUYA_PP_REPEAT_ARG126(MACRO) \ + KAGUYA_PP_REPEAT_ARG125(MACRO), MACRO(126) +#define KAGUYA_PP_REPEAT_ARG127(MACRO) \ + KAGUYA_PP_REPEAT_ARG126(MACRO), MACRO(127) +#define KAGUYA_PP_REPEAT_ARG128(MACRO) \ + KAGUYA_PP_REPEAT_ARG127(MACRO), MACRO(128) +#define KAGUYA_PP_REPEAT_ARG129(MACRO) \ + KAGUYA_PP_REPEAT_ARG128(MACRO), MACRO(129) +#define KAGUYA_PP_REPEAT_ARG130(MACRO) \ + KAGUYA_PP_REPEAT_ARG129(MACRO), MACRO(130) +#define KAGUYA_PP_REPEAT_ARG131(MACRO) \ + KAGUYA_PP_REPEAT_ARG130(MACRO), MACRO(131) +#define KAGUYA_PP_REPEAT_ARG132(MACRO) \ + KAGUYA_PP_REPEAT_ARG131(MACRO), MACRO(132) +#define KAGUYA_PP_REPEAT_ARG133(MACRO) \ + KAGUYA_PP_REPEAT_ARG132(MACRO), MACRO(133) +#define KAGUYA_PP_REPEAT_ARG134(MACRO) \ + KAGUYA_PP_REPEAT_ARG133(MACRO), MACRO(134) +#define KAGUYA_PP_REPEAT_ARG135(MACRO) \ + KAGUYA_PP_REPEAT_ARG134(MACRO), MACRO(135) +#define KAGUYA_PP_REPEAT_ARG136(MACRO) \ + KAGUYA_PP_REPEAT_ARG135(MACRO), MACRO(136) +#define KAGUYA_PP_REPEAT_ARG137(MACRO) \ + KAGUYA_PP_REPEAT_ARG136(MACRO), MACRO(137) +#define KAGUYA_PP_REPEAT_ARG138(MACRO) \ + KAGUYA_PP_REPEAT_ARG137(MACRO), MACRO(138) +#define KAGUYA_PP_REPEAT_ARG139(MACRO) \ + KAGUYA_PP_REPEAT_ARG138(MACRO), MACRO(139) +#define KAGUYA_PP_REPEAT_ARG140(MACRO) \ + KAGUYA_PP_REPEAT_ARG139(MACRO), MACRO(140) +#define KAGUYA_PP_REPEAT_ARG141(MACRO) \ + KAGUYA_PP_REPEAT_ARG140(MACRO), MACRO(141) +#define KAGUYA_PP_REPEAT_ARG142(MACRO) \ + KAGUYA_PP_REPEAT_ARG141(MACRO), MACRO(142) +#define KAGUYA_PP_REPEAT_ARG143(MACRO) \ + KAGUYA_PP_REPEAT_ARG142(MACRO), MACRO(143) +#define KAGUYA_PP_REPEAT_ARG144(MACRO) \ + KAGUYA_PP_REPEAT_ARG143(MACRO), MACRO(144) +#define KAGUYA_PP_REPEAT_ARG145(MACRO) \ + KAGUYA_PP_REPEAT_ARG144(MACRO), MACRO(145) +#define KAGUYA_PP_REPEAT_ARG146(MACRO) \ + KAGUYA_PP_REPEAT_ARG145(MACRO), MACRO(146) +#define KAGUYA_PP_REPEAT_ARG147(MACRO) \ + KAGUYA_PP_REPEAT_ARG146(MACRO), MACRO(147) +#define KAGUYA_PP_REPEAT_ARG148(MACRO) \ + KAGUYA_PP_REPEAT_ARG147(MACRO), MACRO(148) +#define KAGUYA_PP_REPEAT_ARG149(MACRO) \ + KAGUYA_PP_REPEAT_ARG148(MACRO), MACRO(149) +#define KAGUYA_PP_REPEAT_ARG150(MACRO) \ + KAGUYA_PP_REPEAT_ARG149(MACRO), MACRO(150) +#define KAGUYA_PP_REPEAT_ARG151(MACRO) \ + KAGUYA_PP_REPEAT_ARG150(MACRO), MACRO(151) +#define KAGUYA_PP_REPEAT_ARG152(MACRO) \ + KAGUYA_PP_REPEAT_ARG151(MACRO), MACRO(152) +#define KAGUYA_PP_REPEAT_ARG153(MACRO) \ + KAGUYA_PP_REPEAT_ARG152(MACRO), MACRO(153) +#define KAGUYA_PP_REPEAT_ARG154(MACRO) \ + KAGUYA_PP_REPEAT_ARG153(MACRO), MACRO(154) +#define KAGUYA_PP_REPEAT_ARG155(MACRO) \ + KAGUYA_PP_REPEAT_ARG154(MACRO), MACRO(155) +#define KAGUYA_PP_REPEAT_ARG156(MACRO) \ + KAGUYA_PP_REPEAT_ARG155(MACRO), MACRO(156) +#define KAGUYA_PP_REPEAT_ARG157(MACRO) \ + KAGUYA_PP_REPEAT_ARG156(MACRO), MACRO(157) +#define KAGUYA_PP_REPEAT_ARG158(MACRO) \ + KAGUYA_PP_REPEAT_ARG157(MACRO), MACRO(158) +#define KAGUYA_PP_REPEAT_ARG159(MACRO) \ + KAGUYA_PP_REPEAT_ARG158(MACRO), MACRO(159) +#define KAGUYA_PP_REPEAT_ARG160(MACRO) \ + KAGUYA_PP_REPEAT_ARG159(MACRO), MACRO(160) +#define KAGUYA_PP_REPEAT_ARG161(MACRO) \ + KAGUYA_PP_REPEAT_ARG160(MACRO), MACRO(161) +#define KAGUYA_PP_REPEAT_ARG162(MACRO) \ + KAGUYA_PP_REPEAT_ARG161(MACRO), MACRO(162) +#define KAGUYA_PP_REPEAT_ARG163(MACRO) \ + KAGUYA_PP_REPEAT_ARG162(MACRO), MACRO(163) +#define KAGUYA_PP_REPEAT_ARG164(MACRO) \ + KAGUYA_PP_REPEAT_ARG163(MACRO), MACRO(164) +#define KAGUYA_PP_REPEAT_ARG165(MACRO) \ + KAGUYA_PP_REPEAT_ARG164(MACRO), MACRO(165) +#define KAGUYA_PP_REPEAT_ARG166(MACRO) \ + KAGUYA_PP_REPEAT_ARG165(MACRO), MACRO(166) +#define KAGUYA_PP_REPEAT_ARG167(MACRO) \ + KAGUYA_PP_REPEAT_ARG166(MACRO), MACRO(167) +#define KAGUYA_PP_REPEAT_ARG168(MACRO) \ + KAGUYA_PP_REPEAT_ARG167(MACRO), MACRO(168) +#define KAGUYA_PP_REPEAT_ARG169(MACRO) \ + KAGUYA_PP_REPEAT_ARG168(MACRO), MACRO(169) +#define KAGUYA_PP_REPEAT_ARG170(MACRO) \ + KAGUYA_PP_REPEAT_ARG169(MACRO), MACRO(170) +#define KAGUYA_PP_REPEAT_ARG171(MACRO) \ + KAGUYA_PP_REPEAT_ARG170(MACRO), MACRO(171) +#define KAGUYA_PP_REPEAT_ARG172(MACRO) \ + KAGUYA_PP_REPEAT_ARG171(MACRO), MACRO(172) +#define KAGUYA_PP_REPEAT_ARG173(MACRO) \ + KAGUYA_PP_REPEAT_ARG172(MACRO), MACRO(173) +#define KAGUYA_PP_REPEAT_ARG174(MACRO) \ + KAGUYA_PP_REPEAT_ARG173(MACRO), MACRO(174) +#define KAGUYA_PP_REPEAT_ARG175(MACRO) \ + KAGUYA_PP_REPEAT_ARG174(MACRO), MACRO(175) +#define KAGUYA_PP_REPEAT_ARG176(MACRO) \ + KAGUYA_PP_REPEAT_ARG175(MACRO), MACRO(176) +#define KAGUYA_PP_REPEAT_ARG177(MACRO) \ + KAGUYA_PP_REPEAT_ARG176(MACRO), MACRO(177) +#define KAGUYA_PP_REPEAT_ARG178(MACRO) \ + KAGUYA_PP_REPEAT_ARG177(MACRO), MACRO(178) +#define KAGUYA_PP_REPEAT_ARG179(MACRO) \ + KAGUYA_PP_REPEAT_ARG178(MACRO), MACRO(179) +#define KAGUYA_PP_REPEAT_ARG180(MACRO) \ + KAGUYA_PP_REPEAT_ARG179(MACRO), MACRO(180) +#define KAGUYA_PP_REPEAT_ARG181(MACRO) \ + KAGUYA_PP_REPEAT_ARG180(MACRO), MACRO(181) +#define KAGUYA_PP_REPEAT_ARG182(MACRO) \ + KAGUYA_PP_REPEAT_ARG181(MACRO), MACRO(182) +#define KAGUYA_PP_REPEAT_ARG183(MACRO) \ + KAGUYA_PP_REPEAT_ARG182(MACRO), MACRO(183) +#define KAGUYA_PP_REPEAT_ARG184(MACRO) \ + KAGUYA_PP_REPEAT_ARG183(MACRO), MACRO(184) +#define KAGUYA_PP_REPEAT_ARG185(MACRO) \ + KAGUYA_PP_REPEAT_ARG184(MACRO), MACRO(185) +#define KAGUYA_PP_REPEAT_ARG186(MACRO) \ + KAGUYA_PP_REPEAT_ARG185(MACRO), MACRO(186) +#define KAGUYA_PP_REPEAT_ARG187(MACRO) \ + KAGUYA_PP_REPEAT_ARG186(MACRO), MACRO(187) +#define KAGUYA_PP_REPEAT_ARG188(MACRO) \ + KAGUYA_PP_REPEAT_ARG187(MACRO), MACRO(188) +#define KAGUYA_PP_REPEAT_ARG189(MACRO) \ + KAGUYA_PP_REPEAT_ARG188(MACRO), MACRO(189) +#define KAGUYA_PP_REPEAT_ARG190(MACRO) \ + KAGUYA_PP_REPEAT_ARG189(MACRO), MACRO(190) +#define KAGUYA_PP_REPEAT_ARG191(MACRO) \ + KAGUYA_PP_REPEAT_ARG190(MACRO), MACRO(191) +#define KAGUYA_PP_REPEAT_ARG192(MACRO) \ + KAGUYA_PP_REPEAT_ARG191(MACRO), MACRO(192) +#define KAGUYA_PP_REPEAT_ARG193(MACRO) \ + KAGUYA_PP_REPEAT_ARG192(MACRO), MACRO(193) +#define KAGUYA_PP_REPEAT_ARG194(MACRO) \ + KAGUYA_PP_REPEAT_ARG193(MACRO), MACRO(194) +#define KAGUYA_PP_REPEAT_ARG195(MACRO) \ + KAGUYA_PP_REPEAT_ARG194(MACRO), MACRO(195) +#define KAGUYA_PP_REPEAT_ARG196(MACRO) \ + KAGUYA_PP_REPEAT_ARG195(MACRO), MACRO(196) +#define KAGUYA_PP_REPEAT_ARG197(MACRO) \ + KAGUYA_PP_REPEAT_ARG196(MACRO), MACRO(197) +#define KAGUYA_PP_REPEAT_ARG198(MACRO) \ + KAGUYA_PP_REPEAT_ARG197(MACRO), MACRO(198) +#define KAGUYA_PP_REPEAT_ARG199(MACRO) \ + KAGUYA_PP_REPEAT_ARG198(MACRO), MACRO(199) +#define KAGUYA_PP_REPEAT_ARG200(MACRO) \ + KAGUYA_PP_REPEAT_ARG199(MACRO), MACRO(200) +#define KAGUYA_PP_REPEAT_ARG201(MACRO) \ + KAGUYA_PP_REPEAT_ARG200(MACRO), MACRO(201) +#define KAGUYA_PP_REPEAT_ARG202(MACRO) \ + KAGUYA_PP_REPEAT_ARG201(MACRO), MACRO(202) +#define KAGUYA_PP_REPEAT_ARG203(MACRO) \ + KAGUYA_PP_REPEAT_ARG202(MACRO), MACRO(203) +#define KAGUYA_PP_REPEAT_ARG204(MACRO) \ + KAGUYA_PP_REPEAT_ARG203(MACRO), MACRO(204) +#define KAGUYA_PP_REPEAT_ARG205(MACRO) \ + KAGUYA_PP_REPEAT_ARG204(MACRO), MACRO(205) +#define KAGUYA_PP_REPEAT_ARG206(MACRO) \ + KAGUYA_PP_REPEAT_ARG205(MACRO), MACRO(206) +#define KAGUYA_PP_REPEAT_ARG207(MACRO) \ + KAGUYA_PP_REPEAT_ARG206(MACRO), MACRO(207) +#define KAGUYA_PP_REPEAT_ARG208(MACRO) \ + KAGUYA_PP_REPEAT_ARG207(MACRO), MACRO(208) +#define KAGUYA_PP_REPEAT_ARG209(MACRO) \ + KAGUYA_PP_REPEAT_ARG208(MACRO), MACRO(209) +#define KAGUYA_PP_REPEAT_ARG210(MACRO) \ + KAGUYA_PP_REPEAT_ARG209(MACRO), MACRO(210) +#define KAGUYA_PP_REPEAT_ARG211(MACRO) \ + KAGUYA_PP_REPEAT_ARG210(MACRO), MACRO(211) +#define KAGUYA_PP_REPEAT_ARG212(MACRO) \ + KAGUYA_PP_REPEAT_ARG211(MACRO), MACRO(212) +#define KAGUYA_PP_REPEAT_ARG213(MACRO) \ + KAGUYA_PP_REPEAT_ARG212(MACRO), MACRO(213) +#define KAGUYA_PP_REPEAT_ARG214(MACRO) \ + KAGUYA_PP_REPEAT_ARG213(MACRO), MACRO(214) +#define KAGUYA_PP_REPEAT_ARG215(MACRO) \ + KAGUYA_PP_REPEAT_ARG214(MACRO), MACRO(215) +#define KAGUYA_PP_REPEAT_ARG216(MACRO) \ + KAGUYA_PP_REPEAT_ARG215(MACRO), MACRO(216) +#define KAGUYA_PP_REPEAT_ARG217(MACRO) \ + KAGUYA_PP_REPEAT_ARG216(MACRO), MACRO(217) +#define KAGUYA_PP_REPEAT_ARG218(MACRO) \ + KAGUYA_PP_REPEAT_ARG217(MACRO), MACRO(218) +#define KAGUYA_PP_REPEAT_ARG219(MACRO) \ + KAGUYA_PP_REPEAT_ARG218(MACRO), MACRO(219) +#define KAGUYA_PP_REPEAT_ARG220(MACRO) \ + KAGUYA_PP_REPEAT_ARG219(MACRO), MACRO(220) +#define KAGUYA_PP_REPEAT_ARG221(MACRO) \ + KAGUYA_PP_REPEAT_ARG220(MACRO), MACRO(221) +#define KAGUYA_PP_REPEAT_ARG222(MACRO) \ + KAGUYA_PP_REPEAT_ARG221(MACRO), MACRO(222) +#define KAGUYA_PP_REPEAT_ARG223(MACRO) \ + KAGUYA_PP_REPEAT_ARG222(MACRO), MACRO(223) +#define KAGUYA_PP_REPEAT_ARG224(MACRO) \ + KAGUYA_PP_REPEAT_ARG223(MACRO), MACRO(224) +#define KAGUYA_PP_REPEAT_ARG225(MACRO) \ + KAGUYA_PP_REPEAT_ARG224(MACRO), MACRO(225) +#define KAGUYA_PP_REPEAT_ARG226(MACRO) \ + KAGUYA_PP_REPEAT_ARG225(MACRO), MACRO(226) +#define KAGUYA_PP_REPEAT_ARG227(MACRO) \ + KAGUYA_PP_REPEAT_ARG226(MACRO), MACRO(227) +#define KAGUYA_PP_REPEAT_ARG228(MACRO) \ + KAGUYA_PP_REPEAT_ARG227(MACRO), MACRO(228) +#define KAGUYA_PP_REPEAT_ARG229(MACRO) \ + KAGUYA_PP_REPEAT_ARG228(MACRO), MACRO(229) +#define KAGUYA_PP_REPEAT_ARG230(MACRO) \ + KAGUYA_PP_REPEAT_ARG229(MACRO), MACRO(230) +#define KAGUYA_PP_REPEAT_ARG231(MACRO) \ + KAGUYA_PP_REPEAT_ARG230(MACRO), MACRO(231) +#define KAGUYA_PP_REPEAT_ARG232(MACRO) \ + KAGUYA_PP_REPEAT_ARG231(MACRO), MACRO(232) +#define KAGUYA_PP_REPEAT_ARG233(MACRO) \ + KAGUYA_PP_REPEAT_ARG232(MACRO), MACRO(233) +#define KAGUYA_PP_REPEAT_ARG234(MACRO) \ + KAGUYA_PP_REPEAT_ARG233(MACRO), MACRO(234) +#define KAGUYA_PP_REPEAT_ARG235(MACRO) \ + KAGUYA_PP_REPEAT_ARG234(MACRO), MACRO(235) +#define KAGUYA_PP_REPEAT_ARG236(MACRO) \ + KAGUYA_PP_REPEAT_ARG235(MACRO), MACRO(236) +#define KAGUYA_PP_REPEAT_ARG237(MACRO) \ + KAGUYA_PP_REPEAT_ARG236(MACRO), MACRO(237) +#define KAGUYA_PP_REPEAT_ARG238(MACRO) \ + KAGUYA_PP_REPEAT_ARG237(MACRO), MACRO(238) +#define KAGUYA_PP_REPEAT_ARG239(MACRO) \ + KAGUYA_PP_REPEAT_ARG238(MACRO), MACRO(239) +#define KAGUYA_PP_REPEAT_ARG240(MACRO) \ + KAGUYA_PP_REPEAT_ARG239(MACRO), MACRO(240) +#define KAGUYA_PP_REPEAT_ARG241(MACRO) \ + KAGUYA_PP_REPEAT_ARG240(MACRO), MACRO(241) +#define KAGUYA_PP_REPEAT_ARG242(MACRO) \ + KAGUYA_PP_REPEAT_ARG241(MACRO), MACRO(242) +#define KAGUYA_PP_REPEAT_ARG243(MACRO) \ + KAGUYA_PP_REPEAT_ARG242(MACRO), MACRO(243) +#define KAGUYA_PP_REPEAT_ARG244(MACRO) \ + KAGUYA_PP_REPEAT_ARG243(MACRO), MACRO(244) +#define KAGUYA_PP_REPEAT_ARG245(MACRO) \ + KAGUYA_PP_REPEAT_ARG244(MACRO), MACRO(245) +#define KAGUYA_PP_REPEAT_ARG246(MACRO) \ + KAGUYA_PP_REPEAT_ARG245(MACRO), MACRO(246) +#define KAGUYA_PP_REPEAT_ARG247(MACRO) \ + KAGUYA_PP_REPEAT_ARG246(MACRO), MACRO(247) +#define KAGUYA_PP_REPEAT_ARG248(MACRO) \ + KAGUYA_PP_REPEAT_ARG247(MACRO), MACRO(248) +#define KAGUYA_PP_REPEAT_ARG249(MACRO) \ + KAGUYA_PP_REPEAT_ARG248(MACRO), MACRO(249) +#define KAGUYA_PP_REPEAT_ARG250(MACRO) \ + KAGUYA_PP_REPEAT_ARG249(MACRO), MACRO(250) +#define KAGUYA_PP_REPEAT_ARG251(MACRO) \ + KAGUYA_PP_REPEAT_ARG250(MACRO), MACRO(251) +#define KAGUYA_PP_REPEAT_ARG252(MACRO) \ + KAGUYA_PP_REPEAT_ARG251(MACRO), MACRO(252) +#define KAGUYA_PP_REPEAT_ARG253(MACRO) \ + KAGUYA_PP_REPEAT_ARG252(MACRO), MACRO(253) +#define KAGUYA_PP_REPEAT_ARG254(MACRO) \ + KAGUYA_PP_REPEAT_ARG253(MACRO), MACRO(254) +#define KAGUYA_PP_REPEAT_ARG(COUNT, MACRO) \ + KAGUYA_PP_CAT(KAGUYA_PP_REPEAT_ARG, COUNT)(MACRO) + +#define KAGUYA_PP_REPEAT_DEF_VA_ARG0(MACRO, ...) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG1(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG0(MACRO, __VA_ARGS__) \ + MACRO(1, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG2(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG1(MACRO, __VA_ARGS__) \ + MACRO(2, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG3(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG2(MACRO, __VA_ARGS__) \ + MACRO(3, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG4(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG3(MACRO, __VA_ARGS__) \ + MACRO(4, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG5(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG4(MACRO, __VA_ARGS__) \ + MACRO(5, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG6(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG5(MACRO, __VA_ARGS__) \ + MACRO(6, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG7(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG6(MACRO, __VA_ARGS__) \ + MACRO(7, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG8(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG7(MACRO, __VA_ARGS__) \ + MACRO(8, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG9(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG8(MACRO, __VA_ARGS__) \ + MACRO(9, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG10(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG9(MACRO, __VA_ARGS__) \ + MACRO(10, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG11(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG10(MACRO, __VA_ARGS__) \ + MACRO(11, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG12(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG11(MACRO, __VA_ARGS__) \ + MACRO(12, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG13(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG12(MACRO, __VA_ARGS__) \ + MACRO(13, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG14(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG13(MACRO, __VA_ARGS__) \ + MACRO(14, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG15(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG14(MACRO, __VA_ARGS__) \ + MACRO(15, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG16(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG15(MACRO, __VA_ARGS__) \ + MACRO(16, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG17(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG16(MACRO, __VA_ARGS__) \ + MACRO(17, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG18(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG17(MACRO, __VA_ARGS__) \ + MACRO(18, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG19(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG18(MACRO, __VA_ARGS__) \ + MACRO(19, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG20(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG19(MACRO, __VA_ARGS__) \ + MACRO(20, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG21(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG20(MACRO, __VA_ARGS__) \ + MACRO(21, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG22(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG21(MACRO, __VA_ARGS__) \ + MACRO(22, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG23(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG22(MACRO, __VA_ARGS__) \ + MACRO(23, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG24(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG23(MACRO, __VA_ARGS__) \ + MACRO(24, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG25(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG24(MACRO, __VA_ARGS__) \ + MACRO(25, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG26(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG25(MACRO, __VA_ARGS__) \ + MACRO(26, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG27(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG26(MACRO, __VA_ARGS__) \ + MACRO(27, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG28(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG27(MACRO, __VA_ARGS__) \ + MACRO(28, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG29(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG28(MACRO, __VA_ARGS__) \ + MACRO(29, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG30(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG29(MACRO, __VA_ARGS__) \ + MACRO(30, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG31(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG30(MACRO, __VA_ARGS__) \ + MACRO(31, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG32(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG31(MACRO, __VA_ARGS__) \ + MACRO(32, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG33(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG32(MACRO, __VA_ARGS__) \ + MACRO(33, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG34(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG33(MACRO, __VA_ARGS__) \ + MACRO(34, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG35(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG34(MACRO, __VA_ARGS__) \ + MACRO(35, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG36(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG35(MACRO, __VA_ARGS__) \ + MACRO(36, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG37(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG36(MACRO, __VA_ARGS__) \ + MACRO(37, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG38(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG37(MACRO, __VA_ARGS__) \ + MACRO(38, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG39(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG38(MACRO, __VA_ARGS__) \ + MACRO(39, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG40(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG39(MACRO, __VA_ARGS__) \ + MACRO(40, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG41(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG40(MACRO, __VA_ARGS__) \ + MACRO(41, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG42(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG41(MACRO, __VA_ARGS__) \ + MACRO(42, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG43(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG42(MACRO, __VA_ARGS__) \ + MACRO(43, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG44(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG43(MACRO, __VA_ARGS__) \ + MACRO(44, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG45(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG44(MACRO, __VA_ARGS__) \ + MACRO(45, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG46(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG45(MACRO, __VA_ARGS__) \ + MACRO(46, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG47(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG46(MACRO, __VA_ARGS__) \ + MACRO(47, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG48(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG47(MACRO, __VA_ARGS__) \ + MACRO(48, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG49(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG48(MACRO, __VA_ARGS__) \ + MACRO(49, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG50(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG49(MACRO, __VA_ARGS__) \ + MACRO(50, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG51(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG50(MACRO, __VA_ARGS__) \ + MACRO(51, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG52(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG51(MACRO, __VA_ARGS__) \ + MACRO(52, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG53(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG52(MACRO, __VA_ARGS__) \ + MACRO(53, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG54(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG53(MACRO, __VA_ARGS__) \ + MACRO(54, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG55(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG54(MACRO, __VA_ARGS__) \ + MACRO(55, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG56(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG55(MACRO, __VA_ARGS__) \ + MACRO(56, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG57(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG56(MACRO, __VA_ARGS__) \ + MACRO(57, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG58(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG57(MACRO, __VA_ARGS__) \ + MACRO(58, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG59(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG58(MACRO, __VA_ARGS__) \ + MACRO(59, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG60(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG59(MACRO, __VA_ARGS__) \ + MACRO(60, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG61(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG60(MACRO, __VA_ARGS__) \ + MACRO(61, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG62(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG61(MACRO, __VA_ARGS__) \ + MACRO(62, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG63(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG62(MACRO, __VA_ARGS__) \ + MACRO(63, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG64(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG63(MACRO, __VA_ARGS__) \ + MACRO(64, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG65(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG64(MACRO, __VA_ARGS__) \ + MACRO(65, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG66(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG65(MACRO, __VA_ARGS__) \ + MACRO(66, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG67(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG66(MACRO, __VA_ARGS__) \ + MACRO(67, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG68(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG67(MACRO, __VA_ARGS__) \ + MACRO(68, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG69(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG68(MACRO, __VA_ARGS__) \ + MACRO(69, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG70(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG69(MACRO, __VA_ARGS__) \ + MACRO(70, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG71(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG70(MACRO, __VA_ARGS__) \ + MACRO(71, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG72(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG71(MACRO, __VA_ARGS__) \ + MACRO(72, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG73(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG72(MACRO, __VA_ARGS__) \ + MACRO(73, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG74(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG73(MACRO, __VA_ARGS__) \ + MACRO(74, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG75(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG74(MACRO, __VA_ARGS__) \ + MACRO(75, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG76(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG75(MACRO, __VA_ARGS__) \ + MACRO(76, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG77(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG76(MACRO, __VA_ARGS__) \ + MACRO(77, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG78(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG77(MACRO, __VA_ARGS__) \ + MACRO(78, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG79(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG78(MACRO, __VA_ARGS__) \ + MACRO(79, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG80(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG79(MACRO, __VA_ARGS__) \ + MACRO(80, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG81(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG80(MACRO, __VA_ARGS__) \ + MACRO(81, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG82(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG81(MACRO, __VA_ARGS__) \ + MACRO(82, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG83(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG82(MACRO, __VA_ARGS__) \ + MACRO(83, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG84(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG83(MACRO, __VA_ARGS__) \ + MACRO(84, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG85(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG84(MACRO, __VA_ARGS__) \ + MACRO(85, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG86(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG85(MACRO, __VA_ARGS__) \ + MACRO(86, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG87(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG86(MACRO, __VA_ARGS__) \ + MACRO(87, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG88(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG87(MACRO, __VA_ARGS__) \ + MACRO(88, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG89(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG88(MACRO, __VA_ARGS__) \ + MACRO(89, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG90(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG89(MACRO, __VA_ARGS__) \ + MACRO(90, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG91(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG90(MACRO, __VA_ARGS__) \ + MACRO(91, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG92(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG91(MACRO, __VA_ARGS__) \ + MACRO(92, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG93(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG92(MACRO, __VA_ARGS__) \ + MACRO(93, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG94(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG93(MACRO, __VA_ARGS__) \ + MACRO(94, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG95(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG94(MACRO, __VA_ARGS__) \ + MACRO(95, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG96(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG95(MACRO, __VA_ARGS__) \ + MACRO(96, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG97(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG96(MACRO, __VA_ARGS__) \ + MACRO(97, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG98(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG97(MACRO, __VA_ARGS__) \ + MACRO(98, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG99(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG98(MACRO, __VA_ARGS__) \ + MACRO(99, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG100(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG99(MACRO, __VA_ARGS__) \ + MACRO(100, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG101(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG100(MACRO, __VA_ARGS__) \ + MACRO(101, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG102(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG101(MACRO, __VA_ARGS__) \ + MACRO(102, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG103(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG102(MACRO, __VA_ARGS__) \ + MACRO(103, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG104(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG103(MACRO, __VA_ARGS__) \ + MACRO(104, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG105(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG104(MACRO, __VA_ARGS__) \ + MACRO(105, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG106(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG105(MACRO, __VA_ARGS__) \ + MACRO(106, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG107(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG106(MACRO, __VA_ARGS__) \ + MACRO(107, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG108(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG107(MACRO, __VA_ARGS__) \ + MACRO(108, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG109(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG108(MACRO, __VA_ARGS__) \ + MACRO(109, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG110(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG109(MACRO, __VA_ARGS__) \ + MACRO(110, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG111(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG110(MACRO, __VA_ARGS__) \ + MACRO(111, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG112(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG111(MACRO, __VA_ARGS__) \ + MACRO(112, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG113(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG112(MACRO, __VA_ARGS__) \ + MACRO(113, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG114(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG113(MACRO, __VA_ARGS__) \ + MACRO(114, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG115(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG114(MACRO, __VA_ARGS__) \ + MACRO(115, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG116(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG115(MACRO, __VA_ARGS__) \ + MACRO(116, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG117(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG116(MACRO, __VA_ARGS__) \ + MACRO(117, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG118(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG117(MACRO, __VA_ARGS__) \ + MACRO(118, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG119(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG118(MACRO, __VA_ARGS__) \ + MACRO(119, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG120(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG119(MACRO, __VA_ARGS__) \ + MACRO(120, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG121(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG120(MACRO, __VA_ARGS__) \ + MACRO(121, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG122(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG121(MACRO, __VA_ARGS__) \ + MACRO(122, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG123(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG122(MACRO, __VA_ARGS__) \ + MACRO(123, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG124(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG123(MACRO, __VA_ARGS__) \ + MACRO(124, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG125(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG124(MACRO, __VA_ARGS__) \ + MACRO(125, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG126(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG125(MACRO, __VA_ARGS__) \ + MACRO(126, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG127(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG126(MACRO, __VA_ARGS__) \ + MACRO(127, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG128(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG127(MACRO, __VA_ARGS__) \ + MACRO(128, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG129(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG128(MACRO, __VA_ARGS__) \ + MACRO(129, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG130(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG129(MACRO, __VA_ARGS__) \ + MACRO(130, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG131(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG130(MACRO, __VA_ARGS__) \ + MACRO(131, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG132(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG131(MACRO, __VA_ARGS__) \ + MACRO(132, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG133(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG132(MACRO, __VA_ARGS__) \ + MACRO(133, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG134(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG133(MACRO, __VA_ARGS__) \ + MACRO(134, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG135(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG134(MACRO, __VA_ARGS__) \ + MACRO(135, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG136(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG135(MACRO, __VA_ARGS__) \ + MACRO(136, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG137(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG136(MACRO, __VA_ARGS__) \ + MACRO(137, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG138(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG137(MACRO, __VA_ARGS__) \ + MACRO(138, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG139(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG138(MACRO, __VA_ARGS__) \ + MACRO(139, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG140(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG139(MACRO, __VA_ARGS__) \ + MACRO(140, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG141(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG140(MACRO, __VA_ARGS__) \ + MACRO(141, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG142(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG141(MACRO, __VA_ARGS__) \ + MACRO(142, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG143(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG142(MACRO, __VA_ARGS__) \ + MACRO(143, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG144(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG143(MACRO, __VA_ARGS__) \ + MACRO(144, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG145(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG144(MACRO, __VA_ARGS__) \ + MACRO(145, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG146(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG145(MACRO, __VA_ARGS__) \ + MACRO(146, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG147(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG146(MACRO, __VA_ARGS__) \ + MACRO(147, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG148(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG147(MACRO, __VA_ARGS__) \ + MACRO(148, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG149(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG148(MACRO, __VA_ARGS__) \ + MACRO(149, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG150(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG149(MACRO, __VA_ARGS__) \ + MACRO(150, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG151(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG150(MACRO, __VA_ARGS__) \ + MACRO(151, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG152(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG151(MACRO, __VA_ARGS__) \ + MACRO(152, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG153(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG152(MACRO, __VA_ARGS__) \ + MACRO(153, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG154(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG153(MACRO, __VA_ARGS__) \ + MACRO(154, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG155(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG154(MACRO, __VA_ARGS__) \ + MACRO(155, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG156(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG155(MACRO, __VA_ARGS__) \ + MACRO(156, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG157(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG156(MACRO, __VA_ARGS__) \ + MACRO(157, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG158(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG157(MACRO, __VA_ARGS__) \ + MACRO(158, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG159(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG158(MACRO, __VA_ARGS__) \ + MACRO(159, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG160(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG159(MACRO, __VA_ARGS__) \ + MACRO(160, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG161(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG160(MACRO, __VA_ARGS__) \ + MACRO(161, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG162(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG161(MACRO, __VA_ARGS__) \ + MACRO(162, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG163(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG162(MACRO, __VA_ARGS__) \ + MACRO(163, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG164(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG163(MACRO, __VA_ARGS__) \ + MACRO(164, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG165(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG164(MACRO, __VA_ARGS__) \ + MACRO(165, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG166(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG165(MACRO, __VA_ARGS__) \ + MACRO(166, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG167(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG166(MACRO, __VA_ARGS__) \ + MACRO(167, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG168(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG167(MACRO, __VA_ARGS__) \ + MACRO(168, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG169(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG168(MACRO, __VA_ARGS__) \ + MACRO(169, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG170(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG169(MACRO, __VA_ARGS__) \ + MACRO(170, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG171(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG170(MACRO, __VA_ARGS__) \ + MACRO(171, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG172(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG171(MACRO, __VA_ARGS__) \ + MACRO(172, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG173(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG172(MACRO, __VA_ARGS__) \ + MACRO(173, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG174(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG173(MACRO, __VA_ARGS__) \ + MACRO(174, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG175(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG174(MACRO, __VA_ARGS__) \ + MACRO(175, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG176(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG175(MACRO, __VA_ARGS__) \ + MACRO(176, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG177(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG176(MACRO, __VA_ARGS__) \ + MACRO(177, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG178(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG177(MACRO, __VA_ARGS__) \ + MACRO(178, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG179(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG178(MACRO, __VA_ARGS__) \ + MACRO(179, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG180(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG179(MACRO, __VA_ARGS__) \ + MACRO(180, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG181(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG180(MACRO, __VA_ARGS__) \ + MACRO(181, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG182(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG181(MACRO, __VA_ARGS__) \ + MACRO(182, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG183(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG182(MACRO, __VA_ARGS__) \ + MACRO(183, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG184(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG183(MACRO, __VA_ARGS__) \ + MACRO(184, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG185(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG184(MACRO, __VA_ARGS__) \ + MACRO(185, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG186(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG185(MACRO, __VA_ARGS__) \ + MACRO(186, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG187(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG186(MACRO, __VA_ARGS__) \ + MACRO(187, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG188(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG187(MACRO, __VA_ARGS__) \ + MACRO(188, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG189(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG188(MACRO, __VA_ARGS__) \ + MACRO(189, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG190(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG189(MACRO, __VA_ARGS__) \ + MACRO(190, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG191(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG190(MACRO, __VA_ARGS__) \ + MACRO(191, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG192(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG191(MACRO, __VA_ARGS__) \ + MACRO(192, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG193(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG192(MACRO, __VA_ARGS__) \ + MACRO(193, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG194(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG193(MACRO, __VA_ARGS__) \ + MACRO(194, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG195(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG194(MACRO, __VA_ARGS__) \ + MACRO(195, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG196(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG195(MACRO, __VA_ARGS__) \ + MACRO(196, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG197(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG196(MACRO, __VA_ARGS__) \ + MACRO(197, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG198(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG197(MACRO, __VA_ARGS__) \ + MACRO(198, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG199(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG198(MACRO, __VA_ARGS__) \ + MACRO(199, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG200(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG199(MACRO, __VA_ARGS__) \ + MACRO(200, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG201(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG200(MACRO, __VA_ARGS__) \ + MACRO(201, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG202(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG201(MACRO, __VA_ARGS__) \ + MACRO(202, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG203(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG202(MACRO, __VA_ARGS__) \ + MACRO(203, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG204(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG203(MACRO, __VA_ARGS__) \ + MACRO(204, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG205(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG204(MACRO, __VA_ARGS__) \ + MACRO(205, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG206(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG205(MACRO, __VA_ARGS__) \ + MACRO(206, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG207(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG206(MACRO, __VA_ARGS__) \ + MACRO(207, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG208(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG207(MACRO, __VA_ARGS__) \ + MACRO(208, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG209(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG208(MACRO, __VA_ARGS__) \ + MACRO(209, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG210(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG209(MACRO, __VA_ARGS__) \ + MACRO(210, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG211(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG210(MACRO, __VA_ARGS__) \ + MACRO(211, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG212(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG211(MACRO, __VA_ARGS__) \ + MACRO(212, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG213(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG212(MACRO, __VA_ARGS__) \ + MACRO(213, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG214(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG213(MACRO, __VA_ARGS__) \ + MACRO(214, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG215(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG214(MACRO, __VA_ARGS__) \ + MACRO(215, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG216(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG215(MACRO, __VA_ARGS__) \ + MACRO(216, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG217(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG216(MACRO, __VA_ARGS__) \ + MACRO(217, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG218(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG217(MACRO, __VA_ARGS__) \ + MACRO(218, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG219(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG218(MACRO, __VA_ARGS__) \ + MACRO(219, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG220(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG219(MACRO, __VA_ARGS__) \ + MACRO(220, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG221(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG220(MACRO, __VA_ARGS__) \ + MACRO(221, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG222(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG221(MACRO, __VA_ARGS__) \ + MACRO(222, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG223(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG222(MACRO, __VA_ARGS__) \ + MACRO(223, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG224(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG223(MACRO, __VA_ARGS__) \ + MACRO(224, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG225(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG224(MACRO, __VA_ARGS__) \ + MACRO(225, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG226(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG225(MACRO, __VA_ARGS__) \ + MACRO(226, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG227(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG226(MACRO, __VA_ARGS__) \ + MACRO(227, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG228(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG227(MACRO, __VA_ARGS__) \ + MACRO(228, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG229(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG228(MACRO, __VA_ARGS__) \ + MACRO(229, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG230(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG229(MACRO, __VA_ARGS__) \ + MACRO(230, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG231(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG230(MACRO, __VA_ARGS__) \ + MACRO(231, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG232(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG231(MACRO, __VA_ARGS__) \ + MACRO(232, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG233(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG232(MACRO, __VA_ARGS__) \ + MACRO(233, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG234(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG233(MACRO, __VA_ARGS__) \ + MACRO(234, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG235(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG234(MACRO, __VA_ARGS__) \ + MACRO(235, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG236(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG235(MACRO, __VA_ARGS__) \ + MACRO(236, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG237(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG236(MACRO, __VA_ARGS__) \ + MACRO(237, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG238(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG237(MACRO, __VA_ARGS__) \ + MACRO(238, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG239(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG238(MACRO, __VA_ARGS__) \ + MACRO(239, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG240(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG239(MACRO, __VA_ARGS__) \ + MACRO(240, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG241(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG240(MACRO, __VA_ARGS__) \ + MACRO(241, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG242(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG241(MACRO, __VA_ARGS__) \ + MACRO(242, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG243(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG242(MACRO, __VA_ARGS__) \ + MACRO(243, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG244(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG243(MACRO, __VA_ARGS__) \ + MACRO(244, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG245(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG244(MACRO, __VA_ARGS__) \ + MACRO(245, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG246(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG245(MACRO, __VA_ARGS__) \ + MACRO(246, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG247(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG246(MACRO, __VA_ARGS__) \ + MACRO(247, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG248(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG247(MACRO, __VA_ARGS__) \ + MACRO(248, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG249(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG248(MACRO, __VA_ARGS__) \ + MACRO(249, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG250(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG249(MACRO, __VA_ARGS__) \ + MACRO(250, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG251(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG250(MACRO, __VA_ARGS__) \ + MACRO(251, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG252(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG251(MACRO, __VA_ARGS__) \ + MACRO(252, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG253(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG252(MACRO, __VA_ARGS__) \ + MACRO(253, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG254(MACRO, ...) \ + KAGUYA_VA_ARG(KAGUYA_PP_REPEAT_DEF_VA_ARG253(MACRO, __VA_ARGS__) \ + MACRO(254, __VA_ARGS__)) +#define KAGUYA_PP_REPEAT_DEF_VA_ARG(COUNT, MACRO, ...) \ + KAGUYA_VA_ARG( \ + KAGUYA_PP_CAT(KAGUYA_PP_REPEAT_DEF_VA_ARG, COUNT)(MACRO, __VA_ARGS__)) + +#define KAGUYA_PP_WHILE0(MACRO, R) R +#define KAGUYA_PP_WHILE1(MACRO, R) MACRO(KAGUYA_PP_WHILE0(MACRO, R)) +#define KAGUYA_PP_WHILE2(MACRO, R) MACRO(KAGUYA_PP_WHILE1(MACRO, R)) +#define KAGUYA_PP_WHILE3(MACRO, R) MACRO(KAGUYA_PP_WHILE2(MACRO, R)) +#define KAGUYA_PP_WHILE4(MACRO, R) MACRO(KAGUYA_PP_WHILE3(MACRO, R)) +#define KAGUYA_PP_WHILE5(MACRO, R) MACRO(KAGUYA_PP_WHILE4(MACRO, R)) +#define KAGUYA_PP_WHILE6(MACRO, R) MACRO(KAGUYA_PP_WHILE5(MACRO, R)) +#define KAGUYA_PP_WHILE7(MACRO, R) MACRO(KAGUYA_PP_WHILE6(MACRO, R)) +#define KAGUYA_PP_WHILE8(MACRO, R) MACRO(KAGUYA_PP_WHILE7(MACRO, R)) +#define KAGUYA_PP_WHILE9(MACRO, R) MACRO(KAGUYA_PP_WHILE8(MACRO, R)) +#define KAGUYA_PP_WHILE10(MACRO, R) MACRO(KAGUYA_PP_WHILE9(MACRO, R)) +#define KAGUYA_PP_WHILE11(MACRO, R) MACRO(KAGUYA_PP_WHILE10(MACRO, R)) +#define KAGUYA_PP_WHILE12(MACRO, R) MACRO(KAGUYA_PP_WHILE11(MACRO, R)) +#define KAGUYA_PP_WHILE13(MACRO, R) MACRO(KAGUYA_PP_WHILE12(MACRO, R)) +#define KAGUYA_PP_WHILE14(MACRO, R) MACRO(KAGUYA_PP_WHILE13(MACRO, R)) +#define KAGUYA_PP_WHILE15(MACRO, R) MACRO(KAGUYA_PP_WHILE14(MACRO, R)) +#define KAGUYA_PP_WHILE16(MACRO, R) MACRO(KAGUYA_PP_WHILE15(MACRO, R)) +#define KAGUYA_PP_WHILE17(MACRO, R) MACRO(KAGUYA_PP_WHILE16(MACRO, R)) +#define KAGUYA_PP_WHILE18(MACRO, R) MACRO(KAGUYA_PP_WHILE17(MACRO, R)) +#define KAGUYA_PP_WHILE19(MACRO, R) MACRO(KAGUYA_PP_WHILE18(MACRO, R)) +#define KAGUYA_PP_WHILE20(MACRO, R) MACRO(KAGUYA_PP_WHILE19(MACRO, R)) +#define KAGUYA_PP_WHILE21(MACRO, R) MACRO(KAGUYA_PP_WHILE20(MACRO, R)) +#define KAGUYA_PP_WHILE22(MACRO, R) MACRO(KAGUYA_PP_WHILE21(MACRO, R)) +#define KAGUYA_PP_WHILE23(MACRO, R) MACRO(KAGUYA_PP_WHILE22(MACRO, R)) +#define KAGUYA_PP_WHILE24(MACRO, R) MACRO(KAGUYA_PP_WHILE23(MACRO, R)) +#define KAGUYA_PP_WHILE25(MACRO, R) MACRO(KAGUYA_PP_WHILE24(MACRO, R)) +#define KAGUYA_PP_WHILE26(MACRO, R) MACRO(KAGUYA_PP_WHILE25(MACRO, R)) +#define KAGUYA_PP_WHILE27(MACRO, R) MACRO(KAGUYA_PP_WHILE26(MACRO, R)) +#define KAGUYA_PP_WHILE28(MACRO, R) MACRO(KAGUYA_PP_WHILE27(MACRO, R)) +#define KAGUYA_PP_WHILE29(MACRO, R) MACRO(KAGUYA_PP_WHILE28(MACRO, R)) +#define KAGUYA_PP_WHILE30(MACRO, R) MACRO(KAGUYA_PP_WHILE29(MACRO, R)) +#define KAGUYA_PP_WHILE31(MACRO, R) MACRO(KAGUYA_PP_WHILE30(MACRO, R)) +#define KAGUYA_PP_WHILE32(MACRO, R) MACRO(KAGUYA_PP_WHILE31(MACRO, R)) +#define KAGUYA_PP_WHILE33(MACRO, R) MACRO(KAGUYA_PP_WHILE32(MACRO, R)) +#define KAGUYA_PP_WHILE34(MACRO, R) MACRO(KAGUYA_PP_WHILE33(MACRO, R)) +#define KAGUYA_PP_WHILE35(MACRO, R) MACRO(KAGUYA_PP_WHILE34(MACRO, R)) +#define KAGUYA_PP_WHILE36(MACRO, R) MACRO(KAGUYA_PP_WHILE35(MACRO, R)) +#define KAGUYA_PP_WHILE37(MACRO, R) MACRO(KAGUYA_PP_WHILE36(MACRO, R)) +#define KAGUYA_PP_WHILE38(MACRO, R) MACRO(KAGUYA_PP_WHILE37(MACRO, R)) +#define KAGUYA_PP_WHILE39(MACRO, R) MACRO(KAGUYA_PP_WHILE38(MACRO, R)) +#define KAGUYA_PP_WHILE40(MACRO, R) MACRO(KAGUYA_PP_WHILE39(MACRO, R)) +#define KAGUYA_PP_WHILE41(MACRO, R) MACRO(KAGUYA_PP_WHILE40(MACRO, R)) +#define KAGUYA_PP_WHILE42(MACRO, R) MACRO(KAGUYA_PP_WHILE41(MACRO, R)) +#define KAGUYA_PP_WHILE43(MACRO, R) MACRO(KAGUYA_PP_WHILE42(MACRO, R)) +#define KAGUYA_PP_WHILE44(MACRO, R) MACRO(KAGUYA_PP_WHILE43(MACRO, R)) +#define KAGUYA_PP_WHILE45(MACRO, R) MACRO(KAGUYA_PP_WHILE44(MACRO, R)) +#define KAGUYA_PP_WHILE46(MACRO, R) MACRO(KAGUYA_PP_WHILE45(MACRO, R)) +#define KAGUYA_PP_WHILE47(MACRO, R) MACRO(KAGUYA_PP_WHILE46(MACRO, R)) +#define KAGUYA_PP_WHILE48(MACRO, R) MACRO(KAGUYA_PP_WHILE47(MACRO, R)) +#define KAGUYA_PP_WHILE49(MACRO, R) MACRO(KAGUYA_PP_WHILE48(MACRO, R)) +#define KAGUYA_PP_WHILE50(MACRO, R) MACRO(KAGUYA_PP_WHILE49(MACRO, R)) +#define KAGUYA_PP_WHILE51(MACRO, R) MACRO(KAGUYA_PP_WHILE50(MACRO, R)) +#define KAGUYA_PP_WHILE52(MACRO, R) MACRO(KAGUYA_PP_WHILE51(MACRO, R)) +#define KAGUYA_PP_WHILE53(MACRO, R) MACRO(KAGUYA_PP_WHILE52(MACRO, R)) +#define KAGUYA_PP_WHILE54(MACRO, R) MACRO(KAGUYA_PP_WHILE53(MACRO, R)) +#define KAGUYA_PP_WHILE55(MACRO, R) MACRO(KAGUYA_PP_WHILE54(MACRO, R)) +#define KAGUYA_PP_WHILE56(MACRO, R) MACRO(KAGUYA_PP_WHILE55(MACRO, R)) +#define KAGUYA_PP_WHILE57(MACRO, R) MACRO(KAGUYA_PP_WHILE56(MACRO, R)) +#define KAGUYA_PP_WHILE58(MACRO, R) MACRO(KAGUYA_PP_WHILE57(MACRO, R)) +#define KAGUYA_PP_WHILE59(MACRO, R) MACRO(KAGUYA_PP_WHILE58(MACRO, R)) +#define KAGUYA_PP_WHILE60(MACRO, R) MACRO(KAGUYA_PP_WHILE59(MACRO, R)) +#define KAGUYA_PP_WHILE61(MACRO, R) MACRO(KAGUYA_PP_WHILE60(MACRO, R)) +#define KAGUYA_PP_WHILE62(MACRO, R) MACRO(KAGUYA_PP_WHILE61(MACRO, R)) +#define KAGUYA_PP_WHILE63(MACRO, R) MACRO(KAGUYA_PP_WHILE62(MACRO, R)) +#define KAGUYA_PP_WHILE64(MACRO, R) MACRO(KAGUYA_PP_WHILE63(MACRO, R)) +#define KAGUYA_PP_WHILE65(MACRO, R) MACRO(KAGUYA_PP_WHILE64(MACRO, R)) +#define KAGUYA_PP_WHILE66(MACRO, R) MACRO(KAGUYA_PP_WHILE65(MACRO, R)) +#define KAGUYA_PP_WHILE67(MACRO, R) MACRO(KAGUYA_PP_WHILE66(MACRO, R)) +#define KAGUYA_PP_WHILE68(MACRO, R) MACRO(KAGUYA_PP_WHILE67(MACRO, R)) +#define KAGUYA_PP_WHILE69(MACRO, R) MACRO(KAGUYA_PP_WHILE68(MACRO, R)) +#define KAGUYA_PP_WHILE70(MACRO, R) MACRO(KAGUYA_PP_WHILE69(MACRO, R)) +#define KAGUYA_PP_WHILE71(MACRO, R) MACRO(KAGUYA_PP_WHILE70(MACRO, R)) +#define KAGUYA_PP_WHILE72(MACRO, R) MACRO(KAGUYA_PP_WHILE71(MACRO, R)) +#define KAGUYA_PP_WHILE73(MACRO, R) MACRO(KAGUYA_PP_WHILE72(MACRO, R)) +#define KAGUYA_PP_WHILE74(MACRO, R) MACRO(KAGUYA_PP_WHILE73(MACRO, R)) +#define KAGUYA_PP_WHILE75(MACRO, R) MACRO(KAGUYA_PP_WHILE74(MACRO, R)) +#define KAGUYA_PP_WHILE76(MACRO, R) MACRO(KAGUYA_PP_WHILE75(MACRO, R)) +#define KAGUYA_PP_WHILE77(MACRO, R) MACRO(KAGUYA_PP_WHILE76(MACRO, R)) +#define KAGUYA_PP_WHILE78(MACRO, R) MACRO(KAGUYA_PP_WHILE77(MACRO, R)) +#define KAGUYA_PP_WHILE79(MACRO, R) MACRO(KAGUYA_PP_WHILE78(MACRO, R)) +#define KAGUYA_PP_WHILE80(MACRO, R) MACRO(KAGUYA_PP_WHILE79(MACRO, R)) +#define KAGUYA_PP_WHILE81(MACRO, R) MACRO(KAGUYA_PP_WHILE80(MACRO, R)) +#define KAGUYA_PP_WHILE82(MACRO, R) MACRO(KAGUYA_PP_WHILE81(MACRO, R)) +#define KAGUYA_PP_WHILE83(MACRO, R) MACRO(KAGUYA_PP_WHILE82(MACRO, R)) +#define KAGUYA_PP_WHILE84(MACRO, R) MACRO(KAGUYA_PP_WHILE83(MACRO, R)) +#define KAGUYA_PP_WHILE85(MACRO, R) MACRO(KAGUYA_PP_WHILE84(MACRO, R)) +#define KAGUYA_PP_WHILE86(MACRO, R) MACRO(KAGUYA_PP_WHILE85(MACRO, R)) +#define KAGUYA_PP_WHILE87(MACRO, R) MACRO(KAGUYA_PP_WHILE86(MACRO, R)) +#define KAGUYA_PP_WHILE88(MACRO, R) MACRO(KAGUYA_PP_WHILE87(MACRO, R)) +#define KAGUYA_PP_WHILE89(MACRO, R) MACRO(KAGUYA_PP_WHILE88(MACRO, R)) +#define KAGUYA_PP_WHILE90(MACRO, R) MACRO(KAGUYA_PP_WHILE89(MACRO, R)) +#define KAGUYA_PP_WHILE91(MACRO, R) MACRO(KAGUYA_PP_WHILE90(MACRO, R)) +#define KAGUYA_PP_WHILE92(MACRO, R) MACRO(KAGUYA_PP_WHILE91(MACRO, R)) +#define KAGUYA_PP_WHILE93(MACRO, R) MACRO(KAGUYA_PP_WHILE92(MACRO, R)) +#define KAGUYA_PP_WHILE94(MACRO, R) MACRO(KAGUYA_PP_WHILE93(MACRO, R)) +#define KAGUYA_PP_WHILE95(MACRO, R) MACRO(KAGUYA_PP_WHILE94(MACRO, R)) +#define KAGUYA_PP_WHILE96(MACRO, R) MACRO(KAGUYA_PP_WHILE95(MACRO, R)) +#define KAGUYA_PP_WHILE97(MACRO, R) MACRO(KAGUYA_PP_WHILE96(MACRO, R)) +#define KAGUYA_PP_WHILE98(MACRO, R) MACRO(KAGUYA_PP_WHILE97(MACRO, R)) +#define KAGUYA_PP_WHILE99(MACRO, R) MACRO(KAGUYA_PP_WHILE98(MACRO, R)) +#define KAGUYA_PP_WHILE100(MACRO, R) MACRO(KAGUYA_PP_WHILE99(MACRO, R)) +#define KAGUYA_PP_WHILE101(MACRO, R) MACRO(KAGUYA_PP_WHILE100(MACRO, R)) +#define KAGUYA_PP_WHILE102(MACRO, R) MACRO(KAGUYA_PP_WHILE101(MACRO, R)) +#define KAGUYA_PP_WHILE103(MACRO, R) MACRO(KAGUYA_PP_WHILE102(MACRO, R)) +#define KAGUYA_PP_WHILE104(MACRO, R) MACRO(KAGUYA_PP_WHILE103(MACRO, R)) +#define KAGUYA_PP_WHILE105(MACRO, R) MACRO(KAGUYA_PP_WHILE104(MACRO, R)) +#define KAGUYA_PP_WHILE106(MACRO, R) MACRO(KAGUYA_PP_WHILE105(MACRO, R)) +#define KAGUYA_PP_WHILE107(MACRO, R) MACRO(KAGUYA_PP_WHILE106(MACRO, R)) +#define KAGUYA_PP_WHILE108(MACRO, R) MACRO(KAGUYA_PP_WHILE107(MACRO, R)) +#define KAGUYA_PP_WHILE109(MACRO, R) MACRO(KAGUYA_PP_WHILE108(MACRO, R)) +#define KAGUYA_PP_WHILE110(MACRO, R) MACRO(KAGUYA_PP_WHILE109(MACRO, R)) +#define KAGUYA_PP_WHILE111(MACRO, R) MACRO(KAGUYA_PP_WHILE110(MACRO, R)) +#define KAGUYA_PP_WHILE112(MACRO, R) MACRO(KAGUYA_PP_WHILE111(MACRO, R)) +#define KAGUYA_PP_WHILE113(MACRO, R) MACRO(KAGUYA_PP_WHILE112(MACRO, R)) +#define KAGUYA_PP_WHILE114(MACRO, R) MACRO(KAGUYA_PP_WHILE113(MACRO, R)) +#define KAGUYA_PP_WHILE115(MACRO, R) MACRO(KAGUYA_PP_WHILE114(MACRO, R)) +#define KAGUYA_PP_WHILE116(MACRO, R) MACRO(KAGUYA_PP_WHILE115(MACRO, R)) +#define KAGUYA_PP_WHILE117(MACRO, R) MACRO(KAGUYA_PP_WHILE116(MACRO, R)) +#define KAGUYA_PP_WHILE118(MACRO, R) MACRO(KAGUYA_PP_WHILE117(MACRO, R)) +#define KAGUYA_PP_WHILE119(MACRO, R) MACRO(KAGUYA_PP_WHILE118(MACRO, R)) +#define KAGUYA_PP_WHILE120(MACRO, R) MACRO(KAGUYA_PP_WHILE119(MACRO, R)) +#define KAGUYA_PP_WHILE121(MACRO, R) MACRO(KAGUYA_PP_WHILE120(MACRO, R)) +#define KAGUYA_PP_WHILE122(MACRO, R) MACRO(KAGUYA_PP_WHILE121(MACRO, R)) +#define KAGUYA_PP_WHILE123(MACRO, R) MACRO(KAGUYA_PP_WHILE122(MACRO, R)) +#define KAGUYA_PP_WHILE124(MACRO, R) MACRO(KAGUYA_PP_WHILE123(MACRO, R)) +#define KAGUYA_PP_WHILE125(MACRO, R) MACRO(KAGUYA_PP_WHILE124(MACRO, R)) +#define KAGUYA_PP_WHILE126(MACRO, R) MACRO(KAGUYA_PP_WHILE125(MACRO, R)) +#define KAGUYA_PP_WHILE127(MACRO, R) MACRO(KAGUYA_PP_WHILE126(MACRO, R)) +#define KAGUYA_PP_WHILE128(MACRO, R) MACRO(KAGUYA_PP_WHILE127(MACRO, R)) +#define KAGUYA_PP_WHILE129(MACRO, R) MACRO(KAGUYA_PP_WHILE128(MACRO, R)) +#define KAGUYA_PP_WHILE130(MACRO, R) MACRO(KAGUYA_PP_WHILE129(MACRO, R)) +#define KAGUYA_PP_WHILE131(MACRO, R) MACRO(KAGUYA_PP_WHILE130(MACRO, R)) +#define KAGUYA_PP_WHILE132(MACRO, R) MACRO(KAGUYA_PP_WHILE131(MACRO, R)) +#define KAGUYA_PP_WHILE133(MACRO, R) MACRO(KAGUYA_PP_WHILE132(MACRO, R)) +#define KAGUYA_PP_WHILE134(MACRO, R) MACRO(KAGUYA_PP_WHILE133(MACRO, R)) +#define KAGUYA_PP_WHILE135(MACRO, R) MACRO(KAGUYA_PP_WHILE134(MACRO, R)) +#define KAGUYA_PP_WHILE136(MACRO, R) MACRO(KAGUYA_PP_WHILE135(MACRO, R)) +#define KAGUYA_PP_WHILE137(MACRO, R) MACRO(KAGUYA_PP_WHILE136(MACRO, R)) +#define KAGUYA_PP_WHILE138(MACRO, R) MACRO(KAGUYA_PP_WHILE137(MACRO, R)) +#define KAGUYA_PP_WHILE139(MACRO, R) MACRO(KAGUYA_PP_WHILE138(MACRO, R)) +#define KAGUYA_PP_WHILE140(MACRO, R) MACRO(KAGUYA_PP_WHILE139(MACRO, R)) +#define KAGUYA_PP_WHILE141(MACRO, R) MACRO(KAGUYA_PP_WHILE140(MACRO, R)) +#define KAGUYA_PP_WHILE142(MACRO, R) MACRO(KAGUYA_PP_WHILE141(MACRO, R)) +#define KAGUYA_PP_WHILE143(MACRO, R) MACRO(KAGUYA_PP_WHILE142(MACRO, R)) +#define KAGUYA_PP_WHILE144(MACRO, R) MACRO(KAGUYA_PP_WHILE143(MACRO, R)) +#define KAGUYA_PP_WHILE145(MACRO, R) MACRO(KAGUYA_PP_WHILE144(MACRO, R)) +#define KAGUYA_PP_WHILE146(MACRO, R) MACRO(KAGUYA_PP_WHILE145(MACRO, R)) +#define KAGUYA_PP_WHILE147(MACRO, R) MACRO(KAGUYA_PP_WHILE146(MACRO, R)) +#define KAGUYA_PP_WHILE148(MACRO, R) MACRO(KAGUYA_PP_WHILE147(MACRO, R)) +#define KAGUYA_PP_WHILE149(MACRO, R) MACRO(KAGUYA_PP_WHILE148(MACRO, R)) +#define KAGUYA_PP_WHILE150(MACRO, R) MACRO(KAGUYA_PP_WHILE149(MACRO, R)) +#define KAGUYA_PP_WHILE151(MACRO, R) MACRO(KAGUYA_PP_WHILE150(MACRO, R)) +#define KAGUYA_PP_WHILE152(MACRO, R) MACRO(KAGUYA_PP_WHILE151(MACRO, R)) +#define KAGUYA_PP_WHILE153(MACRO, R) MACRO(KAGUYA_PP_WHILE152(MACRO, R)) +#define KAGUYA_PP_WHILE154(MACRO, R) MACRO(KAGUYA_PP_WHILE153(MACRO, R)) +#define KAGUYA_PP_WHILE155(MACRO, R) MACRO(KAGUYA_PP_WHILE154(MACRO, R)) +#define KAGUYA_PP_WHILE156(MACRO, R) MACRO(KAGUYA_PP_WHILE155(MACRO, R)) +#define KAGUYA_PP_WHILE157(MACRO, R) MACRO(KAGUYA_PP_WHILE156(MACRO, R)) +#define KAGUYA_PP_WHILE158(MACRO, R) MACRO(KAGUYA_PP_WHILE157(MACRO, R)) +#define KAGUYA_PP_WHILE159(MACRO, R) MACRO(KAGUYA_PP_WHILE158(MACRO, R)) +#define KAGUYA_PP_WHILE160(MACRO, R) MACRO(KAGUYA_PP_WHILE159(MACRO, R)) +#define KAGUYA_PP_WHILE161(MACRO, R) MACRO(KAGUYA_PP_WHILE160(MACRO, R)) +#define KAGUYA_PP_WHILE162(MACRO, R) MACRO(KAGUYA_PP_WHILE161(MACRO, R)) +#define KAGUYA_PP_WHILE163(MACRO, R) MACRO(KAGUYA_PP_WHILE162(MACRO, R)) +#define KAGUYA_PP_WHILE164(MACRO, R) MACRO(KAGUYA_PP_WHILE163(MACRO, R)) +#define KAGUYA_PP_WHILE165(MACRO, R) MACRO(KAGUYA_PP_WHILE164(MACRO, R)) +#define KAGUYA_PP_WHILE166(MACRO, R) MACRO(KAGUYA_PP_WHILE165(MACRO, R)) +#define KAGUYA_PP_WHILE167(MACRO, R) MACRO(KAGUYA_PP_WHILE166(MACRO, R)) +#define KAGUYA_PP_WHILE168(MACRO, R) MACRO(KAGUYA_PP_WHILE167(MACRO, R)) +#define KAGUYA_PP_WHILE169(MACRO, R) MACRO(KAGUYA_PP_WHILE168(MACRO, R)) +#define KAGUYA_PP_WHILE170(MACRO, R) MACRO(KAGUYA_PP_WHILE169(MACRO, R)) +#define KAGUYA_PP_WHILE171(MACRO, R) MACRO(KAGUYA_PP_WHILE170(MACRO, R)) +#define KAGUYA_PP_WHILE172(MACRO, R) MACRO(KAGUYA_PP_WHILE171(MACRO, R)) +#define KAGUYA_PP_WHILE173(MACRO, R) MACRO(KAGUYA_PP_WHILE172(MACRO, R)) +#define KAGUYA_PP_WHILE174(MACRO, R) MACRO(KAGUYA_PP_WHILE173(MACRO, R)) +#define KAGUYA_PP_WHILE175(MACRO, R) MACRO(KAGUYA_PP_WHILE174(MACRO, R)) +#define KAGUYA_PP_WHILE176(MACRO, R) MACRO(KAGUYA_PP_WHILE175(MACRO, R)) +#define KAGUYA_PP_WHILE177(MACRO, R) MACRO(KAGUYA_PP_WHILE176(MACRO, R)) +#define KAGUYA_PP_WHILE178(MACRO, R) MACRO(KAGUYA_PP_WHILE177(MACRO, R)) +#define KAGUYA_PP_WHILE179(MACRO, R) MACRO(KAGUYA_PP_WHILE178(MACRO, R)) +#define KAGUYA_PP_WHILE180(MACRO, R) MACRO(KAGUYA_PP_WHILE179(MACRO, R)) +#define KAGUYA_PP_WHILE181(MACRO, R) MACRO(KAGUYA_PP_WHILE180(MACRO, R)) +#define KAGUYA_PP_WHILE182(MACRO, R) MACRO(KAGUYA_PP_WHILE181(MACRO, R)) +#define KAGUYA_PP_WHILE183(MACRO, R) MACRO(KAGUYA_PP_WHILE182(MACRO, R)) +#define KAGUYA_PP_WHILE184(MACRO, R) MACRO(KAGUYA_PP_WHILE183(MACRO, R)) +#define KAGUYA_PP_WHILE185(MACRO, R) MACRO(KAGUYA_PP_WHILE184(MACRO, R)) +#define KAGUYA_PP_WHILE186(MACRO, R) MACRO(KAGUYA_PP_WHILE185(MACRO, R)) +#define KAGUYA_PP_WHILE187(MACRO, R) MACRO(KAGUYA_PP_WHILE186(MACRO, R)) +#define KAGUYA_PP_WHILE188(MACRO, R) MACRO(KAGUYA_PP_WHILE187(MACRO, R)) +#define KAGUYA_PP_WHILE189(MACRO, R) MACRO(KAGUYA_PP_WHILE188(MACRO, R)) +#define KAGUYA_PP_WHILE190(MACRO, R) MACRO(KAGUYA_PP_WHILE189(MACRO, R)) +#define KAGUYA_PP_WHILE191(MACRO, R) MACRO(KAGUYA_PP_WHILE190(MACRO, R)) +#define KAGUYA_PP_WHILE192(MACRO, R) MACRO(KAGUYA_PP_WHILE191(MACRO, R)) +#define KAGUYA_PP_WHILE193(MACRO, R) MACRO(KAGUYA_PP_WHILE192(MACRO, R)) +#define KAGUYA_PP_WHILE194(MACRO, R) MACRO(KAGUYA_PP_WHILE193(MACRO, R)) +#define KAGUYA_PP_WHILE195(MACRO, R) MACRO(KAGUYA_PP_WHILE194(MACRO, R)) +#define KAGUYA_PP_WHILE196(MACRO, R) MACRO(KAGUYA_PP_WHILE195(MACRO, R)) +#define KAGUYA_PP_WHILE197(MACRO, R) MACRO(KAGUYA_PP_WHILE196(MACRO, R)) +#define KAGUYA_PP_WHILE198(MACRO, R) MACRO(KAGUYA_PP_WHILE197(MACRO, R)) +#define KAGUYA_PP_WHILE199(MACRO, R) MACRO(KAGUYA_PP_WHILE198(MACRO, R)) +#define KAGUYA_PP_WHILE200(MACRO, R) MACRO(KAGUYA_PP_WHILE199(MACRO, R)) +#define KAGUYA_PP_WHILE201(MACRO, R) MACRO(KAGUYA_PP_WHILE200(MACRO, R)) +#define KAGUYA_PP_WHILE202(MACRO, R) MACRO(KAGUYA_PP_WHILE201(MACRO, R)) +#define KAGUYA_PP_WHILE203(MACRO, R) MACRO(KAGUYA_PP_WHILE202(MACRO, R)) +#define KAGUYA_PP_WHILE204(MACRO, R) MACRO(KAGUYA_PP_WHILE203(MACRO, R)) +#define KAGUYA_PP_WHILE205(MACRO, R) MACRO(KAGUYA_PP_WHILE204(MACRO, R)) +#define KAGUYA_PP_WHILE206(MACRO, R) MACRO(KAGUYA_PP_WHILE205(MACRO, R)) +#define KAGUYA_PP_WHILE207(MACRO, R) MACRO(KAGUYA_PP_WHILE206(MACRO, R)) +#define KAGUYA_PP_WHILE208(MACRO, R) MACRO(KAGUYA_PP_WHILE207(MACRO, R)) +#define KAGUYA_PP_WHILE209(MACRO, R) MACRO(KAGUYA_PP_WHILE208(MACRO, R)) +#define KAGUYA_PP_WHILE210(MACRO, R) MACRO(KAGUYA_PP_WHILE209(MACRO, R)) +#define KAGUYA_PP_WHILE211(MACRO, R) MACRO(KAGUYA_PP_WHILE210(MACRO, R)) +#define KAGUYA_PP_WHILE212(MACRO, R) MACRO(KAGUYA_PP_WHILE211(MACRO, R)) +#define KAGUYA_PP_WHILE213(MACRO, R) MACRO(KAGUYA_PP_WHILE212(MACRO, R)) +#define KAGUYA_PP_WHILE214(MACRO, R) MACRO(KAGUYA_PP_WHILE213(MACRO, R)) +#define KAGUYA_PP_WHILE215(MACRO, R) MACRO(KAGUYA_PP_WHILE214(MACRO, R)) +#define KAGUYA_PP_WHILE216(MACRO, R) MACRO(KAGUYA_PP_WHILE215(MACRO, R)) +#define KAGUYA_PP_WHILE217(MACRO, R) MACRO(KAGUYA_PP_WHILE216(MACRO, R)) +#define KAGUYA_PP_WHILE218(MACRO, R) MACRO(KAGUYA_PP_WHILE217(MACRO, R)) +#define KAGUYA_PP_WHILE219(MACRO, R) MACRO(KAGUYA_PP_WHILE218(MACRO, R)) +#define KAGUYA_PP_WHILE220(MACRO, R) MACRO(KAGUYA_PP_WHILE219(MACRO, R)) +#define KAGUYA_PP_WHILE221(MACRO, R) MACRO(KAGUYA_PP_WHILE220(MACRO, R)) +#define KAGUYA_PP_WHILE222(MACRO, R) MACRO(KAGUYA_PP_WHILE221(MACRO, R)) +#define KAGUYA_PP_WHILE223(MACRO, R) MACRO(KAGUYA_PP_WHILE222(MACRO, R)) +#define KAGUYA_PP_WHILE224(MACRO, R) MACRO(KAGUYA_PP_WHILE223(MACRO, R)) +#define KAGUYA_PP_WHILE225(MACRO, R) MACRO(KAGUYA_PP_WHILE224(MACRO, R)) +#define KAGUYA_PP_WHILE226(MACRO, R) MACRO(KAGUYA_PP_WHILE225(MACRO, R)) +#define KAGUYA_PP_WHILE227(MACRO, R) MACRO(KAGUYA_PP_WHILE226(MACRO, R)) +#define KAGUYA_PP_WHILE228(MACRO, R) MACRO(KAGUYA_PP_WHILE227(MACRO, R)) +#define KAGUYA_PP_WHILE229(MACRO, R) MACRO(KAGUYA_PP_WHILE228(MACRO, R)) +#define KAGUYA_PP_WHILE230(MACRO, R) MACRO(KAGUYA_PP_WHILE229(MACRO, R)) +#define KAGUYA_PP_WHILE231(MACRO, R) MACRO(KAGUYA_PP_WHILE230(MACRO, R)) +#define KAGUYA_PP_WHILE232(MACRO, R) MACRO(KAGUYA_PP_WHILE231(MACRO, R)) +#define KAGUYA_PP_WHILE233(MACRO, R) MACRO(KAGUYA_PP_WHILE232(MACRO, R)) +#define KAGUYA_PP_WHILE234(MACRO, R) MACRO(KAGUYA_PP_WHILE233(MACRO, R)) +#define KAGUYA_PP_WHILE235(MACRO, R) MACRO(KAGUYA_PP_WHILE234(MACRO, R)) +#define KAGUYA_PP_WHILE236(MACRO, R) MACRO(KAGUYA_PP_WHILE235(MACRO, R)) +#define KAGUYA_PP_WHILE237(MACRO, R) MACRO(KAGUYA_PP_WHILE236(MACRO, R)) +#define KAGUYA_PP_WHILE238(MACRO, R) MACRO(KAGUYA_PP_WHILE237(MACRO, R)) +#define KAGUYA_PP_WHILE239(MACRO, R) MACRO(KAGUYA_PP_WHILE238(MACRO, R)) +#define KAGUYA_PP_WHILE240(MACRO, R) MACRO(KAGUYA_PP_WHILE239(MACRO, R)) +#define KAGUYA_PP_WHILE241(MACRO, R) MACRO(KAGUYA_PP_WHILE240(MACRO, R)) +#define KAGUYA_PP_WHILE242(MACRO, R) MACRO(KAGUYA_PP_WHILE241(MACRO, R)) +#define KAGUYA_PP_WHILE243(MACRO, R) MACRO(KAGUYA_PP_WHILE242(MACRO, R)) +#define KAGUYA_PP_WHILE244(MACRO, R) MACRO(KAGUYA_PP_WHILE243(MACRO, R)) +#define KAGUYA_PP_WHILE245(MACRO, R) MACRO(KAGUYA_PP_WHILE244(MACRO, R)) +#define KAGUYA_PP_WHILE246(MACRO, R) MACRO(KAGUYA_PP_WHILE245(MACRO, R)) +#define KAGUYA_PP_WHILE247(MACRO, R) MACRO(KAGUYA_PP_WHILE246(MACRO, R)) +#define KAGUYA_PP_WHILE248(MACRO, R) MACRO(KAGUYA_PP_WHILE247(MACRO, R)) +#define KAGUYA_PP_WHILE249(MACRO, R) MACRO(KAGUYA_PP_WHILE248(MACRO, R)) +#define KAGUYA_PP_WHILE250(MACRO, R) MACRO(KAGUYA_PP_WHILE249(MACRO, R)) +#define KAGUYA_PP_WHILE251(MACRO, R) MACRO(KAGUYA_PP_WHILE250(MACRO, R)) +#define KAGUYA_PP_WHILE252(MACRO, R) MACRO(KAGUYA_PP_WHILE251(MACRO, R)) +#define KAGUYA_PP_WHILE253(MACRO, R) MACRO(KAGUYA_PP_WHILE252(MACRO, R)) +#define KAGUYA_PP_WHILE254(MACRO, R) MACRO(KAGUYA_PP_WHILE253(MACRO, R)) +#define KAGUYA_PP_WHILE(COUNT, R, MACRO) \ + KAGUYA_PP_CAT(KAGUYA_PP_WHILE, COUNT)(MACRO, R) + +#define KAGUYA_PP_INC0 1 +#define KAGUYA_PP_INC1 2 +#define KAGUYA_PP_INC2 3 +#define KAGUYA_PP_INC3 4 +#define KAGUYA_PP_INC4 5 +#define KAGUYA_PP_INC5 6 +#define KAGUYA_PP_INC6 7 +#define KAGUYA_PP_INC7 8 +#define KAGUYA_PP_INC8 9 +#define KAGUYA_PP_INC9 10 +#define KAGUYA_PP_INC10 11 +#define KAGUYA_PP_INC11 12 +#define KAGUYA_PP_INC12 13 +#define KAGUYA_PP_INC13 14 +#define KAGUYA_PP_INC14 15 +#define KAGUYA_PP_INC15 16 +#define KAGUYA_PP_INC16 17 +#define KAGUYA_PP_INC17 18 +#define KAGUYA_PP_INC18 19 +#define KAGUYA_PP_INC19 20 +#define KAGUYA_PP_INC20 21 +#define KAGUYA_PP_INC21 22 +#define KAGUYA_PP_INC22 23 +#define KAGUYA_PP_INC23 24 +#define KAGUYA_PP_INC24 25 +#define KAGUYA_PP_INC25 26 +#define KAGUYA_PP_INC26 27 +#define KAGUYA_PP_INC27 28 +#define KAGUYA_PP_INC28 29 +#define KAGUYA_PP_INC29 30 +#define KAGUYA_PP_INC30 31 +#define KAGUYA_PP_INC31 32 +#define KAGUYA_PP_INC32 33 +#define KAGUYA_PP_INC33 34 +#define KAGUYA_PP_INC34 35 +#define KAGUYA_PP_INC35 36 +#define KAGUYA_PP_INC36 37 +#define KAGUYA_PP_INC37 38 +#define KAGUYA_PP_INC38 39 +#define KAGUYA_PP_INC39 40 +#define KAGUYA_PP_INC40 41 +#define KAGUYA_PP_INC41 42 +#define KAGUYA_PP_INC42 43 +#define KAGUYA_PP_INC43 44 +#define KAGUYA_PP_INC44 45 +#define KAGUYA_PP_INC45 46 +#define KAGUYA_PP_INC46 47 +#define KAGUYA_PP_INC47 48 +#define KAGUYA_PP_INC48 49 +#define KAGUYA_PP_INC49 50 +#define KAGUYA_PP_INC50 51 +#define KAGUYA_PP_INC51 52 +#define KAGUYA_PP_INC52 53 +#define KAGUYA_PP_INC53 54 +#define KAGUYA_PP_INC54 55 +#define KAGUYA_PP_INC55 56 +#define KAGUYA_PP_INC56 57 +#define KAGUYA_PP_INC57 58 +#define KAGUYA_PP_INC58 59 +#define KAGUYA_PP_INC59 60 +#define KAGUYA_PP_INC60 61 +#define KAGUYA_PP_INC61 62 +#define KAGUYA_PP_INC62 63 +#define KAGUYA_PP_INC63 64 +#define KAGUYA_PP_INC64 65 +#define KAGUYA_PP_INC65 66 +#define KAGUYA_PP_INC66 67 +#define KAGUYA_PP_INC67 68 +#define KAGUYA_PP_INC68 69 +#define KAGUYA_PP_INC69 70 +#define KAGUYA_PP_INC70 71 +#define KAGUYA_PP_INC71 72 +#define KAGUYA_PP_INC72 73 +#define KAGUYA_PP_INC73 74 +#define KAGUYA_PP_INC74 75 +#define KAGUYA_PP_INC75 76 +#define KAGUYA_PP_INC76 77 +#define KAGUYA_PP_INC77 78 +#define KAGUYA_PP_INC78 79 +#define KAGUYA_PP_INC79 80 +#define KAGUYA_PP_INC80 81 +#define KAGUYA_PP_INC81 82 +#define KAGUYA_PP_INC82 83 +#define KAGUYA_PP_INC83 84 +#define KAGUYA_PP_INC84 85 +#define KAGUYA_PP_INC85 86 +#define KAGUYA_PP_INC86 87 +#define KAGUYA_PP_INC87 88 +#define KAGUYA_PP_INC88 89 +#define KAGUYA_PP_INC89 90 +#define KAGUYA_PP_INC90 91 +#define KAGUYA_PP_INC91 92 +#define KAGUYA_PP_INC92 93 +#define KAGUYA_PP_INC93 94 +#define KAGUYA_PP_INC94 95 +#define KAGUYA_PP_INC95 96 +#define KAGUYA_PP_INC96 97 +#define KAGUYA_PP_INC97 98 +#define KAGUYA_PP_INC98 99 +#define KAGUYA_PP_INC99 100 +#define KAGUYA_PP_INC100 101 +#define KAGUYA_PP_INC101 102 +#define KAGUYA_PP_INC102 103 +#define KAGUYA_PP_INC103 104 +#define KAGUYA_PP_INC104 105 +#define KAGUYA_PP_INC105 106 +#define KAGUYA_PP_INC106 107 +#define KAGUYA_PP_INC107 108 +#define KAGUYA_PP_INC108 109 +#define KAGUYA_PP_INC109 110 +#define KAGUYA_PP_INC110 111 +#define KAGUYA_PP_INC111 112 +#define KAGUYA_PP_INC112 113 +#define KAGUYA_PP_INC113 114 +#define KAGUYA_PP_INC114 115 +#define KAGUYA_PP_INC115 116 +#define KAGUYA_PP_INC116 117 +#define KAGUYA_PP_INC117 118 +#define KAGUYA_PP_INC118 119 +#define KAGUYA_PP_INC119 120 +#define KAGUYA_PP_INC120 121 +#define KAGUYA_PP_INC121 122 +#define KAGUYA_PP_INC122 123 +#define KAGUYA_PP_INC123 124 +#define KAGUYA_PP_INC124 125 +#define KAGUYA_PP_INC125 126 +#define KAGUYA_PP_INC126 127 +#define KAGUYA_PP_INC127 128 +#define KAGUYA_PP_INC128 129 +#define KAGUYA_PP_INC129 130 +#define KAGUYA_PP_INC130 131 +#define KAGUYA_PP_INC131 132 +#define KAGUYA_PP_INC132 133 +#define KAGUYA_PP_INC133 134 +#define KAGUYA_PP_INC134 135 +#define KAGUYA_PP_INC135 136 +#define KAGUYA_PP_INC136 137 +#define KAGUYA_PP_INC137 138 +#define KAGUYA_PP_INC138 139 +#define KAGUYA_PP_INC139 140 +#define KAGUYA_PP_INC140 141 +#define KAGUYA_PP_INC141 142 +#define KAGUYA_PP_INC142 143 +#define KAGUYA_PP_INC143 144 +#define KAGUYA_PP_INC144 145 +#define KAGUYA_PP_INC145 146 +#define KAGUYA_PP_INC146 147 +#define KAGUYA_PP_INC147 148 +#define KAGUYA_PP_INC148 149 +#define KAGUYA_PP_INC149 150 +#define KAGUYA_PP_INC150 151 +#define KAGUYA_PP_INC151 152 +#define KAGUYA_PP_INC152 153 +#define KAGUYA_PP_INC153 154 +#define KAGUYA_PP_INC154 155 +#define KAGUYA_PP_INC155 156 +#define KAGUYA_PP_INC156 157 +#define KAGUYA_PP_INC157 158 +#define KAGUYA_PP_INC158 159 +#define KAGUYA_PP_INC159 160 +#define KAGUYA_PP_INC160 161 +#define KAGUYA_PP_INC161 162 +#define KAGUYA_PP_INC162 163 +#define KAGUYA_PP_INC163 164 +#define KAGUYA_PP_INC164 165 +#define KAGUYA_PP_INC165 166 +#define KAGUYA_PP_INC166 167 +#define KAGUYA_PP_INC167 168 +#define KAGUYA_PP_INC168 169 +#define KAGUYA_PP_INC169 170 +#define KAGUYA_PP_INC170 171 +#define KAGUYA_PP_INC171 172 +#define KAGUYA_PP_INC172 173 +#define KAGUYA_PP_INC173 174 +#define KAGUYA_PP_INC174 175 +#define KAGUYA_PP_INC175 176 +#define KAGUYA_PP_INC176 177 +#define KAGUYA_PP_INC177 178 +#define KAGUYA_PP_INC178 179 +#define KAGUYA_PP_INC179 180 +#define KAGUYA_PP_INC180 181 +#define KAGUYA_PP_INC181 182 +#define KAGUYA_PP_INC182 183 +#define KAGUYA_PP_INC183 184 +#define KAGUYA_PP_INC184 185 +#define KAGUYA_PP_INC185 186 +#define KAGUYA_PP_INC186 187 +#define KAGUYA_PP_INC187 188 +#define KAGUYA_PP_INC188 189 +#define KAGUYA_PP_INC189 190 +#define KAGUYA_PP_INC190 191 +#define KAGUYA_PP_INC191 192 +#define KAGUYA_PP_INC192 193 +#define KAGUYA_PP_INC193 194 +#define KAGUYA_PP_INC194 195 +#define KAGUYA_PP_INC195 196 +#define KAGUYA_PP_INC196 197 +#define KAGUYA_PP_INC197 198 +#define KAGUYA_PP_INC198 199 +#define KAGUYA_PP_INC199 200 +#define KAGUYA_PP_INC200 201 +#define KAGUYA_PP_INC201 202 +#define KAGUYA_PP_INC202 203 +#define KAGUYA_PP_INC203 204 +#define KAGUYA_PP_INC204 205 +#define KAGUYA_PP_INC205 206 +#define KAGUYA_PP_INC206 207 +#define KAGUYA_PP_INC207 208 +#define KAGUYA_PP_INC208 209 +#define KAGUYA_PP_INC209 210 +#define KAGUYA_PP_INC210 211 +#define KAGUYA_PP_INC211 212 +#define KAGUYA_PP_INC212 213 +#define KAGUYA_PP_INC213 214 +#define KAGUYA_PP_INC214 215 +#define KAGUYA_PP_INC215 216 +#define KAGUYA_PP_INC216 217 +#define KAGUYA_PP_INC217 218 +#define KAGUYA_PP_INC218 219 +#define KAGUYA_PP_INC219 220 +#define KAGUYA_PP_INC220 221 +#define KAGUYA_PP_INC221 222 +#define KAGUYA_PP_INC222 223 +#define KAGUYA_PP_INC223 224 +#define KAGUYA_PP_INC224 225 +#define KAGUYA_PP_INC225 226 +#define KAGUYA_PP_INC226 227 +#define KAGUYA_PP_INC227 228 +#define KAGUYA_PP_INC228 229 +#define KAGUYA_PP_INC229 230 +#define KAGUYA_PP_INC230 231 +#define KAGUYA_PP_INC231 232 +#define KAGUYA_PP_INC232 233 +#define KAGUYA_PP_INC233 234 +#define KAGUYA_PP_INC234 235 +#define KAGUYA_PP_INC235 236 +#define KAGUYA_PP_INC236 237 +#define KAGUYA_PP_INC237 238 +#define KAGUYA_PP_INC238 239 +#define KAGUYA_PP_INC239 240 +#define KAGUYA_PP_INC240 241 +#define KAGUYA_PP_INC241 242 +#define KAGUYA_PP_INC242 243 +#define KAGUYA_PP_INC243 244 +#define KAGUYA_PP_INC244 245 +#define KAGUYA_PP_INC245 246 +#define KAGUYA_PP_INC246 247 +#define KAGUYA_PP_INC247 248 +#define KAGUYA_PP_INC248 249 +#define KAGUYA_PP_INC249 250 +#define KAGUYA_PP_INC250 251 +#define KAGUYA_PP_INC251 252 +#define KAGUYA_PP_INC252 253 +#define KAGUYA_PP_INC253 254 +#define KAGUYA_PP_INC254 255 +#define KAGUYA_PP_INC(N) KAGUYA_PP_CAT(KAGUYA_PP_INC, N) + +#define KAGUYA_PP_DEC1 0 +#define KAGUYA_PP_DEC2 1 +#define KAGUYA_PP_DEC3 2 +#define KAGUYA_PP_DEC4 3 +#define KAGUYA_PP_DEC5 4 +#define KAGUYA_PP_DEC6 5 +#define KAGUYA_PP_DEC7 6 +#define KAGUYA_PP_DEC8 7 +#define KAGUYA_PP_DEC9 8 +#define KAGUYA_PP_DEC10 9 +#define KAGUYA_PP_DEC11 10 +#define KAGUYA_PP_DEC12 11 +#define KAGUYA_PP_DEC13 12 +#define KAGUYA_PP_DEC14 13 +#define KAGUYA_PP_DEC15 14 +#define KAGUYA_PP_DEC16 15 +#define KAGUYA_PP_DEC17 16 +#define KAGUYA_PP_DEC18 17 +#define KAGUYA_PP_DEC19 18 +#define KAGUYA_PP_DEC20 19 +#define KAGUYA_PP_DEC21 20 +#define KAGUYA_PP_DEC22 21 +#define KAGUYA_PP_DEC23 22 +#define KAGUYA_PP_DEC24 23 +#define KAGUYA_PP_DEC25 24 +#define KAGUYA_PP_DEC26 25 +#define KAGUYA_PP_DEC27 26 +#define KAGUYA_PP_DEC28 27 +#define KAGUYA_PP_DEC29 28 +#define KAGUYA_PP_DEC30 29 +#define KAGUYA_PP_DEC31 30 +#define KAGUYA_PP_DEC32 31 +#define KAGUYA_PP_DEC33 32 +#define KAGUYA_PP_DEC34 33 +#define KAGUYA_PP_DEC35 34 +#define KAGUYA_PP_DEC36 35 +#define KAGUYA_PP_DEC37 36 +#define KAGUYA_PP_DEC38 37 +#define KAGUYA_PP_DEC39 38 +#define KAGUYA_PP_DEC40 39 +#define KAGUYA_PP_DEC41 40 +#define KAGUYA_PP_DEC42 41 +#define KAGUYA_PP_DEC43 42 +#define KAGUYA_PP_DEC44 43 +#define KAGUYA_PP_DEC45 44 +#define KAGUYA_PP_DEC46 45 +#define KAGUYA_PP_DEC47 46 +#define KAGUYA_PP_DEC48 47 +#define KAGUYA_PP_DEC49 48 +#define KAGUYA_PP_DEC50 49 +#define KAGUYA_PP_DEC51 50 +#define KAGUYA_PP_DEC52 51 +#define KAGUYA_PP_DEC53 52 +#define KAGUYA_PP_DEC54 53 +#define KAGUYA_PP_DEC55 54 +#define KAGUYA_PP_DEC56 55 +#define KAGUYA_PP_DEC57 56 +#define KAGUYA_PP_DEC58 57 +#define KAGUYA_PP_DEC59 58 +#define KAGUYA_PP_DEC60 59 +#define KAGUYA_PP_DEC61 60 +#define KAGUYA_PP_DEC62 61 +#define KAGUYA_PP_DEC63 62 +#define KAGUYA_PP_DEC64 63 +#define KAGUYA_PP_DEC65 64 +#define KAGUYA_PP_DEC66 65 +#define KAGUYA_PP_DEC67 66 +#define KAGUYA_PP_DEC68 67 +#define KAGUYA_PP_DEC69 68 +#define KAGUYA_PP_DEC70 69 +#define KAGUYA_PP_DEC71 70 +#define KAGUYA_PP_DEC72 71 +#define KAGUYA_PP_DEC73 72 +#define KAGUYA_PP_DEC74 73 +#define KAGUYA_PP_DEC75 74 +#define KAGUYA_PP_DEC76 75 +#define KAGUYA_PP_DEC77 76 +#define KAGUYA_PP_DEC78 77 +#define KAGUYA_PP_DEC79 78 +#define KAGUYA_PP_DEC80 79 +#define KAGUYA_PP_DEC81 80 +#define KAGUYA_PP_DEC82 81 +#define KAGUYA_PP_DEC83 82 +#define KAGUYA_PP_DEC84 83 +#define KAGUYA_PP_DEC85 84 +#define KAGUYA_PP_DEC86 85 +#define KAGUYA_PP_DEC87 86 +#define KAGUYA_PP_DEC88 87 +#define KAGUYA_PP_DEC89 88 +#define KAGUYA_PP_DEC90 89 +#define KAGUYA_PP_DEC91 90 +#define KAGUYA_PP_DEC92 91 +#define KAGUYA_PP_DEC93 92 +#define KAGUYA_PP_DEC94 93 +#define KAGUYA_PP_DEC95 94 +#define KAGUYA_PP_DEC96 95 +#define KAGUYA_PP_DEC97 96 +#define KAGUYA_PP_DEC98 97 +#define KAGUYA_PP_DEC99 98 +#define KAGUYA_PP_DEC100 99 +#define KAGUYA_PP_DEC101 100 +#define KAGUYA_PP_DEC102 101 +#define KAGUYA_PP_DEC103 102 +#define KAGUYA_PP_DEC104 103 +#define KAGUYA_PP_DEC105 104 +#define KAGUYA_PP_DEC106 105 +#define KAGUYA_PP_DEC107 106 +#define KAGUYA_PP_DEC108 107 +#define KAGUYA_PP_DEC109 108 +#define KAGUYA_PP_DEC110 109 +#define KAGUYA_PP_DEC111 110 +#define KAGUYA_PP_DEC112 111 +#define KAGUYA_PP_DEC113 112 +#define KAGUYA_PP_DEC114 113 +#define KAGUYA_PP_DEC115 114 +#define KAGUYA_PP_DEC116 115 +#define KAGUYA_PP_DEC117 116 +#define KAGUYA_PP_DEC118 117 +#define KAGUYA_PP_DEC119 118 +#define KAGUYA_PP_DEC120 119 +#define KAGUYA_PP_DEC121 120 +#define KAGUYA_PP_DEC122 121 +#define KAGUYA_PP_DEC123 122 +#define KAGUYA_PP_DEC124 123 +#define KAGUYA_PP_DEC125 124 +#define KAGUYA_PP_DEC126 125 +#define KAGUYA_PP_DEC127 126 +#define KAGUYA_PP_DEC128 127 +#define KAGUYA_PP_DEC129 128 +#define KAGUYA_PP_DEC130 129 +#define KAGUYA_PP_DEC131 130 +#define KAGUYA_PP_DEC132 131 +#define KAGUYA_PP_DEC133 132 +#define KAGUYA_PP_DEC134 133 +#define KAGUYA_PP_DEC135 134 +#define KAGUYA_PP_DEC136 135 +#define KAGUYA_PP_DEC137 136 +#define KAGUYA_PP_DEC138 137 +#define KAGUYA_PP_DEC139 138 +#define KAGUYA_PP_DEC140 139 +#define KAGUYA_PP_DEC141 140 +#define KAGUYA_PP_DEC142 141 +#define KAGUYA_PP_DEC143 142 +#define KAGUYA_PP_DEC144 143 +#define KAGUYA_PP_DEC145 144 +#define KAGUYA_PP_DEC146 145 +#define KAGUYA_PP_DEC147 146 +#define KAGUYA_PP_DEC148 147 +#define KAGUYA_PP_DEC149 148 +#define KAGUYA_PP_DEC150 149 +#define KAGUYA_PP_DEC151 150 +#define KAGUYA_PP_DEC152 151 +#define KAGUYA_PP_DEC153 152 +#define KAGUYA_PP_DEC154 153 +#define KAGUYA_PP_DEC155 154 +#define KAGUYA_PP_DEC156 155 +#define KAGUYA_PP_DEC157 156 +#define KAGUYA_PP_DEC158 157 +#define KAGUYA_PP_DEC159 158 +#define KAGUYA_PP_DEC160 159 +#define KAGUYA_PP_DEC161 160 +#define KAGUYA_PP_DEC162 161 +#define KAGUYA_PP_DEC163 162 +#define KAGUYA_PP_DEC164 163 +#define KAGUYA_PP_DEC165 164 +#define KAGUYA_PP_DEC166 165 +#define KAGUYA_PP_DEC167 166 +#define KAGUYA_PP_DEC168 167 +#define KAGUYA_PP_DEC169 168 +#define KAGUYA_PP_DEC170 169 +#define KAGUYA_PP_DEC171 170 +#define KAGUYA_PP_DEC172 171 +#define KAGUYA_PP_DEC173 172 +#define KAGUYA_PP_DEC174 173 +#define KAGUYA_PP_DEC175 174 +#define KAGUYA_PP_DEC176 175 +#define KAGUYA_PP_DEC177 176 +#define KAGUYA_PP_DEC178 177 +#define KAGUYA_PP_DEC179 178 +#define KAGUYA_PP_DEC180 179 +#define KAGUYA_PP_DEC181 180 +#define KAGUYA_PP_DEC182 181 +#define KAGUYA_PP_DEC183 182 +#define KAGUYA_PP_DEC184 183 +#define KAGUYA_PP_DEC185 184 +#define KAGUYA_PP_DEC186 185 +#define KAGUYA_PP_DEC187 186 +#define KAGUYA_PP_DEC188 187 +#define KAGUYA_PP_DEC189 188 +#define KAGUYA_PP_DEC190 189 +#define KAGUYA_PP_DEC191 190 +#define KAGUYA_PP_DEC192 191 +#define KAGUYA_PP_DEC193 192 +#define KAGUYA_PP_DEC194 193 +#define KAGUYA_PP_DEC195 194 +#define KAGUYA_PP_DEC196 195 +#define KAGUYA_PP_DEC197 196 +#define KAGUYA_PP_DEC198 197 +#define KAGUYA_PP_DEC199 198 +#define KAGUYA_PP_DEC200 199 +#define KAGUYA_PP_DEC201 200 +#define KAGUYA_PP_DEC202 201 +#define KAGUYA_PP_DEC203 202 +#define KAGUYA_PP_DEC204 203 +#define KAGUYA_PP_DEC205 204 +#define KAGUYA_PP_DEC206 205 +#define KAGUYA_PP_DEC207 206 +#define KAGUYA_PP_DEC208 207 +#define KAGUYA_PP_DEC209 208 +#define KAGUYA_PP_DEC210 209 +#define KAGUYA_PP_DEC211 210 +#define KAGUYA_PP_DEC212 211 +#define KAGUYA_PP_DEC213 212 +#define KAGUYA_PP_DEC214 213 +#define KAGUYA_PP_DEC215 214 +#define KAGUYA_PP_DEC216 215 +#define KAGUYA_PP_DEC217 216 +#define KAGUYA_PP_DEC218 217 +#define KAGUYA_PP_DEC219 218 +#define KAGUYA_PP_DEC220 219 +#define KAGUYA_PP_DEC221 220 +#define KAGUYA_PP_DEC222 221 +#define KAGUYA_PP_DEC223 222 +#define KAGUYA_PP_DEC224 223 +#define KAGUYA_PP_DEC225 224 +#define KAGUYA_PP_DEC226 225 +#define KAGUYA_PP_DEC227 226 +#define KAGUYA_PP_DEC228 227 +#define KAGUYA_PP_DEC229 228 +#define KAGUYA_PP_DEC230 229 +#define KAGUYA_PP_DEC231 230 +#define KAGUYA_PP_DEC232 231 +#define KAGUYA_PP_DEC233 232 +#define KAGUYA_PP_DEC234 233 +#define KAGUYA_PP_DEC235 234 +#define KAGUYA_PP_DEC236 235 +#define KAGUYA_PP_DEC237 236 +#define KAGUYA_PP_DEC238 237 +#define KAGUYA_PP_DEC239 238 +#define KAGUYA_PP_DEC240 239 +#define KAGUYA_PP_DEC241 240 +#define KAGUYA_PP_DEC242 241 +#define KAGUYA_PP_DEC243 242 +#define KAGUYA_PP_DEC244 243 +#define KAGUYA_PP_DEC245 244 +#define KAGUYA_PP_DEC246 245 +#define KAGUYA_PP_DEC247 246 +#define KAGUYA_PP_DEC248 247 +#define KAGUYA_PP_DEC249 248 +#define KAGUYA_PP_DEC250 249 +#define KAGUYA_PP_DEC251 250 +#define KAGUYA_PP_DEC252 251 +#define KAGUYA_PP_DEC253 252 +#define KAGUYA_PP_DEC254 253 +#define KAGUYA_PP_DEC(N) KAGUYA_PP_CAT(KAGUYA_PP_DEC, N) + +#define KAGUYA_PP_VARIADIC_TARG_CONCAT_REP(N) , KAGUYA_PP_CAT(A, N) +#define KAGUYA_PP_VARIADIC_TARG_REP(N) KAGUYA_PP_CAT(A, N) + +#define KAGUYA_PP_TEMPLATE_ARG_REPEAT_CONCAT(N) \ + KAGUYA_PP_REPEAT(N, KAGUYA_PP_VARIADIC_TARG_CONCAT_REP) +#define KAGUYA_PP_TEMPLATE_ARG_REPEAT(N) \ + KAGUYA_PP_REPEAT_ARG(N, KAGUYA_PP_VARIADIC_TARG_REP) + +#define KAGUYA_PP_ARG_DEF_CONCAT_REP(N) \ + , KAGUYA_PP_CAT(A, N) KAGUYA_PP_CAT(a, N) +#define KAGUYA_PP_ARG_DEF_REP(N) KAGUYA_PP_CAT(A, N) KAGUYA_PP_CAT(a, N) + +#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) + +#define KAGUYA_PP_ARG_REPEAT_CONCAT(N) \ + KAGUYA_PP_REPEAT(N, KAGUYA_PP_ARG_CONCAT_REP) +#define KAGUYA_PP_ARG_REPEAT(N) KAGUYA_PP_REPEAT_ARG(N, KAGUYA_PP_ARG_REP) + +#define KAGUYA_PP_VARIADIC_TDEF_CONCAT_REP(N) , KAGUYA_PP_CAT(typename A, N) +#define KAGUYA_PP_VARIADIC_TDEF_REP(N) KAGUYA_PP_CAT(typename A, N) + +#define KAGUYA_PP_TEMPLATE_DEF_REPEAT_CONCAT(N) \ + KAGUYA_PP_REPEAT(N, KAGUYA_PP_VARIADIC_TDEF_CONCAT_REP) +#define KAGUYA_PP_TEMPLATE_DEF_REPEAT(N) \ + KAGUYA_PP_REPEAT_ARG(N, KAGUYA_PP_VARIADIC_TDEF_REP) + +#define KAGUYA_PP_ADD(X, Y) KAGUYA_PP_WHILE(Y, X, KAGUYA_PP_INC) +#define KAGUYA_PP_SUB(X, Y) KAGUYA_PP_WHILE(Y, X, KAGUYA_PP_DEC) +// Copyright satoren +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + + +#include +#include + +namespace kaguya { +class LuaException : public std::exception { + int status_; + std::string what_; + const char *what_c_; + +public: + LuaException(int status, const char *what) throw() + : status_(status), what_c_(what) {} + LuaException(int status, const std::string &what) + : status_(status), what_(what), what_c_(0) {} + int status() const throw() { return status_; } + const char *what() const throw() { return what_c_ ? what_c_ : what_.c_str(); } + + ~LuaException() throw() {} +}; +class KaguyaException : public std::exception { + std::string what_; + const char *what_c_; + +public: + KaguyaException(const char *what) throw() : what_c_(what) {} + KaguyaException(const std::string &what) : what_(what), what_c_(0) {} + const char *what() const throw() { return what_c_ ? what_c_ : what_.c_str(); } + + ~KaguyaException() throw() {} +}; +class LuaTypeMismatch : public LuaException { +public: + LuaTypeMismatch() throw() : LuaException(0, "type mismatch!!") {} + LuaTypeMismatch(const char *what) throw() : LuaException(0, what) {} + LuaTypeMismatch(const std::string &what) : LuaException(0, what) {} +}; +class LuaMemoryError : public LuaException { +public: + LuaMemoryError(int status, const char *what) throw() + : LuaException(status, what) {} + LuaMemoryError(int status, const std::string &what) + : LuaException(status, what) {} +}; +class LuaRuntimeError : public LuaException { +public: + LuaRuntimeError(int status, const char *what) throw() + : LuaException(status, what) {} + LuaRuntimeError(int status, const std::string &what) + : LuaException(status, what) {} +}; +class LuaErrorRunningError : public LuaException { +public: + LuaErrorRunningError(int status, const char *what) throw() + : LuaException(status, what) {} + LuaErrorRunningError(int status, const std::string &what) + : LuaException(status, what) {} +}; +class LuaGCError : public LuaException { +public: + LuaGCError(int status, const char *what) throw() + : LuaException(status, what) {} + LuaGCError(int status, const std::string &what) + : LuaException(status, what) {} +}; +class LuaUnknownError : public LuaException { +public: + LuaUnknownError(int status, const char *what) throw() + : LuaException(status, what) {} + LuaUnknownError(int status, const std::string &what) + : LuaException(status, what) {} +}; + +class LuaSyntaxError : public LuaException { +public: + LuaSyntaxError(int status, const std::string &what) + : LuaException(status, what) {} +}; + +namespace except { +void OtherError(lua_State *state, const std::string &message); +void typeMismatchError(lua_State *state, const std::string &message); +void memoryError(lua_State *state, const char *message); +bool checkErrorAndThrow(int status, lua_State *state); +} +} + +#if KAGUYA_USE_CPP11 +// Copyright satoren +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include + + +namespace kaguya { +namespace util { +struct null_type {}; + +template struct TypeTuple {}; +template struct FunctionSignatureType { + typedef Ret result_type; + typedef TypeTuple argument_type_tuple; + static const size_t argument_count = sizeof...(Args); + typedef Ret (*c_function_type)(Args...); +}; +template struct FunctorSignature {}; + +template +struct FunctorSignature { + typedef FunctionSignatureType type; +}; +template +struct FunctorSignature { + typedef FunctionSignatureType type; +}; + +#if defined(_MSC_VER) && _MSC_VER < 1900 +template +struct FunctionSignature : public FunctorSignature {}; +#else + +template struct FunctionSignature; + +template +struct has_operator_fn : std::false_type {}; +template +struct has_operator_fn::value>::type> + : std::true_type {}; + +template +struct FunctionSignature< + T, typename std::enable_if::value>::type> + : public FunctorSignature {}; +#endif + +template +struct FunctionSignature { + typedef FunctionSignatureType type; +}; +template +struct FunctionSignature { + typedef FunctionSignatureType type; +}; + +#if defined(_MSC_VER) && _MSC_VER >= 1900 || defined(__cpp_ref_qualifiers) +template +struct FunctionSignature { + typedef FunctionSignatureType type; +}; +template +struct FunctionSignature { + typedef FunctionSignatureType type; +}; +#endif + +template struct FunctionSignature { + typedef FunctionSignatureType type; +}; +template struct FunctionSignature { + typedef FunctionSignatureType type; +}; + +template struct FunctionResultType { + typedef typename FunctionSignature::type::result_type type; +}; + +template +struct TypeIndexGet; + +template +struct TypeIndexGet, true> { + typedef Arg type; +}; + +template +struct TypeIndexGet, false> + : TypeIndexGet > {}; +template struct ArgumentType { + typedef typename TypeIndexGet< + N, typename FunctionSignature::type::argument_type_tuple>::type type; +}; + +namespace detail { +template +auto invoke_helper(F &&f, ThisType &&this_, Args &&... args) + -> decltype((std::forward(this_).* + f)(std::forward(args)...)) { + return (std::forward(this_).*f)(std::forward(args)...); +} + +template +auto invoke_helper(F &&f, Args &&... args) + -> decltype(f(std::forward(args)...)) { + return f(std::forward(args)...); +} +} +template +typename FunctionResultType::type>::type +invoke(F &&f, Args &&... args) { + return detail::invoke_helper(std::forward(f), std::forward(args)...); +} +} +} +#else +// Copyright satoren +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include + + +namespace kaguya { +namespace util { +///! +struct null_type {}; + +#define KAGUYA_PP_STRUCT_TDEF_REP(N) KAGUYA_PP_CAT(typename A, N) = null_type +#define KAGUYA_PP_STRUCT_TEMPLATE_DEF_REPEAT(N) \ + KAGUYA_PP_REPEAT_ARG(N, KAGUYA_PP_STRUCT_TDEF_REP) + +template +struct TypeTuple {}; + +template struct TypeTupleSize; + +#define KAGUYA_TYPE_TUPLE_SIZE_DEF(N) \ + template \ + struct TypeTupleSize > { \ + static const size_t value = N; \ + }; + +KAGUYA_TYPE_TUPLE_SIZE_DEF(0) +KAGUYA_PP_REPEAT_DEF(KAGUYA_FUNCTION_MAX_ARGS, KAGUYA_TYPE_TUPLE_SIZE_DEF) +#undef KAGUYA_TYPE_TUPLE_SIZE_DEF + +template struct CFuntionType; +#define KAGUYA_CFUNCTION_TYPE_DEF(N) \ + template \ + struct CFuntionType > { \ + typedef Ret (*type)(KAGUYA_PP_TEMPLATE_ARG_REPEAT(N)); \ + }; + +KAGUYA_CFUNCTION_TYPE_DEF(0) +KAGUYA_PP_REPEAT_DEF(KAGUYA_FUNCTION_MAX_ARGS, KAGUYA_CFUNCTION_TYPE_DEF) +#undef KAGUYA_CFUNCTION_TYPE_DEF + +template +struct FunctionSignatureType { + typedef Ret result_type; + typedef TypeTuple + argument_type_tuple; + static const size_t argument_count = + TypeTupleSize::value; + typedef typename CFuntionType::type c_function_type; +}; + +template struct FunctionSignature; + +#define KAGUYA_MEMBER_FUNCTION_SIGNATURE_DEF(N) \ + template \ + struct FunctionSignature { \ + typedef FunctionSignatureType \ + type; \ + }; \ + template \ + struct FunctionSignature { \ + typedef FunctionSignatureType< \ + Ret, const T & KAGUYA_PP_TEMPLATE_ARG_REPEAT_CONCAT(N)> \ + type; \ + }; + +#define KAGUYA_FUNCTION_SIGNATURE_DEF(N) \ + template \ + struct FunctionSignature { \ + typedef FunctionSignatureType \ + type; \ + }; \ + template \ + struct FunctionSignature { \ + typedef FunctionSignatureType \ + type; \ + }; \ + template \ + struct FunctionSignature< \ + standard::function > { \ + typedef FunctionSignatureType \ + type; \ + }; + +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_FUNCTION_SIGNATURE_DEF + +template struct FunctionResultType { + typedef typename FunctionSignature::type::result_type type; +}; + +template +struct TypeIndexGet {}; + +#define KAGUYA_TYPE_INDEX_GET_DEF(N) \ + template \ + struct TypeIndexGet< \ + remain, TypeTuple, true> { \ + typedef arg type; \ + }; \ + template \ + struct TypeIndexGet< \ + remain, TypeTuple, false> \ + : TypeIndexGet > {}; + +// 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 { + typedef typename TypeIndexGet< + N, typename FunctionSignature::type::argument_type_tuple>::type type; +}; + +namespace detail { + +#define KAGUYA_INVOKE_HELPER_DEF(N) \ + template \ + typename FunctionResultType::type invoke_helper( \ + typename FunctionResultType::type (T::*f)( \ + KAGUYA_PP_TEMPLATE_ARG_REPEAT(N)), \ + ThisType this_ KAGUYA_PP_ARG_DEF_REPEAT_CONCAT(N)) { \ + return (this_.*f)(KAGUYA_PP_ARG_REPEAT(N)); \ + } \ + template \ + typename FunctionResultType::type invoke_helper( \ + typename FunctionResultType::type (T::*f)( \ + KAGUYA_PP_TEMPLATE_ARG_REPEAT(N)) const, \ + ThisType this_ KAGUYA_PP_ARG_DEF_REPEAT_CONCAT(N)) { \ + return (this_.*f)(KAGUYA_PP_ARG_REPEAT(N)); \ + } \ + template \ + typename FunctionResultType::type invoke_helper( \ + F f KAGUYA_PP_ARG_DEF_REPEAT_CONCAT(N)) { \ + return f(KAGUYA_PP_ARG_REPEAT(N)); \ + } + +KAGUYA_INVOKE_HELPER_DEF(0) +KAGUYA_PP_REPEAT_DEF(KAGUYA_FUNCTION_MAX_ARGS, KAGUYA_INVOKE_HELPER_DEF) +#undef KAGUYA_INVOKE_HELPER_DEF +} + +#define KAGUYA_INVOKE_DEF(N) \ + template \ + typename FunctionResultType::type invoke( \ + F f KAGUYA_PP_ARG_DEF_REPEAT_CONCAT(N)) { \ + return detail::invoke_helper( \ + f KAGUYA_PP_ARG_REPEAT_CONCAT(N)); \ + } + +KAGUYA_INVOKE_DEF(0) +KAGUYA_PP_REPEAT_DEF(KAGUYA_FUNCTION_MAX_ARGS, KAGUYA_INVOKE_DEF) +#undef KAGUYA_INVOKE_DEF + +#undef KAGUYA_PP_STRUCT_TDEF_REP +#undef KAGUYA_PP_STRUCT_TEMPLATE_DEF_REPEAT +} +} +#endif + +namespace kaguya { +namespace util { +/// @brief save stack count and restore on destructor +class ScopedSavedStack { + lua_State *state_; + int saved_top_index_; + +public: + /// @brief save stack count + /// @param state + explicit ScopedSavedStack(lua_State *state) + : state_(state), saved_top_index_(state_ ? lua_gettop(state_) : 0) {} + + /// @brief save stack count + /// @param state + /// @param count stack count + explicit ScopedSavedStack(lua_State *state, int count) + : state_(state), saved_top_index_(count) {} + + /// @brief restore stack count + ~ScopedSavedStack() { + if (state_) { + lua_settop(state_, saved_top_index_); + } + } + +private: + ScopedSavedStack(ScopedSavedStack const &); + ScopedSavedStack &operator=(ScopedSavedStack const &); +}; +inline void traceBack(lua_State *state, const char *message, int level = 0) { +#if LUA_VERSION_NUM >= 502 + luaL_traceback(state, state, message, level); +#else + KAGUYA_UNUSED(level); + lua_pushstring(state, message); +#endif +} + +inline void stackDump(lua_State *L) { + int i; + int top = lua_gettop(L); + for (i = 1; i <= top; i++) { /* repeat for each level */ + int t = lua_type(L, i); + switch (t) { + + case LUA_TSTRING: /* strings */ + printf("`%s'", lua_tostring(L, i)); + break; + + case LUA_TBOOLEAN: /* booleans */ + printf(lua_toboolean(L, i) ? "true" : "false"); + break; + + case LUA_TNUMBER: /* numbers */ + printf("%g", lua_tonumber(L, i)); + break; + case LUA_TUSERDATA: + if (luaL_getmetafield(L, i, "__name") == LUA_TSTRING) { + printf("userdata:%s", lua_tostring(L, -1)); + lua_pop(L, 1); + break; + } + default: /* other values */ + printf("%s", lua_typename(L, t)); + break; + } + printf(" "); /* put a separator */ + } + printf("\n"); /* end the listing */ +} + +inline void stackValueDump(std::ostream &os, lua_State *state, int stackIndex, + int max_recursive = 2) { + stackIndex = lua_absindex(state, stackIndex); + util::ScopedSavedStack save(state); + int type = lua_type(state, stackIndex); + switch (type) { + case LUA_TNONE: + os << "none"; + break; + case LUA_TNIL: + os << "nil"; + break; + case LUA_TBOOLEAN: + os << ((lua_toboolean(state, stackIndex) != 0) ? "true" : "false"); + break; + case LUA_TNUMBER: + os << lua_tonumber(state, stackIndex); + break; + case LUA_TSTRING: + os << "'" << lua_tostring(state, stackIndex) << "'"; + break; + case LUA_TTABLE: { + os << "{"; + if (max_recursive <= 1) { + os << "..."; + } else { + lua_pushnil(state); + if ((lua_next(state, stackIndex) != 0)) { + stackValueDump(os, state, -2, max_recursive - 1); + os << "="; + stackValueDump(os, state, -1, max_recursive - 1); + lua_pop(state, 1); // pop value + + while (lua_next(state, stackIndex) != 0) { + os << ","; + stackValueDump(os, state, -2, max_recursive - 1); + os << "="; + stackValueDump(os, state, -1, max_recursive - 1); + lua_pop(state, 1); // pop value + } + } + } + os << "}"; + } break; + case LUA_TUSERDATA: + case LUA_TLIGHTUSERDATA: + case LUA_TTHREAD: + os << lua_typename(state, type) << "(" << lua_topointer(state, stackIndex) + << ")"; + break; + case LUA_TFUNCTION: + os << lua_typename(state, type); + break; + default: + os << "unknown type value"; + break; + } +} + +#if LUA_VERSION_NUM >= 502 +inline lua_State *toMainThread(lua_State *state) { + if (state) { + lua_rawgeti(state, LUA_REGISTRYINDEX, LUA_RIDX_MAINTHREAD); + lua_State *mainthread = lua_tothread(state, -1); + lua_pop(state, 1); + if (mainthread) { + return mainthread; + } + } + return state; +} + +#else +inline lua_State *toMainThread(lua_State *state) { + if (state) { + // lua_pushthread return 1 if state is main thread + bool state_is_main = lua_pushthread(state) == 1; + lua_pop(state, 1); + if (state_is_main) { + return state; + } + lua_getfield(state, LUA_REGISTRYINDEX, "KAGUYA_REG_MAINTHREAD"); + lua_State *mainthread = lua_tothread(state, -1); + lua_pop(state, 1); + if (mainthread) { + return mainthread; + } + } + return state; +} +inline bool registerMainThread(lua_State *state) { + if (lua_pushthread(state)) { + lua_setfield(state, LUA_REGISTRYINDEX, "KAGUYA_REG_MAINTHREAD"); + return true; + } else { + lua_pop(state, 1); + return false; + } +} +#endif + +#if KAGUYA_USE_CPP11 +inline int push_args(lua_State *) { return 0; } +template +inline int push_args(lua_State *l, Arg &&arg, Args &&... args) { + int c = lua_type_traits::type>::push( + l, std::forward(arg)); + return c + push_args(l, std::forward(args)...); +} +template +inline int push_args(lua_State *l, const Arg &arg, Args &&... args) { + int c = lua_type_traits::push(l, arg); + return c + push_args(l, std::forward(args)...); +} +#else +inline int push_args(lua_State *) { return 0; } + +#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_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_PUSH_DEF +#undef KAGUYA_PUSH_ARG_DEF +#endif + +#if KAGUYA_USE_CPP11 +template inline bool one_push(lua_State *state, T &&v) { + int count = util::push_args(state, std::forward(v)); + if (count > 1) { + lua_pop(state, count - 1); + } + return count != 0; +} +#else +template inline bool one_push(lua_State *state, const T &v) { + int count = util::push_args(state, v); + if (count > 1) { + lua_pop(state, count - 1); + } + return count != 0; +} +#endif + +inline std::string pretty_name(const std::type_info &t) { +#if KAGUYA_USE_CXX_ABI_DEMANGLE + int status = 0; + char *demangle_name = abi::__cxa_demangle(t.name(), 0, 0, &status); + struct deleter { + char *data; + deleter(char *d) : data(d) {} + ~deleter() { std::free(data); } + } d(demangle_name); + return demangle_name; +#else + return t.name(); +#endif +} +} +} + +namespace kaguya { +namespace types { +template struct typetag {}; +} +#if KAGUYA_SUPPORT_MULTIPLE_SHARED_LIBRARY +inline const char *metatable_name_key() { return "\x80KAGUYA_N_KEY"; } +inline const char *metatable_type_table_key() { return "\x80KAGUYA_T_KEY"; } +#else +inline void *metatable_name_key() { + static int key; + return &key; +} +inline void *metatable_type_table_key() { + static int key; + return &key; +} +#endif + +template const std::type_info &metatableType() { + return typeid(typename traits::decay::type); +} +template inline std::string metatableName() { + return util::pretty_name(metatableType()); +} + +struct ObjectWrapperBase { + virtual const void *cget() = 0; + virtual void *get() = 0; + + virtual const std::type_info &type() = 0; + + virtual const std::type_info &native_type() { return type(); } + virtual void *native_get() { return get(); } + + ObjectWrapperBase() {} + virtual ~ObjectWrapperBase() {} + +private: + // noncopyable + ObjectWrapperBase(const ObjectWrapperBase &); + ObjectWrapperBase &operator=(const ObjectWrapperBase &); +}; + +template struct ObjectWrapper : ObjectWrapperBase { +#if KAGUYA_USE_CPP11 + template + ObjectWrapper(Args &&... args) : object_(std::forward(args)...) {} +#else + + ObjectWrapper() : object_() {} +#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() { return metatableType(); } + + virtual void *get() { return &object_; } + virtual const void *cget() { return &object_; } + +private: + T object_; +}; + +struct ObjectSharedPointerWrapper : ObjectWrapperBase { + template + ObjectSharedPointerWrapper(const standard::shared_ptr &sptr) + : object_(standard::const_pointer_cast< + typename standard::remove_const::type>(sptr)), + type_(metatableType()), + shared_ptr_type_( + metatableType< + standard::shared_ptr::type> >()), + const_value_(traits::is_const::value) {} +#if KAGUYA_USE_RVALUE_REFERENCE + template + ObjectSharedPointerWrapper(standard::shared_ptr &&sptr) + : object_(std::move(standard::const_pointer_cast< + typename standard::remove_const::type>(sptr))), + type_(metatableType()), + shared_ptr_type_( + metatableType< + standard::shared_ptr::type> >()), + const_value_(traits::is_const::value) {} +#endif + virtual const std::type_info &type() { return type_; } + virtual void *get() { return const_value_ ? 0 : object_.get(); } + virtual const void *cget() { return object_.get(); } + standard::shared_ptr object() const { + return const_value_ ? standard::shared_ptr() : object_; + } + standard::shared_ptr const_object() const { return object_; } + const std::type_info &shared_ptr_type() const { return shared_ptr_type_; } + + virtual const std::type_info &native_type() { + return metatableType >(); + } + virtual void *native_get() { return &object_; } + +private: + standard::shared_ptr object_; + const std::type_info &type_; + + const std::type_info &shared_ptr_type_; + bool const_value_; +}; + +template +struct ObjectSmartPointerWrapper : ObjectWrapperBase { + ObjectSmartPointerWrapper(const T &sptr) : object_(sptr) {} +#if KAGUYA_USE_RVALUE_REFERENCE + ObjectSmartPointerWrapper(T &&sptr) : object_(std::move(sptr)) {} +#endif + virtual const std::type_info &type() { return metatableType(); } + virtual void *get() { return object_ ? &(*object_) : 0; } + virtual const void *cget() { return object_ ? &(*object_) : 0; } + virtual const std::type_info &native_type() { return metatableType(); } + virtual void *native_get() { return &object_; } + +private: + T object_; +}; + +template struct ObjectPointerWrapper : ObjectWrapperBase { + ObjectPointerWrapper(T *ptr) : object_(ptr) {} + + virtual const std::type_info &type() { return metatableType(); } + virtual void *get() { + if (traits::is_const::value) { + return 0; + } + return const_cast(static_cast(object_)); + } + virtual const void *cget() { return object_; } + ~ObjectPointerWrapper() {} + +protected: + T *object_; +}; + +// Customizable for ObjectPointerWrapper +template struct ObjectPointerWrapperType { + typedef ObjectPointerWrapper type; +}; + +// for internal use +struct PointerConverter { + template static void *base_pointer_cast(void *from) { + return static_cast(static_cast(from)); + } + template + static standard::shared_ptr + base_shared_pointer_cast(const standard::shared_ptr &from) { + return standard::shared_ptr(standard::static_pointer_cast(from)); + } + + typedef void *(*convert_function_type)(void *); + typedef standard::shared_ptr (*shared_ptr_convert_function_type)( + const standard::shared_ptr &); + typedef std::pair convert_map_key; + + template void add_type_conversion() { + add_function(metatableType(), metatableType(), + &base_pointer_cast); + add_function(metatableType >(), + metatableType >(), + &base_shared_pointer_cast); + } + + template TO *get_pointer(ObjectWrapperBase *from) const { + const std::type_info &to_type = metatableType(); + // unreachable + // if (to_type == from->type()) + //{ + // return static_cast(from->get()); + //} + std::map >::const_iterator match = + function_map_.find( + convert_map_key(to_type.name(), from->type().name())); + if (match != function_map_.end()) { + return static_cast(pcvt_list_apply(from->get(), match->second)); + } + return 0; + } + template + const TO *get_const_pointer(ObjectWrapperBase *from) const { + const std::type_info &to_type = metatableType(); + // unreachable + // if (to_type == from->type()) + //{ + // return static_cast(from->cget()); + //} + std::map >::const_iterator match = + function_map_.find( + convert_map_key(to_type.name(), from->type().name())); + if (match != function_map_.end()) { + return static_cast( + pcvt_list_apply(const_cast(from->cget()), match->second)); + } + return 0; + } + + template + standard::shared_ptr + get_shared_pointer(ObjectSharedPointerWrapper *from) const { + const std::type_info &to_type = metatableType< + standard::shared_ptr::type> >(); + // unreachable + // if (to_type == from->type()) + // { + // return + // standard::static_pointer_cast(from->object()); + // } + const std::type_info &from_type = from->shared_ptr_type(); + std::map >::const_iterator + match = shared_ptr_function_map_.find( + convert_map_key(to_type.name(), from_type.name())); + if (match != shared_ptr_function_map_.end()) { + standard::shared_ptr sptr = from->object(); + + if (!sptr && standard::is_const::value) { + sptr = standard::const_pointer_cast(from->const_object()); + } + + return standard::static_pointer_cast( + pcvt_list_apply(sptr, match->second)); + } + return standard::shared_ptr(); + } + + template + T *get_pointer(ObjectWrapperBase *from, types::typetag) { + return get_pointer(from); + } + template + standard::shared_ptr + get_pointer(ObjectWrapperBase *from, + types::typetag >) { + ObjectSharedPointerWrapper *ptr = + dynamic_cast(from); + if (ptr) { + return get_shared_pointer(ptr); + } + return standard::shared_ptr(); + } + + static int deleter(lua_State *state) { + PointerConverter *ptr = (PointerConverter *)lua_touserdata(state, 1); + ptr->~PointerConverter(); + return 0; + } + + static PointerConverter &get(lua_State *state) { +#if KAGUYA_SUPPORT_MULTIPLE_SHARED_LIBRARY + const char *kaguya_ptrcvt_key_ptr = "\x80KAGUYA_CVT_KEY"; +#else + static char kaguya_ptrcvt_key_ptr; +#endif + util::ScopedSavedStack save(state); +#if KAGUYA_SUPPORT_MULTIPLE_SHARED_LIBRARY + lua_pushstring(state, kaguya_ptrcvt_key_ptr); +#else + lua_pushlightuserdata(state, &kaguya_ptrcvt_key_ptr); +#endif + lua_rawget(state, LUA_REGISTRYINDEX); + if (lua_isuserdata(state, -1)) { + return *static_cast(lua_touserdata(state, -1)); + } else { + void *ptr = lua_newuserdata( + state, sizeof(PointerConverter)); // dummy data for gc call + PointerConverter *converter = new (ptr) PointerConverter(); + + lua_createtable(state, 0, 2); + lua_pushcclosure(state, &deleter, 0); + lua_setfield(state, -2, "__gc"); + lua_pushvalue(state, -1); + lua_setfield(state, -2, "__index"); + lua_setmetatable(state, -2); // set to userdata +#if KAGUYA_SUPPORT_MULTIPLE_SHARED_LIBRARY + lua_pushstring(state, kaguya_ptrcvt_key_ptr); +#else + lua_pushlightuserdata(state, &kaguya_ptrcvt_key_ptr); +#endif + lua_pushvalue(state, -2); + lua_rawset(state, LUA_REGISTRYINDEX); + return *converter; + } + } + +private: + void add_function(const std::type_info &to_type, + const std::type_info &from_type, convert_function_type f) { + std::map > add_map; + for (std::map >::iterator it = + function_map_.begin(); + it != function_map_.end(); ++it) { + if (it->first.second == to_type.name()) { + std::vector newlist; + newlist.push_back(f); + newlist.insert(newlist.end(), it->second.begin(), it->second.end()); + add_map[convert_map_key(it->first.first, from_type.name())] = newlist; + } + } + function_map_.insert(add_map.begin(), add_map.end()); + + std::vector flist; + flist.push_back(f); + function_map_[convert_map_key(to_type.name(), from_type.name())] = flist; + } + void add_function(const std::type_info &to_type, + const std::type_info &from_type, + shared_ptr_convert_function_type f) { + std::map > + add_map; + for (std::map >::iterator it = + shared_ptr_function_map_.begin(); + it != shared_ptr_function_map_.end(); ++it) { + if (it->first.second == to_type.name()) { + std::vector newlist; + newlist.push_back(f); + newlist.insert(newlist.end(), it->second.begin(), it->second.end()); + add_map[convert_map_key(it->first.first, from_type.name())] = newlist; + } + } + shared_ptr_function_map_.insert(add_map.begin(), add_map.end()); + + std::vector flist; + flist.push_back(f); + shared_ptr_function_map_[convert_map_key(to_type.name(), + from_type.name())] = flist; + } + + void *pcvt_list_apply(void *ptr, + const std::vector &flist) const { + for (std::vector::const_iterator i = flist.begin(); + i != flist.end(); ++i) { + ptr = (*i)(ptr); + } + return ptr; + } + standard::shared_ptr pcvt_list_apply( + standard::shared_ptr ptr, + const std::vector &flist) const { + for (std::vector::const_iterator i = + flist.begin(); + i != flist.end(); ++i) { + +#if KAGUYA_USE_CPP11 + ptr = (*i)(std::move(ptr)); +#else + ptr = (*i)(ptr); +#endif + } + return ptr; + } + + PointerConverter() {} + + std::map > function_map_; + std::map > + shared_ptr_function_map_; + + PointerConverter(PointerConverter &); + PointerConverter &operator=(PointerConverter &); +}; + +namespace detail { +inline bool object_wrapper_type_check(lua_State *l, int index) { +#if KAGUYA_NO_USERDATA_TYPE_CHECK + return lua_isuserdata(l, index) && !lua_islightuserdata(l, index); +#endif + if (lua_getmetatable(l, index)) { +#if KAGUYA_SUPPORT_MULTIPLE_SHARED_LIBRARY + lua_pushstring(l, metatable_name_key()); +#else + lua_pushlightuserdata(l, metatable_name_key()); +#endif + int type = lua_rawget_rtype(l, -2); + lua_pop(l, 2); + return type == LUA_TSTRING; + } + return false; +} +} + +inline ObjectWrapperBase *object_wrapper(lua_State *l, int index) { + if (detail::object_wrapper_type_check(l, index)) { + ObjectWrapperBase *ptr = + static_cast(lua_touserdata(l, index)); + return ptr; + } + return 0; +} + +template +inline ObjectWrapperBase * +object_wrapper(lua_State *l, int index, bool convert = true, + types::typetag = types::typetag()) { + if (detail::object_wrapper_type_check(l, index)) { + ObjectWrapperBase *ptr = + static_cast(lua_touserdata(l, index)); +#if KAGUYA_NAME_BASED_TYPE_CHECK + if (strcmp(ptr->type().name(), metatableType().name()) == 0) { +#else + if (ptr->type() == metatableType()) { +#endif + return ptr; + } else if (convert) { + PointerConverter &pcvt = PointerConverter::get(l); + return pcvt.get_pointer(ptr, types::typetag()) ? ptr : 0; + } + return 0; + } + return 0; +} + +template T *get_pointer(lua_State *l, int index, types::typetag) { + int type = lua_type(l, index); + + if (type == LUA_TLIGHTUSERDATA) { + return (T *)lua_topointer(l, index); + } else if (type != LUA_TUSERDATA) { + return 0; + } else { + ObjectWrapperBase *objwrapper = object_wrapper(l, index); + if (objwrapper) { + const std::type_info &to_type = metatableType(); +#if KAGUYA_NAME_BASED_TYPE_CHECK + if (strcmp(objwrapper->type().name(), to_type.name()) == 0) { +#else + if (objwrapper->type() == to_type) { +#endif + return static_cast(objwrapper->get()); + } + if (objwrapper->native_type() == to_type) { + return static_cast(objwrapper->native_get()); + } else { + PointerConverter &pcvt = PointerConverter::get(l); + return pcvt.get_pointer(objwrapper); + } + } + } + return 0; +} +template +const T *get_const_pointer(lua_State *l, int index, types::typetag) { + int type = lua_type(l, index); + + if (type == LUA_TLIGHTUSERDATA) { + return (T *)lua_topointer(l, index); + } else if (type != LUA_TUSERDATA) { + return 0; + } else { + ObjectWrapperBase *objwrapper = object_wrapper(l, index); + if (objwrapper) { +#if KAGUYA_NAME_BASED_TYPE_CHECK + if (strcmp(objwrapper->type().name(), metatableType().name()) == 0) { +#else + if (objwrapper->type() == metatableType()) { +#endif + return static_cast(objwrapper->cget()); + } else { + PointerConverter &pcvt = PointerConverter::get(l); + return pcvt.get_const_pointer(objwrapper); + } + } + } + return 0; +} +template +const T *get_pointer(lua_State *l, int index, types::typetag) { + return get_const_pointer(l, index, types::typetag()); +} + +template +standard::shared_ptr get_shared_pointer(lua_State *l, int index, + types::typetag) { + ObjectSharedPointerWrapper *ptr = + dynamic_cast(object_wrapper(l, index)); + if (ptr) { + const std::type_info &from_type = ptr->shared_ptr_type(); + const std::type_info &to_type = + metatableType::type> >(); +#if KAGUYA_NAME_BASED_TYPE_CHECK + if (strcmp(from_type.name(), to_type.name()) == 0) { +#else + if (from_type == to_type) { +#endif + if (standard::is_const::value) { + return standard::static_pointer_cast( + standard::const_pointer_cast(ptr->const_object())); + } else { + return standard::static_pointer_cast(ptr->object()); + } + } + PointerConverter &pcvt = PointerConverter::get(l); + return pcvt.get_shared_pointer(ptr); + } + return standard::shared_ptr(); +} +inline standard::shared_ptr get_shared_pointer(lua_State *l, int index, + types::typetag) { + ObjectSharedPointerWrapper *ptr = + dynamic_cast(object_wrapper(l, index)); + if (ptr) { + return ptr->object(); + } + return standard::shared_ptr(); +} +inline standard::shared_ptr +get_shared_pointer(lua_State *l, int index, types::typetag) { + ObjectSharedPointerWrapper *ptr = + dynamic_cast(object_wrapper(l, index)); + if (ptr) { + return ptr->const_object(); + } + return standard::shared_ptr(); +} + +namespace class_userdata { +template inline void destructor(T *pointer) { + if (pointer) { + pointer->~T(); + } +} +inline bool get_metatable(lua_State *l, const std::type_info &typeinfo) { +#if KAGUYA_SUPPORT_MULTIPLE_SHARED_LIBRARY + lua_pushstring(l, metatable_type_table_key()); +#else + lua_pushlightuserdata(l, metatable_type_table_key()); +#endif + int ttype = + lua_rawget_rtype(l, LUA_REGISTRYINDEX); // get metatable registry table + if (ttype != LUA_TTABLE) { +#if KAGUYA_SUPPORT_MULTIPLE_SHARED_LIBRARY + lua_pushstring(l, metatable_type_table_key()); +#else + lua_pushlightuserdata(l, metatable_type_table_key()); +#endif + lua_newtable(l); + lua_rawset(l, LUA_REGISTRYINDEX); + return false; + } +#if KAGUYA_NAME_BASED_TYPE_CHECK + lua_pushstring(l, typeinfo.name()); + int type = lua_rawget_rtype(l, -2); +#else + int type = lua_rawgetp_rtype(l, -1, &typeinfo); +#endif + lua_remove(l, -2); // remove metatable registry table + return type != LUA_TNIL; +} +template bool get_metatable(lua_State *l) { + return get_metatable(l, metatableType()); +} +template bool available_metatable(lua_State *l) { + util::ScopedSavedStack save(l); + return get_metatable(l); +} + +inline bool newmetatable(lua_State *l, const std::type_info &typeinfo, + const char *name) { + if (get_metatable(l, typeinfo)) // already register + { + return false; // + } + lua_pop(l, 1); + +// get metatable registry table +#if KAGUYA_SUPPORT_MULTIPLE_SHARED_LIBRARY + lua_getfield(l, LUA_REGISTRYINDEX, metatable_type_table_key()); +#else + lua_rawgetp_rtype(l, LUA_REGISTRYINDEX, metatable_type_table_key()); +#endif + + int metaregindex = lua_absindex(l, -1); + + lua_createtable(l, 0, 2); + lua_pushstring(l, name); + lua_setfield(l, -2, "__name"); // metatable.__name = name + +#if KAGUYA_SUPPORT_MULTIPLE_SHARED_LIBRARY + lua_pushstring(l, metatable_name_key()); +#else + lua_pushlightuserdata(l, metatable_name_key()); +#endif + lua_pushstring(l, name); + lua_rawset(l, -3); +#if KAGUYA_NAME_BASED_TYPE_CHECK + lua_pushstring(l, typeinfo.name()); + lua_pushvalue(l, -2); + lua_rawset(l, metaregindex); +#else + lua_pushvalue(l, -1); + lua_rawsetp(l, metaregindex, &typeinfo); +#endif + lua_remove(l, metaregindex); // remove metatable registry table + + return true; +} +template bool newmetatable(lua_State *l) { + return newmetatable(l, metatableType(), metatableName().c_str()); +} + +template inline int deleter(lua_State *state) { + T *ptr = (T *)lua_touserdata(state, 1); + ptr->~T(); + return 0; +} +struct UnknownType {}; +inline void setmetatable(lua_State *l, const std::type_info &typeinfo) { + // if not available metatable, set unknown class metatable + if (!get_metatable(l, typeinfo)) { + lua_pop(l, 1); + if (!get_metatable(l)) { + lua_pop(l, 1); + newmetatable(l); + lua_pushcclosure(l, &deleter, 0); + lua_setfield(l, -2, "__gc"); + } + } + lua_setmetatable(l, -2); +} +template void setmetatable(lua_State *l) { + setmetatable(l, metatableType()); +} +} +template +bool available_metatable(lua_State *l, + types::typetag = types::typetag()) { + return class_userdata::available_metatable(l); +} + +namespace util { +template inline bool object_checkType(lua_State *l, int index) { + return object_wrapper(l, index) != 0; +} +template +inline bool object_strictCheckType(lua_State *l, int index) { + return object_wrapper(l, index, false) != 0; +} + +template +inline optional object_getopt(lua_State *l, int index) { + const typename traits::remove_reference::type *pointer = get_const_pointer( + l, index, types::typetag::type>()); + if (!pointer) { + return optional(); + } + return *pointer; +} + +template inline T object_get(lua_State *l, int index) { + const typename traits::remove_reference::type *pointer = get_const_pointer( + l, index, types::typetag::type>()); + if (!pointer) { + throw LuaTypeMismatch(); + } + return *pointer; +} + +template struct ConvertibleRegisterHelperProxy { + template + ConvertibleRegisterHelperProxy(DataType v) + : holder_(new DataHolder(v)) {} + operator To() { return holder_->get(); } + +private: + struct DataHolderBase { + virtual To get() const = 0; + virtual ~DataHolderBase() {} + }; + template class DataHolder : public DataHolderBase { + typedef typename traits::decay::type DataType; + + public: + explicit DataHolder(DataType v) : data_(v) {} + virtual To get() const { return To(data_); } + + private: + DataType data_; + }; + standard::shared_ptr holder_; +}; + +#if KAGUYA_USE_CPP11 +template inline int object_push(lua_State *l, T &&v) { + typedef ObjectWrapper::type> + wrapper_type; + void *storage = lua_newuserdata(l, sizeof(wrapper_type)); + new (storage) wrapper_type(std::forward(v)); + class_userdata::setmetatable(l); + return 1; +} + +namespace conv_helper_detail { +template bool checkType(lua_State *, int) { return false; } +template +bool checkType(lua_State *l, int index) { + return lua_type_traits::checkType(l, index) || + checkType(l, index); +} +template bool strictCheckType(lua_State *, int) { return false; } +template +bool strictCheckType(lua_State *l, int index) { + return lua_type_traits::strictCheckType(l, index) || + strictCheckType(l, index); + ; +} + +template To get(lua_State *, int) { throw LuaTypeMismatch(); } +template +To get(lua_State *l, int index) { + typedef optional::get_type> opt_type; + if (auto opt = lua_type_traits::get(l, index)) { + return *opt; + } + return get(l, index); +} +} + +template struct ConvertibleRegisterHelper { + typedef To get_type; + + static bool checkType(lua_State *l, int index) { + if (object_checkType(l, index)) { + return true; + } + return conv_helper_detail::checkType(l, index); + } + static bool strictCheckType(lua_State *l, int index) { + if (object_strictCheckType(l, index)) { + return true; + } + return conv_helper_detail::strictCheckType(l, index); + } + + static get_type get(lua_State *l, int index) { + if (auto opt = object_getopt(l, index)) { + return *opt; + } + return conv_helper_detail::get(l, index); + } +}; +#else +template inline int object_push(lua_State *l, T v) { + typedef ObjectWrapper::type> + wrapper_type; + void *storage = lua_newuserdata(l, sizeof(wrapper_type)); + new (storage) wrapper_type(v); + class_userdata::setmetatable(l); + return 1; +} +namespace conv_helper_detail { +#define KAGUYA_CONVERTIBLE_REG_HELPER_CHECK_TYPE_REP(N) \ + || lua_type_traits::checkType(state, index) +#define KAGUYA_CONVERTIBLE_REG_HELPER_STRICT_CHECK_TYPE_REP(N) \ + || lua_type_traits::strictCheckType(state, index) +#define KAGUYA_CONVERTIBLE_REG_HELPER_GET_OPT_TYPEDEF(N) \ + typedef optional::get_type> \ + KAGUYA_PP_CAT(opt_type, N); +#define KAGUYA_CONVERTIBLE_REG_HELPER_GET_REP(N) \ + if (KAGUYA_PP_CAT(opt_type, N) opt = \ + lua_type_traits::get(state, index)) { \ + return *opt; \ + } else + +template bool checkType(lua_State *, int, TypeTuple<>) { + return false; +} +#define KAGUYA_CONVERTIBLE_REG_HELPER_CHECK_TYPE_DEF(N) \ + template \ + bool checkType(lua_State *state, int index, \ + TypeTuple) { \ + return false KAGUYA_PP_REPEAT( \ + N, KAGUYA_CONVERTIBLE_REG_HELPER_CHECK_TYPE_REP); \ + } + +KAGUYA_PP_REPEAT_DEF(KAGUYA_FUNCTION_MAX_ARGS, + KAGUYA_CONVERTIBLE_REG_HELPER_CHECK_TYPE_DEF) +#undef KAGUYA_CONVERTIBLE_REG_HELPER_CHECK_TYPE_DEF +template bool strictCheckType(lua_State *, int, TypeTuple<>) { + return false; +} +#define KAGUYA_CONVERTIBLE_REG_HELPER_ST_CHECK_TYPE_DEF(N) \ + template \ + bool strictCheckType(lua_State *state, int index, \ + TypeTuple) { \ + return false KAGUYA_PP_REPEAT( \ + N, KAGUYA_CONVERTIBLE_REG_HELPER_STRICT_CHECK_TYPE_REP); \ + } +KAGUYA_PP_REPEAT_DEF(KAGUYA_FUNCTION_MAX_ARGS, + KAGUYA_CONVERTIBLE_REG_HELPER_ST_CHECK_TYPE_DEF) +#undef KAGUYA_CONVERTIBLE_REG_HELPER_ST_CHECK_TYPE_DEF +#define KAGUYA_CONVERTIBLE_REG_HELPER_GET_DEF(N) \ + template \ + To get(lua_State *state, int index, \ + TypeTuple) { \ + KAGUYA_PP_REPEAT(N, KAGUYA_CONVERTIBLE_REG_HELPER_GET_OPT_TYPEDEF) \ + KAGUYA_PP_REPEAT(N, KAGUYA_CONVERTIBLE_REG_HELPER_GET_REP) { \ + throw LuaTypeMismatch(); \ + } \ + } +KAGUYA_PP_REPEAT_DEF(KAGUYA_FUNCTION_MAX_ARGS, + KAGUYA_CONVERTIBLE_REG_HELPER_GET_DEF) +#undef KAGUYA_CONVERTIBLE_REG_HELPER_GET_DEF + +#undef KAGUYA_CONVERTIBLE_REG_HELPER_CHECK_TYPE_REP +#undef KAGUYA_CONVERTIBLE_REG_HELPER_STRICT_CHECK_TYPE_REP +#undef KAGUYA_CONVERTIBLE_REG_HELPER_ST_GET_REP +#undef KAGUYA_CONVERTIBLE_REG_HELPER_GET_REP +} + +#define KAGUYA_PP_CONVERTIBLE_REG_HELPER_DEF_REP(N) \ + KAGUYA_PP_CAT(typename A, N) = null_type +#define KAGUYA_PP_CONVERTIBLE_REG_HELPER_DEF_REPEAT(N) \ + KAGUYA_PP_REPEAT_ARG(N, KAGUYA_PP_CONVERTIBLE_REG_HELPER_DEF_REP) + +template +struct ConvertibleRegisterHelper { + typedef To get_type; + typedef TypeTuple + conv_types; + + static bool checkType(lua_State *l, int index) { + if (object_checkType(l, index)) { + return true; + } + return conv_helper_detail::checkType(l, index, conv_types()); + } + static bool strictCheckType(lua_State *l, int index) { + if (object_strictCheckType(l, index)) { + return true; + } + return conv_helper_detail::strictCheckType(l, index, conv_types()); + } + static get_type get(lua_State *l, int index) { + if (optional opt = object_getopt(l, index)) { + return *opt; + } + return conv_helper_detail::get(l, index, conv_types()); + } +}; +#undef KAGUYA_PP_CONVERTIBLE_REG_HELPER_DEF_REP +#undef KAGUYA_PP_CONVERTIBLE_REG_HELPER_DEF_REPEAT +#endif +} +} +// Copyright satoren +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + + + +namespace kaguya { +#if KAGUYA_USE_CPP11 +namespace detail { +template struct index_tuple {}; +template , + bool flag = first >= last> +struct index_range { + using type = result; +}; +template +struct index_range, false> + : index_range > {}; + +template +int push_tuple(lua_State *l, index_tuple, std::tuple &&v) { + return util::push_args(l, std::get(v)...); +} +} + +/// @ingroup lua_type_traits +/// @brief lua_type_traits for std::tuple or boost::tuple +template struct lua_type_traits > { + static int push(lua_State *l, std::tuple &&v) { + typename detail::index_range<0, sizeof...(Args)>::type index; + return detail::push_tuple(l, index, std::forward >(v)); + } +}; +#else +#define KAGUYA_PP_GET_DATA(N) standard::get(v) +#define KAGUYA_PUSH_TUPLE_DEF(N) \ + template \ + struct lua_type_traits > { \ + static int \ + push(lua_State *l, \ + const standard::tuple &v) { \ + return util::push_args(l, KAGUYA_PP_REPEAT_ARG(N, KAGUYA_PP_GET_DATA)); \ + } \ + }; +KAGUYA_PP_REPEAT_DEF(KAGUYA_FUNCTION_MAX_TUPLE_SIZE, KAGUYA_PUSH_TUPLE_DEF) +#undef KAGUYA_PP_GET_DATA +#undef KAGUYA_PUSH_TUPLE_DEF +#endif +} + +namespace kaguya { + +// default implements +template +bool lua_type_traits::checkType(lua_State *l, int index) { + return object_wrapper(l, index) != 0; +} +template +bool lua_type_traits::strictCheckType(lua_State *l, int index) { + return object_wrapper(l, index, false) != 0; +} +template +typename lua_type_traits::opt_type +lua_type_traits::opt(lua_State *l, int index) KAGUYA_NOEXCEPT { + const typename traits::remove_reference::type *pointer = get_const_pointer( + l, index, types::typetag::type>()); + if (!pointer) { + return opt_type(); + } + return *pointer; +} +template +typename lua_type_traits::get_type +lua_type_traits::get(lua_State *l, int index) { + const typename traits::remove_reference::type *pointer = get_const_pointer( + l, index, types::typetag::type>()); + if (!pointer) { + throw LuaTypeMismatch(); + } + return *pointer; +} +template +int lua_type_traits::push(lua_State *l, push_type v) { + return util::object_push(l, v); +} + +#if KAGUYA_USE_RVALUE_REFERENCE + +template +int lua_type_traits::push(lua_State *l, NCRT &&v) { + return util::object_push(l, std::forward(v)); +} +#endif + +/// @ingroup lua_type_traits +/// @brief lua_type_traits for const reference type +template +struct lua_type_traits< + T, typename traits::enable_if::value>::type> + : lua_type_traits::type> {}; + +/// @ingroup lua_type_traits +/// @brief lua_type_traits for lvalue reference type +template +struct lua_type_traits< + REF, typename traits::enable_if< + traits::is_lvalue_reference::value && + !traits::is_const< + typename traits::remove_reference::type>::value>::type> { + typedef void Registerable; + + typedef REF get_type; + typedef optional opt_type; + typedef REF push_type; + typedef typename traits::remove_reference::type T; + + static bool strictCheckType(lua_State *l, int index) { + return object_wrapper(l, index, false) != 0; + } + static bool checkType(lua_State *l, int index) { + if (lua_type(l, index) == LUA_TLIGHTUSERDATA) { + return true; + } + return object_wrapper(l, index) != 0; + } + static get_type get(lua_State *l, int index) { + T *pointer = get_pointer(l, index, types::typetag()); + if (!pointer) { + throw LuaTypeMismatch(); + } + return *pointer; + } + static opt_type opt(lua_State *l, int index) KAGUYA_NOEXCEPT { + T *pointer = get_pointer(l, index, types::typetag()); + if (!pointer) { + return opt_type(); + } + return opt_type(*pointer); + } + static int push(lua_State *l, push_type v) { + if (!available_metatable(l)) { + lua_pushlightuserdata( + l, const_cast::type *>(&v)); + } else { + typedef typename ObjectPointerWrapperType::type wrapper_type; + void *storage = lua_newuserdata(l, sizeof(wrapper_type)); + new (storage) wrapper_type(&v); + class_userdata::setmetatable(l); + } + return 1; + } +}; + +/// @ingroup lua_type_traits +/// @brief lua_type_traits for pointer type +template +struct lua_type_traits< + PTR, typename traits::enable_if< + traits::is_pointer< + typename traits::remove_const_reference::type>::value && + !traits::is_function< + typename traits::remove_pointer::type>::value>::type> { + typedef void Registerable; + + typedef PTR get_type; + typedef optional opt_type; + typedef PTR push_type; + typedef typename traits::remove_pointer::type T; + + static bool strictCheckType(lua_State *l, int index) { + return object_wrapper(l, index, false) != 0; + } + static bool checkType(lua_State *l, int index) { + int type = lua_type(l, index); + if (type == LUA_TLIGHTUSERDATA || type == LUA_TNIL || type == LUA_TNONE) { + return true; + } + return object_wrapper(l, index) != 0; + } + static get_type get(lua_State *l, int index) { + int type = lua_type(l, index); + if (type == LUA_TUSERDATA || type == LUA_TLIGHTUSERDATA) { + return get_pointer(l, index, types::typetag()); + } + + if (type == LUA_TNIL || type == LUA_TNONE) { + return 0; + } + throw LuaTypeMismatch(); + return 0; + } + static opt_type opt(lua_State *l, int index) KAGUYA_NOEXCEPT { + int type = lua_type(l, index); + if (type == LUA_TUSERDATA || type == LUA_TLIGHTUSERDATA) { + return get_pointer(l, index, types::typetag()); + } + if (type == LUA_TNIL || type == LUA_TNONE) { + return opt_type(0); + } + return opt_type(); + } + static int push(lua_State *l, push_type v) { + if (!v) { + lua_pushnil(l); + } else if (!available_metatable(l)) { + lua_pushlightuserdata( + l, const_cast::type *>(v)); + } else { + typedef typename ObjectPointerWrapperType::type wrapper_type; + void *storage = lua_newuserdata(l, sizeof(wrapper_type)); + new (storage) wrapper_type(v); + class_userdata::setmetatable(l); + } + return 1; + } +}; + +/// @ingroup lua_type_traits +/// @brief lua_type_traits for bool +template <> struct lua_type_traits { + typedef bool get_type; + typedef optional opt_type; + typedef bool push_type; + + static bool strictCheckType(lua_State *l, int index) { + return lua_type(l, index) == LUA_TBOOLEAN; + } + static bool checkType(lua_State *l, int index) { + KAGUYA_UNUSED(l); + KAGUYA_UNUSED(index); + return true; + } + static bool get(lua_State *l, int index) { + return l && lua_toboolean(l, index) != 0; + } + static opt_type opt(lua_State *l, int index) KAGUYA_NOEXCEPT { + if (l) { + return opt_type(lua_toboolean(l, index) != 0); + } else { + return opt_type(); + } + } + static int push(lua_State *l, bool s) { + lua_pushboolean(l, s); + return 1; + } +}; + +/// @ingroup lua_type_traits +/// @brief lua_type_traits for void +template <> struct lua_type_traits { + typedef void *get_type; + typedef void *push_type; + + static bool strictCheckType(lua_State *, int) { return true; } + static bool checkType(lua_State *, int) { return true; } + static get_type get(lua_State *, int) { return 0; } + static int push(lua_State *, push_type) { return 0; } +}; + +/// @ingroup lua_type_traits +/// @brief lua_type_traits for reference_wrapper +template struct lua_type_traits > { + typedef const standard::reference_wrapper &push_type; + + static int push(lua_State *l, push_type v) { + return util::push_args(l, &v.get()); + } +}; + +namespace detail { + +template +struct has_optional_get : traits::false_type {}; +template +struct has_optional_get< + T, typename traits::enable_if::opt_type>::value>::type> + : traits::true_type {}; + +template +typename traits::enable_if::value, optional >::type +opt_helper(lua_State *state, int index) KAGUYA_NOEXCEPT { + return lua_type_traits::opt(state, index); +} +template +typename traits::enable_if::value, optional >::type +opt_helper(lua_State *state, int index) { + try { + return lua_type_traits::get(state, index); + } catch (...) { + return optional(); + } +} +} + +/// @ingroup lua_type_traits +/// @brief lua_type_traits for optional +template struct lua_type_traits > { + typedef const optional &push_type; + typedef optional get_type; + + static bool strictCheckType(lua_State *l, int index) { + return lua_type_traits::strictCheckType(l, index); + } + static bool checkType(lua_State *l, int index) { + KAGUYA_UNUSED(l); + KAGUYA_UNUSED(index); + return true; + } + static get_type get(lua_State *l, int index) KAGUYA_NOEXCEPT { + return detail::opt_helper(l, index); + } + + static int push(lua_State *l, push_type v) KAGUYA_NOEXCEPT { + if (v) { + return util::push_args(l, v.value()); + } else { + lua_pushnil(l); + } + return 1; + } +}; + +/// @ingroup lua_type_traits +/// @brief lua_type_traits for shared_ptr +template struct lua_type_traits > { + typedef const standard::shared_ptr &push_type; + typedef standard::shared_ptr get_type; + + static bool strictCheckType(lua_State *l, int index) { + ObjectSharedPointerWrapper *wrapper = + dynamic_cast(object_wrapper(l, index)); + if (!wrapper) { + return false; + } + const std::type_info &type = + metatableType::type> >(); +#if KAGUYA_NAME_BASED_TYPE_CHECK + return strcmp(wrapper->shared_ptr_type().name(), type.name()) == 0; +#else + return wrapper->shared_ptr_type() == type; +#endif + } + static bool checkType(lua_State *l, int index) { + return get_shared_pointer(l, index, types::typetag()) || + lua_isnil(l, index); + } + static get_type get(lua_State *l, int index) { + if (lua_isnil(l, index)) { + return get_type(); + } + return get_shared_pointer(l, index, types::typetag()); + } + + static int push(lua_State *l, push_type v) { + if (v) { + typedef ObjectSharedPointerWrapper wrapper_type; + void *storage = lua_newuserdata(l, sizeof(wrapper_type)); + new (storage) wrapper_type(v); + class_userdata::setmetatable(l); + } else { + lua_pushnil(l); + } + return 1; + } +}; +#if KAGUYA_USE_CPP11 +/// @ingroup lua_type_traits +/// @brief lua_type_traits for unique_ptr +template +struct lua_type_traits > { + typedef std::unique_ptr &&push_type; + typedef std::unique_ptr &get_type; + typedef std::unique_ptr type; + + static bool strictCheckType(lua_State *l, int index) { + return object_wrapper(l, index, false) != 0; + } + static bool checkType(lua_State *l, int index) { + return object_wrapper(l, index) != 0 || lua_isnil(l, index); + } + static get_type get(lua_State *l, int index) { + type *pointer = get_pointer(l, index, types::typetag()); + if (!pointer) { + throw LuaTypeMismatch(); + } + return *pointer; + } + + static int push(lua_State *l, push_type v) { + if (v) { + typedef ObjectSmartPointerWrapper wrapper_type; + void *storage = lua_newuserdata(l, sizeof(wrapper_type)); + new (storage) wrapper_type(std::forward(v)); + class_userdata::setmetatable(l); + } else { + lua_pushnil(l); + } + return 1; + } +}; +/// @ingroup lua_type_traits +/// @brief lua_type_traits for nullptr +template <> struct lua_type_traits { + typedef const std::nullptr_t &push_type; + typedef std::nullptr_t get_type; + typedef optional opt_type; + + static bool checkType(lua_State *l, int index) { + return lua_isnoneornil(l, index); + } + static bool strictCheckType(lua_State *l, int index) { + return lua_isnil(l, index); + } + static opt_type opt(lua_State *l, int index) { + if (!lua_isnoneornil(l, index)) { + return opt_type(); + } + return nullptr; + } + static get_type get(lua_State *l, int index) { + if (!lua_isnoneornil(l, index)) { + throw LuaTypeMismatch(); + } + return nullptr; + } + + static int push(lua_State *l, const std::nullptr_t &) { + lua_pushnil(l); + return 1; + } +}; +#endif + +/// @ingroup lua_type_traits +/// @brief lua_type_traits for ObjectWrapperBase* +template <> struct lua_type_traits { + typedef ObjectWrapperBase *get_type; + typedef ObjectWrapperBase *push_type; + + static bool strictCheckType(lua_State *l, int index) { + return object_wrapper(l, index) != 0; + } + static bool checkType(lua_State *l, int index) { + return object_wrapper(l, index) != 0; + } + static get_type get(lua_State *l, int index) { + return object_wrapper(l, index); + } +}; + +/// @ingroup lua_type_traits +/// @brief lua_type_traits for native type of luathread(lua_State*) +template <> struct lua_type_traits { + typedef lua_State *get_type; + typedef lua_State *push_type; + + static bool strictCheckType(lua_State *l, int index) { + return lua_isthread(l, index); + } + static bool checkType(lua_State *l, int index) { + return lua_isthread(l, index); + } + static lua_State *get(lua_State *l, int index) { + return lua_tothread(l, index); + } +}; + +/// @ingroup lua_type_traits +/// @brief lua_type_traits for floating point number value +template +struct lua_type_traits< + T, typename traits::enable_if::value>::type> { + typedef typename traits::remove_const_reference::type get_type; + typedef optional opt_type; + typedef lua_Number push_type; + + static bool strictCheckType(lua_State *l, int index) { + return lua_type(l, index) == LUA_TNUMBER; + } + static bool checkType(lua_State *l, int index) { + return lua_isnumber(l, index) != 0; + } + static opt_type opt(lua_State *l, int index) KAGUYA_NOEXCEPT { + int isnum = 0; + get_type num = static_cast(lua_tonumberx(l, index, &isnum)); + if (!isnum) { + return opt_type(); + } + return num; + } + static get_type get(lua_State *l, int index) { + int isnum = 0; + get_type num = static_cast(lua_tonumberx(l, index, &isnum)); + if (!isnum) { + throw LuaTypeMismatch(); + } + return num; + } + static int push(lua_State *l, lua_Number s) { + lua_pushnumber(l, s); + return 1; + } +}; + +/// @ingroup lua_type_traits +/// @brief lua_type_traits for integral number value +template +struct lua_type_traits< + T, typename traits::enable_if::value>::type> { + typedef typename traits::remove_const_reference::type get_type; + typedef optional opt_type; +#if LUA_VERSION_NUM >= 503 + typedef lua_Integer push_type; + + static bool strictCheckType(lua_State *l, int index) { + return lua_isinteger(l, index) != 0; + } + static bool checkType(lua_State *l, int index) { + return lua_isnumber(l, index) != 0; + } + static opt_type opt(lua_State *l, int index) KAGUYA_NOEXCEPT { + int isnum = 0; + get_type num = static_cast(lua_tointegerx(l, index, &isnum)); + if (!isnum) { + return opt_type(); + } + return num; + } + static get_type get(lua_State *l, int index) { + int isnum = 0; + get_type num = static_cast(lua_tointegerx(l, index, &isnum)); + if (!isnum) { + throw LuaTypeMismatch(); + } + return num; + } + static int push(lua_State *l, lua_Integer s) { + lua_pushinteger(l, s); + return 1; + } +#else + typedef typename lua_type_traits::push_type push_type; + + static bool strictCheckType(lua_State *l, int index) { + return lua_type_traits::strictCheckType(l, index); + } + static bool checkType(lua_State *l, int index) { + return lua_type_traits::checkType(l, index); + } + static get_type get(lua_State *l, int index) { + return static_cast(lua_type_traits::get(l, index)); + } + static opt_type opt(lua_State *l, int index) KAGUYA_NOEXCEPT { + lua_type_traits::opt_type v = + lua_type_traits::opt(l, index); + if (!v) { + return opt_type(); + } + return static_cast(*v); + } + static int push(lua_State *l, push_type s) { return util::push_args(l, s); } +#endif +}; + +/// @ingroup lua_type_traits +/// @brief lua_type_traits for enum +template +struct lua_type_traits< + T, typename traits::enable_if::value>::type> { + typedef typename traits::remove_const_reference::type get_type; + typedef optional opt_type; + typedef typename traits::remove_const_reference::type push_type; + + static bool strictCheckType(lua_State *l, int index) { + return lua_type_traits::strictCheckType(l, index); + } + static bool checkType(lua_State *l, int index) { + return lua_type_traits::checkType(l, index); + } + static opt_type opt(lua_State *l, int index) KAGUYA_NOEXCEPT { + if (lua_type_traits::opt_type t = + lua_type_traits::opt(l, index)) { + return opt_type(static_cast(*t)); + } + return opt_type(); + } + static get_type get(lua_State *l, int index) { + return static_cast(lua_type_traits::get(l, index)); + } + static int push(lua_State *l, push_type s) { + return util::push_args( + l, static_cast::push_type>(s)); + } +}; + +/// @ingroup lua_type_traits +/// @brief lua_type_traits for cstring +template <> struct lua_type_traits { + typedef const char *get_type; + typedef optional opt_type; + typedef const char *push_type; + + static bool strictCheckType(lua_State *l, int index) { + return lua_type(l, index) == LUA_TSTRING; + } + static bool checkType(lua_State *l, int index) { + return lua_isstring(l, index) != 0; + } + static get_type get(lua_State *l, int index) { + const char *buffer = lua_tostring(l, index); + if (!buffer) { + throw LuaTypeMismatch(); + } + return buffer; + } + static opt_type opt(lua_State *l, int index) { + const char *buffer = lua_tostring(l, index); + if (!buffer) { + return opt_type(); + } + return buffer; + } + static int push(lua_State *l, const char *s) { + lua_pushstring(l, s); + return 1; + } +}; + +/// @ingroup lua_type_traits +/// @brief lua_type_traits for cstring +template struct lua_type_traits { + typedef std::string get_type; + typedef const char *push_type; + + static bool strictCheckType(lua_State *l, int index) { + return lua_type(l, index) == LUA_TSTRING; + } + static bool checkType(lua_State *l, int index) { + return lua_isstring(l, index) != 0; + } + static const char *get(lua_State *l, int index) { + const char *buffer = lua_tostring(l, index); + if (!buffer) { + throw LuaTypeMismatch(); + } + return buffer; + } + static int push(lua_State *l, const char s[N]) { + lua_pushlstring(l, s, s[N - 1] != '\0' ? N : N - 1); + return 1; + } +}; +/// @ingroup lua_type_traits +/// @brief lua_type_traits for cstring +template +struct lua_type_traits : lua_type_traits {}; + +/// @ingroup lua_type_traits +/// @brief lua_type_traits for std::string +template <> struct lua_type_traits { + typedef std::string get_type; + typedef optional opt_type; + typedef const std::string &push_type; + + static bool strictCheckType(lua_State *l, int index) { + return lua_type(l, index) == LUA_TSTRING; + } + static bool checkType(lua_State *l, int index) { + return lua_isstring(l, index) != 0; + } + static opt_type opt(lua_State *l, int index) KAGUYA_NOEXCEPT { + size_t size = 0; + const char *buffer = lua_tolstring(l, index, &size); + if (!buffer) { + return opt_type(); + } + return std::string(buffer, size); + } + static get_type get(lua_State *l, int index) { + if (opt_type o = opt(l, index)) { + return *o; + } + throw LuaTypeMismatch(); + } + static int push(lua_State *l, const std::string &s) { + lua_pushlstring(l, s.c_str(), s.size()); + return 1; + } +}; + +struct NewTable { + NewTable() : reserve_array_(0), reserve_record_(0) {} + NewTable(int reserve_array, int reserve_record_) + : reserve_array_(reserve_array), reserve_record_(reserve_record_) {} + int reserve_array_; + int reserve_record_; +}; +struct NewThread {}; +struct GlobalTable {}; +struct NilValue {}; + +struct NoTypeCheck {}; + +/// @ingroup lua_type_traits +/// @brief lua_type_traits for NewTable, push only +template <> struct lua_type_traits { + static int push(lua_State *l, const NewTable &table) { + lua_createtable(l, table.reserve_array_, table.reserve_record_); + return 1; + } +}; + +/// @ingroup lua_type_traits +/// @brief lua_type_traits for NewThread, push only +template <> struct lua_type_traits { + static int push(lua_State *l, const NewThread &) { + lua_newthread(l); + return 1; + } +}; +/// @ingroup lua_type_traits +/// @brief lua_type_traits for NilValue, similar to nullptr_t +/// If you using C++11, recommend use nullptr instead. +template <> struct lua_type_traits { + typedef NilValue get_type; + typedef optional opt_type; + typedef NilValue push_type; + + static bool checkType(lua_State *l, int index) { + return lua_isnoneornil(l, index); + } + static bool strictCheckType(lua_State *l, int index) { + return lua_isnil(l, index); + } + + static opt_type opt(lua_State *l, int index) { + if (!checkType(l, index)) { + return opt_type(); + } + return NilValue(); + } + static get_type get(lua_State *l, int index) { + if (!checkType(l, index)) { + throw LuaTypeMismatch(); + } + return NilValue(); + } + static int push(lua_State *l, const NilValue &) { + lua_pushnil(l); + return 1; + } +}; +inline std::ostream &operator<<(std::ostream &os, const NilValue &) { + return os << "nil"; +} +inline bool operator==(const NilValue &, const NilValue &) { return true; } +inline bool operator!=(const NilValue &, const NilValue &) { return false; } + +/// @ingroup lua_type_traits +/// @brief lua_type_traits for GlobalTable, push only +template <> struct lua_type_traits { + static int push(lua_State *l, const GlobalTable &) { + lua_pushglobaltable(l); + return 1; + } +}; + +namespace detail { +template class LuaBasicTypeFunctions { + template friend class LuaBasicTypeFunctions; + typedef void (LuaBasicTypeFunctions::*bool_type)() const; + void this_type_does_not_support_comparisons() const {} + +public: + enum value_type { + TYPE_NONE = LUA_TNONE, //!< none type + TYPE_NIL = LUA_TNIL, //!< nil type + TYPE_BOOLEAN = LUA_TBOOLEAN, //!< boolean type + TYPE_LIGHTUSERDATA = LUA_TLIGHTUSERDATA, //!< light userdata type + TYPE_NUMBER = LUA_TNUMBER, //!< number type + TYPE_STRING = LUA_TSTRING, //!< string type + TYPE_TABLE = LUA_TTABLE, //!< table type + TYPE_FUNCTION = LUA_TFUNCTION, //!< function type + TYPE_USERDATA = LUA_TUSERDATA, //!< userdata type + TYPE_THREAD = LUA_TTHREAD //!< thread(coroutine) type + }; + + /// @brief If reference value is none or nil return true. Otherwise false. + bool isNilref_() const { + int t = type(); + return t == LUA_TNIL || t == LUA_TNONE; + } + + /// @brief Equivalent to `#` operator for strings and tables with no + /// metamethods. + /// Follows Lua's reference manual documentation of `lua_rawlen`, ie. types + /// other + /// than tables, strings or userdatas return 0. + /// @return Size of table, string length or userdata memory block size. + size_t size() const { + lua_State *state = state_(); + if (!state) { + return 0; + } + util::ScopedSavedStack save(state); + int index = pushStackIndex_(state); + + return lua_rawlen(state, index); + } + + // return type + int type() const { + lua_State *state = state_(); + if (!state) { + return LUA_TNONE; + } + util::ScopedSavedStack save(state); + return lua_type(state, pushStackIndex_(state)); + } + + // return type name + const char *typeName() const { return lua_typename(state_(), type()); } + + operator bool_type() const { + lua_State *state = state_(); + if (!state) { + return 0; // hasn't lua_State + } + util::ScopedSavedStack save(state); + int stackindex = pushStackIndex_(state); + int t = lua_type(state, stackindex); + if (t == LUA_TNONE) { + return 0; // none + } + return lua_toboolean(state, stackindex) + ? &LuaBasicTypeFunctions::this_type_does_not_support_comparisons + : 0; + } + + /** + * @name relational operators + * @brief + */ + //@{ + template + inline bool operator==(const LuaBasicTypeFunctions &rhs) const { + if (isNilref_() || rhs.isNilref_()) { + return !isNilref_() == !rhs.isNilref_(); + } + lua_State *state = state_(); + util::ScopedSavedStack save(state); + int index = pushStackIndex_(state); + int rhsindex = rhs.pushStackIndex_(state); + return lua_compare(state, index, rhsindex, LUA_OPEQ) != 0; + } + template + inline bool operator<(const LuaBasicTypeFunctions &rhs) const { + if (isNilref_() || rhs.isNilref_()) { + return !isNilref_() != !rhs.isNilref_(); + } + lua_State *state = state_(); + util::ScopedSavedStack save(state); + int index = pushStackIndex_(state); + int rhsindex = rhs.pushStackIndex_(state); + return lua_compare(state, index, rhsindex, LUA_OPLT) != 0; + } + template + inline bool operator<=(const LuaBasicTypeFunctions &rhs) const { + if (isNilref_() || rhs.isNilref_()) { + return !isNilref_() == !rhs.isNilref_(); + } + lua_State *state = state_(); + util::ScopedSavedStack save(state); + int index = pushStackIndex_(state); + int rhsindex = rhs.pushStackIndex_(state); + return lua_compare(state, index, rhsindex, LUA_OPLE) != 0; + } + template + inline bool operator>=(const LuaBasicTypeFunctions &rhs) const { + return rhs <= (*this); + } + template + inline bool operator>(const LuaBasicTypeFunctions &rhs) const { + return rhs < (*this); + } + template + inline bool operator!=(const LuaBasicTypeFunctions &rhs) const { + return !this->operator==(rhs); + } + + template + inline typename traits::enable_if< + !traits::is_convertible *>::value, + bool>::type + operator==(const T &rhs) const { + if (optional::get_type> d = checkGet_()) { + return *d == rhs; + } + return false; + } + template + inline typename traits::enable_if< + !traits::is_convertible *>::value, + bool>::type + operator!=(const T &rhs) const { + return !((*this) == rhs); + } + //@} + + void dump(std::ostream &os) const { + lua_State *state = state_(); + util::ScopedSavedStack save(state); + int stackIndex = pushStackIndex_(state); + util::stackValueDump(os, state, stackIndex); + } + +private: + lua_State *state_() const { + return static_cast(this)->state(); + } + int pushStackIndex_(lua_State *state) const { + return static_cast(this)->pushStackIndex(state); + } + template + optional::get_type> checkGet_() const { + lua_State *state = state_(); + util::ScopedSavedStack save(state); + int stackindex = pushStackIndex_(state); + return lua_type_traits< + optional::get_type> >::get(state, + stackindex); + } +}; +template +inline std::ostream &operator<<(std::ostream &os, + const LuaBasicTypeFunctions &ref) { + ref.dump(os); + return os; +} +/** +* @name relational operators +* @brief +*/ +//@{ + +#define KAGUYA_ENABLE_IF_NOT_LUAREF(RETTYPE) \ + typename traits::enable_if< \ + !traits::is_convertible *>::value, \ + RETTYPE>::type +template +inline KAGUYA_ENABLE_IF_NOT_LUAREF(bool) +operator==(const T &lhs, const LuaBasicTypeFunctions &rhs) { + return rhs == lhs; +} +template +inline KAGUYA_ENABLE_IF_NOT_LUAREF(bool) +operator!=(const T &lhs, const LuaBasicTypeFunctions &rhs) { + return !(rhs == lhs); +} +#undef KAGUYA_ENABLE_IF_NOT_LUAREF +//@} +} +} + +namespace kaguya { +inline const char *get_error_message(lua_State *state) { + if (lua_type(state, -1) == LUA_TSTRING) { + const char *message = lua_tostring(state, -1); + return message ? message : "unknown error"; + } else { + return "unknown error"; + } +} +inline int lua_pcall_wrap(lua_State *state, int argnum, int retnum) { + int result = lua_pcall(state, argnum, retnum, 0); + return result; +} + +struct ErrorHandler { + typedef standard::function function_type; + + static bool handle(const char *message, lua_State *state) { + function_type *handler = getFunctionPointer(state); + if (handler) { + (*handler)(0, message); + return true; + } + return false; + } + static bool handle(int status_code, const char *message, lua_State *state) { + function_type *handler = getFunctionPointer(state); + if (handler) { + (*handler)(status_code, message); + return true; + } + return false; + } + static bool handle(int status_code, lua_State *state) { + function_type *handler = getFunctionPointer(state); + if (handler) { + (*handler)(status_code, get_error_message(state)); + return true; + } + return false; + } + + static function_type getHandler(lua_State *state) { + function_type *funptr = getFunctionPointer(state); + if (funptr) { + return *funptr; + } + return function_type(); + } + + static void unregisterHandler(lua_State *state) { + if (state) { + function_type *funptr = getFunctionPointer(state); + if (funptr) { + *funptr = function_type(); + } + } + } + static void registerHandler(lua_State *state, function_type f) { + if (state) { + function_type *funptr = getFunctionPointer(state); + if (!funptr) { + util::ScopedSavedStack save(state); +#if KAGUYA_SUPPORT_MULTIPLE_SHARED_LIBRARY + lua_pushstring(state, handlerRegistryKey()); +#else + lua_pushlightuserdata(state, handlerRegistryKey()); +#endif + void *ptr = lua_newuserdata( + state, sizeof(function_type)); // dummy data for gc call + funptr = new (ptr) function_type(); + + // create function_type metatable + lua_newtable(state); + lua_pushcclosure(state, &error_handler_cleanner, 0); + lua_setfield(state, -2, "__gc"); + lua_pushvalue(state, -1); + lua_setfield(state, -1, "__index"); + lua_setmetatable(state, -2); + + lua_rawset(state, LUA_REGISTRYINDEX); + } + *funptr = f; + } + } + + static void throwDefaultError(int status, const char *message = 0) { + switch (status) { + case LUA_ERRSYNTAX: + throw LuaSyntaxError( + status, message ? std::string(message) : "unknown syntax error"); + case LUA_ERRRUN: + throw LuaRuntimeError( + status, message ? std::string(message) : "unknown runtime error"); + case LUA_ERRMEM: + throw LuaMemoryError(status, + message ? std::string(message) + : "lua memory allocation error"); + case LUA_ERRERR: + throw LuaErrorRunningError(status, + message ? std::string(message) + : "unknown error running error"); +#if LUA_VERSION_NUM >= 502 + case LUA_ERRGCMM: + throw LuaGCError(status, + message ? std::string(message) : "unknown gc error"); +#endif + default: + throw LuaUnknownError( + status, message ? std::string(message) : "lua unknown error"); + } + } + +private: +#if KAGUYA_SUPPORT_MULTIPLE_SHARED_LIBRARY + static const char *handlerRegistryKey() { + return "\x80KAGUYA_ERROR_HANDLER_REGISTRY_KEY"; + } +#else + static void *handlerRegistryKey() { + static void *key; + return key; + } +#endif + static function_type *getFunctionPointer(lua_State *state) { + if (state) { + util::ScopedSavedStack save(state); +#if KAGUYA_SUPPORT_MULTIPLE_SHARED_LIBRARY + lua_pushstring(state, handlerRegistryKey()); +#else + lua_pushlightuserdata(state, handlerRegistryKey()); +#endif + lua_rawget(state, LUA_REGISTRYINDEX); + function_type *ptr = (function_type *)lua_touserdata(state, -1); + return ptr; + } + return 0; + } + + ErrorHandler() {} + + ErrorHandler(const ErrorHandler &); + ErrorHandler &operator=(const ErrorHandler &); + + static int error_handler_cleanner(lua_State *state) { + function_type *ptr = (function_type *)lua_touserdata(state, 1); + ptr->~function_type(); + return 0; + } +}; + +namespace except { +inline void OtherError(lua_State *state, const std::string &message) { + if (ErrorHandler::handle(message.c_str(), state)) { + return; + } +} +inline void typeMismatchError(lua_State *state, const std::string &message) { + if (ErrorHandler::handle(message.c_str(), state)) { + return; + } +} +inline void memoryError(lua_State *state, const char *message) { + if (ErrorHandler::handle(message, state)) { + return; + } +} +inline bool checkErrorAndThrow(int status, lua_State *state) { + if (status != 0 && status != LUA_YIELD) { + ErrorHandler::handle(status, state); + + return false; + } + return true; +} +} +} +// Copyright satoren +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + + +#include +#include +#include +#include +#include + +namespace kaguya { +/// @brief StackTop tag type +struct StackTop {}; + +namespace Ref { +/// @brief NoMainCheck tag type +struct NoMainCheck {}; + +/// @brief reference to Lua stack value +class StackRef { +protected: + lua_State *state_; + int stack_index_; + mutable bool pop_; +#if KAGUYA_USE_CPP11 + StackRef(StackRef &&src) + : state_(src.state_), stack_index_(src.stack_index_), pop_(src.pop_) { + src.pop_ = false; + } + StackRef &operator=(StackRef &&src) { + state_ = src.state_; + stack_index_ = src.stack_index_; + pop_ = src.pop_; + + src.pop_ = false; + return *this; + } + + StackRef(const StackRef &src) = delete; + StackRef &operator=(const StackRef &src) = delete; +#else + StackRef(const StackRef &src) + : state_(src.state_), stack_index_(src.stack_index_), pop_(src.pop_) { + src.pop_ = false; + } + StackRef &operator=(const StackRef &src) { + if (this != &src) { + state_ = src.state_; + stack_index_ = src.stack_index_; + pop_ = src.pop_; + + src.pop_ = false; + } + return *this; + } +#endif + StackRef(lua_State *s, int index) + : state_(s), stack_index_(lua_absindex(s, index)), pop_(true) {} + StackRef(lua_State *s, int index, bool pop) + : state_(s), stack_index_(lua_absindex(s, index)), pop_(pop) {} + StackRef() : state_(0), stack_index_(0), pop_(false) {} + ~StackRef() { + if (state_ && pop_) { + if (lua_gettop(state_) >= stack_index_) { + lua_settop(state_, stack_index_ - 1); + } + } + } + +public: + bool isNilref() const { + return state_ == 0 || lua_type(state_, stack_index_) == LUA_TNIL; + } + + int push() const { + lua_pushvalue(state_, stack_index_); + return 1; + } + int push(lua_State *state) const { + lua_pushvalue(state_, stack_index_); + if (state_ != state) { + lua_pushvalue(state_, stack_index_); + lua_xmove(state_, state, 1); + } + return 1; + } + + int pushStackIndex(lua_State *state) const { + if (state_ != state) { + lua_pushvalue(state_, stack_index_); + lua_xmove(state_, state, 1); + return lua_gettop(state); + } else { + return stack_index_; + } + } + lua_State *state() const { return state_; } +}; + +/// @brief Reference to Lua value. Retain reference by LUA_REGISTRYINDEX +class RegistoryRef { +public: +#if KAGUYA_USE_SHARED_LUAREF + struct RefHolder { + struct RefDeleter { + RefDeleter(lua_State *L) : state_(L) {} + void operator()(int *ref) { + luaL_unref(state_, LUA_REGISTRYINDEX, *ref); + delete ref; + } + lua_State *state_; + }; + RefHolder(lua_State *L, int ref) + : state_(L), ref_(new int(ref), RefDeleter(L)) {} + + RefHolder(const RefHolder &src) : state_(src.state_), ref_(src.ref_) {} + RefHolder &operator=(const RefHolder &src) { + state_ = src.state_; + ref_ = src.ref_; + return *this; + } +#if KAGUYA_USE_RVALUE_REFERENCE + RefHolder(RefHolder &&src) : state_(0), ref_() { swap(src); } + RefHolder &operator=(RefHolder &&src) throw() { + swap(src); + return *this; + } +#endif + void swap(RefHolder &other) throw() { + std::swap(state_, other.state_); + std::swap(ref_, other.ref_); + } + int ref() const { + if (state_ && ref_) { + return *ref_; + } + return LUA_REFNIL; + } + void reset() { ref_.reset(); } + lua_State *state() const { return state_; } + + private: + lua_State *state_; + standard::shared_ptr ref_; + }; +#else + struct RefHolder { + RefHolder(lua_State *L, int ref) : state_(L), ref_(ref) {} + RefHolder(const RefHolder &src) : state_(src.state_), ref_(LUA_REFNIL) { + if (state_) { + lua_rawgeti(state_, LUA_REGISTRYINDEX, src.ref_); + ref_ = luaL_ref(state_, LUA_REGISTRYINDEX); + } + } + RefHolder &operator=(const RefHolder &src) { + reset(); + state_ = src.state_; + if (state_) { + lua_rawgeti(state_, LUA_REGISTRYINDEX, src.ref_); + ref_ = luaL_ref(state_, LUA_REGISTRYINDEX); + } else { + ref_ = LUA_REFNIL; + } + return *this; + } +#if KAGUYA_USE_RVALUE_REFERENCE + RefHolder(RefHolder &&src) throw() : state_(src.state_), ref_(src.ref_) { + src.ref_ = LUA_REFNIL; + } + RefHolder &operator=(RefHolder &&src) throw() { + swap(src); + return *this; + } +#endif + void swap(RefHolder &other) throw() { + std::swap(state_, other.state_); + std::swap(ref_, other.ref_); + } + int ref() const { + if (state_) { + return ref_; + } + return LUA_REFNIL; + } + void reset() { + if (ref_ != LUA_REFNIL && state_) { + luaL_unref(state_, LUA_REGISTRYINDEX, ref_); + ref_ = LUA_REFNIL; + } + } + ~RefHolder() { reset(); } + + lua_State *state() const { return state_; } + + private: + lua_State *state_; + int ref_; + }; +#endif + RegistoryRef(const RegistoryRef &src) : ref_(src.ref_) {} + RegistoryRef &operator=(const RegistoryRef &src) { + if (this != &src) { + ref_ = src.ref_; + } + return *this; + } + + static int ref_from_stacktop(lua_State *state) { + if (state) { + return luaL_ref(state, LUA_REGISTRYINDEX); + } else { + return LUA_REFNIL; + } + } +#if KAGUYA_USE_RVALUE_REFERENCE + RegistoryRef(RegistoryRef &&src) throw() : ref_(0, LUA_REFNIL) { swap(src); } + RegistoryRef &operator=(RegistoryRef &&src) throw() { + swap(src); + return *this; + } +#endif + + RegistoryRef() : ref_(0, LUA_REFNIL) {} + RegistoryRef(lua_State *state) : ref_(state, LUA_REFNIL) {} + + RegistoryRef(lua_State *state, StackTop, NoMainCheck) + : ref_(state, ref_from_stacktop(state)) {} + + RegistoryRef(lua_State *state, StackTop) + : ref_(util::toMainThread(state), ref_from_stacktop(state)) {} + + void swap(RegistoryRef &other) throw() { ref_.swap(other.ref_); } + + template + RegistoryRef(lua_State *state, const T &v, NoMainCheck) + : ref_(0, LUA_REFNIL) { + if (!state) { + return; + } + util::ScopedSavedStack save(state); + util::one_push(state, v); + ref_ = RefHolder(state, ref_from_stacktop(state)); + } + template + RegistoryRef(lua_State *state, const T &v) : ref_(0, LUA_REFNIL) { + if (!state) { + return; + } + util::ScopedSavedStack save(state); + util::one_push(state, v); + ref_ = RefHolder(util::toMainThread(state), ref_from_stacktop(state)); + } +#if KAGUYA_USE_CPP11 + template + RegistoryRef(lua_State *state, T &&v, NoMainCheck) : ref_(0, LUA_REFNIL) { + if (!state) { + return; + } + util::ScopedSavedStack save(state); + util::one_push(state, standard::forward(v)); + ref_ = RefHolder(state, ref_from_stacktop(state)); + } + template + RegistoryRef(lua_State *state, T &&v) : ref_(0, LUA_REFNIL) { + if (!state) { + return; + } + util::ScopedSavedStack save(state); + util::one_push(state, standard::forward(v)); + ref_ = RefHolder(util::toMainThread(state), ref_from_stacktop(state)); + } +#endif + ~RegistoryRef() { + try { + unref(); + } catch (...) { + } // can't throw at Destructor + } + + /// @brief push to Lua stack + int push() const { return push(ref_.state()); } + /// @brief push to Lua stack + int push(lua_State *state) const { + if (isNilref()) { + lua_pushnil(state); + return 1; + } +#if LUA_VERSION_NUM >= 502 + if (state != ref_.state()) { // state check + assert(util::toMainThread(state) == util::toMainThread(ref_.state())); + } +#endif + lua_rawgeti(state, LUA_REGISTRYINDEX, ref_.ref()); + return 1; + } + + int pushStackIndex(lua_State *state) const { + push(state); + return lua_gettop(state); + } + lua_State *state() const { return ref_.state(); } + + bool isNilref() const { return ref_.ref() == LUA_REFNIL; } + + void unref() { ref_.reset(); } + +private: + RefHolder ref_; +}; +} +} +// Copyright satoren +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + + +// Copyright satoren +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + + +#include +#include +#include +#include +#include + +namespace kaguya { +class LuaTable; +class LuaFunction; + +class FunctionResults; + +/** +* status of coroutine +*/ +enum coroutine_status { + COSTAT_RUNNING, //!< coroutine is running + COSTAT_SUSPENDED, //!< coroutine is suspended + COSTAT_NORMAL, //!< + COSTAT_DEAD //!< coroutine is dead +}; + +namespace detail { +class FunctionResultProxy { +public: + template + static RetType ReturnValue(lua_State *state, int restatus, int retindex, + types::typetag tag); + static FunctionResults ReturnValue(lua_State *state, int restatus, + int retindex, + types::typetag tag); + static void ReturnValue(lua_State *state, int restatus, int retindex, + types::typetag tag); +}; + +template class LuaFunctionImpl { +private: + lua_State *state_() const { + return static_cast(this)->state(); + } + int pushStackIndex_(lua_State *state) const { + return static_cast(this)->pushStackIndex(state); + } + int push_(lua_State *state) const { + return static_cast(this)->push(state); + } + +public: + /** + * set function environment table + */ + bool setFunctionEnv(const LuaTable &env); + /** + * set function environment to new table + */ + bool setFunctionEnv(NewTable env); + /** + * get function environment table + */ + LuaTable getFunctionEnv() const; + +#if KAGUYA_USE_CPP11 + template Result call(Args &&... args) { + lua_State *state = state_(); + if (!state) { + except::typeMismatchError(state, "nil"); + return Result(); + } + int argstart = lua_gettop(state) + 1; + push_(state); + int argnum = util::push_args(state, std::forward(args)...); + int result = lua_pcall_wrap(state, argnum, LUA_MULTRET); + except::checkErrorAndThrow(result, state); + return detail::FunctionResultProxy::ReturnValue(state, result, argstart, + types::typetag()); + } + + template FunctionResults operator()(Args &&... args); +#else + +#define KAGUYA_CALL_DEF(N) \ + template \ + Result call(KAGUYA_PP_ARG_CR_DEF_REPEAT(N)) { \ + lua_State *state = state_(); \ + if (!state) { \ + except::typeMismatchError(state, "attempt to call nil value"); \ + 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) + +#undef KAGUYA_RESUME_DEF + + inline FunctionResults operator()(); + +#define KAGUYA_OP_FN_DEF(N) \ + template \ + inline FunctionResults operator()(KAGUYA_PP_ARG_CR_DEF_REPEAT(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) +#undef KAGUYA_OP_FN_DEF + +#undef KAGUYA_CALL_ARGS +#undef KAGUYA_FUNCTION_ARGS_DEF +#undef KAGUYA_CALL_DEF +#endif +}; + +template class LuaThreadImpl { +private: + lua_State *state_() const { + return static_cast(this)->state(); + } + int pushStackIndex_(lua_State *state) const { + return static_cast(this)->pushStackIndex(state); + } + +public: +#if KAGUYA_USE_CPP11 + template Result resume(Args &&... args) { + lua_State *state = state_(); + if (!state) { + except::typeMismatchError(state, "attempt to call nil value"); + 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; // exist function in stack at first resume. + if (lua_status(thread) == LUA_YIELD) { + argstart = 0; + } + util::push_args(thread, std::forward(args)...); + 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()); + } + template FunctionResults operator()(Args &&... args); +#else + +#define KAGUYA_RESUME_DEF(N) \ + template \ + Result resume(KAGUYA_PP_ARG_CR_DEF_REPEAT(N)) { \ + lua_State *state = state_(); \ + if (!state) { \ + except::typeMismatchError(state, "attempt to call nil value"); \ + 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_RESUME_DEF(0) + KAGUYA_PP_REPEAT_DEF(KAGUYA_FUNCTION_MAX_ARGS, KAGUYA_RESUME_DEF) + +#undef KAGUYA_RESUME_DEF + + inline FunctionResults operator()(); + +#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_OP_FN_DEF +#endif + + //! + //! @return state status + //! + int threadStatus() const { + lua_State *state = state_(); + if (!state) { + except::typeMismatchError(state, "attempt to call nil value"); + return LUA_ERRRUN; + } + util::ScopedSavedStack save(state); + int corStackIndex = pushStackIndex_(state); + lua_State *thread = lua_tothread(state, corStackIndex); + + if (!thread) { + except::typeMismatchError(state, "not thread"); + return LUA_ERRRUN; + } + return lua_status(thread); + } + + //! deprecate + int thread_status() const { return threadStatus(); } + + //! + //! @return coroutine status + //! + coroutine_status costatus(lua_State *l = 0) const { + lua_State *state = state_(); + if (!state) { + return COSTAT_DEAD; + } + util::ScopedSavedStack save(state); + int corStackIndex = pushStackIndex_(state); + lua_State *thread = lua_tothread(state, corStackIndex); + + if (!thread) { + except::typeMismatchError(state, "not thread"); + return COSTAT_DEAD; + } else if (thread == l) { + return COSTAT_RUNNING; + } else { + switch (lua_status(thread)) { + case LUA_YIELD: + return COSTAT_SUSPENDED; + case 0: // LUA_OK + { + if (lua_gettop(thread) == 0) { + return COSTAT_DEAD; + } else { + return COSTAT_SUSPENDED; + } + } + default: + break; + } + } + return COSTAT_DEAD; + } + + //! + //! @return if coroutine status is dead, return true. Otherwise return false + //! + bool isThreadDead() const { return costatus() == COSTAT_DEAD; } + + /// @brief set function for thread running. + void setFunction(const LuaFunction &f); + + /// @brief get lua thread + lua_State *getthread() { + lua_State *state = state_(); + util::ScopedSavedStack save(state); + int corStackIndex = pushStackIndex_(state); + return lua_tothread(state, corStackIndex); + } +}; +} +} +// Copyright satoren +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + + +#include +#include +#include + +namespace kaguya { +class LuaRef; +class LuaStackRef; +class LuaTable; +template class TableKeyReferenceProxy; +class MemberFunctionBinder; + +namespace detail { + +struct table_proxy { + +#if KAGUYA_USE_CPP11 + template + static void set(lua_State *state, int table_index, KEY &&key, V &&value) { + util::one_push(state, std::forward(key)); + util::one_push(state, std::forward(value)); + lua_settable(state, table_index); + } + template + static void set(lua_State *state, int table_index, const char *key, + V &&value) { + util::one_push(state, std::forward(value)); + lua_setfield(state, table_index, key); + } + template + static void set(lua_State *state, int table_index, const std::string &key, + V &&value) { + set(state, table_index, key.c_str(), std::forward(value)); + } + + template + static void set(lua_State *state, int table_index, luaInt key, V &&value) { + util::one_push(state, std::forward(value)); + lua_seti(state, table_index, key); + } + template + static void rawset(lua_State *state, int table_index, KEY &&key, V &&value) { + util::one_push(state, std::forward(key)); + util::one_push(state, std::forward(value)); + lua_rawset(state, table_index); + } + template + static void rawset(lua_State *state, int table_index, luaInt key, V &&value) { + util::one_push(state, std::forward(value)); + lua_rawseti(state, table_index, key); + } +#else + template + static void set(lua_State *state, int table_index, const KEY &key, + const V &value) { + util::one_push(state, key); + util::one_push(state, value); + lua_settable(state, table_index); + } + template + static void set(lua_State *state, int table_index, const char *key, + const V &value) { + util::one_push(state, value); + lua_setfield(state, table_index, key); + } + template + static void set(lua_State *state, int table_index, const std::string &key, + const V &value) { + util::one_push(state, value); + lua_setfield(state, table_index, key.c_str()); + } + + template + static void set(lua_State *state, int table_index, luaInt key, + const V &value) { + util::one_push(state, value); + lua_seti(state, table_index, key); + } + + template + static void rawset(lua_State *state, int table_index, const KEY &key, + const V &value) { + util::one_push(state, key); + util::one_push(state, value); + lua_rawset(state, table_index); + } + template + static void rawset(lua_State *state, int table_index, luaInt key, + const V &value) { + util::one_push(state, value); + lua_rawseti(state, table_index, key); + } +#endif + +#if KAGUYA_USE_CPP11 + template + static void get(lua_State *state, int table_index, KEY &&key) { + util::one_push(state, std::forward(key)); + lua_gettable(state, table_index); + } +#endif + template + static void get(lua_State *state, int table_index, const KEY &key) { + util::one_push(state, key); + lua_gettable(state, table_index); + } + static void get(lua_State *state, int table_index, const char *key) { + lua_getfield(state, table_index, key); + } + static void get(lua_State *state, int table_index, const std::string &key) { + lua_getfield(state, table_index, key.c_str()); + } + static void get(lua_State *state, int table_index, luaInt key) { + lua_geti(state, table_index, key); + } +#if KAGUYA_USE_CPP11 + template + static void rawget(lua_State *state, int table_index, KEY &&key) { + util::one_push(state, std::forward(key)); + lua_rawget(state, table_index); + } +#endif + template + static void rawget(lua_State *state, int table_index, const KEY &key) { + util::one_push(state, key); + lua_rawget(state, table_index); + } + static void rawget(lua_State *state, int table_index, luaInt key) { + lua_rawgeti(state, table_index, key); + } +}; + +template class LuaTableOrUserDataImpl { +private: + lua_State *state_() const { + return static_cast(this)->state(); + } + int pushStackIndex_(lua_State *state) const { + return static_cast(this)->pushStackIndex(state); + } + int push_(lua_State *state) const { + return static_cast(this)->push(state); + } + +public: + /// @brief set metatable + /// @param table metatable + bool setMetatable(const LuaTable &table); + + /// @brief get metatable + LuaTable getMetatable() const; + + /// @brief table->*"function_name"() in c++ and table:function_name(); in lua + /// is same + /// @param function_name function_name in table + MemberFunctionBinder operator->*(const char *function_name); + + /// @brief value = table[key]; + /// @param key key of table + /// @return reference of field value + template + typename lua_type_traits::get_type getField(const KEY &key) const { + lua_State *state = state_(); + typedef typename lua_type_traits::get_type get_type; + if (!state) { + except::typeMismatchError(state, "is nil"); + return get_type(); + } + util::ScopedSavedStack save(state); + int stackIndex = pushStackIndex_(state); + + table_proxy::get(state, stackIndex, key); + + return lua_type_traits::get(state, -1); + } + + /// @brief value = table[key]; + /// @param key key of table + /// @return reference of field value + template LuaStackRef getField(const KEY &key) const; + +#if KAGUYA_USE_CPP11 + /// @brief table[key] = value; + template bool setField(K &&key, V &&value) { + lua_State *state = state_(); + if (!state) { + except::typeMismatchError(state, "is nil"); + return false; + } + util::ScopedSavedStack save(state); + int stackIndex = pushStackIndex_(state); + + table_proxy::set(state, stackIndex, std::forward(key), + std::forward(value)); + return true; + } +#else + /// @brief table[key] = value; + template + bool setField(const K &key, const V &value) { + lua_State *state = state_(); + if (!state) { + except::typeMismatchError(state, "is nil"); + return false; + } + util::ScopedSavedStack save(state); + int stackIndex = pushStackIndex_(state); + + table_proxy::set(state, stackIndex, key, value); + + return true; + } +#endif + + /// @brief value = table[key]; + /// @param key key of table + /// @return reference of field value + template LuaStackRef operator[](K key) const; + + /// @brief value = table[key];or table[key] = value; + /// @param key key of table + /// @return reference of field value + template TableKeyReferenceProxy operator[](K key); +}; + +template class LuaTableImpl { +private: + lua_State *state_() const { + return static_cast(this)->state(); + } + int pushStackIndex_(lua_State *state) const { + return static_cast(this)->pushStackIndex(state); + } + int push_(lua_State *state) const { + return static_cast(this)->push(state); + } + + template struct gettablekey { + typedef K key_type; + typedef void value_type; + std::vector &v_; + gettablekey(std::vector &v) : v_(v) {} + void operator()(K key, const void *) { v_.push_back(key); } + }; + template struct gettablevalue { + typedef void key_type; + typedef V value_type; + std::vector &v_; + gettablevalue(std::vector &v) : v_(v) {} + void operator()(const void *, V value) { v_.push_back(value); } + }; + template struct gettablemap { + typedef K key_type; + typedef V value_type; + std::map &m_; + gettablemap(std::map &m) : m_(m) {} + void operator()(K key, V value) { m_[key] = value; } + }; + +public: +#if KAGUYA_USE_CPP11 + /// @brief rawset(table,key,value) + template bool setRawField(K &&key, V &&value) { + lua_State *state = state_(); + if (!state) { + except::typeMismatchError(state, "is nil"); + return false; + } + util::ScopedSavedStack save(state); + int stackIndex = pushStackIndex_(state); + + table_proxy::rawset(state, stackIndex, std::forward(key), + std::forward(value)); + + return true; + } +#else + /// @brief rawset(table,key,value) + template + bool setRawField(const K &key, const V &value) { + lua_State *state = state_(); + if (!state) { + except::typeMismatchError(state, "is nil"); + return false; + } + util::ScopedSavedStack save(state); + int stackIndex = pushStackIndex_(state); + table_proxy::rawset(state, stackIndex, key, value); + return true; + } +#endif + /// @brief value = rawget(table,key); + /// @param key key of table + /// @return reference of field value + template + typename lua_type_traits::get_type getRawField(const KEY &key) const { + lua_State *state = state_(); + typedef typename lua_type_traits::get_type get_type; + if (!state) { + except::typeMismatchError(state, "is nil"); + return get_type(); + } + util::ScopedSavedStack save(state); + int stackIndex = pushStackIndex_(state); + + table_proxy::rawget(state, stackIndex, key); + + return lua_type_traits::get(state, -1); + } + /// @brief value = rawget(table,key); + /// @param key key of table + /// @return reference of field value + template LuaStackRef getRawField(const KEY &key) const; + + /// @brief foreach table fields + template void foreach_table(Fun f) const { + lua_State *state = state_(); + if (!state) { + except::typeMismatchError(state, "is nil"); + return; + } + util::ScopedSavedStack save(state); + int stackIndex = pushStackIndex_(state); + lua_pushnil(state); + while (lua_next(state, stackIndex) != 0) { + // backup key + lua_pushvalue(state, -2); + + f(lua_type_traits::get(state, -1), lua_type_traits::get(state, -2)); + lua_pop(state, 2); // pop key and value + } + } + + /// @brief foreach table fields + template + void foreach_table_breakable(Fun f) const { + lua_State *state = state_(); + if (!state) { + except::typeMismatchError(state, "is nil"); + return; + } + util::ScopedSavedStack save(state); + int stackIndex = pushStackIndex_(state); + lua_pushnil(state); + while (lua_next(state, stackIndex) != 0) { + lua_pushvalue(state, -2); // backup key + + bool cont = f(lua_type_traits::get(state, -1), + lua_type_traits::get(state, -2)); + lua_pop(state, 2); // pop key and value + if (!cont) { + break; + } + } + } + + /// @brief If type is table or userdata, return keys. + /// @return field keys + template std::vector keys() const { + std::vector res; + util::ScopedSavedStack save(state_()); + int stackIndex = pushStackIndex_(state_()); + size_t size = lua_rawlen(state_(), stackIndex); + res.reserve(size); + foreach_table(gettablekey(res)); + return res; + } + + /// @brief If type is table or userdata, return keys. + /// @return field keys + template std::vector keys() const { + return keys >(); + } + std::vector keys() const; + + /// @brief If type is table or userdata, return values. + /// @return field value + template std::vector values() const { + std::vector res; + util::ScopedSavedStack save(state_()); + int stackIndex = pushStackIndex_(state_()); + size_t size = lua_rawlen(state_(), stackIndex); + res.reserve(size); + foreach_table(gettablevalue(res)); + return res; + } + + /// @brief If type is table or userdata, return values. + /// @return field value + template std::vector values() const { + return values >(); + } + std::vector values() const; + + /// @brief If type is table or userdata, return key value pair. + /// @return key value pair + template + std::map map() const { + std::map res; + foreach_table(gettablemap(res)); + return res; + } + + /// @brief If type is table or userdata, return key value pair. + /// @return key value pair + template std::map map() const { + return map > >(); + } + + /// @brief If type is table or userdata, return key value pair. + /// @return key value pair + template std::map map() const { + return map >(); + } + std::map map() const; +}; + +template class LuaUserDataImpl { +private: + lua_State *state_() const { + return static_cast(this)->state(); + } + int pushStackIndex_(lua_State *state) const { + return static_cast(this)->pushStackIndex(state); + } + int push_(lua_State *state) const { + return static_cast(this)->push(state); + } + +public: + /// @brief is type test + template bool isType() const { + lua_State *state = state_(); + util::ScopedSavedStack save(state); + return lua_type_traits::strictCheckType(state, pushStackIndex_(state)); + } + + template bool isConvertible() const { + lua_State *state = state_(); + util::ScopedSavedStack save(state); + return lua_type_traits::checkType(state, pushStackIndex_(state)); + } + + template bool typeTest() const { return isType(); } + template bool weakTypeTest() const { return isConvertible(); } + + template typename lua_type_traits::get_type get() const { + lua_State *state = state_(); + util::ScopedSavedStack save(state); + return lua_type_traits::get(state, state ? pushStackIndex_(state) : 0); + } + + template operator T() const { return get(); } +}; +} +} + +namespace kaguya { +class LuaRef; +class LuaTable; +template class TableKeyReferenceProxy; +class MemberFunctionBinder; + +namespace detail { + +template +class LuaVariantImpl : public LuaTableImpl, + public LuaTableOrUserDataImpl, + public detail::LuaFunctionImpl, + public detail::LuaThreadImpl, + public LuaBasicTypeFunctions { +private: + lua_State *state_() const { + return static_cast(this)->state(); + } + int pushStackIndex_(lua_State *state) const { + return static_cast(this)->pushStackIndex(state); + } + +public: + using LuaBasicTypeFunctions::type; + using LuaBasicTypeFunctions::typeName; + + /// @brief deprecated, use isType instead. + template bool typeTest() const { return isType(); } + + /// @brief deprecated, use isConvertible instead. + template bool weakTypeTest() const { return isConvertible(); } + + /// @brief is type test + template bool isType() const { + lua_State *state = state_(); + util::ScopedSavedStack save(state); + return lua_type_traits::strictCheckType(state, pushStackIndex_(state)); + } + + template bool isConvertible() const { + lua_State *state = state_(); + util::ScopedSavedStack save(state); + return lua_type_traits::checkType(state, pushStackIndex_(state)); + } + + template typename lua_type_traits::get_type get() const { + lua_State *state = state_(); + util::ScopedSavedStack save(state); + return lua_type_traits::get(state, state ? pushStackIndex_(state) : 0); + } + template + typename lua_type_traits::get_type value_or(U v) const { + lua_State *state = state_(); + util::ScopedSavedStack save(state); + return lua_type_traits >::get( + state, state ? pushStackIndex_(state) : 0) + .value_or(v); + } + + // deprecated. use get >() instead; + template + typename lua_type_traits::get_type + get(bool &was_valid, bool allow_convertible = true) const { + lua_State *state = state_(); + util::ScopedSavedStack save(state); + int stackindex = pushStackIndex_(state); + if (allow_convertible) { + was_valid = lua_type_traits::checkType(state, stackindex); + } else { + was_valid = lua_type_traits::strictCheckType(state, stackindex); + } + if (was_valid) { + return lua_type_traits::get(state, stackindex); + } else { + return T(); + } + } + template operator T() const { return get(); } + +#if KAGUYA_USE_CPP11 + template FunctionResults operator()(Args &&... args); +#else + inline FunctionResults operator()(); + +#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_OP_FN_DEF +#endif +}; +} +} + +namespace kaguya { +namespace util { +template +inline Result get_result_impl(lua_State *l, int startindex, + types::typetag) { + return lua_type_traits::get(l, startindex); +} +#if KAGUYA_USE_CPP11 +inline standard::tuple<> +get_result_tuple_impl(lua_State *, int, types::typetag >) { + return standard::tuple<>(); +} +template +inline standard::tuple +get_result_tuple_impl(lua_State *l, int index, + types::typetag >) { + return standard::tuple_cat( + standard::tuple(lua_type_traits::get(l, index)), + get_result_tuple_impl(l, index + 1, + types::typetag >())); +} +template +inline standard::tuple +get_result_impl(lua_State *l, int startindex, + types::typetag > tag) { + return get_result_tuple_impl(l, startindex, tag); +} +#else + +inline standard::tuple<> get_result_impl(lua_State *l, int startindex, + types::typetag >) { + KAGUYA_UNUSED(l); + KAGUYA_UNUSED(startindex); + return standard::tuple<>(); +} + +#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 >) { \ + 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_GET_DEF +#undef KAGUYA_GET_TUPLE_DEF +#endif + +template inline Result get_result(lua_State *l, int startindex) { + return get_result_impl(l, startindex, types::typetag()); +} +template <> inline void get_result(lua_State *, int) {} +} + +/// @addtogroup Lua_reference_types + +/// @ingroup Lua_reference_types +/// @brief Reference to any Lua data. +class LuaRef : public Ref::RegistoryRef, public detail::LuaVariantImpl { +private: +public: + LuaRef(const Ref::RegistoryRef &src) : Ref::RegistoryRef(src) {} + LuaRef(const LuaRef &src) : Ref::RegistoryRef(src) {} + LuaRef &operator=(const LuaRef &src) { + static_cast(*this) = src; + return *this; + } + +#if KAGUYA_USE_CPP11 + + LuaRef(LuaRef &&src) : Ref::RegistoryRef(std::move(src)) {} + + LuaRef &operator=(LuaRef &&src) throw() { + swap(src); + return *this; + } + + LuaRef(RegistoryRef &&src) throw() : Ref::RegistoryRef(std::move(src)) {} + template + LuaRef(lua_State *state, T &&v, Ref::NoMainCheck) + : Ref::RegistoryRef(state, std::move(v), Ref::NoMainCheck()) {} + template + LuaRef(lua_State *state, T &&v) : Ref::RegistoryRef(state, std::move(v)) {} +#endif + + LuaRef() {} + LuaRef(lua_State *state) : Ref::RegistoryRef(state) {} + + LuaRef(lua_State *state, StackTop, Ref::NoMainCheck) + : Ref::RegistoryRef(state, StackTop(), Ref::NoMainCheck()) {} + + LuaRef(lua_State *state, StackTop) : Ref::RegistoryRef(state, StackTop()) {} + + template + LuaRef(lua_State *state, const T &v, Ref::NoMainCheck) + : Ref::RegistoryRef(state, v, Ref::NoMainCheck()) {} + template + LuaRef(lua_State *state, const T &v) : Ref::RegistoryRef(state, v) {} + + const void *native_pointer() const { + util::ScopedSavedStack save(state()); + push(state()); + return lua_topointer(state(), -1); + } + static void putindent(std::ostream &os, int indent) { + while (indent-- > 0) { + os << " "; + } + } +}; + +/// @ingroup lua_type_traits +/// @brief lua_type_traits for LuaRef +template <> struct lua_type_traits { + typedef LuaRef get_type; + typedef const LuaRef &push_type; + + static bool checkType(lua_State *l, int index) { + KAGUYA_UNUSED(l); + KAGUYA_UNUSED(index); + return true; + } + static bool strictCheckType(lua_State *l, int index) { + KAGUYA_UNUSED(l); + KAGUYA_UNUSED(index); + return false; + } + + static get_type get(lua_State *l, int index) { + lua_pushvalue(l, index); + return LuaRef(l, StackTop()); + } + static int push(lua_State *l, push_type v) { return v.push(l); } +}; +/// @ingroup lua_type_traits +/// @brief lua_type_traits for LuaRef +template <> struct lua_type_traits : lua_type_traits {}; + +class LuaStackRef : public Ref::StackRef, + public detail::LuaVariantImpl { +public: + LuaStackRef() : Ref::StackRef() {} + LuaStackRef(lua_State *s, int index) : Ref::StackRef(s, index, false) {} + LuaStackRef(lua_State *s, int index, bool popAtDestruct) + : Ref::StackRef(s, index, popAtDestruct) {} +#if KAGUYA_USE_CPP11 + LuaStackRef(LuaStackRef &&src) : Ref::StackRef(std::move(src)) { + src.pop_ = false; + } + LuaStackRef &operator=(LuaStackRef &&src) { + if (this != &src) { + Ref::StackRef::operator=(std::move(src)); + src.pop_ = false; + } + return *this; + } + LuaStackRef(const LuaStackRef &src) = delete; +#else + LuaStackRef(const LuaStackRef &src) : Ref::StackRef(src) { src.pop_ = false; } + LuaStackRef &operator=(const LuaStackRef &src) { + if (this != &src) { + Ref::StackRef::operator=(src); + src.pop_ = false; + } + return *this; + } +#endif +}; + +/// @ingroup lua_type_traits +/// @brief lua_type_traits for LuaStackRef +template <> struct lua_type_traits { + typedef LuaStackRef get_type; + typedef const LuaStackRef &push_type; + + static bool checkType(lua_State *l, int index) { + KAGUYA_UNUSED(l); + KAGUYA_UNUSED(index); + return true; + } + static bool strictCheckType(lua_State *l, int index) { + KAGUYA_UNUSED(l); + KAGUYA_UNUSED(index); + return false; + } + + static get_type get(lua_State *l, int index) { return LuaStackRef(l, index); } + static int push(lua_State *l, push_type v) { return v.push(l); } +}; +/// @ingroup lua_type_traits +/// @brief lua_type_traits for LuaStackRef +template <> +struct lua_type_traits : lua_type_traits {}; + +/// @ingroup Lua_reference_types +/// @brief Reference to Lua userdata. +class LuaUserData : public Ref::RegistoryRef, + public detail::LuaUserDataImpl, + public detail::LuaTableOrUserDataImpl, + public detail::LuaBasicTypeFunctions { + + void typecheck() { + int t = type(); + if (t != TYPE_USERDATA && t != TYPE_LIGHTUSERDATA && t != TYPE_NIL && + t != TYPE_NONE) { + except::typeMismatchError(state(), "not user data"); + unref(); + } + } + +public: + operator LuaRef() { + push(state()); + return LuaRef(state(), StackTop()); + } + LuaUserData(lua_State *state, StackTop) + : Ref::RegistoryRef(state, StackTop()) { + typecheck(); + } + template + LuaUserData(lua_State *state, const TYPE &table) + : Ref::RegistoryRef(state, table) { + typecheck(); + } + explicit LuaUserData(lua_State *state) + : Ref::RegistoryRef(state, NilValue()) { + typecheck(); + } + LuaUserData() { typecheck(); } +}; + +/// @ingroup lua_type_traits +/// @brief lua_type_traits for LuaUserData +template <> struct lua_type_traits { + typedef LuaUserData get_type; + typedef LuaUserData push_type; + + static bool strictCheckType(lua_State *l, int index) { + return lua_type(l, index) == LUA_TUSERDATA; + } + static bool checkType(lua_State *l, int index) { + return lua_type(l, index) == LUA_TUSERDATA || lua_isnil(l, index); + } + static LuaUserData get(lua_State *l, int index) { + lua_pushvalue(l, index); + return LuaUserData(l, StackTop()); + } + static int push(lua_State *l, const LuaUserData &ref) { return ref.push(l); } +}; +/// @ingroup lua_type_traits +/// @brief lua_type_traits for LuaUserData +template <> +struct lua_type_traits : lua_type_traits {}; + +/// @ingroup Lua_reference_types +/// @brief Reference to Lua table. +class LuaTable : public Ref::RegistoryRef, + public detail::LuaTableImpl, + public detail::LuaTableOrUserDataImpl, + public detail::LuaBasicTypeFunctions { + + void typecheck() { + int t = type(); + if (t != TYPE_TABLE && t != TYPE_NIL && t != TYPE_NONE) { + except::typeMismatchError(state(), "not table"); + unref(); + } + } + +public: + operator LuaRef() { + push(state()); + return LuaRef(state(), StackTop()); + } + LuaTable(lua_State *state, StackTop) : Ref::RegistoryRef(state, StackTop()) { + typecheck(); + } + LuaTable(lua_State *state, const NewTable &table) + : Ref::RegistoryRef(state, table) { + typecheck(); + } + explicit LuaTable(lua_State *state) : Ref::RegistoryRef(state, NewTable()) { + typecheck(); + } + LuaTable() { typecheck(); } +}; + +/// @ingroup lua_type_traits +/// @brief lua_type_traits for LuaTable +template <> struct lua_type_traits { + typedef LuaTable get_type; + typedef LuaTable push_type; + + static bool strictCheckType(lua_State *l, int index) { + return lua_istable(l, index); + } + static bool checkType(lua_State *l, int index) { + return lua_istable(l, index) || lua_isnil(l, index); + } + static LuaTable get(lua_State *l, int index) { + lua_pushvalue(l, index); + return LuaTable(l, StackTop()); + } + static int push(lua_State *l, const LuaTable &ref) { return ref.push(l); } +}; +/// @ingroup lua_type_traits +/// @brief lua_type_traits for LuaTable +template <> +struct lua_type_traits : lua_type_traits {}; + +/// @ingroup Lua_reference_types +/// @brief Reference to Lua function. +class LuaFunction : public Ref::RegistoryRef, + public detail::LuaFunctionImpl, + public detail::LuaBasicTypeFunctions { + void typecheck() { + int t = type(); + if (t != TYPE_FUNCTION && t != TYPE_NIL && t != TYPE_NONE) { + except::typeMismatchError(state(), "not function"); + RegistoryRef::unref(); + } + } + + struct LuaLoadStreamWrapper { + LuaLoadStreamWrapper(std::istream &stream) + : preloaded_(false), stream_(stream) { + buffer_.reserve(512); + skipComment(); + preloaded_ = !buffer_.empty(); + } + + void skipComment() { + // skip bom + const char *bom = "\xEF\xBB\xBF"; + const char *bomseq = bom; + char c; + while (stream_.get(c)) { + if (c != *bomseq) // not bom sequence + { + buffer_.assign(bom, bomseq); + buffer_.push_back(c); + break; + } + bomseq++; + if ('\0' == *bomseq) { + return; + } + } + + // skip comment + if (!buffer_.empty() && buffer_.front() == '#') { + buffer_.clear(); + std::string comment; + std::getline(stream_, comment); + } + } + + static const char *getdata(lua_State *, void *ud, size_t *size) { + LuaLoadStreamWrapper *loader = static_cast(ud); + + if (loader->preloaded_) { + loader->preloaded_ = false; + } else { + loader->buffer_.clear(); + } + + char c = 0; + while (loader->buffer_.size() < loader->buffer_.capacity() && + loader->stream_.get(c)) { + loader->buffer_.push_back(c); + } + *size = loader->buffer_.size(); + return loader->buffer_.empty() ? 0 : &loader->buffer_[0]; + } + + private: + bool preloaded_; + std::vector buffer_; + std::istream &stream_; + }; + +public: + /// @brief construct with state and function . + /// @param state pointer to lua_State + /// @param f execute function for lua thread. e.g. + /// kaguya::function(function_ptr),kaguya::overload(function_ptr) + template + LuaFunction(lua_State *state, F f) : Ref::RegistoryRef(state, f) { + typecheck(); + } + + /// @brief construct with stack top value. + /// @param state pointer to lua_State + LuaFunction(lua_State *state, StackTop) + : Ref::RegistoryRef(state, StackTop()) { + typecheck(); + } + + /// @brief construct with nil reference. + LuaFunction() {} + + /// @brief load lua code . + /// @param state pointer to lua_State + /// @param luacode string + static LuaFunction loadstring(lua_State *state, const std::string &luacode) { + return loadstring(state, luacode.c_str()); + } + /// @brief load lua code . + /// @param state pointer to lua_State + /// @param luacode string + static LuaFunction loadstring(lua_State *state, const char *luacode) { + util::ScopedSavedStack save(state); + int status = luaL_loadstring(state, luacode); + + if (status) { + ErrorHandler::handle(status, state); + lua_pushnil(state); + } + return LuaFunction(state, StackTop()); + } + + /// @brief If there are no errors,compiled file as a Lua function and return. + /// Otherwise send error message to error handler and return nil reference + /// @param state pointer to lua_State + /// @param file file path of lua script + /// @return reference of lua function + static LuaFunction loadfile(lua_State *state, const std::string &file) { + return loadfile(state, file.c_str()); + } + + /// @brief If there are no errors,compiled file as a Lua function and return. + /// Otherwise send error message to error handler and return nil reference + /// @param state pointer to lua_State + /// @param file file path of lua script + /// @return reference of lua function + static LuaFunction loadfile(lua_State *state, const char *file) { + util::ScopedSavedStack save(state); + + int status = luaL_loadfile(state, file); + + if (status) { + ErrorHandler::handle(status, state); + lua_pushnil(state); + } + return LuaFunction(state, StackTop()); + } + + /// @brief If there are no errors,compiled stream as a Lua function and + /// return. + /// Otherwise send error message to error handler and return nil reference + /// @param state pointer to lua_State + /// @param stream stream of lua script data + /// @param chunkname use for error message. + /// @return reference of lua function + static LuaStackRef loadstreamtostack(lua_State *state, std::istream &stream, + const char *chunkname = 0) { + LuaLoadStreamWrapper wrapper(stream); +#if LUA_VERSION_NUM >= 502 + int status = + lua_load(state, &LuaLoadStreamWrapper::getdata, &wrapper, chunkname, 0); +#else + int status = + lua_load(state, &LuaLoadStreamWrapper::getdata, &wrapper, chunkname); +#endif + if (status) { + ErrorHandler::handle(status, state); + lua_pushnil(state); + } + return LuaStackRef(state, -1, true); + } + + /// @brief If there are no errors,compiled stream as a Lua function and + /// return. + /// Otherwise send error message to error handler and return nil reference + /// @param state pointer to lua_State + /// @param stream stream of lua script data + /// @param chunkname use for error message. + /// @return reference of lua function + static LuaFunction loadstream(lua_State *state, std::istream &stream, + const char *chunkname = 0) { + util::ScopedSavedStack save(state); + LuaLoadStreamWrapper wrapper(stream); +#if LUA_VERSION_NUM >= 502 + int status = + lua_load(state, &LuaLoadStreamWrapper::getdata, &wrapper, chunkname, 0); +#else + int status = + lua_load(state, &LuaLoadStreamWrapper::getdata, &wrapper, chunkname); +#endif + if (status) { + ErrorHandler::handle(status, state); + lua_pushnil(state); + } + return LuaFunction(state, StackTop()); + } +}; + +/// @ingroup Lua_reference_types +/// @brief Reference to Lua thread(coroutine). +class LuaThread : public Ref::RegistoryRef, + public detail::LuaThreadImpl, + public detail::LuaBasicTypeFunctions { + void typecheck() { + int t = type(); + if (t != TYPE_THREAD && t != TYPE_NIL && t != TYPE_NONE) { + except::typeMismatchError(state(), "not lua thread"); + RegistoryRef::unref(); + } + } + +public: + /// @brief construct with stack top value. + LuaThread(lua_State *state, StackTop) : Ref::RegistoryRef(state, StackTop()) { + typecheck(); + } + /// @brief construct with new thread. + LuaThread(lua_State *state, const NewThread &t) + : Ref::RegistoryRef(state, t) {} + /// @brief construct with nil reference. + LuaThread(lua_State *state) : Ref::RegistoryRef(state, NewThread()) {} + /// @brief construct with nil reference. + LuaThread() {} + /// @brief get lua thread + operator lua_State *() { return getthread(); } +}; +} + +#if KAGUYA_USE_CPP11 +#else +namespace std { +template <> inline void swap(kaguya::LuaUserData &a, kaguya::LuaUserData &b) { + a.swap(b); +} +template <> inline void swap(kaguya::LuaTable &a, kaguya::LuaTable &b) { + a.swap(b); +} +template <> inline void swap(kaguya::LuaFunction &a, kaguya::LuaFunction &b) { + a.swap(b); +} +template <> inline void swap(kaguya::LuaThread &a, kaguya::LuaThread &b) { + a.swap(b); +} +template <> inline void swap(kaguya::LuaRef &a, kaguya::LuaRef &b) { + a.swap(b); +} +} +#endif +// Copyright satoren +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + + +#include +#include +#include + + +#if KAGUYA_USE_CPP11 +// Copyright satoren +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include + + +namespace kaguya { +namespace nativefunction { +template struct index_tuple {}; + +template , + bool flag = first >= last> +struct index_range { + using type = result; +}; + +template +struct index_range, false> + : index_range > {}; + +template +int _call_apply(lua_State *state, F &&f, index_tuple, + util::FunctionSignatureType) { + return util::push_args( + state, util::invoke(f, lua_type_traits::get(state, Indexes)...)); +} +template +int _call_apply(lua_State *state, F &&f, index_tuple, + util::FunctionSignatureType) { + KAGUYA_UNUSED(state); + util::invoke(f, lua_type_traits::get(state, Indexes)...); + return 0; +} + +inline bool all_true() { return true; } +template +bool all_true(Arg f, Args... args) { // check from backward and lazy evaluation + return all_true(args...) && bool(f); +} + +inline void join(std::string &, const char *) {} +template +void join(std::string &result, const char *delim, const Arg &str, + const Args &... args) { + result += str; + result += delim; + join(result, delim, args...); +} + +template struct _wcheckeval { + _wcheckeval(lua_State *s, int i, bool opt) + : state(s), index(i), opt_arg(opt) {} + lua_State *state; + int index; + bool opt_arg; + operator bool() { + return (opt_arg && lua_isnoneornil(state, index)) || + lua_type_traits::checkType(state, index); + } +}; + +template struct _scheckeval { + _scheckeval(lua_State *s, int i, bool opt) + : state(s), index(i), opt_arg(opt) {} + lua_State *state; + int index; + bool opt_arg; + operator bool() { + return (opt_arg && lua_isnoneornil(state, index)) || + lua_type_traits::strictCheckType(state, index); + } +}; + +template +bool _ctype_apply(lua_State *state, index_tuple, + util::TypeTuple, int opt_count) { + KAGUYA_UNUSED(state); + KAGUYA_UNUSED(opt_count); + return all_true(_wcheckeval( + state, Indexes, sizeof...(Indexes) - opt_count < Indexes)...); +} +template +bool _sctype_apply(lua_State *state, index_tuple, + util::TypeTuple, int opt_count) { + KAGUYA_UNUSED(state); + KAGUYA_UNUSED(opt_count); + return all_true(_scheckeval( + state, Indexes, sizeof...(Indexes) - opt_count < Indexes)...); +} + +template +std::string _type_name_apply(index_tuple, util::TypeTuple, + int opt_count) { + KAGUYA_UNUSED(opt_count); + std::string result; + const int max_arg = sizeof...(Args); + join(result, ",", + (((max_arg - opt_count < int(Indexes)) ? std::string("[OPT]") + : std::string("")) + + util::pretty_name(typeid(Args)))...); + return result; +} + +template int call(lua_State *state, F &&f) { + typedef typename traits::decay::type ftype; + typedef typename util::FunctionSignature::type fsigtype; + typedef typename index_range<1, fsigtype::argument_count + 1>::type index; + return _call_apply(state, f, index(), fsigtype()); +} +template +bool checkArgTypes(lua_State *state, const F &, int opt_count = 0) { + typedef typename traits::decay::type ftype; + typedef typename util::FunctionSignature::type fsigtype; + typedef typename index_range<1, fsigtype::argument_count + 1>::type index; + typedef typename fsigtype::argument_type_tuple argument_type_tuple; + return _ctype_apply(state, index(), argument_type_tuple(), opt_count); +} +template +bool strictCheckArgTypes(lua_State *state, const F &, int opt_count = 0) { + typedef typename traits::decay::type ftype; + typedef typename util::FunctionSignature::type fsigtype; + typedef typename index_range<1, fsigtype::argument_count + 1>::type index; + typedef typename fsigtype::argument_type_tuple argument_type_tuple; + return _sctype_apply(state, index(), argument_type_tuple(), opt_count); +} + +template std::string argTypesName(const F &, int opt_count = 0) { + typedef typename traits::decay::type ftype; + typedef typename util::FunctionSignature::type fsigtype; + typedef typename index_range<1, fsigtype::argument_count + 1>::type index; + typedef typename fsigtype::argument_type_tuple argument_type_tuple; + return _type_name_apply(index(), argument_type_tuple(), opt_count); +} +template int minArgCount(const F &) { + typedef typename traits::decay::type ftype; + typedef typename util::FunctionSignature::type fsigtype; + return fsigtype::argument_count; +} +template int maxArgCount(const F &) { + typedef typename traits::decay::type ftype; + typedef typename util::FunctionSignature::type fsigtype; + return fsigtype::argument_count; +} + +// for constructor +template struct ConstructorFunctor; + +template +struct ConstructorFunctor > { + typedef util::FunctionSignatureType signature_type; + typedef typename index_range<1, sizeof...(Args) + 1>::type get_index; + + template + int invoke(lua_State *L, index_tuple) const { + typedef ObjectWrapper wrapper_type; + void *storage = lua_newuserdata(L, sizeof(wrapper_type)); + try { + new (storage) wrapper_type(lua_type_traits::get(L, Indexes)...); + } catch (...) { + lua_pop(L, 1); + throw; + } + + class_userdata::setmetatable(L); + return 1; + } + + int operator()(lua_State *L) const { return invoke(L, get_index()); } + + bool checkArgTypes(lua_State *L, int opt_count = 0) const { + return _ctype_apply(L, get_index(), + typename signature_type::argument_type_tuple(), + opt_count); + } + bool strictCheckArgTypes(lua_State *L, int opt_count = 0) const { + return _sctype_apply(L, get_index(), + typename signature_type::argument_type_tuple(), + opt_count); + } + std::string argTypesName(int opt_count = 0) const { + return _type_name_apply( + get_index(), typename signature_type::argument_type_tuple(), opt_count); + } +}; + +template struct ConstructorFunction; +template +struct ConstructorFunction { + typedef ConstructorFunctor > + type; +}; +template +struct ConstructorFunction // class type check version +{ + typedef ConstructorFunctor > + type; +}; +} +using nativefunction::ConstructorFunction; +} +#else +// Copyright satoren +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include + + +namespace kaguya { +namespace nativefunction { + +#define KAGUYA_INVOKE_SIG_TARG_DEF_CONCAT_REP(N) \ + , typename util::ArgumentType::type +#define KAGUYA_INVOKE_SIG_TARG_DEF_REPEAT_CONCAT(N) \ + KAGUYA_PP_REPEAT(N, KAGUYA_INVOKE_SIG_TARG_DEF_CONCAT_REP) + +#define KAGUYA_GET_REP(N) , lua_type_traits::get(state, N) +#define KAGUYA_FUNC_DEF(N) \ + const util::FunctionSignatureType &fsig +#define KAGUYA_TYPENAME_REP(N) \ + +((MAX_ARG - opt_count < N) ? "[OPT]" : "") + \ + util::pretty_name(typeid(KAGUYA_PP_CAT(A, N))) + "," +#define KAGUYA_TYPECHECK_REP(N) \ + &&(((MAX_ARG - opt_count < N) && lua_isnoneornil(state, N)) || \ + lua_type_traits::checkType(state, N)) +#define KAGUYA_STRICT_TYPECHECK_REP(N) \ + &&(((MAX_ARG - opt_count < N) && lua_isnoneornil(state, N)) || \ + lua_type_traits::strictCheckType(state, N)) +#define KAGUYA_CALL_FN_DEF(N) \ + template \ + inline typename traits::enable_if::value, \ + int>::type \ + _call_apply(lua_State *state, F &f, KAGUYA_FUNC_DEF(N)) { \ + KAGUYA_UNUSED(fsig); \ + return util::push_args( \ + state, util::invoke( \ + f KAGUYA_PP_REPEAT(N, KAGUYA_GET_REP))); \ + } \ + template \ + inline \ + typename traits::enable_if::value, int>::type \ + _call_apply(lua_State *state, F &f, KAGUYA_FUNC_DEF(N)) { \ + KAGUYA_UNUSED(state); \ + KAGUYA_UNUSED(fsig); \ + util::invoke( \ + f KAGUYA_PP_REPEAT(N, KAGUYA_GET_REP)); \ + return 0; \ + } \ + template \ + bool _ctype_apply(lua_State *state, KAGUYA_FUNC_DEF(N), int opt_count = 0) { \ + KAGUYA_UNUSED(state); \ + KAGUYA_UNUSED(opt_count); \ + KAGUYA_UNUSED(fsig); \ + const int MAX_ARG = N; \ + (void)MAX_ARG; \ + return true KAGUYA_PP_REVERSE_REPEAT(N, KAGUYA_TYPECHECK_REP); \ + } \ + template \ + bool _sctype_apply(lua_State *state, KAGUYA_FUNC_DEF(N), \ + int opt_count = 0) { \ + KAGUYA_UNUSED(state); \ + KAGUYA_UNUSED(opt_count); \ + KAGUYA_UNUSED(fsig); \ + const int MAX_ARG = N; \ + (void)MAX_ARG; \ + return true KAGUYA_PP_REVERSE_REPEAT(N, KAGUYA_STRICT_TYPECHECK_REP); \ + } \ + template \ + std::string _type_name_apply(KAGUYA_FUNC_DEF(N), int opt_count) { \ + KAGUYA_UNUSED(fsig); \ + KAGUYA_UNUSED(opt_count); \ + const int MAX_ARG = N; \ + (void)MAX_ARG; \ + return std::string() KAGUYA_PP_REPEAT(N, KAGUYA_TYPENAME_REP); \ + } + +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 + +template int call(lua_State *state, F f) { + typedef typename traits::decay::type ftype; + typedef typename util::FunctionSignature::type fsigtype; + return _call_apply(state, f, fsigtype()); +} +template +bool checkArgTypes(lua_State *state, const F &, int opt_count = 0) { + typedef typename traits::decay::type ftype; + typedef typename util::FunctionSignature::type fsigtype; + return _ctype_apply(state, fsigtype(), opt_count); +} +template +bool strictCheckArgTypes(lua_State *state, const F &, int opt_count = 0) { + typedef typename traits::decay::type ftype; + typedef typename util::FunctionSignature::type fsigtype; + return _sctype_apply(state, fsigtype(), opt_count); +} + +template std::string argTypesName(const F &f, int opt_count = 0) { + KAGUYA_UNUSED(f); + typedef typename traits::decay::type ftype; + typedef typename util::FunctionSignature::type fsigtype; + return _type_name_apply(fsigtype(), opt_count); +} +template int minArgCount(const F &f) { + KAGUYA_UNUSED(f); + typedef typename traits::decay::type ftype; + typedef typename util::FunctionSignature::type fsigtype; + return fsigtype::argument_count; +} +template int maxArgCount(const F &f) { + KAGUYA_UNUSED(f); + typedef typename traits::decay::type ftype; + typedef typename util::FunctionSignature::type fsigtype; + return fsigtype::argument_count; +} + +///! for constructor +template struct ConstructorFunctor; + +#define KAGUYA_CONSTRUCTOR_GET_REP(N) \ + lua_type_traits::get(L, N) +#define KAGUYA_CONSTRUCTOR_CALL_FN_DEF(N) \ + template \ + struct ConstructorFunctor > { \ + typedef util::FunctionSignatureType< \ + ClassType KAGUYA_PP_TEMPLATE_ARG_REPEAT_CONCAT(N)> \ + signature_type; \ + int operator()(lua_State *L) const { \ + typedef ObjectWrapper wrapper_type; \ + void *storage = lua_newuserdata(L, sizeof(wrapper_type)); \ + try { \ + new (storage) \ + wrapper_type(KAGUYA_PP_REPEAT_ARG(N, KAGUYA_CONSTRUCTOR_GET_REP)); \ + } catch (...) { \ + lua_pop(L, 1); \ + throw; \ + } \ + class_userdata::setmetatable(L); \ + return 1; \ + } \ + bool checkArgTypes(lua_State *L, int opt_count = 0) const { \ + return _ctype_apply(L, signature_type(), opt_count); \ + } \ + bool strictCheckArgTypes(lua_State *L, int opt_count = 0) const { \ + return _sctype_apply(L, signature_type(), opt_count); \ + } \ + std::string argTypesName(int opt_count = 0) const { \ + KAGUYA_UNUSED(opt_count); \ + return _type_name_apply(signature_type(), 0); \ + } \ + }; + +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; + +#define KAGUYA_F_TO_CONSIG_TYPE_DEF(N) \ + ConstructorFunctor > +#define KAGUYA_F_TO_CONSIG_DEF(N) \ + template \ + struct ConstructorFunction { \ + typedef KAGUYA_F_TO_CONSIG_TYPE_DEF(N) type; \ + }; \ + template \ + struct ConstructorFunction { \ + typedef KAGUYA_F_TO_CONSIG_TYPE_DEF(N) type; \ + }; + +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; +} +#endif + +// Copyright satoren +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include + + +namespace kaguya { +namespace fntuple { + +#if KAGUYA_USE_CPP11 && !defined(KAGUYA_FUNCTION_MAX_OVERLOADS) +// In Clang with libstdc++. +// std::tuple elements is limited to 16 for template depth limit +using std::tuple; +using std::get; +using std::tuple_element; +using std::tuple_size; +#else +using util::null_type; +// boost::tuple is max +#define KAGUYA_PP_STRUCT_TDEF_REP(N) KAGUYA_PP_CAT(typename A, N) = null_type +#define KAGUYA_PP_STRUCT_TEMPLATE_DEF_REPEAT(N) \ + KAGUYA_PP_REPEAT_ARG(N, KAGUYA_PP_STRUCT_TDEF_REP) + +template +struct tuple {}; +#undef KAGUYA_PP_STRUCT_TDEF_REP +#undef KAGUYA_PP_STRUCT_TEMPLATE_DEF_REPEAT + +#define KAGUYA_FUNCTION_TUPLE_ELEMENT(N) \ + KAGUYA_PP_CAT(A, N) KAGUYA_PP_CAT(elem, N); +#define KAGUYA_FUNCTION_TUPLE_ELEMENT_INIT(N) \ + KAGUYA_PP_CAT(elem, N)(KAGUYA_PP_CAT(a, N)) +#define KAGUYA_FUNCTION_TUPLE_IMPL_DEF(N) \ + template \ + struct tuple { \ + KAGUYA_PP_REPEAT(N, KAGUYA_FUNCTION_TUPLE_ELEMENT) \ + tuple(KAGUYA_PP_ARG_DEF_REPEAT(N)) \ + : KAGUYA_PP_REPEAT_ARG(N, KAGUYA_FUNCTION_TUPLE_ELEMENT_INIT) {} \ + }; + +KAGUYA_PP_REPEAT_DEF(KAGUYA_FUNCTION_MAX_OVERLOADS, + KAGUYA_FUNCTION_TUPLE_IMPL_DEF) + +template struct tuple_size; + +#define KAGUYA_TUPLE_SIZE_DEF(N) \ + template \ + struct tuple_size > { \ + static const size_t value = N; \ + }; + +KAGUYA_TUPLE_SIZE_DEF(0) +KAGUYA_PP_REPEAT_DEF(KAGUYA_FUNCTION_MAX_OVERLOADS, KAGUYA_TUPLE_SIZE_DEF) +#undef KAGUYA_TUPLE_SIZE_DEF + +template +struct tuple_element {}; +#define KAGUYA_TUPLE_ELEMENT_DEF(N) \ + template \ + struct tuple_element< \ + remain, tuple, true> { \ + typedef arg type; \ + }; \ + template \ + struct tuple_element< \ + remain, tuple, false> \ + : tuple_element > { \ + }; + +KAGUYA_PP_REPEAT_DEF(KAGUYA_FUNCTION_MAX_OVERLOADS, KAGUYA_TUPLE_ELEMENT_DEF) + +#undef KAGUYA_TUPLE_SIZE_DEF + +template struct tuple_get_helper; +#define KAGUYA_TUPLE_GET_DEF(N) \ + template struct tuple_get_helper { \ + static typename tuple_element::type &get(T &t) { \ + return t.KAGUYA_PP_CAT(elem, N); \ + } \ + static const typename tuple_element::type &cget(const T &t) { \ + return t.KAGUYA_PP_CAT(elem, N); \ + } \ + }; +KAGUYA_PP_REPEAT_DEF(KAGUYA_FUNCTION_MAX_OVERLOADS, KAGUYA_TUPLE_GET_DEF) + +template typename tuple_element::type &get(T &t) { + return tuple_get_helper::get(t); +} +template +const typename tuple_element::type &get(const T &t) { + return tuple_get_helper::cget(t); +} +#endif +} +} + +namespace kaguya { +struct FunctionImpl { + virtual int invoke(lua_State *state) = 0; + virtual std::string argTypesName() const = 0; + virtual bool checkArgTypes(lua_State *state) const = 0; + virtual bool strictCheckArgTypes(lua_State *state) const = 0; + virtual int minArgCount() const = 0; + virtual int maxArgCount() const = 0; + virtual ~FunctionImpl() {} +}; +struct PolymorphicInvoker { + typedef standard::shared_ptr holder_type; + PolymorphicInvoker(const holder_type &fptr) : fnc(fptr) {} + int invoke(lua_State *state) const { return fnc->invoke(state); } + std::string argTypesName() const { return fnc->argTypesName(); } + bool checkArgTypes(lua_State *state) const { + return fnc->checkArgTypes(state); + } + bool strictCheckArgTypes(lua_State *state) const { + return fnc->strictCheckArgTypes(state); + } + int minArgCount() const { return fnc->minArgCount(); } + int maxArgCount() const { return fnc->maxArgCount(); } + ~PolymorphicInvoker() {} + +private: + holder_type fnc; +}; +struct PolymorphicMemberInvoker : PolymorphicInvoker { + PolymorphicMemberInvoker(const holder_type &fptr) + : PolymorphicInvoker(fptr) {} +}; + +namespace nativefunction { +template +typename lua_type_traits::type>::get_type +getArgument(lua_State *state) { + return lua_type_traits::type>::get( + state, INDEX + 1); +} + +template +struct is_callable + : traits::integral_constant< + bool, !traits::is_same< + void, typename util::FunctionSignature::type>::value> {}; + +template +struct is_callable : traits::integral_constant {}; + +template +struct is_callable > + : traits::integral_constant {}; + +// for constructors +template int call(lua_State *state, ConstructorFunctor &con) { + return con(state); +} +template +int call(lua_State *state, const ConstructorFunctor &con) { + return con(state); +} +template +bool checkArgTypes(lua_State *state, const ConstructorFunctor &con, + int opt_count = 0) { + return con.checkArgTypes(state, opt_count); +} +template +bool strictCheckArgTypes(lua_State *state, const ConstructorFunctor &con, + int opt_count = 0) { + return con.strictCheckArgTypes(state, opt_count); +} +template std::string argTypesName(const ConstructorFunctor &con) { + return con.argTypesName(); +} +template int minArgCount(const ConstructorFunctor &) { + return ConstructorFunctor::signature_type::argument_count; +} +template int maxArgCount(const ConstructorFunctor &) { + return ConstructorFunctor::signature_type::argument_count; +} + +// for data member +// using is_member_function_pointer in MSVC2010 : fatal error LNK1179: invalid +// or corrupt file: duplicate COMDAT +// '?value@?$result_@P8ABC@test_02_classreg@@AE?AV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@XZ@?$is_mem_fun_pointer_select@$0A@@detail@boost@@2_NB' +template +typename traits::enable_if::value, int>::type +call(lua_State *state, MemType T::*mptr) { + T *this_ = lua_type_traits::get(state, 1); + if (lua_gettop(state) == 1) { + if (!this_) { + const T &this_ = lua_type_traits::get(state, 1); + if (is_usertype::value && !traits::is_pointer::value) { + return util::push_args( + state, standard::reference_wrapper(this_.*mptr)); + } else { + return util::push_args(state, this_.*mptr); + } + } else { + if (is_usertype::value && !traits::is_pointer::value) { + return util::push_args( + state, standard::reference_wrapper(this_->*mptr)); + } else { + return util::push_args(state, this_->*mptr); + } + } + } else { + if (!this_) { + throw LuaTypeMismatch(); + } + this_->*mptr = lua_type_traits::get(state, 2); + return 0; + } +} +template +typename traits::enable_if::value, bool>::type +checkArgTypes(lua_State *state, MemType T::*, int opt_count = 0) { + KAGUYA_UNUSED(opt_count); + if (lua_gettop(state) >= 2) { + // setter typecheck + return lua_type_traits::checkType(state, 2) && + lua_type_traits::checkType(state, 1); + } + // getter typecheck + return lua_type_traits::checkType(state, 1); +} +template +typename traits::enable_if::value, bool>::type +strictCheckArgTypes(lua_State *state, MemType T::*, int opt_count = 0) { + KAGUYA_UNUSED(opt_count); + if (lua_gettop(state) == 2) { + // setter typecheck + return lua_type_traits::strictCheckType(state, 2) && + lua_type_traits::strictCheckType(state, 1); + } + // getter typecheck + return lua_type_traits::strictCheckType(state, 1); +} +template +typename traits::enable_if::value, std::string>::type +argTypesName(MemType T::*) { + return util::pretty_name(typeid(T *)) + ",[OPT] " + + util::pretty_name(typeid(MemType)); +} +template +typename traits::enable_if::value, int>::type +minArgCount(MemType T::*) { + return 1; +} +template +typename traits::enable_if::value, int>::type +maxArgCount(MemType T::*) { + return 2; +} + +inline int call(lua_State *state, const PolymorphicInvoker &f) { + return f.invoke(state); +} +inline int call(lua_State *state, PolymorphicInvoker &f) { + return f.invoke(state); +} +inline bool checkArgTypes(lua_State *state, const PolymorphicInvoker &f) { + return f.checkArgTypes(state); +} +inline bool strictCheckArgTypes(lua_State *state, const PolymorphicInvoker &f) { + return f.strictCheckArgTypes(state); +} +inline std::string argTypesName(const PolymorphicInvoker &f) { + return f.argTypesName(); +} +inline int minArgCount(const PolymorphicInvoker &f) { return f.minArgCount(); } +inline int maxArgCount(const PolymorphicInvoker &f) { return f.maxArgCount(); } + +template <> +struct is_callable : traits::integral_constant { +}; + +inline int call(lua_State *state, const PolymorphicMemberInvoker &f) { + return f.invoke(state); +} +inline int call(lua_State *state, PolymorphicMemberInvoker &f) { + return f.invoke(state); +} +inline bool checkArgTypes(lua_State *state, const PolymorphicMemberInvoker &f) { + return f.checkArgTypes(state); +} +inline bool strictCheckArgTypes(lua_State *state, + const PolymorphicMemberInvoker &f) { + return f.strictCheckArgTypes(state); +} +inline std::string argTypesName(const PolymorphicMemberInvoker &f) { + return f.argTypesName(); +} +inline int minArgCount(const PolymorphicMemberInvoker &f) { + return f.minArgCount(); +} +inline int maxArgCount(const PolymorphicMemberInvoker &f) { + return f.maxArgCount(); +} + +template <> +struct is_callable + : traits::integral_constant {}; +} + +class VariadicArgType { +public: + VariadicArgType(lua_State *state, int startIndex) + : state_(state), startIndex_(startIndex), + endIndex_(lua_gettop(state) + 1) { + if (startIndex_ > endIndex_) { + endIndex_ = startIndex_; + } + } + + template operator std::vector() const { + if (startIndex_ >= endIndex_) { + return std::vector(); + } + std::vector result; + result.reserve(endIndex_ - startIndex_); + for (int index = startIndex_; index < endIndex_; ++index) { + result.push_back(lua_type_traits::get(state_, index)); + } + return result; + } + + struct reference : public Ref::StackRef, + public detail::LuaVariantImpl { + reference(lua_State *s, int index) : Ref::StackRef(s, index, false) {} + + const reference *operator->() const { return this; } + }; + + struct iterator { + typedef std::random_access_iterator_tag iterator_category; + typedef VariadicArgType::reference reference; + typedef int difference_type; + typedef reference value_type; + typedef reference *pointer; + + iterator() : state_(0), stack_index_(0) {} + iterator(lua_State *state, int index) + : state_(state), stack_index_(index) {} + reference operator*() const { return reference(state_, stack_index_); } + reference operator->() const { return reference(state_, stack_index_); } + iterator &operator++() { + stack_index_++; + return *this; + } + iterator operator++(int) { return iterator(state_, stack_index_++); } + + iterator &operator+=(int n) { + stack_index_ += n; + return *this; + } + iterator operator+(int n) const { + return iterator(state_, stack_index_ + n); + } + iterator &operator--() { + stack_index_--; + return *this; + } + iterator operator--(int) { return iterator(state_, stack_index_--); } + iterator &operator-=(int n) { + stack_index_ -= n; + return *this; + } + iterator operator-(int n) const { + return iterator(state_, stack_index_ - n); + } + difference_type operator-(const iterator &n) { + return stack_index_ - n.stack_index_; + } + + reference operator[](difference_type offset) const { + return reference(state_, stack_index_ + offset); + } + /** + * @name relational operators + * @brief + */ + //@{ + bool operator==(const iterator &other) const { + return state_ == other.state_ && stack_index_ == other.stack_index_; + } + bool operator!=(const iterator &other) const { return !(*this == other); } + bool operator<(const iterator &other) const { + return stack_index_ < other.stack_index_; + } + bool operator>(const iterator &other) const { return other < *this; } + bool operator<=(const iterator &other) const { return other >= *this; } + bool operator>=(const iterator &other) const { return !(*this < other); } + //@} + private: + lua_State *state_; + int stack_index_; + }; + typedef iterator const_iterator; + typedef reference const_reference; + typedef reference value_type; + + iterator begin() { return iterator(state_, startIndex_); } + iterator end() { return iterator(state_, endIndex_); } + const_iterator cbegin() { return const_iterator(state_, startIndex_); } + const_iterator cend() { return const_iterator(state_, endIndex_); } + + template + typename lua_type_traits::get_type at(size_t index) const { + if (index >= size()) { + throw std::out_of_range("variadic arguments out of range"); + } + return lua_type_traits::get(state_, + startIndex_ + static_cast(index)); + } + + reference at(size_t index) const { + if (index >= size()) { + throw std::out_of_range("variadic arguments out of range"); + } + return reference(state_, startIndex_ + static_cast(index)); + } + + reference operator[](size_t index) const { + return reference(state_, startIndex_ + static_cast(index)); + } + size_t size() const { return endIndex_ - startIndex_; } + size_t empty() const { return endIndex_ == startIndex_; } + +private: + lua_State *state_; + int startIndex_; + int endIndex_; +}; + +inline VariadicArgType::iterator operator+(int n, + const VariadicArgType::iterator &i) { + return i + n; +} + +/// @ingroup lua_type_traits +/// @brief lua_type_traits for VariadicArgType +template <> struct lua_type_traits { + typedef VariadicArgType get_type; + + static bool strictCheckType(lua_State *l, int index) { + KAGUYA_UNUSED(l); + KAGUYA_UNUSED(index); + return true; + } + static bool checkType(lua_State *l, int index) { + KAGUYA_UNUSED(l); + KAGUYA_UNUSED(index); + return true; + } + static get_type get(lua_State *l, int index) { + return VariadicArgType(l, index); + } +}; + +namespace nativefunction { +static const int MAX_OVERLOAD_SCORE = 255; +template +uint8_t compute_function_matching_score(lua_State *state, const Fn &fn) { + int argcount = lua_gettop(state); + + if (strictCheckArgTypes(state, fn)) { + const int minargcount = minArgCount(fn); + const int maxargcount = maxArgCount(fn); + if (minargcount <= argcount && maxargcount >= argcount) { + return MAX_OVERLOAD_SCORE; + } else { + int diff = std::min(std::abs(argcount - minargcount), + std::abs(argcount - maxargcount)); + return std::max(100 - diff, 51); + } + } else if (checkArgTypes(state, fn)) { + const int minargcount = minArgCount(fn); + const int maxargcount = maxArgCount(fn); + if (minargcount <= argcount && maxargcount >= argcount) { + return 200; + } else { + int diff = std::min(std::abs(argcount - minargcount), + std::abs(argcount - maxargcount)); + return std::max(50 - diff, 1); + } + } else { + return 0; + } +} +inline int pushArgmentTypeNames(lua_State *state, int top) { + for (int i = 1; i <= top; i++) { + if (i != 1) { + lua_pushliteral(state, ","); + } + + int type = lua_type(state, i); + if (type == LUA_TUSERDATA) { + int nametype = luaL_getmetafield(state, i, "__name"); + if (nametype != LUA_TSTRING) { + lua_pop(state, 1); + lua_pushstring(state, lua_typename(state, type)); + } + } else { + lua_pushstring(state, lua_typename(state, type)); + } + } + return lua_gettop(state) - top; +} +} + +#if KAGUYA_USE_CPP11 + +namespace detail { +template +void function_match_scoring(lua_State *state, uint8_t *score_array, + int current_index, const Fn &fn) { + score_array[current_index] = + nativefunction::compute_function_matching_score(state, fn); +} +template +void function_match_scoring(lua_State *state, uint8_t *score_array, + int current_index, const Fn &fn, + const Functions &... fns) { + score_array[current_index] = + nativefunction::compute_function_matching_score(state, fn); + if (score_array[current_index] < nativefunction::MAX_OVERLOAD_SCORE) { + function_match_scoring(state, score_array, current_index + 1, fns...); + } +} +template +int best_function_index(lua_State *state, const Functions &... fns) { + static const int fncount = sizeof...(fns); + uint8_t score[fncount] = {}; + function_match_scoring(state, score, 0, fns...); + uint8_t best_score = 0; + int best_score_index = -1; + for (int i = 0; i < fncount; ++i) { + if (best_score < score[i]) { + best_score = score[i]; + best_score_index = i; + if (best_score == nativefunction::MAX_OVERLOAD_SCORE) { + break; + } + } + } + return best_score_index; +} +template +int invoke_index(lua_State *state, int index, int current_index, Fn &&fn) { + KAGUYA_UNUSED(index); + KAGUYA_UNUSED(current_index); + return nativefunction::call(state, fn); +} +template +int invoke_index(lua_State *state, int index, int current_index, Fn &&fn, + Functions &&... fns) { + if (index == current_index) { + return nativefunction::call(state, fn); + } else { + return invoke_index(state, index, current_index + 1, fns...); + } +} + +template int best_match_invoke(lua_State *state, Fun &&fn) { + return nativefunction::call(state, fn); +} + +template +int best_match_invoke(lua_State *state, Fun &&fn, Functions &&... fns) { + int index = best_function_index(state, fn, fns...); + if (index >= 0) { + assert(size_t(index) <= sizeof...(fns)); + return invoke_index(state, index, 0, fn, fns...); + } else { + throw LuaTypeMismatch(); + } + return 0; +} + +template +int invoke_tuple_impl(lua_State *state, TupleType &&tuple, + nativefunction::index_tuple) { + return best_match_invoke(state, fntuple::get(tuple)...); +} +template +int invoke_tuple(lua_State *state, TupleType &&tuple) { + typedef typename std::decay::type ttype; + + typedef typename nativefunction::index_range< + 0, fntuple::tuple_size::value>::type indexrange; + + return invoke_tuple_impl(state, tuple, indexrange()); +} + +template +void push_arg_typename(lua_State *state, const Fun &fn) { + lua_pushliteral(state, "\t\t"); + lua_pushstring(state, nativefunction::argTypesName(fn).c_str()); + lua_pushliteral(state, "\n"); +} + +template +void push_arg_typename(lua_State *state, const Fun &fn, + const Functions &... fns) { + lua_pushliteral(state, "\t\t"); + lua_pushstring(state, nativefunction::argTypesName(fn).c_str()); + lua_pushliteral(state, "\n"); + push_arg_typename(state, fns...); +} +template +void push_arg_typename_tuple_impl(lua_State *state, TupleType &&tuple, + nativefunction::index_tuple) { + return push_arg_typename(state, fntuple::get(tuple)...); +} +template +void push_arg_typename_tuple(lua_State *state, TupleType &&tuple) { + typedef typename std::decay::type ttype; + typedef typename nativefunction::index_range< + 0, fntuple::tuple_size::value>::type indexrange; + + return push_arg_typename_tuple_impl(state, tuple, indexrange()); +} +} + +#else + +namespace detail { +#define KAGUYA_FUNCTION_SCOREING(N) \ + if (currentbestscore < nativefunction::MAX_OVERLOAD_SCORE) { \ + int score = nativefunction::compute_function_matching_score( \ + state, fntuple::get(tuple)); \ + if (currentbestscore < score) { \ + currentbestscore = score; \ + currentbestindex = N; \ + } \ + } +#define KAGUYA_FUNCTION_INVOKE(N) \ + if (currentbestindex == N) { \ + return nativefunction::call(state, fntuple::get(tuple)); \ + } + +#define KAGUYA_ARG_PUSH_TYPENAMES(N) \ + lua_pushliteral(state, "\t\t"); \ + lua_pushstring( \ + state, \ + nativefunction::argTypesName(fntuple::get(tuple)).c_str()); \ + lua_pushliteral(state, "\n"); +#define KAGUYA_TEMPLATE_PARAMETER(N) template +#define KAGUYA_TUPLE_INVOKE_DEF(N) \ + KAGUYA_TEMPLATE_PARAMETER(N) \ + int invoke_tuple(lua_State *state, \ + fntuple::tuple &tuple) { \ + if (N == 1) { \ + return nativefunction::call(state, fntuple::get<0>(tuple)); \ + } \ + int32_t currentbestscore = 0; \ + int32_t currentbestindex = -1; \ + KAGUYA_PP_REPEAT(N, KAGUYA_FUNCTION_SCOREING); \ + KAGUYA_PP_REPEAT(N, KAGUYA_FUNCTION_INVOKE); \ + throw LuaTypeMismatch(); \ + } \ + KAGUYA_TEMPLATE_PARAMETER(N) \ + void push_arg_typename_tuple( \ + lua_State *state, \ + fntuple::tuple &tuple) { \ + KAGUYA_PP_REPEAT(N, KAGUYA_ARG_PUSH_TYPENAMES); \ + } + +KAGUYA_PP_REPEAT_DEF(KAGUYA_FUNCTION_MAX_OVERLOADS, KAGUYA_TUPLE_INVOKE_DEF) +#undef KAGUYA_TEMPLATE_PARAMETER +#undef KAGUYA_TUPLE_INVOKE_DEF +#undef KAGUYA_ARG_TYPENAMES +#undef KAGUYA_FUNCTION_INVOKE +#undef KAGUYA_FUNCTION_SCOREING + +template +int invoke_tuple(lua_State *state, TupleType &tuple) { + KAGUYA_UNUSED(state); + KAGUYA_UNUSED(tuple); + return 0; +} +} +#endif + +template struct FunctionInvokerType { + FunctionTuple functions; + FunctionInvokerType(const FunctionTuple &t) : functions(t) {} +}; + +template +inline FunctionInvokerType > function(T f) { + KAGUYA_STATIC_ASSERT( + nativefunction::is_callable::type>::value, + "argument need callable"); + return FunctionInvokerType >(fntuple::tuple(f)); +} + +template +inline FunctionInvokerType > > +function(T f) { + return FunctionInvokerType > >( + fntuple::tuple >(standard::function(f))); +} +#if KAGUYA_USE_CPP11 + +template +FunctionInvokerType > overload(Functions... fns) { + return FunctionInvokerType >( + fntuple::tuple(fns...)); +} +#else +#define KAGUYA_FOVERLOAD_DEF(N) \ + template \ + FunctionInvokerType > \ + overload(KAGUYA_PP_ARG_DEF_REPEAT(N)) { \ + 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_FOVERLOAD_DEF +#endif + +struct luacfunction { + lua_CFunction ptr; + + luacfunction(lua_CFunction f) : ptr(f) {} + operator lua_CFunction() { return ptr; } +}; + +/// @ingroup lua_type_traits +/// @brief lua_type_traits for FunctionInvokerType +template +struct lua_type_traits > { + typedef FunctionInvokerType userdatatype; + typedef const FunctionInvokerType &push_type; + + static const char *build_arg_error_message(lua_State *state, const char *msg, + FunctionTuple *tuple) { + int stack_top = lua_gettop(state); + if (msg) { + lua_pushstring(state, msg); + } + lua_pushliteral(state, "Argument mismatch:"); + nativefunction::pushArgmentTypeNames(state, stack_top); + + lua_pushliteral(state, "\t candidate is:\n"); + detail::push_arg_typename_tuple(state, *tuple); + + lua_concat(state, lua_gettop(state) - stack_top); + return lua_tostring(state, -1); + } + + static int invoke(lua_State *state) { + FunctionTuple *t = static_cast( + lua_touserdata(state, lua_upvalueindex(1))); + + if (t) { + try { + return detail::invoke_tuple(state, *t); + } catch (LuaTypeMismatch &e) { + if (strcmp(e.what(), "type mismatch!!") == 0) { + util::traceBack(state, build_arg_error_message(state, "maybe...", t)); + } else { + util::traceBack(state, e.what()); + } + } catch (std::exception &e) { + util::traceBack(state, e.what()); + } catch (...) { + util::traceBack(state, "Unknown exception"); + } + } + return lua_error(state); + } + + inline static int tuple_destructor(lua_State *state) { + FunctionTuple *f = static_cast(lua_touserdata(state, 1)); + if (f) { + f->~FunctionTuple(); + } + return 0; + } + + static int push(lua_State *state, push_type fns) { + void *ptr = lua_newuserdata(state, sizeof(FunctionTuple)); + new (ptr) FunctionTuple(fns.functions); + lua_createtable(state, 0, 2); + lua_pushcclosure(state, &tuple_destructor, 0); + lua_setfield(state, -2, "__gc"); + lua_pushvalue(state, -1); + lua_setfield(state, -1, "__index"); + lua_setmetatable(state, -2); + lua_pushcclosure(state, &invoke, 1); + + return 1; + } +}; + +/// @ingroup lua_type_traits +/// @brief lua_type_traits for c function +template +struct lua_type_traits< + T, typename traits::enable_if::type>::value>::type> { + static int push(lua_State *l, T f) { + return util::one_push(l, kaguya::function(f)); + } +}; +/// @ingroup lua_type_traits +/// @brief lua_type_traits for luacfunction +template <> struct lua_type_traits { + typedef luacfunction push_type; + typedef luacfunction get_type; + static bool strictCheckType(lua_State *l, int index) { + return lua_iscfunction(l, index) != 0; + } + static bool checkType(lua_State *l, int index) { + return lua_iscfunction(l, index) != 0; + } + static get_type get(lua_State *l, int index) { + return lua_tocfunction(l, index); + } + static int push(lua_State *l, push_type f) { + lua_pushcfunction(l, f); + return 1; + } +}; + +/// @ingroup lua_type_traits +/// @brief lua_type_traits for std::function or boost::function +template struct lua_type_traits > { + typedef const standard::function &push_type; + typedef standard::function get_type; + + static bool strictCheckType(lua_State *l, int index) { + return lua_type(l, index) == LUA_TFUNCTION; + } + static bool checkType(lua_State *l, int index) { + return lua_type(l, index) == LUA_TFUNCTION; + } + static get_type get(lua_State *l, int index) { + if (!l || lua_type(l, index) != LUA_TFUNCTION) { + return get_type(); + } + lua_pushvalue(l, index); + return get_type(LuaFunction(l, StackTop())); + } + + static int push(lua_State *l, push_type v) { + return util::one_push(l, kaguya::function(v)); + } +}; + +template ::type::result_type> +struct OverloadFunctionImpl : kaguya::FunctionImpl { + typedef Ret result_type; + typedef typename util::FunctionSignature::type::c_function_type + c_function_type; + + virtual result_type invoke_type(lua_State *state) = 0; + + virtual int invoke(lua_State *state) { + return util::push_args(state, invoke_type(state)); + } + virtual std::string argTypesName() const { + return nativefunction::argTypesName(c_function_type(0), + maxArgCount() - minArgCount()); + } + virtual bool checkArgTypes(lua_State *state) const { + return kaguya::nativefunction::checkArgTypes(state, c_function_type(0), + maxArgCount() - minArgCount()); + } + virtual bool strictCheckArgTypes(lua_State *state) const { + return kaguya::nativefunction::strictCheckArgTypes( + state, c_function_type(0), maxArgCount() - minArgCount()); + } +}; + +template +struct OverloadFunctionImpl : kaguya::FunctionImpl { + typedef void result_type; + typedef typename util::FunctionSignature::type::c_function_type + c_function_type; + + virtual result_type invoke_type(lua_State *state) = 0; + + virtual int invoke(lua_State *state) { + invoke_type(state); + return 0; + } + virtual std::string argTypesName() const { + return nativefunction::argTypesName(c_function_type(0), + maxArgCount() - minArgCount()); + } + virtual bool checkArgTypes(lua_State *state) const { + return kaguya::nativefunction::checkArgTypes(state, c_function_type(0), + maxArgCount() - minArgCount()); + } + virtual bool strictCheckArgTypes(lua_State *state) const { + return kaguya::nativefunction::strictCheckArgTypes( + state, c_function_type(0), maxArgCount() - minArgCount()); + } +}; +} + +#define KAGUYA_INTERNAL_OVERLOAD_FUNCTION_GET_REP(N) \ + getArgument(state) +#define KAGUYA_INTERNAL_OVERLOAD_FUNCTION_GET_REPEAT(N) \ + KAGUYA_PP_REPEAT_ARG(N, KAGUYA_INTERNAL_OVERLOAD_FUNCTION_GET_REP) +#define KAGUYA_INTERNAL_OVERLOAD_FUNCTION_INVOKE(N, FNAME, MINARG, MAXARG) \ + if (argcount == KAGUYA_PP_ADD(MINARG, KAGUYA_PP_DEC(N))) { \ + return FNAME(KAGUYA_INTERNAL_OVERLOAD_FUNCTION_GET_REPEAT( \ + KAGUYA_PP_ADD(MINARG, KAGUYA_PP_DEC(N)))); \ + } + +#define KAGUYA_FUNCTION_OVERLOADS_INTERNAL(GENERATE_NAME, FNAME, MINARG, \ + MAXARG, CREATE_FN) \ + \ +struct GENERATE_NAME \ +{ \ + template struct Function : kaguya::OverloadFunctionImpl { \ + typedef \ + typename kaguya::OverloadFunctionImpl::result_type result_type; \ + virtual result_type invoke_type(lua_State *state) { \ + using namespace kaguya::nativefunction; \ + int argcount = lua_gettop(state); \ + KAGUYA_PP_REPEAT_DEF_VA_ARG( \ + KAGUYA_PP_INC(KAGUYA_PP_SUB(MAXARG, MINARG)), \ + KAGUYA_INTERNAL_OVERLOAD_FUNCTION_INVOKE, FNAME, MINARG, MAXARG) \ + throw kaguya::LuaTypeMismatch("argument count mismatch"); \ + } \ + virtual int minArgCount() const { return MINARG; } \ + virtual int maxArgCount() const { return MAXARG; } \ + }; \ + template kaguya::PolymorphicInvoker::holder_type create(F) { \ + kaguya::OverloadFunctionImpl *ptr = new Function(); \ + return kaguya::PolymorphicInvoker::holder_type(ptr); \ + } \ + template kaguya::PolymorphicInvoker::holder_type create() { \ + kaguya::OverloadFunctionImpl *ptr = new Function(); \ + return kaguya::PolymorphicInvoker::holder_type(ptr); \ + } \ + kaguya::PolymorphicInvoker operator()() { return CREATE_FN; } \ + \ +} \ + GENERATE_NAME; + +#define KAGUYA_INTERNAL_OVERLOAD_MEMBER_FUNCTION_GET_REP(N) \ + getArgument(state) +#define KAGUYA_INTERNAL_OVERLOAD_MEMBER_FUNCTION_GET_REPEAT(N) \ + KAGUYA_PP_REPEAT_ARG(N, KAGUYA_INTERNAL_OVERLOAD_MEMBER_FUNCTION_GET_REP) +#define KAGUYA_INTERNAL_OVERLOAD_MEMBER_FUNCTION_INVOKE(N, FNAME, MINARG, \ + MAXARG) \ + if (argcount == 1 + KAGUYA_PP_ADD(MINARG, KAGUYA_PP_DEC(N))) { \ + return (getArgument<0, F>(state)) \ + .FNAME(KAGUYA_INTERNAL_OVERLOAD_MEMBER_FUNCTION_GET_REPEAT( \ + KAGUYA_PP_ADD(MINARG, KAGUYA_PP_DEC(N)))); \ + } + +#define KAGUYA_MEMBER_FUNCTION_OVERLOADS_INTERNAL(GENERATE_NAME, CLASS, FNAME, \ + MINARG, MAXARG, CREATE_FN) \ + \ +struct GENERATE_NAME \ +{ \ + template struct Function : kaguya::OverloadFunctionImpl { \ + typedef \ + typename kaguya::OverloadFunctionImpl::result_type result_type; \ + virtual result_type invoke_type(lua_State *state) { \ + using namespace kaguya::nativefunction; \ + int argcount = lua_gettop(state); \ + KAGUYA_PP_REPEAT_DEF_VA_ARG( \ + KAGUYA_PP_INC(KAGUYA_PP_SUB(MAXARG, MINARG)), \ + KAGUYA_INTERNAL_OVERLOAD_MEMBER_FUNCTION_INVOKE, FNAME, MINARG, \ + MAXARG) \ + throw kaguya::LuaTypeMismatch("argument count mismatch"); \ + } \ + virtual int minArgCount() const { return MINARG + 1; } \ + virtual int maxArgCount() const { return MAXARG + 1; } \ + }; \ + template \ + kaguya::PolymorphicMemberInvoker::holder_type create(F f) { \ + KAGUYA_UNUSED(f); \ + kaguya::OverloadFunctionImpl *ptr = new Function(); \ + return kaguya::PolymorphicMemberInvoker::holder_type(ptr); \ + } \ + template \ + kaguya::PolymorphicMemberInvoker::holder_type create() { \ + kaguya::OverloadFunctionImpl *ptr = new Function(); \ + return kaguya::PolymorphicMemberInvoker::holder_type(ptr); \ + } \ + kaguya::PolymorphicMemberInvoker operator()() { return CREATE_FN; } \ + \ +} \ + GENERATE_NAME; + +/// @brief Generate wrapper function object for count based overloads with +/// nonvoid return function. Include default arguments parameter function +/// @param GENERATE_NAME generate function object name +/// @param FNAME target function name +/// @param MINARG minimum arguments count +/// @param MAXARG maximum arguments count +#define KAGUYA_FUNCTION_OVERLOADS(GENERATE_NAME, FNAME, MINARG, MAXARG) \ + KAGUYA_FUNCTION_OVERLOADS_INTERNAL(GENERATE_NAME, FNAME, MINARG, MAXARG, \ + create(FNAME)) + +/// @brief Generate wrapper function object for count based overloads with +/// nonvoid return function. Include default arguments parameter function +/// @param GENERATE_NAME generate function object name +/// @param FNAME target function name +/// @param MINARG minimum arguments count +/// @param MAXARG maximum arguments count +/// @param SIGNATURE function signature. e,g, int(int) +#define KAGUYA_FUNCTION_OVERLOADS_WITH_SIGNATURE(GENERATE_NAME, FNAME, MINARG, \ + MAXARG, SIGNATURE) \ + KAGUYA_FUNCTION_OVERLOADS_INTERNAL(GENERATE_NAME, FNAME, MINARG, MAXARG, \ + create()) + +/// @brief Generate wrapper function object for count based overloads with +/// nonvoid return function. Include default arguments parameter function +/// @param GENERATE_NAME generate function object name +/// @param CLASS target class name +/// @param FNAME target function name +/// @param MINARG minimum arguments count +/// @param MAXARG maximum arguments count +#define KAGUYA_MEMBER_FUNCTION_OVERLOADS(GENERATE_NAME, CLASS, FNAME, MINARG, \ + MAXARG) \ + KAGUYA_MEMBER_FUNCTION_OVERLOADS_INTERNAL( \ + GENERATE_NAME, CLASS, FNAME, MINARG, MAXARG, create(&CLASS::FNAME)) + +/// @brief Generate wrapper function object for count based overloads with +/// nonvoid return function. Include default arguments parameter function +/// @param GENERATE_NAME generate function object name +/// @param CLASS target class name +/// @param FNAME target function name +/// @param MINARG minimum arguments count +/// @param MAXARG maximum arguments count +/// @param SIGNATURE function signature. e,g, int(Test::*)(int) +#define KAGUYA_MEMBER_FUNCTION_OVERLOADS_WITH_SIGNATURE( \ + GENERATE_NAME, CLASS, FNAME, MINARG, MAXARG, SIGNATURE) \ + KAGUYA_MEMBER_FUNCTION_OVERLOADS_INTERNAL( \ + GENERATE_NAME, CLASS, FNAME, MINARG, MAXARG, create()) +// Copyright satoren +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + + +#include +#include + + +// Copyright satoren +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + + +#include +#include +#include +#include + +// Copyright satoren +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +#include + + +namespace kaguya { +/// @brief any data holder class for push to lua +class AnyDataPusher { +public: + int pushToLua(lua_State *state) const { + if (empty()) { + lua_pushnil(state); + return 1; + } else { + return holder_->pushToLua(state); + } + } + + AnyDataPusher() : holder_() {} + + template + AnyDataPusher(const DataType &v) : holder_(new DataHolder(v)) {} + +#if KAGUYA_USE_CPP11 + AnyDataPusher(AnyDataPusher &&other) : holder_(std::move(other.holder_)) {} + AnyDataPusher &operator=(AnyDataPusher &&rhs) { + holder_ = std::move(rhs.holder_); + return *this; + } + template + AnyDataPusher(DataType &&v) + : holder_(new DataHolder(std::move(v))) {} +#endif + AnyDataPusher(const AnyDataPusher &other) : holder_(other.holder_) {} + AnyDataPusher &operator=(const AnyDataPusher &other) { + holder_ = other.holder_; + return *this; + } + + bool empty() const { return !holder_.get(); } + +private: + struct DataHolderBase { + virtual int pushToLua(lua_State *data) const = 0; + // virtual DataHolderBase * clone(void) = 0; + virtual ~DataHolderBase() {} + }; + template class DataHolder : public DataHolderBase { + typedef typename traits::decay::type DataType; + + public: +#if KAGUYA_USE_CPP11 + explicit DataHolder(DataType &&v) : data_(std::forward(v)) {} +#else + explicit DataHolder(const DataType &v) : data_(v) {} +#endif + virtual int pushToLua(lua_State *state) const { + return util::push_args(state, data_); + } + + private: + DataType data_; + }; + // specialize for string literal + template struct DataHolder : DataHolder { + explicit DataHolder(const char *v) + : DataHolder( + std::string(v, v[N - 1] != '\0' ? v + N : v + N - 1)) {} + }; + template struct DataHolder : DataHolder { + explicit DataHolder(const char *v) + : DataHolder( + std::string(v, v[N - 1] != '\0' ? v + N : v + N - 1)) {} + }; + standard::shared_ptr holder_; +}; + +/// @ingroup lua_type_traits +/// @brief lua_type_traits for AnyDataPusher +template <> struct lua_type_traits { + static int push(lua_State *l, const AnyDataPusher &data) { + return data.pushToLua(l); + } +}; +} +// Copyright satoren +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + + +#include +#include +#include + +namespace kaguya { +/// @brief function result value proxy class. +/// don't direct use. +class FunctionResults : public Ref::StackRef, + public detail::LuaVariantImpl { + FunctionResults(lua_State *state, int return_status, int startIndex) + : Ref::StackRef(state, startIndex, true), state_(state), + resultStatus_(return_status), + resultCount_(lua_gettop(state) + 1 - startIndex) {} + FunctionResults(lua_State *state, int return_status, int startIndex, + int endIndex) + : Ref::StackRef(state, startIndex, true), state_(state), + resultStatus_(return_status), resultCount_(endIndex - startIndex) {} + friend class detail::FunctionResultProxy; + +public: + FunctionResults() + : Ref::StackRef(), state_(0), resultStatus_(0), resultCount_(0) {} + FunctionResults(lua_State *state) + : Ref::StackRef(state, 0, true), state_(state), resultStatus_(0), + resultCount_(0) {} +#if KAGUYA_USE_CPP11 + FunctionResults(FunctionResults &&src) + : Ref::StackRef(std::move(src)), state_(src.state_), + resultStatus_(src.resultStatus_), resultCount_(src.resultCount_) { + src.state_ = 0; + } +#else + FunctionResults(const FunctionResults &src) + : Ref::StackRef(src), state_(src.state_), + resultStatus_(src.resultStatus_), resultCount_(src.resultCount_) { + src.state_ = 0; + } +#endif + + ~FunctionResults() {} + + struct reference : public Ref::StackRef, + public detail::LuaVariantImpl { + reference(lua_State *s, int index) : Ref::StackRef(s, index, false) {} + + reference *operator->() { return this; } + const reference *operator->() const { return this; } + }; + template struct iterator_base { + iterator_base(lua_State *s, int i) : state(s), stack_index(i) {} + template + iterator_base(const iterator_base &other) + : state(other.state), stack_index(other.stack_index) {} + T operator*() const { return reference(state, stack_index); } + T operator->() const { return reference(state, stack_index); } + const iterator_base &operator++() { + stack_index++; + return *this; + } + iterator_base operator++(int) { + return iterator_base(state, stack_index++); + } + + iterator_base operator+=(int n) { + stack_index += n; + return iterator_base(state, stack_index); + } + /** + * @name relational operators + * @brief + */ + //@{ + bool operator==(const iterator_base &other) const { + return state == other.state && stack_index == other.stack_index; + } + bool operator!=(const iterator_base &other) const { + return !(*this == other); + } + //@} + int index() const { return stack_index; } + + private: + template friend struct iterator_base; + lua_State *state; + int stack_index; + }; + typedef iterator_base iterator; + typedef iterator_base const_iterator; + typedef reference const_reference; + + iterator begin() { return iterator(state_, stack_index_); } + iterator end() { return iterator(state_, stack_index_ + resultCount_); } + const_iterator begin() const { return const_iterator(state_, stack_index_); } + const_iterator end() const { + return const_iterator(state_, stack_index_ + resultCount_); + } + const_iterator cbegin() const { return const_iterator(state_, stack_index_); } + const_iterator cend() const { + return const_iterator(state_, stack_index_ + resultCount_); + } + + template + Result get_result(types::typetag = types::typetag()) const { + return util::get_result(state_, stack_index_); + } + LuaStackRef get_result(types::typetag) const { + pop_ = 0; + return LuaStackRef(state_, stack_index_, true); + } + lua_State *state() const { return state_; } + + template + typename lua_type_traits::get_type result_at(size_t index) const { + if (index >= result_size()) { + throw std::out_of_range("function result out of range"); + } + return lua_type_traits::get(state_, + stack_index_ + static_cast(index)); + } + reference result_at(size_t index) const { + if (index >= result_size()) { + throw std::out_of_range("function result out of range"); + } + return reference(state_, stack_index_ + static_cast(index)); + } + + size_t result_size() const { return resultCount_; } + + size_t resultStatus() const { return resultStatus_; } + + operator LuaStackRef() { + pop_ = 0; + return LuaStackRef(state_, stack_index_, true); + } + +private: + mutable lua_State *state_; + int resultStatus_; + int resultCount_; +}; + +namespace detail { +template +inline RetType FunctionResultProxy::ReturnValue(lua_State *state, + int return_status, int retindex, + types::typetag) { + return FunctionResults(state, return_status, retindex) + .get_result(types::typetag()); +} +inline FunctionResults +FunctionResultProxy::ReturnValue(lua_State *state, int return_status, + int retindex, + types::typetag) { + return FunctionResults(state, return_status, retindex); +} +inline void FunctionResultProxy::ReturnValue(lua_State *state, + int return_status, int retindex, + types::typetag) { + KAGUYA_UNUSED(return_status); + lua_settop(state, retindex - 1); +} + +#if KAGUYA_USE_CPP11 +template +template +FunctionResults LuaFunctionImpl::operator()(Args &&... args) { + return this->template call(std::forward(args)...); +} + +template +template +FunctionResults LuaThreadImpl::operator()(Args &&... args) { + return this->template resume(std::forward(args)...); +} +template +template +FunctionResults LuaVariantImpl::operator()(Args &&... args) { + int t = type(); + if (t == LUA_TTHREAD) { + return this->template resume(std::forward(args)...); + } else if (t == LUA_TFUNCTION) { + return this->template call(std::forward(args)...); + } else { + except::typeMismatchError(state_(), " is not function or thread"); + return FunctionResults(state_()); + } +} +#else +#define KAGUYA_TEMPLATE_PARAMETER(N) template +#define KAGUYA_FUNCTION_ARGS_DEF(N) +#define KAGUYA_CALL_ARGS(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) { \ + 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_ARG_CR_DEF_REPEAT(N) +#define KAGUYA_CALL_ARGS(N) KAGUYA_PP_ARG_REPEAT(N) + +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_CALL_DEF +#undef KAGUYA_OP_FN_DEF +#endif +} + +inline std::ostream &operator<<(std::ostream &os, const FunctionResults &res) { + for (FunctionResults::const_iterator it = res.begin(); it != res.end(); + ++it) { + if (it != res.begin()) { + os << ","; + } + util::stackValueDump(os, res.state(), it.index()); + } + + return os; +} + +/// @ingroup lua_type_traits +/// @brief lua_type_traits for FunctionResults +template <> struct lua_type_traits { + static int push(lua_State *l, const FunctionResults &ref) { + int size = 0; + for (FunctionResults::const_iterator it = ref.cbegin(); it != ref.cend(); + ++it) { + size += it->push(l); + } + return size; + } +}; + +/// @ingroup lua_type_traits +/// @brief lua_type_traits for FunctionResults::reference +template <> struct lua_type_traits { + static int push(lua_State *l, const FunctionResults::reference &ref) { + return ref.push(l); + } +}; +template +FunctionResults::reference get(const FunctionResults &res) { + return res.result_at(I); +} + +/// @ingroup lua_type_traits +/// @brief lua_type_traits for LuaFunction +template <> struct lua_type_traits { + typedef LuaFunction get_type; + typedef LuaFunction push_type; + + static bool strictCheckType(lua_State *l, int index) { + return lua_isfunction(l, index); + } + static bool checkType(lua_State *l, int index) { + return lua_isfunction(l, index) || lua_isnil(l, index); + } + static LuaFunction get(lua_State *l, int index) { + lua_pushvalue(l, index); + return LuaFunction(l, StackTop()); + } + static int push(lua_State *l, const LuaFunction &ref) { return ref.push(l); } +}; +/// @ingroup lua_type_traits +/// @brief lua_type_traits for LuaFunction +template <> +struct lua_type_traits : lua_type_traits {}; + +/// @ingroup lua_type_traits +/// @brief lua_type_traits for LuaThread +template <> struct lua_type_traits { + typedef LuaThread get_type; + typedef LuaThread push_type; + + static bool strictCheckType(lua_State *l, int index) { + return lua_isthread(l, index); + } + static bool checkType(lua_State *l, int index) { + return lua_isthread(l, index) || lua_isnil(l, index); + } + static LuaThread get(lua_State *l, int index) { + lua_pushvalue(l, index); + return LuaThread(l, StackTop()); + } + static int push(lua_State *l, const LuaThread &ref) { return ref.push(l); } +}; +/// @ingroup lua_type_traits +/// @brief lua_type_traits for LuaThread +template <> +struct lua_type_traits : lua_type_traits {}; + +/** +* @brief table and function binder. +* state["table"]->*"fun"() is table:fun() in Lua +* @param arg... function args +*/ +class MemberFunctionBinder { +public: + template + MemberFunctionBinder(LuaRef self, T key) + : self_(self), fun_(self_.getField(key)) {} + +#define KAGUYA_DELEGATE_LUAREF fun_ +#define KAGUYA_DELEGATE_FIRST_ARG self_ +#define KAGUYA_DELEGATE_FIRST_ARG_C KAGUYA_DELEGATE_FIRST_ARG, + +#if KAGUYA_USE_CPP11 + template FunctionResults operator()(Args &&... args) { + return KAGUYA_DELEGATE_LUAREF( + KAGUYA_DELEGATE_FIRST_ARG_C std::forward(args)...); + } + + template Result call(Args &&... args) { + return KAGUYA_DELEGATE_LUAREF.call( + KAGUYA_DELEGATE_FIRST_ARG_C std::forward(args)...); + } +#else + +#define KAGUYA_OP_FN_DEF(N) \ + template \ + FunctionResults operator()(KAGUYA_PP_ARG_CR_DEF_REPEAT(N)) { \ + return KAGUYA_DELEGATE_LUAREF( \ + KAGUYA_DELEGATE_FIRST_ARG_C KAGUYA_PP_ARG_REPEAT(N)); \ + } + + /** + * @brief If type is function, call lua function. + * If type is lua thread,start or resume lua thread. + * Otherwise send error message to error handler + */ + FunctionResults operator()() { + return KAGUYA_DELEGATE_LUAREF(KAGUYA_DELEGATE_FIRST_ARG); + } + 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_ARG_CR_DEF_REPEAT(N)) { \ + return KAGUYA_DELEGATE_LUAREF.call( \ + KAGUYA_DELEGATE_FIRST_ARG_C KAGUYA_PP_ARG_REPEAT(N)); \ + } + + template Result call() { + return KAGUYA_DELEGATE_LUAREF.call(KAGUYA_DELEGATE_FIRST_ARG); + } + KAGUYA_PP_REPEAT_DEF(KAGUYA_FUNCTION_MAX_ARGS, KAGUYA_CALL_DEF) + +#undef KAGUYA_CALL_DEF +#endif + +#undef KAGUYA_DELEGATE_FIRST_ARG_C +#undef KAGUYA_DELEGATE_FIRST_ARG +#undef KAGUYA_DELEGATE_LUAREF + +private: + LuaRef self_; // Table or Userdata + LuaFunction fun_; +}; + +typedef MemberFunctionBinder mem_fun_binder; // for backward conpatible +} + +#define KAGUYA_PROPERTY_PREFIX "_prop_" + +namespace kaguya { + +#define KAGUYA_PP_STRUCT_TDEF_REP(N) KAGUYA_PP_CAT(class A, N) = void +#define KAGUYA_PP_STRUCT_TEMPLATE_DEF_REPEAT(N) \ + KAGUYA_PP_REPEAT_ARG(N, KAGUYA_PP_STRUCT_TDEF_REP) + +template +struct MultipleBase {}; +#undef KAGUYA_PP_STRUCT_TDEF_REP +#undef KAGUYA_PP_STRUCT_TEMPLATE_DEF_REPEAT +} + +namespace kaguya { +struct LuaCodeChunk { + LuaCodeChunk(const std::string &src, const std::string &name = "") + : code_(src), chunk_name_(name) {} + LuaCodeChunk(const char *src, const char *name = "") + : code_(src), chunk_name_(name ? name : "") {} + std::string code_; + std::string chunk_name_; +}; + +/// @ingroup lua_type_traits +/// @brief lua_type_traits for LuaCodeChunk +template <> struct lua_type_traits { + static int push(lua_State *state, const LuaCodeChunk &ref) { + int status = luaL_loadbuffer( + state, ref.code_.c_str(), ref.code_.size(), + ref.chunk_name_.empty() ? ref.code_.c_str() : ref.chunk_name_.c_str()); + if (!except::checkErrorAndThrow(status, state)) { + return 0; + } + return 1; + } +}; +struct LuaCodeChunkExecute : LuaCodeChunk { + LuaCodeChunkExecute(const std::string &src, const std::string &name = "") + : LuaCodeChunk(src, name) {} + LuaCodeChunkExecute(const char *src, const char *name = "") + : LuaCodeChunk(src, name) {} +}; +typedef LuaCodeChunkExecute LuaCodeChunkResult; +/// @ingroup lua_type_traits +/// @brief lua_type_traits for LuaCodeChunkResult +template <> struct lua_type_traits { + static int push(lua_State *state, const LuaCodeChunkExecute &ref) { + int status = luaL_loadbuffer( + state, ref.code_.c_str(), ref.code_.size(), + ref.chunk_name_.empty() ? ref.code_.c_str() : ref.chunk_name_.c_str()); + if (!except::checkErrorAndThrow(status, state)) { + return 0; + } + status = lua_pcall_wrap(state, 0, 1); + if (!except::checkErrorAndThrow(status, state)) { + return 0; + } + return 1; + } +}; + +namespace Metatable { +typedef std::map PropMapType; +typedef std::map MemberMapType; + +inline bool is_property_key(const char *keyname) { + return keyname && + strncmp(keyname, KAGUYA_PROPERTY_PREFIX, + sizeof(KAGUYA_PROPERTY_PREFIX) - 1) != 0; +} +inline int property_index_function(lua_State *L) { + // Lua + // local arg = {...};local metatable = arg[1]; + // return function(table, index) + // if string.find(index,KAGUYA_PROPERTY_PREFIX)~=0 then + // local propfun = metatable[KAGUYA_PROPERTY_PREFIX ..index]; + // if propfun then return propfun(table) end + // end + // return metatable[index] + // end + static const int table = 1; + static const int key = 2; + static const int metatable = lua_upvalueindex(1); + const char *strkey = lua_tostring(L, key); + + if (lua_type(L, 1) == LUA_TUSERDATA && is_property_key(strkey)) { + int type = lua_getfield_rtype( + L, metatable, (KAGUYA_PROPERTY_PREFIX + std::string(strkey)).c_str()); + if (type == LUA_TFUNCTION) { + lua_pushvalue(L, table); + lua_call(L, 1, 1); + return 1; + } + } + lua_pushvalue(L, key); + lua_gettable(L, metatable); + return 1; +} +inline int property_newindex_function(lua_State *L) { + // Lua + // local arg = {...};local metatable = arg[1]; + // return function(table, index, value) + // if type(table) == 'userdata' then + // if string.find(index,KAGUYA_PROPERTY_PREFIX)~=0 then + // local propfun = metatable[KAGUYA_PROPERTY_PREFIX..index]; + // if propfun then return propfun(table,value) end + // end + // end + // rawset(table,index,value) + // end + static const int table = 1; + static const int key = 2; + static const int value = 3; + static const int metatable = lua_upvalueindex(1); + const char *strkey = lua_tostring(L, 2); + + if (lua_type(L, 1) == LUA_TUSERDATA && is_property_key(strkey)) { + int type = lua_getfield_rtype( + L, metatable, (KAGUYA_PROPERTY_PREFIX + std::string(strkey)).c_str()); + if (type == LUA_TFUNCTION) { + lua_pushvalue(L, table); + lua_pushvalue(L, value); + lua_call(L, 2, 0); + return 0; + } + } + lua_pushvalue(L, key); + lua_pushvalue(L, value); + lua_rawset(L, table); + return 0; +} + +inline int multiple_base_index_function(lua_State *L) { + // Lua + // local arg = {...};local metabases = arg[1]; + // return function(t, k) + // for i = 1,#metabases do + // local v = metabases[i][k] + // if v then + // t[k] = v + // return v end + // end + // end + static const int table = 1; + static const int key = 2; + static const int metabases = lua_upvalueindex(1); + + lua_pushnil(L); + while (lua_next(L, metabases) != 0) { + if (lua_type(L, -1) == LUA_TTABLE) { + lua_pushvalue(L, key); + int type = lua_gettable_rtype(L, -2); + if (type != LUA_TNIL) { + lua_pushvalue(L, key); + lua_pushvalue(L, -2); + lua_settable(L, table); + return 1; + } + } + lua_settop(L, 3); // pop value + } + return 0; +} + +inline int call_constructor_function(lua_State *L) { + // function(t,...) return t.new(...) end + lua_getfield(L, 1, "new"); + lua_replace(L, 1); + lua_call(L, lua_gettop(L) - 1, LUA_MULTRET); + return lua_gettop(L); +} +inline void get_call_constructor_metatable(lua_State *L) { +#if KAGUYA_SUPPORT_MULTIPLE_SHARED_LIBRARY + static const char *key = "KAGUYA_CALL_CONSTRUCTOR_METATABLE_KEY"; + lua_pushstring(L, key); +#else + static int key = 0; + lua_pushlightuserdata(L, &key); +#endif + int ttype = lua_rawget_rtype(L, LUA_REGISTRYINDEX); + if (ttype != LUA_TTABLE) { + lua_pop(L, 1); + lua_createtable(L, 0, 1); + lua_pushstring(L, "__call"); + lua_pushcfunction(L, &call_constructor_function); + lua_rawset(L, -3); +#if KAGUYA_SUPPORT_MULTIPLE_SHARED_LIBRARY + lua_pushstring(L, key); +#else + lua_pushlightuserdata(L, &key); +#endif + lua_pushvalue(L, -2); + lua_rawset(L, LUA_REGISTRYINDEX); + } +} + +inline void setMembers(lua_State *state, int metatable_index, + const MemberMapType &member_map, + const PropMapType &property_map) { + for (MemberMapType::const_iterator it = member_map.begin(); + it != member_map.end(); ++it) { + util::one_push(state, it->first); + util::one_push(state, it->second); + lua_rawset(state, metatable_index); + } + for (PropMapType::const_iterator it = property_map.begin(); + it != property_map.end(); ++it) { + util::one_push(state, KAGUYA_PROPERTY_PREFIX + it->first); + util::one_push(state, it->second); + lua_rawset(state, metatable_index); + } +} + +inline void setPropertyIndexMetamethod(lua_State *state, int metatable_index) { + lua_pushstring(state, "__index"); + lua_pushvalue(state, metatable_index); + lua_pushcclosure(state, &property_index_function, 1); + lua_rawset(state, metatable_index); +} + +inline void setPropertyNewIndexMetamethod(lua_State *state, + int metatable_index) { + lua_pushstring(state, "__newindex"); + lua_pushvalue(state, metatable_index); + lua_pushcclosure(state, &property_newindex_function, 1); + lua_rawset(state, metatable_index); +} +inline void setMultipleBase(lua_State *state, int metatable_index, + int metabase_array_index) { + lua_createtable(state, 0, 1); + int newmetaindex = lua_gettop(state); + lua_pushstring(state, "__index"); + lua_pushvalue(state, metabase_array_index); // bind metabase_array to + // multiple_base_index_function + lua_pushcclosure(state, &multiple_base_index_function, 1); + lua_rawset(state, + newmetaindex); // newmeta["__index"] = multiple_base_index_function + lua_setmetatable(state, metatable_index); // metatable.setMetatable(newmeta); +} +} + +/// class binding interface. +template +class UserdataMetatable { +public: + UserdataMetatable() { + addStaticFunction("__gc", &class_userdata::destructor); + + KAGUYA_STATIC_ASSERT(is_registerable::value || + !traits::is_std_vector::value, + "std::vector is binding to lua-table by default.If " + "you wants register for std::vector yourself," + "please define KAGUYA_NO_STD_VECTOR_TO_TABLE"); + + KAGUYA_STATIC_ASSERT(is_registerable::value || + !traits::is_std_map::value, + "std::map is binding to lua-table by default.If you " + "wants register for std::map yourself," + "please define KAGUYA_NO_STD_MAP_TO_TABLE"); + + // can not register push specialized class + KAGUYA_STATIC_ASSERT(is_registerable::value, + "Can not register specialized of type conversion " + "class. e.g. std::tuple"); + } + + bool pushCreateMatatable(lua_State *state) const { + if (!class_userdata::newmetatable(state)) { + except::OtherError(state, + typeid(class_type *).name() + + std::string(" is already registered")); + return false; + } + int metatable_index = lua_gettop(state); + Metatable::setMembers(state, metatable_index, member_map_, property_map_); + + if (!traits::is_same::value || + !property_map_.empty()) // if base class has property and derived class + // hasnt property. need property access + // metamethod + { + if (member_map_.count("__index") == 0) { + Metatable::setPropertyIndexMetamethod(state, metatable_index); + } + + if (member_map_.count("__newindex") == 0) { + Metatable::setPropertyNewIndexMetamethod(state, metatable_index); + } + } else { + if (member_map_.count("__index") == 0) { + lua_pushstring(state, "__index"); + lua_pushvalue(state, metatable_index); + lua_rawset(state, metatable_index); + } + } + + set_base_metatable(state, metatable_index, + types::typetag()); + + if (lua_getmetatable(state, metatable_index)) // get base_metatable + { + lua_pushstring(state, "__call"); + lua_pushcfunction(state, &Metatable::call_constructor_function); + lua_rawset(state, -3); // base_metatable["__call"] = + // Metatable::call_constructor_function + } else { + Metatable::get_call_constructor_metatable(state); + lua_setmetatable(state, metatable_index); + } + lua_settop(state, metatable_index); + return true; + } + LuaTable createMatatable(lua_State *state) const { + util::ScopedSavedStack save(state); + if (!pushCreateMatatable(state)) { + return LuaTable(); + } + return LuaStackRef(state, -1); + } + +#if KAGUYA_USE_CPP11 + template UserdataMetatable &setConstructors() { + addOverloadedFunctions( + "new", typename ConstructorFunction::type()...); + return *this; + } +#else +#define KAGUYA_SET_CON_TYPE_DEF(N) \ + typename ConstructorFunction::type() +#define KAGUYA_SET_CON_FN_DEF(N) \ + 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 + +#endif + + /// @brief add member property with getter function.(experimental) + /// @param name function name for lua + /// @param mem bind member data + template + UserdataMetatable &addProperty(const char *name, Ret class_type::*mem) { + if (has_key(name)) { + throw KaguyaException(std::string(name) + " is already registered."); + return *this; + } + property_map_[name] = AnyDataPusher(kaguya::function(mem)); + return *this; + } + + /// @brief add member property with getter function.(experimental) + /// @param name function name for lua + /// @param getter getter function + template + UserdataMetatable &addProperty(const char *name, + GetType (class_type::*getter)() const) { + if (has_key(name)) { + throw KaguyaException(std::string(name) + " is already registered."); + return *this; + } + property_map_[name] = AnyDataPusher(kaguya::function(getter)); + return *this; + } + + /// @brief add member property with setter, getter functions.(experimental) + /// @param name function name for lua + /// @param getter getter function + /// @param setter setter function + template + UserdataMetatable &addProperty(const char *name, + GetType (*getter)(const class_type *)) { + if (has_key(name)) { + throw KaguyaException(std::string(name) + " is already registered."); + return *this; + } + property_map_[name] = AnyDataPusher(function(getter)); + return *this; + } + /// @brief add member property with setter, getter functions.(experimental) + /// @param name function name for lua + /// @param getter getter function + /// @param setter setter function + template + UserdataMetatable &addProperty(const char *name, + GetType (*getter)(const class_type &)) { + if (has_key(name)) { + throw KaguyaException(std::string(name) + " is already registered."); + return *this; + } + property_map_[name] = AnyDataPusher(function(getter)); + return *this; + } + + /// @brief add member property with setter, getter functions.(experimental) + /// @param name function name for lua + /// @param getter getter function + /// @param setter setter function + template + UserdataMetatable &addProperty(const char *name, + GetType (class_type::*getter)() const, + void (class_type::*setter)(SetType)) { + if (has_key(name)) { + throw KaguyaException(std::string(name) + " is already registered."); + return *this; + } + property_map_[name] = AnyDataPusher(overload(getter, setter)); + return *this; + } + + /// @brief add member property with external setter, getter + /// functions.(experimental) + /// @param name function name for lua + /// @param getter getter function + /// @param setter setter function + template + UserdataMetatable &addProperty(const char *name, + GetType (*getter)(const class_type *), + void (*setter)(class_type *, SetType)) { + if (has_key(name)) { + throw KaguyaException(std::string(name) + " is already registered."); + return *this; + } + property_map_[name] = AnyDataPusher(overload(getter, setter)); + return *this; + } + + /// @brief add member property with external setter, getter + /// functions.(experimental) + /// @param name function name for lua + /// @param getter getter function + /// @param setter setter function + template + UserdataMetatable &addProperty(const char *name, + GetType (*getter)(const class_type &), + void (*setter)(class_type &, SetType)) { + if (has_key(name)) { + throw KaguyaException(std::string(name) + " is already registered."); + return *this; + } + property_map_[name] = AnyDataPusher(overload(getter, setter)); + return *this; + } + + /// @brief add member property with getter function.(experimental) + /// @param name function name for lua + /// @param getter getter function + template + UserdataMetatable &addPropertyAny(const char *name, GetterType getter) { + if (has_key(name)) { + throw KaguyaException(std::string(name) + " is already registered."); + return *this; + } + property_map_[name] = AnyDataPusher(function(getter)); + return *this; + } + /// @brief add member property with setter, getter functions.(experimental) + /// @param name function name for lua + /// @param getter getter function + /// @param setter setter function + template + UserdataMetatable &addPropertyAny(const char *name, GetterType getter, + SetterType setter) { + if (has_key(name)) { + throw KaguyaException(std::string(name) + " is already registered."); + return *this; + } + property_map_[name] = AnyDataPusher(overload(getter, setter)); + return *this; + } + + /// @brief add non member function + /// @param name function name for lua + /// @param f function + template + UserdataMetatable &addStaticFunction(const char *name, Fun f) { + if (has_key(name)) { + throw KaguyaException(std::string(name) + " is already registered."); + return *this; + } + member_map_[name] = AnyDataPusher(kaguya::function(f)); + return *this; + } + +#if KAGUYA_USE_CPP11 + /// @brief assign overloaded from functions. + /// @param name name for lua + /// @param f functions + template + UserdataMetatable &addOverloadedFunctions(const char *name, Funcs... f) { + if (has_key(name)) { + throw KaguyaException(std::string(name) + " is already registered."); + return *this; + } + + member_map_[name] = AnyDataPusher(overload(f...)); + + return *this; + } + + /// @brief assign data by argument value. + /// @param name name for lua + /// @param d data + template + UserdataMetatable &addStaticField(const char *name, Data &&d) { + if (has_key(name)) { + throw KaguyaException(std::string(name) + " is already registered."); + return *this; + } + member_map_[name] = AnyDataPusher(std::forward(d)); + return *this; + } +#else + +#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)) { \ + throw KaguyaException(std::string(name) + " is already registered."); \ + return *this; \ + } \ + 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_ADD_OVERLOAD_FUNCTION_DEF + + /// @brief assign data by argument value. + /// @param name name for lua + /// @param d data + template + UserdataMetatable &addStaticField(const char *name, const Data &d) { + if (has_key(name)) { + throw KaguyaException(std::string(name) + " is already registered."); + return *this; + } + member_map_[name] = AnyDataPusher(d); + return *this; + } +#endif + +#if defined(_MSC_VER) && _MSC_VER <= 1800 + // can not write Ret class_type::* f on MSC++2013 + template + UserdataMetatable &addFunction(const char *name, Fun f) { + if (has_key(name)) { + throw KaguyaException(std::string(name) + " is already registered. To " + "overload a function, use " + "addOverloadedFunctions"); + return *this; + } + member_map_[name] = AnyDataPusher(kaguya::function(f)); + return *this; + } +#else + /// @brief assign function + /// @param name name for lua + /// @param f pointer to member function. + template + UserdataMetatable &addFunction(const char *name, Ret class_type::*f) { + if (has_key(name)) { + throw KaguyaException(std::string(name) + " is already registered. To " + "overload a function, use " + "addOverloadedFunctions"); + return *this; + } + member_map_[name] = AnyDataPusher(kaguya::function(f)); + return *this; + } +#endif + /// @brief assign function + /// @param name name for lua + /// @param f member function object. + UserdataMetatable &addFunction(const char *name, PolymorphicMemberInvoker f) { + if (has_key(name)) { + throw KaguyaException(std::string(name) + " is already registered. To " + "overload a function, use " + "addOverloadedFunctions"); + return *this; + } + member_map_[name] = AnyDataPusher(kaguya::function(f)); + return *this; + } + +private: + void set_base_metatable(lua_State *, int, types::typetag) const {} + template + void set_base_metatable(lua_State *state, int metatable_index, + types::typetag) const { + class_userdata::get_metatable(state); + lua_setmetatable(state, + metatable_index); // metatable.setMetatable(newmeta); + PointerConverter &pconverter = PointerConverter::get(state); + pconverter.add_type_conversion(); + } + +#if KAGUYA_USE_CPP11 + + template + void metatables(lua_State *state, int metabase_array_index, + PointerConverter &pvtreg, + types::typetag >) const { + class_userdata::get_metatable(state); + lua_rawseti(state, metabase_array_index, + lua_rawlen(state, metabase_array_index) + 1); + pvtreg.add_type_conversion(); + } + template + void metatables(lua_State *state, int metabase_array_index, + PointerConverter &pvtreg, + types::typetag >) const { + class_userdata::get_metatable(state); + lua_rawseti(state, metabase_array_index, + lua_rawlen(state, metabase_array_index) + 1); + pvtreg.add_type_conversion(); + metatables(state, metabase_array_index, pvtreg, + types::typetag >()); + } + + template + void + set_base_metatable(lua_State *state, int metatable_index, + types::typetag > metatypes) const { + PointerConverter &pconverter = PointerConverter::get(state); + + lua_createtable(state, sizeof...(Bases), 0); + int metabase_array_index = lua_gettop(state); + metatables(state, metabase_array_index, pconverter, metatypes); + Metatable::setMultipleBase(state, metatable_index, metabase_array_index); + } + +#else +#define KAGUYA_GET_BASE_METATABLE(N) \ + class_userdata::get_metatable(state); \ + lua_rawseti(state, metabase_array_index, \ + lua_rawlen(state, metabase_array_index) + 1); \ + pconverter.add_type_conversion(); +#define KAGUYA_MULTIPLE_INHERITANCE_SETBASE_DEF(N) \ + template \ + void set_base_metatable( \ + lua_State *state, int metatable_index, \ + types::typetag >) const { \ + PointerConverter &pconverter = PointerConverter::get(state); \ + lua_createtable(state, N, 0); \ + int metabase_array_index = lua_gettop(state); \ + KAGUYA_PP_REPEAT(N, KAGUYA_GET_BASE_METATABLE); \ + Metatable::setMultipleBase(state, metatable_index, metabase_array_index); \ + } + + KAGUYA_PP_REPEAT_DEF(KAGUYA_CLASS_MAX_BASE_CLASSES, + KAGUYA_MULTIPLE_INHERITANCE_SETBASE_DEF) +#undef KAGUYA_MULTIPLE_INHERITANCE_SETBASE_DEF +#undef KAGUYA_GET_BASE_METATABLE +#endif + + bool has_key(const std::string &key) { + if (member_map_.count(key) > 0) { + return true; + } + if (property_map_.count(key) > 0) { + return true; + } + std::string propkey = KAGUYA_PROPERTY_PREFIX + key; + if (member_map_.count(propkey) > 0) //_prop_keyname is reserved for property + { + return true; + } + return false; + } + + Metatable::PropMapType property_map_; + Metatable::MemberMapType member_map_; +}; + +/// @ingroup lua_type_traits +/// @brief lua_type_traits for UserdataMetatable +template +struct lua_type_traits > { + typedef const UserdataMetatable &push_type; + + static int push(lua_State *l, push_type ref) { + ref.pushCreateMatatable(l); + return 1; + } +}; +} + +// Copyright satoren +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + + +#include +#include + +namespace kaguya { +class State; + +/** +* This class is the type returned by members of non-const LuaRef(Table) when +* directly accessing its elements. +*/ +template +class TableKeyReferenceProxy + : public detail::LuaVariantImpl > { +public: + int pushStackIndex(lua_State *state) const { + push(state); + return lua_gettop(state); + } + lua_State *state() const { return state_; } + + friend class LuaRef; + friend class State; + + //! this is not copy.same assign from referenced value. + TableKeyReferenceProxy &operator=(const TableKeyReferenceProxy &src) { + detail::table_proxy::set(state_, table_index_, key_, src); + return *this; + } + + //! assign from T + template TableKeyReferenceProxy &operator=(const T &src) { + detail::table_proxy::set(state_, table_index_, key_, src); + return *this; + } +#if KAGUYA_USE_CPP11 + template TableKeyReferenceProxy &operator=(T &&src) { + detail::table_proxy::set(state_, table_index_, key_, std::forward(src)); + return *this; + } +#endif + + bool isNilref() const { + if (!state_) { + return false; + } + util::ScopedSavedStack save(state_); + push(state_); + return lua_isnoneornil(state_, -1); + } + + //! register class metatable to lua and set to table + template + void setClass(const UserdataMetatable ®) { + set_class(reg); + } + + //! set function + template void setFunction(T f) { + detail::table_proxy::set(state_, table_index_, key_, kaguya::function(f)); + } + + int push(lua_State *state) const { + int type = lua_type(state_, table_index_); + if (type != LUA_TTABLE && type != LUA_TUSERDATA) { + lua_pushnil(state); + return 1; + } + + detail::table_proxy::get(state_, table_index_, key_); + + if (state_ != state) { + lua_xmove(state_, state, 1); + } + return 1; + } + + int push() const { return push(state_); } + + int type() const { + util::ScopedSavedStack save(state_); + push(); + return lua_type(state_, -1); + } + + ~TableKeyReferenceProxy() { + if (state_) { + lua_settop(state_, stack_top_); + } + } + + ///!constructs the reference. Accessible only to kaguya::LuaRef itself + TableKeyReferenceProxy(const TableKeyReferenceProxy &src) + : state_(src.state_), stack_top_(src.stack_top_), + table_index_(src.table_index_), key_(src.key_) { + src.state_ = 0; + } + + ///!constructs the reference. Accessible only to kaguya::LuaRef itself + TableKeyReferenceProxy(lua_State *state, int table_index, KEY key, + int revstacktop) + : state_(state), stack_top_(revstacktop), table_index_(table_index), + key_(key) {} + +private: + template + void set_class(const UserdataMetatable ®) { + detail::table_proxy::set(state_, table_index_, key_,reg); + } + + ///!constructs the reference. Accessible only to kaguya::LuaRef itself + TableKeyReferenceProxy(lua_State *state, int table_index, const KEY &key, + int revstacktop, const NoTypeCheck &) + : state_(state), stack_top_(revstacktop), table_index_(table_index), + key_(key) {} + + TableKeyReferenceProxy(const LuaTable &table, const KEY &key) + : state_(table.state()), stack_top_(lua_gettop(state_)), key_(key) { + util::one_push(state_, table); + table_index_ = stack_top_ + 1; + } + TableKeyReferenceProxy(const LuaRef &table, const KEY &key) + : state_(table.state()), stack_top_(lua_gettop(state_)), key_(key) { + util::one_push(state_, table); + table_index_ = stack_top_ + 1; + int t = lua_type(state_, table_index_); + if (t != LUA_TTABLE) { + except::typeMismatchError(state_, lua_typename(state_, t) + + std::string(" is not table")); + } + } + + mutable lua_State *state_; // mutable for RVO unsupported compiler + int stack_top_; + int table_index_; + KEY key_; +}; + +template +inline std::ostream &operator<<(std::ostream &os, + const TableKeyReferenceProxy &ref) { + lua_State *state = ref.state(); + util::ScopedSavedStack save(state); + int stackIndex = ref.pushStackIndex(state); + util::stackValueDump(os, state, stackIndex); + return os; +} + +namespace detail { +template +inline bool LuaFunctionImpl::setFunctionEnv(const LuaTable &env) { + lua_State *state = state_(); + if (!state) { + return false; + } + util::ScopedSavedStack save(state); + int stackIndex = pushStackIndex_(state); + int t = lua_type(state, stackIndex); + if (t != LUA_TFUNCTION) { + except::typeMismatchError(state, lua_typename(state, t) + + std::string(" is not function")); + return false; + } + env.push(state); +#if LUA_VERSION_NUM >= 502 + lua_setupvalue(state, stackIndex, 1); +#else + lua_setfenv(state, stackIndex); +#endif + return true; +} +template inline bool LuaFunctionImpl::setFunctionEnv(NewTable) { + return setFunctionEnv(LuaTable(state_())); +} + +template +inline LuaTable LuaFunctionImpl::getFunctionEnv() const { + lua_State *state = state_(); + util::ScopedSavedStack save(state); + if (!state) { + except::typeMismatchError(state, "is nil"); + return LuaTable(); + } + int stackIndex = pushStackIndex_(state); + int t = lua_type(state, stackIndex); + if (t != LUA_TFUNCTION) { + except::typeMismatchError(state, lua_typename(state, t) + + std::string(" is not function")); + return LuaTable(); + } +#if LUA_VERSION_NUM >= 502 + lua_getupvalue(state, stackIndex, 1); +#else + lua_getfenv(state, stackIndex); +#endif + return LuaTable(state, StackTop()); +} + +template void LuaThreadImpl::setFunction(const LuaFunction &f) { + lua_State *corstate = getthread(); + if (corstate) { + lua_settop(corstate, 0); + f.push(corstate); + } +} + +template +bool LuaTableOrUserDataImpl::setMetatable(const LuaTable &table) { + lua_State *state = state_(); + if (!state) { + except::typeMismatchError(state, "is nil"); + return false; + } + util::ScopedSavedStack save(state); + int stackindex = pushStackIndex_(state); + int t = lua_type(state, stackindex); + if (t != LUA_TTABLE && t != LUA_TUSERDATA) { + except::typeMismatchError(state, lua_typename(state, t) + + std::string(" is not table")); + return false; + } + table.push(); + return lua_setmetatable(state, stackindex) != 0; +} +template LuaTable LuaTableOrUserDataImpl::getMetatable() const { + lua_State *state = state_(); + if (!state) { + except::typeMismatchError(state, "is nil"); + return LuaTable(); + } + util::ScopedSavedStack save(state); + int stackindex = pushStackIndex_(state); + int t = lua_type(state, stackindex); + if (t != LUA_TTABLE && t != LUA_TUSERDATA) { + except::typeMismatchError(state, lua_typename(state, t) + + std::string(" is not table")); + return LuaTable(); + } + if (!lua_getmetatable(state, stackindex)) { + lua_pushnil(state); + } + return LuaTable(state, StackTop()); +} +template +MemberFunctionBinder LuaTableOrUserDataImpl:: +operator->*(const char *function_name) { + push_(state_()); + return MemberFunctionBinder(LuaRef(state_(), StackTop()), function_name); +} + +template +template +LuaStackRef LuaTableOrUserDataImpl::getField(const KEY &key) const { + lua_State *state = state_(); + if (!state) { + except::typeMismatchError(state, "is nil"); + return LuaStackRef(); + } + push_(state); + detail::table_proxy::get(state, lua_gettop(state), key); + lua_remove(state, -2); // remove table + return LuaStackRef(state, -1, true); +} +template +template +LuaStackRef LuaTableImpl::getRawField(const KEY &key) const { + lua_State *state = state_(); + if (!state) { + except::typeMismatchError(state, "is nil"); + return LuaStackRef(); + } + push_(state); + detail::table_proxy::rawget(state, lua_gettop(state), key); + lua_remove(state, -2); // remove table + return LuaStackRef(state, -1, true); +} + +template +template +LuaStackRef LuaTableOrUserDataImpl::operator[](KEY key) const { + return getField(key); +} + +template std::vector LuaTableImpl::values() const { + return values(); +} +template std::vector LuaTableImpl::keys() const { + return keys(); +} +template std::map LuaTableImpl::map() const { + return map(); +} + +template +template +TableKeyReferenceProxy LuaTableOrUserDataImpl::operator[](K key) { + lua_State *state = state_(); + int stack_top = lua_gettop(state); + int stackindex = pushStackIndex_(state); + return TableKeyReferenceProxy(state, stackindex, key, stack_top); +} +} + +/// @ingroup lua_type_traits +/// @brief lua_type_traits for TableKeyReferenceProxy +template struct lua_type_traits > { + static int push(lua_State *l, const TableKeyReferenceProxy &ref) { + return ref.push(l); + } +}; + +#if KAGUYA_USE_CPP11 +/// @ingroup lua_type_traits +/// @brief lua_type_traits for std::array +template struct lua_type_traits > { + typedef std::array get_type; + typedef const std::array &push_type; + + static bool checkType(lua_State *l, int index) { + if (lua_type(l, index) != LUA_TTABLE) { + return false; + } + + LuaStackRef table(l, index); + if (table.size() != S) { + return false; + } // TODO + bool valid = true; + table.foreach_table_breakable( + [&](const LuaStackRef &k, const LuaStackRef &v) { + valid = valid && k.typeTest() && v.typeTest(); + return valid; + }); + return valid; + } + static bool strictCheckType(lua_State *l, int index) { + if (lua_type(l, index) != LUA_TTABLE) { + return false; + } + + LuaStackRef table(l, index); + if (table.size() != S) { + return false; + } // TODO + bool valid = true; + table.foreach_table_breakable( + [&](const LuaStackRef &k, const LuaStackRef &v) { + valid = valid && k.typeTest() && v.typeTest(); + return valid; + }); + return valid; + } + static get_type get(lua_State *l, int index) { + if (lua_type(l, index) != LUA_TTABLE) { + except::typeMismatchError(l, std::string("type mismatch")); + return get_type(); + } + LuaStackRef t(l, index); + if (t.size() != S) // TODO + { + except::typeMismatchError(l, std::string("type mismatch")); + } + get_type res; + t.foreach_table([&](size_t k, const T &v) { + if (k > 0 && k <= S) { + res[k - 1] = v; + } + }); + return res; + } + static int push(lua_State *l, push_type v) { + lua_createtable(l, int(S), 0); + for (size_t i = 0; i < S; ++i) { + util::one_push(l, v[i]); + lua_rawseti(l, -2, i + 1); + } + return 1; + } +}; +#endif +#ifndef KAGUYA_NO_STD_VECTOR_TO_TABLE + +/// @ingroup lua_type_traits +/// @brief lua_type_traits for std::vector +template struct lua_type_traits > { + typedef std::vector get_type; + typedef const std::vector &push_type; + struct checkTypeForEach { + checkTypeForEach(bool &valid) : valid_(valid) {} + bool &valid_; + bool operator()(const LuaStackRef &k, const LuaStackRef &v) { + valid_ = k.typeTest() && v.weakTypeTest(); + return valid_; + } + }; + struct strictCheckTypeForEach { + strictCheckTypeForEach(bool &valid) : valid_(valid) {} + bool &valid_; + bool operator()(const LuaStackRef &k, const LuaStackRef &v) { + valid_ = k.typeTest() && v.typeTest(); + return valid_; + } + }; + + static bool checkType(lua_State *l, int index) { + LuaStackRef table(l, index); + if (table.type() != LuaRef::TYPE_TABLE) { + return false; + } + + bool valid = true; + table.foreach_table_breakable( + checkTypeForEach(valid)); + return valid; + } + static bool strictCheckType(lua_State *l, int index) { + LuaStackRef table(l, index); + if (table.type() != LuaRef::TYPE_TABLE) { + return false; + } + + bool valid = true; + table.foreach_table_breakable( + strictCheckTypeForEach(valid)); + return valid; + } + + static get_type get(lua_State *l, int index) { + if (lua_type(l, index) != LUA_TTABLE) { + except::typeMismatchError(l, std::string("type mismatch")); + return get_type(); + } + return LuaStackRef(l, index).values(); + } +#if KAGUYA_USE_CPP11 + typedef std::vector &&move_push_type; + static int push(lua_State *l, move_push_type v) { + lua_createtable(l, int(v.size()), 0); + int count = 1; // array is 1 origin in Lua + for (typename std::vector::iterator it = v.begin(); it != v.end(); + ++it) { + util::one_push(l, static_cast(*it)); + lua_rawseti(l, -2, count++); + } + return 1; + } +#endif + static int push(lua_State *l, push_type v) { + lua_createtable(l, int(v.size()), 0); + int count = 1; // array is 1 origin in Lua + for (typename std::vector::const_iterator it = v.begin(); + it != v.end(); ++it) { + util::one_push(l, static_cast(*it)); + lua_rawseti(l, -2, count++); + } + return 1; + } +}; +#endif + +#ifndef KAGUYA_NO_STD_MAP_TO_TABLE +/// @ingroup lua_type_traits +/// @brief lua_type_traits for std::map +template +struct lua_type_traits > { + typedef std::map get_type; + typedef const std::map &push_type; + + struct checkTypeForEach { + checkTypeForEach(bool &valid) : valid_(valid) {} + bool &valid_; + bool operator()(const LuaStackRef &k, const LuaStackRef &v) { + valid_ = k.weakTypeTest() && v.weakTypeTest(); + return valid_; + } + }; + struct strictCheckTypeForEach { + strictCheckTypeForEach(bool &valid) : valid_(valid) {} + bool &valid_; + bool operator()(const LuaStackRef &k, const LuaStackRef &v) { + valid_ = k.typeTest() && v.typeTest(); + return valid_; + } + }; + static bool checkType(lua_State *l, int index) { + LuaStackRef table(l, index); + if (table.type() != LuaRef::TYPE_TABLE) { + return false; + } + + bool valid = true; + table.foreach_table_breakable( + checkTypeForEach(valid)); + return valid; + } + static bool strictCheckType(lua_State *l, int index) { + LuaStackRef table(l, index); + if (table.type() != LuaRef::TYPE_TABLE) { + return false; + } + + bool valid = true; + table.foreach_table_breakable( + strictCheckTypeForEach(valid)); + return valid; + } + + static get_type get(lua_State *l, int index) { + if (lua_type(l, index) != LUA_TTABLE) { + except::typeMismatchError(l, std::string("type mismatch")); + return get_type(); + } + return LuaStackRef(l, index).map(); + } + static int push(lua_State *l, push_type v) { + lua_createtable(l, 0, int(v.size())); + for (typename std::map::const_iterator it = v.begin(); + it != v.end(); ++it) { + util::one_push(l, it->first); + util::one_push(l, it->second); + lua_rawset(l, -3); + } + return 1; + } +}; +#endif + +struct TableDataElement { + typedef std::pair keyvalue_type; + + template + TableDataElement(Value value) + : keyvalue(keyvalue_type(AnyDataPusher(), value)) {} + + template + TableDataElement(Key key, Value value) + : keyvalue(keyvalue_type(key, value)) {} + std::pair keyvalue; +}; + +struct TableData { + typedef std::pair data_type; + +#if KAGUYA_USE_CPP11 + TableData(std::initializer_list list) + : elements(list.begin(), list.end()) {} +#endif + template TableData(IT beg, IT end) : elements(beg, end) {} + + TableData() {} + std::vector elements; +}; + +/// @ingroup lua_type_traits +/// @brief lua_type_traits for TableData +template <> struct lua_type_traits { + static int push(lua_State *l, const TableData &list) { + lua_createtable(l, int(list.elements.size()), int(list.elements.size())); + int count = 1; // array is 1 origin in Lua + for (std::vector::const_iterator it = + list.elements.begin(); + it != list.elements.end(); ++it) { + const TableDataElement &v = *it; + if (v.keyvalue.first.empty()) { + util::one_push(l, v.keyvalue.second); + lua_rawseti(l, -2, count++); + } else { + util::one_push(l, v.keyvalue.first); + util::one_push(l, v.keyvalue.second); + lua_rawset(l, -3); + } + } + return 1; + } +}; +} + +namespace kaguya { +/// @addtogroup State +/// @{ + +/// @brief Load library info type @see State::openlibs @see State::State(const +/// LoadLibs &libs) +typedef std::pair LoadLib; + +/// @brief Load libraries info @see State::openlibs @see State::State(const +/// LoadLibs &libs) +typedef std::vector LoadLibs; + +/// @brief return no load library type @see State::State(const LoadLibs &libs) +inline LoadLibs NoLoadLib() { return LoadLibs(); } + +/// @brief All load standard libraries type @see State::openlibs +struct AllLoadLibs {}; + +template +void *AllocatorFunction(void *ud, void *ptr, size_t osize, size_t nsize) { + Allocator *allocator = static_cast(ud); + if (nsize == 0) { + allocator->deallocate(ptr, osize); + } else if (ptr) { + return allocator->reallocate(ptr, nsize); + } else { + return allocator->allocate(nsize); + } + return 0; +} + +struct DefaultAllocator { + typedef void *pointer; + typedef size_t size_type; + pointer allocate(size_type n) { return std::malloc(n); } + pointer reallocate(pointer p, size_type n) { return std::realloc(p, n); } + void deallocate(pointer p, size_type n) { + KAGUYA_UNUSED(n); + std::free(p); + } +}; + +/// lua_State wrap class +class State { + standard::shared_ptr allocator_holder_; + lua_State *state_; + bool created_; + + // non copyable + State(const State &); + State &operator=(const State &); + + static int initializing_panic(lua_State *L) { + ErrorHandler::throwDefaultError(lua_status(L), lua_tostring(L, -1)); + return 0; // return to Lua to abort + } + static int default_panic(lua_State *L) { + if (ErrorHandler::handle(lua_status(L), L)) { + return 0; + } + fprintf(stderr, "PANIC: unprotected error in call to Lua API (%s)\n", + lua_tostring(L, -1)); + fflush(stderr); + return 0; // return to Lua to abort + } + static void stderror_out(int status, const char *message) { + KAGUYA_UNUSED(status); + std::cerr << message << std::endl; + } + + template void init(const Libs &lib) { + if (state_) { + lua_atpanic(state_, &initializing_panic); + try { + if (!ErrorHandler::getHandler(state_)) { + setErrorHandler(&stderror_out); + } + registerMainThreadIfNeeded(); + openlibs(lib); + lua_atpanic(state_, &default_panic); + } catch (const LuaException &) { + lua_close(state_); + state_ = 0; + } + } + } + + void registerMainThreadIfNeeded() { +#if LUA_VERSION_NUM < 502 + if (state_) { + util::registerMainThread(state_); + } +#endif + } + +public: + /// @brief create Lua state with lua standard library + State() : allocator_holder_(), state_(luaL_newstate()), created_(true) { + init(AllLoadLibs()); + } + + /// @brief create Lua state with lua standard library. Can not use this + /// constructor at luajit. error message is 'Must use luaL_newstate() for 64 + /// bit target' + /// @param allocator allocator for memory allocation @see DefaultAllocator + template + State(standard::shared_ptr allocator) + : allocator_holder_(allocator), + state_(lua_newstate(&AllocatorFunction, + allocator_holder_.get())), + created_(true) { + init(AllLoadLibs()); + } + + /// @brief create Lua state with (or without) libraries. + /// @param libs load libraries + /// e.g. LoadLibs libs;libs.push_back(LoadLib("libname",libfunction));State + /// state(libs); + /// e.g. State state({{"libname",libfunction}}); for c++ 11 + State(const LoadLibs &libs) + : allocator_holder_(), state_(luaL_newstate()), created_(true) { + init(libs); + } + + /// @brief create Lua state with (or without) libraries. Can not use this + /// constructor at luajit. error message is 'Must use luaL_newstate() for 64 + /// bit target' + /// @param libs load libraries + /// @param allocator allocator for memory allocation @see DefaultAllocator + template + State(const LoadLibs &libs, standard::shared_ptr allocator) + : allocator_holder_(allocator), + state_(lua_newstate(&AllocatorFunction, + allocator_holder_.get())), + created_(true) { + init(libs); + } + + /// @brief construct using created lua_State. + /// @param lua created lua_State. It is not call lua_close() in this class + State(lua_State *lua) : state_(lua), created_(false) { + if (state_) { + registerMainThreadIfNeeded(); + if (!ErrorHandler::getHandler(state_)) { + setErrorHandler(&stderror_out); + } + } + } + ~State() { + if (created_ && state_) { + lua_close(state_); + } + } + + /// @brief set error handler for lua error. + void + setErrorHandler(standard::function + errorfunction) { + if (!state_) { + return; + } + util::ScopedSavedStack save(state_); + ErrorHandler::registerHandler(state_, errorfunction); + } + + /// @brief load all lua standard library + void openlibs(AllLoadLibs = AllLoadLibs()) { + if (!state_) { + return; + } + luaL_openlibs(state_); + } + + /// @brief load lua library + LuaStackRef openlib(const LoadLib &lib) { + if (!state_) { + return LuaStackRef(); + } + luaL_requiref(state_, lib.first.c_str(), lib.second, 1); + return LuaStackRef(state_, -1, true); + } + /// @brief load lua library + LuaStackRef openlib(std::string name, lua_CFunction f) { + return openlib(LoadLib(name, f)); + } + + /// @brief load lua libraries + void openlibs(const LoadLibs &libs) { + for (LoadLibs::const_iterator it = libs.begin(); it != libs.end(); ++it) { + openlib(*it); + } + } + + /// @brief If there are no errors,compiled file as a Lua function and return. + /// Otherwise send error message to error handler and return nil reference + /// @param file file path of lua script + /// @return reference of lua function + LuaFunction loadfile(const std::string &file) { + return LuaFunction::loadfile(state_, file); + } + /// @brief If there are no errors,compiled file as a Lua function and return. + /// Otherwise send error message to error handler and return nil reference + /// @param file file path of lua script + /// @return reference of lua function + LuaFunction loadfile(const char *file) { + return LuaFunction::loadfile(state_, file); + } + + /// @brief If there are no errors,compiled stream as a Lua function and + /// return. + /// Otherwise send error message to error handler and return nil reference + /// @param stream stream of lua script + /// @param chunkname chunkname of lua script + /// @return reference of lua function + LuaFunction loadstream(std::istream &stream, const char *chunkname = 0) { + return LuaFunction::loadstream(state_, stream, chunkname); + } + /// @brief Loads and runs the given stream. + /// @param stream stream of lua script + /// @param chunkname chunkname of lua script + /// @param env execute env table + /// @return If there are no errors, returns true.Otherwise return false + bool dostream(std::istream &stream, const char *chunkname = 0, + const LuaTable &env = LuaTable()) { + util::ScopedSavedStack save(state_); + LuaStackRef f = LuaFunction::loadstreamtostack(state_, stream, chunkname); + if (!f) { // load failed + return false; + } + if (!env.isNilref()) { + f.setFunctionEnv(env); + } + + FunctionResults ret = f.call(); + return !ret.resultStatus(); + } + + /// @brief If there are no errors,compiled string as a Lua function and + /// return. + /// Otherwise send error message to error handler and return nil reference + /// @param str lua code + /// @return reference of lua function + LuaFunction loadstring(const std::string &str) { + return LuaFunction::loadstring(state_, str); + } + /// @brief If there are no errors,compiled string as a Lua function and + /// return. + /// Otherwise send error message to error handler and return nil reference + /// @param str lua code + /// @return reference of lua function + LuaFunction loadstring(const char *str) { + return LuaFunction::loadstring(state_, str); + } + + /// @brief Loads and runs the given file. + /// @param file file path of lua script + /// @param env execute env table + /// @return If there are no errors, returns true.Otherwise return false + bool dofile(const std::string &file, const LuaTable &env = LuaTable()) { + return dofile(file.c_str(), env); + } + + /// @brief Loads and runs the given file. + /// @param file file path of lua script + /// @param env execute env table + /// @return If there are no errors, returns true.Otherwise return false + bool dofile(const char *file, const LuaTable &env = LuaTable()) { + util::ScopedSavedStack save(state_); + + int status = luaL_loadfile(state_, file); + + if (status) { + ErrorHandler::handle(status, state_); + return false; + } + + if (!env.isNilref()) { // register _ENV + env.push(); +#if LUA_VERSION_NUM >= 502 + lua_setupvalue(state_, -2, 1); +#else + lua_setfenv(state_, -2); +#endif + } + + status = lua_pcall_wrap(state_, 0, LUA_MULTRET); + if (status) { + ErrorHandler::handle(status, state_); + return false; + } + return true; + } + + /// @brief Loads and runs the given string. + /// @param str lua script cpde + /// @param env execute env table + /// @return If there are no errors, returns true.Otherwise return false + bool dostring(const char *str, const LuaTable &env = LuaTable()) { + util::ScopedSavedStack save(state_); + + int status = luaL_loadstring(state_, str); + if (status) { + ErrorHandler::handle(status, state_); + return false; + } + if (!env.isNilref()) { // register _ENV + env.push(); +#if LUA_VERSION_NUM >= 502 + lua_setupvalue(state_, -2, 1); +#else + lua_setfenv(state_, -2); +#endif + } + status = lua_pcall_wrap(state_, 0, LUA_MULTRET); + if (status) { + ErrorHandler::handle(status, state_); + return false; + } + return true; + } + /// @brief Loads and runs the given string. + /// @param str lua script cpde + /// @param env execute env table + /// @return If there are no errors, returns true.Otherwise return false + bool dostring(const std::string &str, const LuaTable &env = LuaTable()) { + return dostring(str.c_str(), env); + } + + /// @brief Loads and runs the given string. + /// @param str lua script cpde + /// @return If there are no errors, returns true.Otherwise return false + bool operator()(const std::string &str) { return dostring(str); } + + /// @brief Loads and runs the given string. + /// @param str lua script cpde + /// @return If there are no errors, returns true.Otherwise return false + bool operator()(const char *str) { return dostring(str); } + + /// @brief return element reference from global table + /// @param str table key + /// @return proxy class for reference to table. + TableKeyReferenceProxy operator[](const std::string &str) { + int stack_top = lua_gettop(state_); + util::push_args(state_, GlobalTable()); + int table_index = stack_top + 1; + return TableKeyReferenceProxy(state_, table_index, str, + stack_top, NoTypeCheck()); + } + + /// @brief return element reference from global table + /// @param str table key + /// @return proxy class for reference to table. + + TableKeyReferenceProxy operator[](const char *str) { + int stack_top = lua_gettop(state_); + util::push_args(state_, GlobalTable()); + int table_index = stack_top + 1; + return TableKeyReferenceProxy(state_, table_index, str, + stack_top, NoTypeCheck()); + } + + /// @brief return global table + /// @return global table. + LuaTable globalTable() { return newRef(GlobalTable()); } + + /// @brief create new Lua reference from argument value + /// @return Lua reference. + template LuaRef newRef(const T &value) { + return LuaRef(state_, value); + } +#if KAGUYA_USE_CPP11 + + /// @brief create new Lua reference from argument value + /// @return Lua reference. + template LuaRef newRef(T &&value) { + return LuaRef(state_, std::forward(value)); + } +#endif + + /// @brief create new Lua table + /// @return Lua table reference. + LuaTable newTable() { return LuaTable(state_); } + + /// @brief create new Lua table + /// @param reserve_array reserved array count + /// @param reserve_record reserved record count + /// @return Lua table reference. + LuaTable newTable(int reserve_array, int reserve_record) { + return LuaTable(state_, NewTable(reserve_array, reserve_record)); + } + + /// @brief create new Lua thread + /// @return Lua thread reference. + LuaThread newThread() { return LuaThread(state_); } + + /// @brief create new Lua thread with lua function + /// @param f function + /// @return Lua thread reference. + LuaThread newThread(const LuaFunction &f) { + LuaThread cor(state_); + cor.setFunction(f); + return cor; + } + + /// @brief argument value push to stack. + /// @param value value + template void pushToStack(T value) { + util::push_args(state_, value); + } + + /// @brief pop from stack. + /// @return reference to pop value. + LuaRef popFromStack() { return LuaRef(state_, StackTop()); } + + /// @brief Garbage Collection of Lua + struct GCType { + GCType(lua_State *state) : state_(state) {} + + /// @brief Performs a full garbage-collection cycle. + void collect() { lua_gc(state_, LUA_GCCOLLECT, 0); } + /// @brief Performs an incremental step of garbage collection. + /// @return If returns true,the step finished a collection cycle. + bool step() { return lua_gc(state_, LUA_GCSTEP, 0) == 1; } + + /// @brief Performs an incremental step of garbage collection. + /// @param size the collector will perform as if that amount of memory (in + /// KBytes) had been allocated by Lua. + bool step(int size) { return lua_gc(state_, LUA_GCSTEP, size) == 1; } + + /// @brief enable gc + void restart() { enable(); } + + /// @brief disable gc + void stop() { disable(); } + + /// @brief returns the total memory in use by Lua in Kbytes. + int count() const { return lua_gc(state_, LUA_GCCOUNT, 0); } + + /// @brief sets arg as the new value for the pause of the collector. Returns + /// the previous value for pause. + int steppause(int value) { return lua_gc(state_, LUA_GCSETPAUSE, value); } + + /// @brief sets arg as the new value for the step multiplier of the + /// collector. Returns the previous value for step. + int setstepmul(int value) { + return lua_gc(state_, LUA_GCSETSTEPMUL, value); + } + + /// @brief enable gc + void enable() { lua_gc(state_, LUA_GCRESTART, 0); } + + /// @brief disable gc + void disable() { lua_gc(state_, LUA_GCSTOP, 0); } +#if LUA_VERSION_NUM >= 502 + + /// @brief returns a boolean that tells whether the collector is running + bool isrunning() const { return isenabled(); } + + /// @brief returns a boolean that tells whether the collector is running + bool isenabled() const { return lua_gc(state_, LUA_GCISRUNNING, 0) != 0; } +#endif + + private: + lua_State *state_; + }; + + // /@brief return Garbage collection interface. + GCType gc() const { return GCType(state_); } + /// @brief performs a full garbage-collection cycle. + void garbageCollect() { gc().collect(); } + + /// @brief returns the current amount of memory (in Kbytes) in use by Lua. + size_t useKBytes() const { return size_t(gc().count()); } + + /// @brief create Table and push to stack. + /// using for Lua module + /// @return return Lua Table Reference + LuaTable newLib() { + LuaTable newtable = newTable(); + newtable.push(state_); + return newtable; + } + + /// @brief return lua_State*. + /// @return lua_State* + lua_State *state() { return state_; }; + + /// @brief check valid lua_State. + bool isInvalid() const { return !state_; } +}; + +/// @} +} +// Copyright satoren +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + + + +namespace kaguya { + +template struct ref_tuple { + RefTuple tref; + ref_tuple(const RefTuple &va) : tref(va) {} + void operator=(const FunctionResults &fres) { + tref = fres.get_result(types::typetag()); + } + template void operator=(const T &fres) { tref = fres; } +}; +#if KAGUYA_USE_CPP11 +template +ref_tuple, standard::tuple > +tie(Args &... va) { + typedef standard::tuple RefTuple; + typedef standard::tuple GetTuple; + return ref_tuple(RefTuple(va...)); +} +#else +#define KAGUYA_VARIADIC_REFARG_REP(N) KAGUYA_PP_CAT(A, N) & KAGUYA_PP_CAT(a, N) +#define KAGUYA_VARIADIC_TREFARG_REP(N) KAGUYA_PP_CAT(A, N) & +#define KAGUYA_TEMPLATE_REFARG_REPEAT(N) \ + KAGUYA_PP_REPEAT_ARG(N, KAGUYA_VARIADIC_TREFARG_REP) +#define KAGUYA_REF_TUPLE(N) standard::tuple +#define KAGUYA_GET_TUPLE(N) standard::tuple +#define KAGUYA_REF_TUPLE_DEF(N) \ + template \ + ref_tuple tie( \ + KAGUYA_PP_REPEAT_ARG(N, KAGUYA_VARIADIC_REFARG_REP)) { \ + return ref_tuple( \ + KAGUYA_REF_TUPLE(N)(KAGUYA_PP_ARG_REPEAT(N))); \ + } + +KAGUYA_PP_REPEAT_DEF(KAGUYA_FUNCTION_MAX_TUPLE_SIZE, KAGUYA_REF_TUPLE_DEF) +#undef KAGUYA_VARIADIC_REFARG_REP +#undef KAGUYA_TEMPLATE_REFARG_REPEAT +#undef KAGUYA_REF_TUPLE +#undef KAGUYA_GET_TUPLE +#undef KAGUYA_REF_TUPLE_DEF +#endif +} +#endif// KAGUYA_LUABINDING_HPP_INCLUDED diff --git a/sol/stack_check.hpp b/sol/stack_check.hpp index 3e138a99..92a24f5c 100644 --- a/sol/stack_check.hpp +++ b/sol/stack_check.hpp @@ -66,6 +66,14 @@ namespace stack { }; } // namespace stack_detail + template + struct userdata_checker { + template + static bool check(lua_State*, int, type, Handler&&, record&) { + return false; + } + }; + template struct checker { template @@ -401,7 +409,14 @@ namespace stack { template struct checker, type::userdata, C> { template - static bool check(types, lua_State* L, type indextype, int index, Handler&& handler, record& tracking) { + static bool check(types, lua_State* L, int index, type indextype, Handler&& handler, record& tracking) { +#ifdef SOL_ENABLE_INTEROP + userdata_checker> uc; + (void)uc; + if (uc.check(L, index, indextype, handler, tracking)) { + return true; + } +#endif // interop extensibility tracking.use(1); if (indextype != type::userdata) { handler(L, index, type::userdata, indextype, "value is not a valid userdata"); @@ -447,7 +462,7 @@ namespace stack { template static bool check(lua_State* L, int index, Handler&& handler, record& tracking) { const type indextype = type_of(L, index); - return checker, type::userdata, C>{}.check(types(), L, indextype, index, std::forward(handler), tracking); + return checker, type::userdata, C>{}.check(types(), L, index, indextype, std::forward(handler), tracking); } }; diff --git a/sol/stack_core.hpp b/sol/stack_core.hpp index 1db061bf..04f8804f 100644 --- a/sol/stack_core.hpp +++ b/sol/stack_core.hpp @@ -109,6 +109,9 @@ namespace sol { namespace stack { + template + struct extensible {}; + template struct field_getter; template @@ -118,12 +121,16 @@ namespace sol { template struct getter; template + struct userdata_getter; + template struct popper; template struct pusher; template ::value, typename = void> struct checker; template + struct userdata_checker; + template struct check_getter; struct probe { diff --git a/sol/stack_get.hpp b/sol/stack_get.hpp index de191c56..b36344c9 100644 --- a/sol/stack_get.hpp +++ b/sol/stack_get.hpp @@ -44,6 +44,13 @@ namespace sol { namespace stack { + template + struct userdata_getter { + static std::pair get(lua_State*, int, void*, record&) { + return { false, nullptr }; + } + }; + template struct getter { static T& get(lua_State* L, int index, record& tracking) { @@ -628,7 +635,16 @@ namespace stack { struct getter> { static T* get_no_lua_nil(lua_State* L, int index, record& tracking) { tracking.use(1); - void** pudata = static_cast(lua_touserdata(L, index)); + void* rawdata = lua_touserdata(L, index); +#ifdef SOL_ENABLE_INTEROP + userdata_getter> ug; + (void)ug; + auto ugr = ug.get(L, index, rawdata, tracking); + if (ugr.first) { + return ugr.second; + } +#endif // interop extensibility + void** pudata = static_cast(rawdata); void* udata = *pudata; return get_no_lua_nil_from(L, udata, index, tracking); }