diff --git a/CMakeLists.txt b/CMakeLists.txt index d84c2709..dc97774f 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -26,9 +26,6 @@ include_directories(${LIBSHP_INCLUDE_DIR}) find_package(Lua REQUIRED) include_directories(${LUA_INCLUDE_DIR}) -find_package(Luabind REQUIRED) -include_directories(${LUABIND_INCLUDE_DIR}) - find_package(ZLIB REQUIRED) include_directories(${ZLIB_INCLUDE_DIR}) @@ -49,6 +46,6 @@ ADD_CUSTOM_COMMAND(OUTPUT osmformat.pb.cc osmformat.pb.h ARGS --cpp_out ${CMAKE_BINARY_DIR} -I ${CMAKE_SOURCE_DIR}/include ${CMAKE_SOURCE_DIR}/include/osmformat.proto) add_executable(tilemaker vector_tile.pb.cc osmformat.pb.cc src/tilemaker.cpp) -target_link_libraries(tilemaker ${Boost_LIBRARIES} ${PROTOBUF_LIBRARY} ${LIBSHP_LIBRARIES} ${SQLITE3_LIBRARIES} ${LUABIND_LIBRARIES} ${LUA_LIBRARIES} ${ZLIB_LIBRARY} ${THREAD_LIB}) +target_link_libraries(tilemaker ${Boost_LIBRARIES} ${PROTOBUF_LIBRARY} ${LIBSHP_LIBRARIES} ${SQLITE3_LIBRARIES} ${LUA_LIBRARIES} ${ZLIB_LIBRARY} ${THREAD_LIB}) install(TARGETS tilemaker RUNTIME DESTINATION bin) diff --git a/CONFIGURATION.md b/CONFIGURATION.md index d125906b..0a6cbac4 100644 --- a/CONFIGURATION.md +++ b/CONFIGURATION.md @@ -182,11 +182,10 @@ You can then find out whether a node is within one of these polygons using the ` if node:Intersects("countries") then print("Looks like it's on land"); end -Or you can find out what country(/ies) the node is within using `FindIntersecting`: +Or you can find out what country(/ies) the node is within using `FindIntersecting`, which returns a table: - for name in node:FindIntersecting("countries") do - print(name) - end + names = node:FindIntersecting("countries") + print(table.concat(name,",")) To enable these functions, set `index` to true in your shapefile layer definition. `index_column` is not needed for `Intersects` but required for `FindIntersecting`. diff --git a/Makefile b/Makefile index ff9c9960..43687a26 100644 --- a/Makefile +++ b/Makefile @@ -1,7 +1,7 @@ LUA_CFLAGS := -I/usr/local/include/lua5.1 -I/usr/include/lua5.1 LUA_LIBS := -llua5.1 CXXFLAGS := -O3 -Wall -Wno-unknown-pragmas -Wno-sign-compare -std=c++11 -pthread $(CONFIG) -LIB := -L/usr/local/lib -lz $(LUA_LIBS) -lboost_program_options -lluabind -lsqlite3 -lboost_filesystem -lboost_system -lprotobuf -lshp +LIB := -L/usr/local/lib -lz $(LUA_LIBS) -lboost_program_options -lsqlite3 -lboost_filesystem -lboost_system -lprotobuf -lshp INC := -I/usr/local/include -I./include -I./src $(LUA_CFLAGS) all: tilemaker diff --git a/README.md b/README.md index b79e315a..918c8219 100644 --- a/README.md +++ b/README.md @@ -14,37 +14,30 @@ Tilemaker is written in C++11. The chief dependencies are: * Google Protocol Buffers * Boost 1.56 or later (for boost::geometry, boost::program_options, boost::filesystem, boost::variant) -* Lua 5.1 and Luabind +* Lua 5.1 * sqlite3 * shapelib -rapidjson (MIT) and sqlite_modern_cpp (MIT) are bundled in the include/ directory. +rapidjson, sqlite_modern_cpp, and kaguya are bundled in the include/ directory. -On OS X, you can install all dependencies with Homebrew: +### OS X - brew install protobuf boost lua51 luabind shapelib +Install all dependencies with Homebrew: -On Ubuntu, start with: + brew install protobuf boost lua51 shapelib + +### Ubuntu + +Start with: sudo apt-get install build-essential liblua5.1-0 liblua5.1-0-dev libprotobuf-dev libsqlite3-dev protobuf-compiler shapelib libshp-dev -You'll then need to install a recent Boost from [this PPA](https://launchpad.net/~ostogvin/+archive/ubuntu/tjo-develop): +If you're using Ubuntu 16.04, you can install Boost with `sudo apt-get install libboost-all-dev`. For 12.04 or 14.04, you'll need to install a recent Boost from [this PPA](https://launchpad.net/~ostogvin/+archive/ubuntu/tjo-develop): sudo add-apt-repository ppa:ostogvin/tjo-develop sudo apt-get update sudo apt-get install libboost1.58-all-dev -Finally, we need to install luabind manually because the Ubuntu package (sigh) requires Boost 1.54, whereas we need 1.56 or later. So: - - git clone https://github.com/rpavlik/luabind.git - cd luabind - # The following line might not be necessary for you, - # but I needed it to make sure that liblua was in /usr/lib: - ln -s /usr/lib/x86_64-linux-gnu/liblua5.1.so /usr/lib/ - sudo bjam install - sudo ln -s /usr/local/lib/libluabindd.so /usr/local/lib/libluabind.so - sudo ldconfig - Once you've installed those, then `cd` back to your Tilemaker directory and simply: make @@ -52,9 +45,11 @@ Once you've installed those, then `cd` back to your Tilemaker directory and simp If it fails, check that the LIB and INC lines in the Makefile correspond with your system, then try again. -On Fedora start with: +### Fedora + +Start with: - dnf install lua-devel luajit-devel luabind-devel sqlite-devel protobuf-devel protobuf-compiler shapelib-devel + dnf install lua-devel luajit-devel sqlite-devel protobuf-devel protobuf-compiler shapelib-devel then build either with lua: @@ -66,6 +61,8 @@ or with luajit: make LUA_CFLAGS="$(pkg-config --cflags luajit)" LUA_LIBS="$(pkg-config --libs luajit)" make install +### Saving memory + To save memory (on any platform), you can choose 32-bit storage for node IDs rather than 64-bit. You will need to run `osmium renumber` or a similar tool over your .osm.pbf first. Then compile Tilemaker with an additional flag: make CONFIG="-DCOMPACT_NODES" @@ -118,7 +115,7 @@ Formatting: braces and indents as shown, hard tabs (4sp). (Yes, I know.) Please Copyright and contact --------------------- -Richard Fairhurst and contributors, 2015-2016. The tilemaker code is licensed as FTWPL; you may do anything you like with this code and there is no warranty. The included rapidjson (Milo Yip and THL A29) and sqlite_modern_cpp (Amin Roosta) libraries are MIT. +Richard Fairhurst and contributors, 2015-2016. The tilemaker code is licensed as FTWPL; you may do anything you like with this code and there is no warranty. The included rapidjson (Milo Yip and THL A29) and sqlite_modern_cpp (Amin Roosta) libraries are MIT; [kaguya](https://github.com/satoren/kaguya) is licensed under the Boost Software Licence. If you'd like to sponsor development of Tilemaker, you can contact me at richard@systemeD.net. diff --git a/cmake/FindLuabind.cmake b/cmake/FindLuabind.cmake deleted file mode 100644 index 4b99b3c0..00000000 --- a/cmake/FindLuabind.cmake +++ /dev/null @@ -1,75 +0,0 @@ -# Locate Luabind library -# This module defines -# LUABIND_FOUND, if false, do not try to link to Luabind -# LUABIND_LIBRARIES -# LUABIND_INCLUDE_DIR, where to find luabind.hpp -# -# Note that the expected include convention is -# #include -# and not -# #include - -IF( NOT LUABIND_FIND_QUIETLY ) - MESSAGE(STATUS "Looking for Luabind...") -ENDIF() - -FIND_PATH(LUABIND_INCLUDE_DIR luabind.hpp - HINTS - $ENV{LUABIND_DIR} - PATH_SUFFIXES luabind include/luabind include - PATHS - ~/Library/Frameworks - /Library/Frameworks - /usr/local - /usr - /opt/local # DarwinPorts - /opt -) - -FIND_LIBRARY(LUABIND_LIBRARY - NAMES luabind luabind09 - HINTS - $ENV{LUABIND_DIR} - PATH_SUFFIXES lib64 lib - PATHS - ~/Library/Frameworks - /Library/Frameworks - /usr/local - /usr - /opt/local - /opt -) - -FIND_LIBRARY(LUABIND_LIBRARY_DBG - NAMES luabindd - HINTS - $ENV{LUABIND_DIR} - PATH_SUFFIXES lib64 lib - PATHS - ~/Library/Frameworks - /Library/Frameworks - /usr/local - /usr - /opt/local - /opt -) - -IF(LUABIND_LIBRARY) - SET( LUABIND_LIBRARIES "${LUABIND_LIBRARY}" CACHE STRING "Luabind Libraries") -ENDIF(LUABIND_LIBRARY) - -INCLUDE(FindPackageHandleStandardArgs) -# handle the QUIETLY and REQUIRED arguments and set LUABIND_FOUND to TRUE if -# all listed variables are TRUE -FIND_PACKAGE_HANDLE_STANDARD_ARGS(Luabind DEFAULT_MSG LUABIND_LIBRARIES LUABIND_INCLUDE_DIR) - -IF( NOT LUABIND_FIND_QUIETLY ) - IF( LUABIND_FOUND ) - MESSAGE(STATUS "Found Luabind: ${LUABIND_LIBRARY}" ) - ENDIF() - IF( LUABIND_LIBRARY_DBG ) - MESSAGE(STATUS "Luabind debug library availible: ${LUABIND_LIBRARY_DBG}") - ENDIF() -ENDIF() - -MARK_AS_ADVANCED(LUABIND_INCLUDE_DIR LUABIND_LIBRARIES LUABIND_LIBRARY LUABIND_LIBRARY_DBG) diff --git a/include/kaguya.hpp b/include/kaguya.hpp new file mode 100644 index 00000000..ef54bdcd --- /dev/null +++ b/include/kaguya.hpp @@ -0,0 +1,12615 @@ +#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 + +#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 + +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). + templateclass 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< class U > + T value_or(U&& default_value) const + { + if (value_) { return *value_; } + return default_value; + } +#else + template< class U > + 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::value>::type storage_; + + T* value_; + }; + + /// @brief specialize optional for reference. + /// sizeof(optional) == sizeof(T*) + templateclass 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< class T > + 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< class T > + bool operator!=(const optional& lhs, const optional& rhs) + { + return !(lhs == rhs); + } + template< class T > + bool operator<(const optional& lhs, const optional& rhs) + { + if (!bool(rhs)) { return false; } + if (!bool(lhs)) { return true; } + return lhs.value() < rhs.value(); + } + template< class T > + bool operator<=(const optional& lhs, const optional& rhs) + { + return !(rhs < lhs); + } + template< class T > + bool operator>(const optional& lhs, const optional& rhs) + { + return rhs < lhs; + } + template< class T > + 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< class T > + 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< typename T > + 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< typename T > + 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< typename T > + 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< typename T > + 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< typename T > + 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< typename T > + 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 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 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< typename T, typename Enable = void> + struct is_usertype : traits::false_type {}; + template< typename T> + struct is_usertype::Registerable> : traits::true_type {}; + + /// @brief Trait class that identifies whether T is a registerable by UserdataMetatable. + template< typename T> + 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 + +// 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_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) + { + 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); + } +#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_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 < typename T, typename = void> + struct has_operator_fn :std::false_type {}; + template < typename T > + struct has_operator_fn::value>::type> :std::true_type {}; + + template + struct FunctionSignature::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::type::argument_type_tuple>::type type; + }; + + + + namespace detail + { + template + Res invoke_helper(Res(ThisType::*f)(FArgs...), ThisType& this_, Args&&... args) + { + return (this_.*f)(std::forward(args)...); + } + + template + Res invoke_helper(Res(ThisType::*f)(FArgs...)const, const ThisType& this_, Args&&... args) + { + return (this_.*f)(std::forward(args)...); + } +#if defined(_MSC_VER) && _MSC_VER >= 1900 || defined(__cpp_ref_qualifiers) + template + Res invoke_helper(Res(ThisType::*f)(FArgs...) &, ThisType& this_, Args&&... args) + { + return (this_.*f)(std::forward(args)...); + } + + template + Res invoke_helper(Res(ThisType::*f)(FArgs...)const &, const ThisType& this_, Args&&... args) + { + return (this_.*f)(std::forward(args)...); + } + template + Res invoke_helper(Res(ThisType::*f)(FArgs...) && , ThisType&& this_, Args&&... args) + { + return (this_.*f)(std::forward(args)...); + } + + template + Res invoke_helper(Res(ThisType::*f)(FArgs...)const &&, const ThisType& this_, Args&&... args) + { + return (this_.*f)(std::forward(args)...); + } +#endif + + 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(f, std::forward(args)...); + } + + namespace conv_helper_detail + { + template + bool checkType(lua_State* l, int index) + { + 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* l, int index) + { + 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* l, int index) + { + throw LuaTypeMismatch(); + } + template + To get(lua_State* l, int index) + { + if (lua_type_traits::strictCheckType(l, index)) + { + return lua_type_traits::get(l, index); + } + else if (strictCheckType(l, index)) + { + return get(l, index); + } + else if (lua_type_traits::checkType(l, index)) + { + return lua_type_traits::get(l, index); + } + else if (checkType(l, index)) + { + return get(l, index); + } + else + { + return get(l, index); + } + } + } + + template + struct ConvertibleRegisterHelper + { + typedef To get_type; + + static bool checkType(lua_State* l, int index) + { + return conv_helper_detail::checkType(l, index); + } + static bool strictCheckType(lua_State* l, int index) + { + return conv_helper_detail::strictCheckType(l, index); + } + + static get_type get(lua_State* l, int index) + { + return conv_helper_detail::get(l, index); + } + }; + } + +} +#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 { + }; + + templatestruct TypeTupleSize; + +#define KAGUYA_TYPE_TUPLE_SIZE_DEF(N) \ + template< KAGUYA_PP_TEMPLATE_DEF_REPEAT(N)>\ + 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 + + templatestruct 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 type;\ + };\ + + +#define KAGUYA_FUNCTION_SIGNATURE_DEF(N) \ + template\ + struct FunctionSignature {\ + typedef FunctionSignatureType type;\ + };\ + template\ + struct FunctionSignature {\ + typedef FunctionSignatureType type;\ + };\ + template\ + struct FunctionSignature > {\ + 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, true>\ + {\ + typedef arg type;\ + };\ + template\ + struct TypeIndexGet, 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::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 + + 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_ST_GET_REP(N) if (lua_type_traits::strictCheckType(state, index)){ return lua_type_traits::get(state, index);}else +#define KAGUYA_CONVERTIBLE_REG_HELPER_GET_REP(N) if (lua_type_traits::checkType(state, index)){ return lua_type_traits::get(state, index);}else + + template + bool checkType(lua_State* state, int index, TypeTuple<> t) + { + 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* state, int index, TypeTuple<> t) + { + 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_ST_GET_REP);\ + 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* state, int index) + { + return conv_helper_detail::checkType(state, index, conv_types()); + } + static bool strictCheckType(lua_State* state, int index) + { + return conv_helper_detail::strictCheckType(state, index, conv_types()); + } + static get_type get(lua_State* state, int index) + { + return conv_helper_detail::get(state, index, conv_types()); + } + }; +#undef KAGUYA_PP_CONVERTIBLE_REG_HELPER_DEF_REP +#undef KAGUYA_PP_CONVERTIBLE_REG_HELPER_DEF_REPEAT + + } + +} +#endif + +#if KAGUYA_USE_CXX_ABI_DEMANGLE +#include +#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 + 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; + } + } + + + + + inline lua_State* toMainThread(lua_State* state) + { +#if LUA_VERSION_NUM >= 502 + 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; + } + } +#endif + return state; + } + +#if KAGUYA_USE_CPP11 + inline int push_args(lua_State *l) + { + 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 *l) + { + 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 {}; + } + + inline void* metatable_name_key() { static int key; return &key; } + inline void* metatable_type_table_key() { static int key; return &key; } + + 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::type>(sptr)), type_(metatableType()), + shared_ptr_type_(metatableType::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::type>(sptr))), type_(metatableType()), + shared_ptr_type_(metatableType::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::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 tag) + { + return get_pointer(from); + } + template + standard::shared_ptr get_pointer(ObjectWrapperBase* from, types::typetag > tag) + { + 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) + { + static char kaguya_ptrcvt_key_ptr; + util::ScopedSavedStack save(state); + lua_pushlightuserdata(state, &kaguya_ptrcvt_key_ptr); + 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 + lua_pushlightuserdata(state, &kaguya_ptrcvt_key_ptr); + 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)) + { + int type = lua_rawgetp_rtype(l, -1, metatable_name_key()); + 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 type = types::typetag()) + { + if (detail::object_wrapper_type_check(l, index)) + { + ObjectWrapperBase* ptr = static_cast(lua_touserdata(l, index)); + + if (ptr->type() == metatableType()) + { + 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 tag) + { + 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 (objwrapper->type() == to_type) + { + 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 tag) + { + 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 (objwrapper->type() == metatableType()) + { + 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 tag) + { + return get_const_pointer(l, index, types::typetag()); + } + + template + standard::shared_ptr get_shared_pointer(lua_State* l, int index, types::typetag tag) + { + 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 (from_type == to_type) + { + 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 tag) + { + 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 tag) + { + ObjectSharedPointerWrapper* ptr = dynamic_cast(object_wrapper(l, index)); + if (ptr) + { + return ptr->const_object(); + } + return standard::shared_ptr(); + } + + namespace class_userdata + { + templateinline void destructor(T* pointer) + { + if (pointer) + { + pointer->~T(); + } + } + inline bool get_metatable(lua_State* l, const std::type_info& typeinfo) + { + int ttype = lua_rawgetp_rtype(l, LUA_REGISTRYINDEX, metatable_type_table_key());//get metatable registry table + if (ttype != LUA_TTABLE) + { + lua_newtable(l); + lua_rawsetp(l, LUA_REGISTRYINDEX, metatable_type_table_key()); + return false; + } + int type = lua_rawgetp_rtype(l, -1, &typeinfo); + lua_remove(l, -2);//remove metatable registry table + return type != LUA_TNIL; + } + templatebool get_metatable(lua_State* l) + { + return get_metatable(l, metatableType()); + } + templatebool 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); + lua_rawgetp_rtype(l, LUA_REGISTRYINDEX, metatable_type_table_key());//get metatable registry table + int metaregindex = lua_absindex(l, -1); + + lua_createtable(l, 0, 2); + lua_pushstring(l, name); + lua_pushvalue(l, -1); + lua_setfield(l, -3, "__name"); // metatable.__name = name + lua_rawsetp(l, -2, metatable_name_key()); + lua_pushvalue(l, -1); + lua_rawsetp(l, metaregindex, &typeinfo); + lua_remove(l, metaregindex);//remove metatable registry table + + return true; + } + templatebool newmetatable(lua_State* l) + { + return newmetatable(l, metatableType(), metatableName().c_str()); + } + + + templateinline 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); + } + templatevoid setmetatable(lua_State* l) + { + setmetatable(l, metatableType()); + } + namespace detail + { + inline int call_constructor_metamethod(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) + { + static int key=0; + + int ttype = lua_rawgetp_rtype(L, LUA_REGISTRYINDEX, &key); + if (ttype != LUA_TTABLE) + { + lua_pop(L,1); + lua_createtable(L, 0, 1); + lua_pushstring(L, "__call"); + lua_pushcfunction(L, &detail::call_constructor_metamethod); + lua_rawset(L,-3); + lua_pushvalue(L, -1); + lua_rawsetp(L, LUA_REGISTRYINDEX, &key); + } + } + } + template + bool available_metatable(lua_State* l, types::typetag type = types::typetag()) + { + return class_userdata::available_metatable(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) + + + +namespace kaguya +{ +#if KAGUYA_USE_CPP11 + namespace detail + { + templatestruct 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 index, 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< std::tuple >(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::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) + { + typedef ObjectWrapper::type> wrapper_type; + void *storage = lua_newuserdata(l, sizeof(wrapper_type)); + new(storage) wrapper_type(v); + class_userdata::setmetatable(l); + return 1; + } + +#if KAGUYA_USE_RVALUE_REFERENCE + + template + int lua_type_traits::push(lua_State* l, NCRT&& 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; + } +#endif + + /// @ingroup lua_type_traits + /// @brief lua_type_traits for const reference type + template struct lua_type_traits::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::value && !traits::is_const::type>::value>::type > + { + typedef void Registerable; + + typedef REF get_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 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::type>::value && !traits::is_function::type>::value>::type > + { + typedef void Registerable; + + typedef PTR get_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 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 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) + { + return true; + } + static bool get(lua_State* l, int index) + { + return l && lua_toboolean(l, index) != 0; + } + 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* l, int index) + { + return true; + } + static bool checkType(lua_State* l, int index) + { + return true; + } + static get_type get(lua_State* l, int index) + { + return 0; + } + static int push(lua_State* l, push_type s) + { + 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()); + } + }; + + + /// @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) + { + return true; + } + static get_type get(lua_State* l, int index)KAGUYA_NOEXCEPT + { + try + { + return lua_type_traits::get(l, index); + } + catch (...) + { + return get_type(); + } + } + + 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)); + const std::type_info& type = metatableType::type > >(); + return wrapper && (wrapper->shared_ptr_type() == type); + } + 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; + + 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 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& v) + { + 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 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 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::value>::type> + { + typedef typename traits::remove_const_reference::type get_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 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 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::value>::type> + { + typedef typename traits::remove_const_reference::type get_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 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 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) + { + 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 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 get_type get(lua_State* l, int index) + { + size_t size = 0; + const char* buffer = lua_tolstring(l, index, &size); + if (!buffer) { + throw LuaTypeMismatch(); + } + return std::string(buffer, size); + } + 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 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 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*>::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*>::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::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*>::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 = getHandler(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 = getHandler(state); + if (handler) + { + handler(status_code, message); + return true; + } + return false; + } + static bool handle(int status_code, lua_State *state) + { + function_type handler = getHandler(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); + lua_pushlightuserdata(state, handlerRegistryKey()); + 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: + + static void* handlerRegistryKey() + { + static void* key; + return key; + } + static function_type* getFunctionPointer(lua_State* state) + { + if (state) + { + util::ScopedSavedStack save(state); + lua_pushlightuserdata(state, handlerRegistryKey()); + 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 + { + 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); + } + + 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: + + /// @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); + util::one_push(state, key); + lua_gettable(state, stackIndex); + return lua_type_traits::get(state, -1); + } + /// @brief value = table[key]; + /// @param key key of table + /// @return reference of field value + template + typename lua_type_traits::get_type getField(const char* key)const + { + lua_State* state = state_(); + if (!state) + { + except::typeMismatchError(state, "is nil"); + return typename lua_type_traits::get_type(); + } + util::ScopedSavedStack save(state); + lua_getfield(state, pushStackIndex_(state), key); + return lua_type_traits::get(state, -1); + } + + /// @brief value = table[key]; + /// @param key key of table + /// @return reference of field value + template + typename lua_type_traits::get_type getField(const std::string& key)const + { + return getField(key.c_str()); + } + + /// @brief value = table[key]; + /// @param key key of table + /// @return reference of field value + template + LuaStackRef getField(const KEY& key)const; + + /// @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); + util::one_push(state, key); + lua_rawget(state, stackIndex); + 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 value = rawget(table,key); + /// @param key key of table + /// @return reference of field value + template + typename lua_type_traits::get_type getRawField(luaInt key)const + { + lua_State* state = state_(); + if (!state) + { + except::typeMismatchError(state, "is nil"); + return typename lua_type_traits::get_type(); + } + util::ScopedSavedStack save(state); + lua_rawgeti(state, pushStackIndex_(state), key); + return lua_type_traits::get(state, -1); + } + + /// @brief foreach table fields + template < class K, class V, class Fun> 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 < class K, class V, class Fun> 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 < K, V, C, std::allocator > >(); + } + + /// @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; + + /// @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); + } + public: + + /// @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); + util::one_push(state, key);//push table key + util::one_push(state, value);//push value + lua_settable(state, stackIndex);//thistable[key] = value + return true; + } + + /// @brief table[key] = value; + template + bool setField(const char* 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); + util::one_push(state, value);//push value + lua_setfield(state, stackIndex, key);//thistable[key] = value + return true; + } + + /// @brief table[key] = value; + template + bool setField(const std::string& key, const V& value) + { + return setField(key.c_str(), value); + } +#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); + util::one_push(state, std::forward(key));//push table key + util::one_push(state, std::forward(value));//push value + lua_settable(state, stackIndex);//thistable[key] = value + return true; + } + /// @brief table[key] = value; + template + bool setField(const char* key, V&& value) + { + lua_State* state = state_(); + if (!state) + { + except::typeMismatchError(state, "is nil"); + return false; + } + util::ScopedSavedStack save(state); + int stackIndex = pushStackIndex_(state); + util::one_push(state, std::forward(value));//push value + lua_setfield(state, stackIndex, key);//thistable[key] = value + return true; + } + /// @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); + util::one_push(state, key);//push table key + util::one_push(state, value);//push value + lua_rawset(state, stackIndex);//thistable[key] = value + return true; + } +#endif + + /// @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); + util::one_push(state, key);//push table key + util::one_push(state, value);//push value + lua_rawset(state, stackIndex);//thistable[key] = value + return true; + } + }; + + 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(); + } + + templatetypename 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)); + } + + + + templatetypename 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); + } + templatetypename 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* l, int index, types::typetag > tag) + { + return standard::tuple<>(); + } + template + inline standard::tuple get_result_tuple_impl(lua_State* l, int index, types::typetag > tag) + { + 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 > tag) + { + 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* l, int startindex) + { + } + } + + /// @addtogroup Lua_reference_types + + /// @ingroup Lua_reference_types + /// @brief Reference to any Lua data. + class LuaRef :public Ref::RegistoryRef, public detail::LuaVariantImpl + { + private: + static lua_State* toMainThread(lua_State* state) + { +#if LUA_VERSION_NUM >= 502 + 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; + } + } +#endif + return state; + } + 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) + { + return true; + } + static bool strictCheckType(lua_State* l, int 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) + { + return true; + } + static bool strictCheckType(lua_State* l, int 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) + { + util::invoke(f, lua_type_traits::get(state, Indexes)...); + return 0; + } + + inline bool all_true() + { + return true; + } + templatebool all_true(Arg f, Args... args) + { //check from backward and lazy evaluation + return all_true(args...) && bool(f); + } + + inline void join(std::string& result, const char* delim) + { + } + templatevoid 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, bool opt) :state(s), opt_arg(opt) {} + lua_State* state; + 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, bool opt) :state(s), opt_arg(opt) {} + lua_State* state; + 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::FunctionSignatureType, int opt_count) + { + return all_true(_wcheckeval(state, sizeof...(Indexes)-opt_count < Indexes)...); + } + template + bool _sctype_apply(lua_State* state, index_tuple, util::FunctionSignatureType, int opt_count) + { + return all_true(_scheckeval(state, sizeof...(Indexes)-opt_count < Indexes)...); + } + + + template + std::string _type_name_apply(index_tuple, util::FunctionSignatureType, int 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& 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; + return _ctype_apply(state, index(), fsigtype(), opt_count); + } + template + bool strictCheckArgTypes(lua_State* state, const F& 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; + + return _sctype_apply(state, index(), fsigtype(), opt_count); + } + + template + std::string argTypesName(const F& 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; + return _type_name_apply(index(),fsigtype(), opt_count); + } + template + int minArgCount(const F& f) + { + typedef typename traits::decay::type ftype; + typedef typename util::FunctionSignature::type fsigtype; + return fsigtype::argument_count; + } + template + int maxArgCount(const F& 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(), signature_type(), opt_count); + } + bool strictCheckArgTypes(lua_State* L, int opt_count = 0)const + { + return _sctype_apply(L, get_index(), signature_type(), opt_count); + } + std::string argTypesName(int opt_count = 0)const + { + return _type_name_apply(get_index(), signature_type(), 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))\ + {\ + 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))\ + {\ + 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)\ + {\ + 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)\ + {\ + 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)\ + {\ + 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& 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& 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) + { + 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) + { + typedef typename traits::decay::type ftype; + typedef typename util::FunctionSignature::type fsigtype; + return fsigtype::argument_count; + } + template + int maxArgCount(const F& f) + { + typedef typename traits::decay::type ftype; + typedef typename util::FunctionSignature::type fsigtype; + return fsigtype::argument_count; + } + + ///! for constructor + templatestruct 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 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\ + {\ + 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) + + templatestruct tuple_size; + +#define KAGUYA_TUPLE_SIZE_DEF(N) \ + template< KAGUYA_PP_TEMPLATE_DEF_REPEAT(N)>\ + 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, true>\ + {\ + typedef arg type;\ + };\ + template\ + struct tuple_element, false>\ + : tuple_element >\ + {\ + };\ + + KAGUYA_PP_REPEAT_DEF(KAGUYA_FUNCTION_MAX_OVERLOADS, KAGUYA_TUPLE_ELEMENT_DEF) + +#undef KAGUYA_TUPLE_SIZE_DEF + + templatestruct tuple_get_helper; +#define KAGUYA_TUPLE_GET_DEF(N) \ + templatestruct 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 argTypeNames()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 argTypeNames()const { return fnc->argTypeNames(); } + 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< typename T, typename Enable = void> + struct is_callable : traits::integral_constant::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& con) + { + return ConstructorFunctor::signature_type::argument_count; + } + template + int maxArgCount(const ConstructorFunctor& con) + { + 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::* mptr, int opt_count = 0) + { + 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::* mptr, int opt_count = 0) + { + 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::* mptr) + { + return util::pretty_name(typeid(T*)) + ",[OPT] " + util::pretty_name(typeid(MemType)); + } + template + typename traits::enable_if::value, int>::type + minArgCount(MemType T::* mptr) + { + return 1; + } + template + typename traits::enable_if::value, int>::type + maxArgCount(MemType T::* mptr) + { + 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.argTypeNames(); + } + 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.argTypeNames(); + } + 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) + { + return true; + } + static bool checkType(lua_State* l, int 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; + templateuint8_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) + { + 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)...); + } + templatevoid 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) + { + 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 < luacfunction > + { + 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 argTypeNames()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 argTypeNames()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 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::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 < typename DataType > + 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 < typename DataType > + 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 < typename Type > + 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 + { +#if KAGUYA_USE_CPP11 + if (!standard::is_copy_constructible::value) + { + return util::push_args(state, std::move(data_)); + } +#endif + 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; + } + }; + templatestruct iterator_base + { + iterator_base(lua_State* s, int i) : state(s), stack_index(i) + { + } + templateiterator_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 tag= types::typetag())const + { + return util::get_result(state_, stack_index_); + } + LuaStackRef get_result(types::typetag tag)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 tag) + { + return FunctionResults(state, return_status, retindex).get_result(types::typetag()); + } + inline FunctionResults FunctionResultProxy::ReturnValue(lua_State* state, int return_status, int retindex, types::typetag tag) + { + return FunctionResults(state, return_status, retindex); + } + inline void FunctionResultProxy::ReturnValue(lua_State* state, int return_status, int retindex, types::typetag tag) + { + lua_settop(state, retindex - 1); + } + +#if KAGUYA_USE_CPP11 + templatetemplate + FunctionResults LuaFunctionImpl::operator()(Args&&... args) + { + return this->template call(std::forward(args)...); + } + + templatetemplate + FunctionResults LuaThreadImpl::operator()(Args&&... args) + { + return this->template resume(std::forward(args)...); + } + templatetemplate + 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 +} + +// 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) + + +namespace kaguya +{ + + namespace nativefunction + { + inline std::string argmentTypes(lua_State *state) + { + int top = lua_gettop(state); + + std::string result = ""; + + for (int i = 1; i <= top; i++) { + if (i != 1) + { + result += ","; + } + + ObjectWrapperBase* object = object_wrapper(state, i); + if (object) + { + result += util::pretty_name(object->type()); + } + else + { + result += lua_typename(state, lua_type(state, i)); + } + } + return result; + } + + struct BaseInvoker + { + virtual int invoke(lua_State *state) = 0; + virtual std::string argumentTypeNames() = 0; + virtual uint8_t argsMatchingScore(lua_State* state) = 0; + virtual ~BaseInvoker() {} + }; + + //! deperecated + struct FunctorType :standard::shared_ptr + { + typedef standard::shared_ptr base_ptr_; + FunctorType() {} + FunctorType(const standard::shared_ptr& ptr) :base_ptr_(ptr) {} + + templateFunctorType(T f) : standard::shared_ptr(create(f)) + { + } + private: + template + struct FunInvoker :BaseInvoker { + typedef F func_type; + func_type func_; + FunInvoker(func_type fun) :func_(fun) {} + virtual int invoke(lua_State *state) + { + int count = call(state, func_); + + return count; + + } + virtual std::string argumentTypeNames() { + return argTypesName(func_); + } + virtual uint8_t argsMatchingScore(lua_State* state) { + return compute_function_matching_score(state, func_); + } + }; + template + static base_ptr_ create(F fun) + { +// KAGUYA_STATIC_ASSERT(nativefunction::is_callable::type>::value, "argument need callable"); + + typedef FunInvoker InvokerType; + return base_ptr_(new InvokerType(fun)); + } + }; + + + inline FunctorType* pick_match_function(lua_State *l) + { + int overloadnum = int(lua_tonumber(l, lua_upvalueindex(1))); + + if (overloadnum == 1) + { + FunctorType* fun = static_cast(lua_touserdata(l, lua_upvalueindex(2))); + + //skip type check for performance +// if (!fun || !(*fun) || !(*fun)->checktype(l, false)) +// { +// return 0; +// } + return fun; + } + FunctorType* match_function = 0; + uint8_t match_score = 0; + for (int i = 0; i < overloadnum; ++i) + { + FunctorType* fun = static_cast(lua_touserdata(l, lua_upvalueindex(i + 2))); + if (!fun || !(*fun)) + { + continue; + } + uint8_t score = (*fun)->argsMatchingScore(l); + if (match_score < score) + { + match_function = fun; + match_score = score; + if (match_score == MAX_OVERLOAD_SCORE) + { + return match_function; + } + } + } + return match_function; + } + + inline std::string build_arg_error_message(lua_State *l) + { + std::string message = "Argument mismatch:" + argmentTypes(l) + "\t candidate is:\n"; + + int overloadnum = int(lua_tonumber(l, lua_upvalueindex(1))); + for (int i = 0; i < overloadnum; ++i) + { + FunctorType* fun = static_cast(lua_touserdata(l, lua_upvalueindex(i + 2))); + if (!fun || !(*fun)) + { + continue; + } + message += std::string("\t\t") + (*fun)->argumentTypeNames() + "\n"; + } + return message; + } + + inline int functor_dispatcher(lua_State *l) + { + FunctorType* fun = pick_match_function(l); + if (fun && (*fun)) + { + try { + return (*fun)->invoke(l); + } + catch (LuaTypeMismatch &) { + util::traceBack(l, (std::string("maybe...") + build_arg_error_message(l)).c_str()); + } + catch (std::exception & e) { + util::traceBack(l, e.what()); + } + catch (...) { + util::traceBack(l, "Unknown exception"); + } + } + else + { + util::traceBack(l, build_arg_error_message(l).c_str()); + } + return lua_error(l); + } + + inline int functor_destructor(lua_State *state) + { + FunctorType* f = static_cast(lua_touserdata(state, 1)); + if (f) + { + f->~FunctorType(); + } + return 0; + } + + inline void reg_functor_destructor(lua_State* state) + { + if (class_userdata::newmetatable(state)) + { + lua_pushcclosure(state, &functor_destructor, 0); + lua_setfield(state, -2, "__gc"); + lua_setfield(state, -1, "__index"); + } + } + } + typedef nativefunction::FunctorType FunctorType; + typedef std::vector FunctorOverloadType; + + + /// @ingroup lua_type_traits + /// @brief lua_type_traits for FunctorType(deprecated) + template<> struct lua_type_traits { + typedef FunctorType get_type; + typedef FunctorType push_type; + static int push(lua_State* l, const FunctorType& f) + { + lua_pushnumber(l, 1);//no overload + void *storage = lua_newuserdata(l, sizeof(FunctorType)); + new(storage) FunctorType(f); + class_userdata::setmetatable(l); + lua_pushcclosure(l, &nativefunction::functor_dispatcher, 2); + return 1; + } +#if KAGUYA_USE_RVALUE_REFERENCE + static int push(lua_State* l, FunctorType&& f) + { + lua_pushnumber(l, 1);//no overload + void *storage = lua_newuserdata(l, sizeof(FunctorType)); + new(storage) FunctorType(std::forward(f)); + class_userdata::setmetatable(l); + lua_pushcclosure(l, &nativefunction::functor_dispatcher, 2); + return 1; + } +#endif + }; + + /// @ingroup lua_type_traits + /// @brief lua_type_traits for FunctorType(deprecated) + template<> struct lua_type_traits :lua_type_traits {}; + + + /// @ingroup lua_type_traits + /// @brief lua_type_traits for FunctorOverloadType(deprecated) + template<> struct lua_type_traits { + typedef const FunctorOverloadType& push_type; + + static int push(lua_State* l, push_type fns) + { + lua_pushnumber(l, static_cast(fns.size())); + for (FunctorOverloadType::const_iterator f = fns.begin(); f != fns.end(); ++f) + { + void *storage = lua_newuserdata(l, sizeof(FunctorType)); + new(storage) FunctorType(*f); + class_userdata::setmetatable(l); + } + lua_pushcclosure(l, &nativefunction::functor_dispatcher, static_cast(fns.size() + 1)); + return 1; + } + }; +} + +namespace kaguya +{ + //!ClassMetatable is deprecated. use UserdataMetatable instead. + template + struct ClassMetatable + { + typedef std::vector FunctorOverloadType; + typedef std::map FuncMapType; + typedef std::map PropMapType; + + typedef std::map MemberMapType; + typedef std::map CodeChunkMapType; + + + ClassMetatable() + { + 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"); + } + + LuaTable registerClass(lua_State* state)const + { + util::ScopedSavedStack save(state); + if (class_userdata::newmetatable(state)) + { + LuaTable metatable(state, StackTop()); + metatable.push(); + registerMember(state); + + if (!traits::is_same::value || !property_map_.empty())//if base class has property and derived class hasnt property. need property access metamethod + { + for (PropMapType::const_iterator it = property_map_.begin(); it != property_map_.end(); ++it) + { + if (util::one_push(state, it->second)) + { + lua_setfield(state, -2, ("_prop_" + it->first).c_str()); + } + } + LuaFunction indexfun = kaguya::LuaFunction::loadstring(state, "local arg = {...};local metatable = arg[1];" + "return function(table, index)" + // " if type(table) == 'userdata' then " + " local propfun = metatable['_prop_'..index];" + " if propfun then return propfun(table) end " + // " end " + " return metatable[index]" + " end")(metatable); + + metatable.setField("__index", indexfun); + + LuaFunction newindexfn = LuaFunction::loadstring(state, "local arg = {...};local metatable = arg[1];" + " return function(table, index, value) " + " if type(table) == 'userdata' then " + " local propfun = metatable['_prop_'..index];" + " if propfun then return propfun(table,value) end " + " end " + " rawset(table,index,value) " + " end")(metatable); + metatable.setField("__newindex", newindexfn); + } + else + { + metatable.setField("__index", metatable); + } + + set_base_metatable(state, metatable, types::typetag()); + + return metatable; + } + else + { + except::OtherError(state, typeid(class_type*).name() + std::string(" is already registered")); + } + return LuaTable(); + } + +#if KAGUYA_USE_CPP11 + template + ClassMetatable& addConstructor() + { + typedef typename ConstructorFunction::type cons; + function_map_["new"].push_back(cons()); + return *this; + } +#else +#define KAGUYA_TEMPLATE_PARAMETER(N) +#define KAGUYA_ADD_CON_FN_DEF(N) \ + KAGUYA_TEMPLATE_PARAMETER(N)\ + inline ClassMetatable& addConstructor()\ + {\ + typedef typename ConstructorFunction::type cons;\ + function_map_["new"].push_back(cons());\ + return *this;\ + } + KAGUYA_ADD_CON_FN_DEF(0) +#undef KAGUYA_TEMPLATE_PARAMETER +#define KAGUYA_TEMPLATE_PARAMETER(N) template + KAGUYA_PP_REPEAT_DEF(KAGUYA_FUNCTION_MAX_OVERLOADS, KAGUYA_ADD_CON_FN_DEF) +#undef KAGUYA_TEMPLATE_PARAMETER +#undef KAGUYA_ADD_CON_FN_DEF + +#endif + //variadic arguments constructor(receive const std::vector&) + // template<>ClassMetatable& addConstructor(types::typetag* ) + ClassMetatable& addConstructorVariadicArg() + { + typedef typename ConstructorFunction::type cons; + function_map_["new"].push_back(FunctorType(cons())); + return *this; + } + +#if defined(_MSC_VER) && _MSC_VER <= 1800 + //deprecated + //can not write Ret class_type::* f on MSC++2013 + template + KAGUYA_DEPRECATED_FEATURE("ClassMetatable is deprecated. use UserdataMetatable instead.") ClassMetatable& addMember(const char* name, Fun f) + { + return addMemberFunction(name, f); + } + //deprecated + //can not write Ret class_type::* f on MSC++2013 + template + ClassMetatable& addMemberFunction(const char* name, Fun f) + { + if (has_key(name, true)) + { + //already registered + return *this; + } + addFunction(name, f); + return *this; + } +#else + //deprecated + template + KAGUYA_DEPRECATED_FEATURE("ClassMetatable is deprecated. use UserdataMetatable instead.") ClassMetatable& addMember(const char* name, Ret class_type::* f) + { + return addMemberFunction(name, f); + } + template + ClassMetatable& addMemberFunction(const char* name, Ret class_type::* f) + { + if (has_key(name, true)) + { + //already registered + return *this; + } + addFunction(name, f); + return *this; + } +#endif + //add member property + template + ClassMetatable& addProperty(const char* name, Ret class_type::* mem) + { + property_map_[name] = FunctorType(mem); + return *this; + } + + + //! deprecated + template + ClassMetatable& addStaticMember(const char* name, Fun f) + { + return addStaticFunction(name, f); + } + //! deprecated + template + ClassMetatable& addStaticFunction(const char* name, Fun f) + { + if (has_key(name, true)) + { + //already registered + return *this; + } + addFunction(name, f); + return *this; + } + + //add field to + ClassMetatable& addCodeChunkResult(const char* name, const std::string& lua_code_chunk) + { + code_chunk_map_[name] = lua_code_chunk; + return *this; + } + + + template + ClassMetatable& addStaticField(const char* name, const Data& f) + { + if (has_key(name)) + { + //already registered + return *this; + } + member_map_[name] = AnyDataPusher(f); + return *this; + } + + +#if KAGUYA_USE_CPP11 + template + ClassMetatable& addStaticField(const char* name, Data&& f) + { + if (has_key(name)) + { + //already registered + return *this; + } + member_map_[name] = AnyDataPusher(std::move(f)); + return *this; + } +#endif + + private: + + void set_base_metatable(lua_State* state, LuaTable& metatable, types::typetag)const + { + } + template + void set_base_metatable(lua_State* state, LuaTable& metatable, types::typetag)const + { + class_userdata::get_metatable(state); + metatable.setMetatable(LuaTable(state, StackTop())); + + PointerConverter& pconverter = PointerConverter::get(state); + pconverter.add_type_conversion(); + } + + void set_multiple_base(lua_State* state, LuaTable& metatable, const LuaTable& metabases)const + { + LuaTable newmeta(state, NewTable()); + + LuaFunction indexfun = kaguya::LuaFunction::loadstring(state, "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")(metabases); + + newmeta.setField("__index", indexfun); + + metatable.setMetatable(newmeta); + + } +#if KAGUYA_USE_CPP11 + + template + void metatables(lua_State* state, LuaTable& metabases, PointerConverter& pvtreg, types::typetag >)const + { + class_userdata::get_metatable(state); + metabases.setField(metabases.size() + 1, LuaTable(state, StackTop())); + pvtreg.add_type_conversion(); + } + template + void metatables(lua_State* state, LuaTable& metabases, PointerConverter& pvtreg, types::typetag >)const + { + class_userdata::get_metatable(state); + metabases.setField(metabases.size() + 1, LuaTable(state, StackTop())); + pvtreg.add_type_conversion(); + metatables(state, metabases, pvtreg, types::typetag >()); + } + + template + void set_base_metatable(lua_State* state, LuaTable& metatable, types::typetag > metatypes)const + { + PointerConverter& pconverter = PointerConverter::get(state); + LuaTable metabases(state, NewTable(sizeof...(Bases), 0)); + metatables(state, metabases, pconverter, metatypes); + set_multiple_base(state, metatable, metabases); + } + +#else +#define KAGUYA_TEMPLATE_PARAMETER(N) template +#define KAGUYA_GET_BASE_METATABLE(N) class_userdata::get_metatable(state);\ + metabases.setField(metabases.size() + 1, LuaTable(state, StackTop())); \ + pconverter.add_type_conversion(); +#define KAGUYA_MULTIPLE_INHERITANCE_SETBASE_DEF(N) \ + KAGUYA_TEMPLATE_PARAMETER(N)\ + void set_base_metatable(lua_State* state, LuaTable& metatable, types::typetag > metatypes)const\ + {\ + PointerConverter& pconverter = PointerConverter::get(state);\ + LuaTable metabases(state, NewTable(N, 0));\ + KAGUYA_PP_REPEAT(N, KAGUYA_GET_BASE_METATABLE); \ + set_multiple_base(state, metatable, metabases);\ + }\ + + KAGUYA_PP_REPEAT_DEF(KAGUYA_CLASS_MAX_BASE_CLASSES, KAGUYA_MULTIPLE_INHERITANCE_SETBASE_DEF) +#undef KAGUYA_TEMPLATE_PARAMETER +#undef KAGUYA_MULTIPLE_INHERITANCE_SETBASE_DEF +#undef KAGUYA_GET_BASE_METATABLE +#undef KAGUYA_TYPE_CHECK_REP +#endif + + bool has_key(const std::string& key, bool exclude_function = false) + { + if (!exclude_function && function_map_.find(key) != function_map_.end()) + { + return true; + } + if (member_map_.find(key) != member_map_.end()) + { + return true; + } + return false; + } + void registerFunction(lua_State* state, const char* name, const FunctorOverloadType& func_array)const + { + if (util::one_push(state, func_array)) + { + lua_setfield(state, -2, name); + } + } + void registerField(lua_State* state, const char* name, const AnyDataPusher& value)const + { + int count = value.pushToLua(state); + if (count > 1) + { + lua_pop(state, count - 1); + count = 1; + } + if (count == 1) + { + lua_setfield(state, -2, name); + } + } + void registerCodeChunk(lua_State* state, const char* name, std::string value)const + { + util::ScopedSavedStack save(state); + int status = luaL_loadstring(state, value.c_str()); + if (!except::checkErrorAndThrow(status, state)) { return; } + status = lua_pcall_wrap(state, 0, 1); + if (!except::checkErrorAndThrow(status, state)) { return; } + lua_setfield(state, -2, name); + } + + void registerMember(lua_State* state)const + { + for (typename FuncMapType::const_iterator it = function_map_.begin(); it != function_map_.end(); ++it) + { + registerFunction(state, it->first.c_str(), it->second); + } + for (typename MemberMapType::const_iterator it = member_map_.begin(); it != member_map_.end(); ++it) + { + registerField(state, it->first.c_str(), it->second); + } + for (typename CodeChunkMapType::const_iterator it = code_chunk_map_.begin(); it != code_chunk_map_.end(); ++it) + { + registerCodeChunk(state, it->first.c_str(), it->second); + } + } + template + ClassMetatable& addFunction(const char* name, Fun f) + { + function_map_[name].push_back(FunctorType(f)); + return *this; + } + FuncMapType function_map_; + PropMapType property_map_; + MemberMapType member_map_; + CodeChunkMapType code_chunk_map_; + }; +} + +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 detail + { + 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; + } + } + + + /// class binding interface. + template + class UserdataMetatable + { + typedef std::map PropMapType; + typedef std::map MemberMapType; + 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"); + } + + LuaTable createMatatable(lua_State* state)const + { + util::ScopedSavedStack save(state); + if (!class_userdata::newmetatable(state)) + { + except::OtherError(state, typeid(class_type*).name() + std::string(" is already registered")); + return LuaTable(); + } + LuaStackRef metatable(state, -1); + registerMember(state); + + 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.push(state); + lua_pushcclosure(state, &detail::property_index_function, 1); + LuaStackRef indexfun(state, -1); + metatable.setRawField("__index", indexfun); + } + + + + if (member_map_.count("__newindex") == 0) + { + metatable.push(state); + lua_pushcclosure(state, &detail::property_newindex_function, 1); + LuaStackRef newindexfun(state, -1); + metatable.setRawField("__newindex", newindexfun); + } + } + else + { + if (member_map_.count("__index") == 0) + { + metatable.setRawField("__index", metatable); + } + } + + set_base_metatable(state, metatable, types::typetag()); + + class_userdata::get_call_constructor_metatable(state); + LuaStackRef call_construct_table(state, -1, true); + LuaTable basemetatable = metatable.getMetatable(); + if (basemetatable) + { + basemetatable.setRawField("__call", call_construct_table.getRawField("__call")); + } + else + { + metatable.setMetatable(call_construct_table); + } + + return metatable; + } + + +#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(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 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; + } + + /// @brief assign data by return value from evaluate code chunk. + /// this function is deprecated. use addStaticField(kaguya::LuaCodeChunkResult(\"luacode\")). + KAGUYA_DEPRECATED_FEATURE("addCodeChunkResult is deprecated. use addStaticField(kaguya::LuaCodeChunkResult(\"luacode\")).") + UserdataMetatable& addCodeChunkResult(const char* name, const std::string& lua_code_chunk) + { + if (has_key(name)) + { + throw KaguyaException(std::string(name) + " is already registered."); + return *this; + } + + member_map_[name] = AnyDataPusher(LuaCodeChunkResult(lua_code_chunk)); + return *this; + } + + /// @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; + } +#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::move(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 +#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; + } + + +#if defined(_MSC_VER) && _MSC_VER <= 1800 + //can not use add at MSVC2013 +#else + template + KAGUYA_DEPRECATED_FEATURE("add is deprecated. use addStaticField instead.") + UserdataMetatable& add(const char* name, const Data& d) + { + return addStaticField(name, d); + } + +#if KAGUYA_USE_CPP11 + template + KAGUYA_DEPRECATED_FEATURE("add is deprecated. use addStaticField instead.") + UserdataMetatable& add(const char* name, Data&& d) + { + return addStaticField(name, d); + } +#endif + template + KAGUYA_DEPRECATED_FEATURE("add is deprecated. use addFunction instead.") + UserdataMetatable& add(const char* name, Ret class_type::* f) + { + return addFunction(name, f); + } +#endif + + private: + + void set_base_metatable(lua_State* state, LuaStackRef& metatable, types::typetag)const + { + } + template + void set_base_metatable(lua_State* state, LuaStackRef& metatable, types::typetag)const + { + class_userdata::get_metatable(state); + metatable.setMetatable(LuaTable(state, StackTop())); + + PointerConverter& pconverter = PointerConverter::get(state); + pconverter.add_type_conversion(); + } + + void set_multiple_base(lua_State* state, LuaStackRef& metatable, const LuaTable& metabases)const + { + LuaTable newmeta(state, NewTable()); + + metabases.push(state); + lua_pushcclosure(state, &detail::multiple_base_index_function, 1); + LuaStackRef indexfun(state, -1); + newmeta.setField("__index", indexfun); + + metatable.setMetatable(newmeta); + + } +#if KAGUYA_USE_CPP11 + + template + void metatables(lua_State* state, LuaStackRef& metabases, PointerConverter& pvtreg, types::typetag >)const + { + class_userdata::get_metatable(state); + metabases.setRawField(metabases.size() + 1, LuaTable(state, StackTop())); + pvtreg.add_type_conversion(); + } + template + void metatables(lua_State* state, LuaStackRef& metabases, PointerConverter& pvtreg, types::typetag >)const + { + class_userdata::get_metatable(state); + metabases.setRawField(metabases.size() + 1, LuaTable(state, StackTop())); + pvtreg.add_type_conversion(); + metatables(state, metabases, pvtreg, types::typetag >()); + } + + template + void set_base_metatable(lua_State* state, LuaStackRef& metatable, types::typetag > metatypes)const + { + PointerConverter& pconverter = PointerConverter::get(state); + + util::one_push(state, NewTable(sizeof...(Bases), 0)); + LuaStackRef metabases(state, -1, true); + metatables(state, metabases, pconverter, metatypes); + set_multiple_base(state, metatable, metabases); + } + +#else +#define KAGUYA_GET_BASE_METATABLE(N) class_userdata::get_metatable(state);\ + metabases.setRawField(metabases.size() + 1, LuaTable(state, StackTop())); \ + pconverter.add_type_conversion(); +#define KAGUYA_MULTIPLE_INHERITANCE_SETBASE_DEF(N) \ + template\ + void set_base_metatable(lua_State* state, LuaStackRef& metatable, types::typetag > metatypes)const\ + {\ + PointerConverter& pconverter = PointerConverter::get(state);\ + util::one_push(state, NewTable(N,0));\ + LuaStackRef metabases(state,-1, true);\ + KAGUYA_PP_REPEAT(N, KAGUYA_GET_BASE_METATABLE); \ + set_multiple_base(state, metatable, metabases);\ + }\ + + 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; + } + void registerField(lua_State* state, const char* name, const AnyDataPusher& value)const + { + int count = value.pushToLua(state); + if (count > 1) + { + lua_pop(state, count - 1); + count = 1; + } + if (count == 1) + { + lua_setfield(state, -2, name); + } + } + void registerMember(lua_State* state)const + { + for (typename MemberMapType::const_iterator it = member_map_.begin(); it != member_map_.end(); ++it) + { + registerField(state, it->first.c_str(), it->second); + } + for (typename PropMapType::const_iterator it = property_map_.begin(); it != property_map_.end(); ++it) + { + registerField(state, (KAGUYA_PROPERTY_PREFIX + it->first).c_str(), it->second); + } + } + + PropMapType property_map_; + 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) + { + return ref.createMatatable(l).push(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 + + +namespace kaguya +{ + class State; + + + struct table_proxy + { + +#if KAGUYA_USE_CPP11 + template + static void set(lua_State* state, int table_index, const KEY& key, V&& value) + { + util::one_push(state, 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) + { + util::one_push(state, std::forward(value)); + lua_setfield(state, table_index, key.c_str()); + } + + template + static void set(lua_State* state, int table_index, const luaInt& key, V&& value) + { + util::one_push(state, std::forward(value)); + lua_seti(state, table_index, key); + } +#endif + 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, const luaInt& key, const V& value) + { + util::one_push(state, value); + lua_seti(state, table_index, key); + } + + 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); + } + }; + + + /** + * 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) + { + table_proxy::set(state_, table_index_, key_, src); + return *this; + } + + + //! assign from T + template + TableKeyReferenceProxy& operator=(const T& src) + { + table_proxy::set(state_, table_index_, key_, src); + + return *this; + } +#if KAGUYA_USE_CPP11 + template + TableKeyReferenceProxy& operator=(T&& src) + { + 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 ClassMetatable& reg) + { + set_class(reg); + } + + //! register class metatable to lua and set to table + template + void setClass(const UserdataMetatable& reg) + { + set_class(reg); + } + + //! set function + template + void setFunction(T f) + { + table_proxy::set(state_, table_index_, key_, kaguya::function(f)); + } + + //deprecated + LuaRef getValue()const + { + util::ScopedSavedStack save(state_); + push(state_); + return lua_type_traits::get(state_, -1); + } + + + int push(lua_State* state)const + { + if (lua_type(state_, table_index_) != LUA_TTABLE) + { + lua_pushnil(state); + return 1; + } + + 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 ClassMetatable& reg) + { + nativefunction::reg_functor_destructor(state_); + LuaRef table(state_, NewTable()); + table.setMetatable(reg.registerClass(state_)); + *this = table; + } + + template + void set_class(const UserdataMetatable& reg) + { + table_proxy::set(state_, table_index_, key_, reg.createMatatable(state_)); + } + + + ///!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); + util::one_push(state_, key); + 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); + util::one_push(state_, key); + 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 env) + { + 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); + util::one_push(state, key);//push key + lua_gettable(state, -2);//get table[key] + lua_remove(state, -2);//remove table + return LuaStackRef(state, -1, true); + } + template template + LuaStackRef LuaTableOrUserDataImpl::getRawField(const KEY& key)const + { + lua_State* state = state_(); + if (!state) + { + except::typeMismatchError(state, "is nil"); + return LuaStackRef(); + } + push_(state); + util::one_push(state, key);//push key + lua_rawget(state, -2);//get table[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 LuaTableOrUserDataImpl::values()const + { + return values(); + } + template + std::vector LuaTableOrUserDataImpl::keys()const + { + return keys(); + } + template + std::map LuaTableOrUserDataImpl::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 + 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(); + } + 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, *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) + { + 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) + { + std::cerr << message << std::endl; + } + + templatevoid init(const Libs& lib) + { + if (state_) + { + lua_atpanic(state_, &initializing_panic); + try + { + if (!ErrorHandler::getHandler(state_)) + { + setErrorHandler(&stderror_out); + } + openlibs(lib); + lua_atpanic(state_, &default_panic); + } + catch (const LuaException&) + { + lua_close(state_); state_ = 0; + } + } + } + + 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_) + { + 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/src/osm_object.cpp b/src/osm_object.cpp index 5f5828e4..068410f4 100644 --- a/src/osm_object.cpp +++ b/src/osm_object.cpp @@ -12,13 +12,13 @@ struct LayerDef { OSMObject - represents the object (from the .osm.pbf) currently being processed Only one instance of this class is ever used. Its main purpose is to provide a - consistent object for Luabind to access. + consistent object for Lua to access. */ class OSMObject { public: - lua_State *luaState; // Lua reference + kaguya::State *luaState; // Lua reference map *indices; // Spatial indices vector *cachedGeometries; // Cached geometries map *cachedGeometryNames; // Cached geometry names @@ -61,7 +61,7 @@ class OSMObject { public: // ---- initialization routines - OSMObject(lua_State *luaPtr, map< string, RTree> *idxPtr, vector *geomPtr, map *namePtr, OSMStore *storePtr) { + OSMObject(kaguya::State *luaPtr, map< string, RTree> *idxPtr, vector *geomPtr, map *namePtr, OSMStore *storePtr) { luaState = luaPtr; indices = idxPtr; cachedGeometries = geomPtr; diff --git a/src/tilemaker.cpp b/src/tilemaker.cpp index 5d8904be..54885a47 100644 --- a/src/tilemaker.cpp +++ b/src/tilemaker.cpp @@ -42,9 +42,7 @@ extern "C" { #include "lualib.h" #include "lauxlib.h" } -#include -#include -#include +#include "kaguya.hpp" // boost::geometry #include @@ -92,15 +90,14 @@ typedef vector WayVec; #include "read_shp.cpp" #include "write_geometry.cpp" -int lua_error_handler(lua_State* luaState) -{ - luabind::object msg(luabind::from_stack(luaState, -1)); - cerr << "lua runtime error: " << msg << endl; +kaguya::State luaState; - std::string traceback = luabind::call_function(luabind::globals(luaState)["debug"]["traceback"]); +int lua_error_handler(int errCode, const char *errMessage) +{ + std::string traceback = luaState["debug"]["traceback"]; + cerr << "lua runtime error: " << errMessage << endl; cerr << "traceback: " << traceback << endl; - - return 1; + exit(0); } int main(int argc, char* argv[]) { @@ -180,30 +177,26 @@ int main(int argc, char* argv[]) { // ---- Initialise Lua - lua_State *luaState = luaL_newstate(); - luaL_openlibs(luaState); - luaL_dofile(luaState, luaFile.c_str()); - luabind::open(luaState); - luabind::set_pcall_callback(&lua_error_handler); - luabind::module(luaState) [ - luabind::class_("OSM") - .def("Id", &OSMObject::Id) - .def("Holds", &OSMObject::Holds) - .def("Find", &OSMObject::Find) - .def("FindIntersecting", &OSMObject::FindIntersecting, luabind::return_stl_iterator) - .def("Intersects", &OSMObject::Intersects) - .def("IsClosed", &OSMObject::IsClosed) - .def("ScaleToMeter", &OSMObject::ScaleToMeter) - .def("ScaleToKiloMeter", &OSMObject::ScaleToKiloMeter) - .def("Area", &OSMObject::Area) - .def("Length", &OSMObject::Length) - .def("Layer", &OSMObject::Layer) - .def("LayerAsCentroid", &OSMObject::LayerAsCentroid) - .def("Attribute", &OSMObject::Attribute) - .def("AttributeNumeric", &OSMObject::AttributeNumeric) - .def("AttributeBoolean", &OSMObject::AttributeBoolean) - ]; - OSMObject osmObject(luaState, &indices, &cachedGeometries, &cachedGeometryNames, &osmStore); + luaState.setErrorHandler(lua_error_handler); + luaState.dofile(luaFile.c_str()); + luaState["OSM"].setClass(kaguya::UserdataMetatable() + .addFunction("Id", &OSMObject::Id) + .addFunction("Holds", &OSMObject::Holds) + .addFunction("Find", &OSMObject::Find) + .addFunction("FindIntersecting", &OSMObject::FindIntersecting) + .addFunction("Intersects", &OSMObject::Intersects) + .addFunction("IsClosed", &OSMObject::IsClosed) + .addFunction("ScaleToMeter", &OSMObject::ScaleToMeter) + .addFunction("ScaleToKiloMeter", &OSMObject::ScaleToKiloMeter) + .addFunction("Area", &OSMObject::Area) + .addFunction("Length", &OSMObject::Length) + .addFunction("Layer", &OSMObject::Layer) + .addFunction("LayerAsCentroid", &OSMObject::LayerAsCentroid) + .addFunction("Attribute", &OSMObject::Attribute) + .addFunction("AttributeNumeric", &OSMObject::AttributeNumeric) + .addFunction("AttributeBoolean", &OSMObject::AttributeBoolean) + ); + OSMObject osmObject(&luaState, &indices, &cachedGeometries, &cachedGeometryNames, &osmStore); // ---- Read JSON config @@ -302,31 +295,13 @@ int main(int argc, char* argv[]) { } // ---- Call init_function of Lua logic - lua_getglobal(luaState, "init_function"); - int exists_init_function = !lua_isnil(luaState, -1); - lua_pop(luaState, 1); - if (exists_init_function) { - try { luabind::call_function(luaState, "init_function"); - } catch (const luabind::error &er) { - cerr << er.what() << endl << "-- " << lua_tostring(er.state(), -1) << endl; - return -1; - } - } + + luaState("if init_function~=nil then init_function() end"); // ---- Read significant node tags - unordered_set nodeKeys; - lua_getglobal( luaState, "node_keys"); - if (lua_isnil(luaState,-1)) { - cerr << "Error found in Lua script when reading node_keys - check your script for syntax errors." << endl; - return -1; - } - lua_pushnil( luaState ); - while(lua_next( luaState, -2) != 0) { - string key = lua_tostring( luaState, -1 ); - lua_pop( luaState, 1); - nodeKeys.insert(key); - } + vector nodeKeyVec = luaState["node_keys"]; + unordered_set nodeKeys(nodeKeyVec.begin(), nodeKeyVec.end()); // ---- Initialise mbtiles if required @@ -434,11 +409,7 @@ int main(int argc, char* argv[]) { // For tagged nodes, call Lua, then save the OutputObject if (significant) { osmObject.setNode(nodeId, &dense, kvStart, kvPos-1, node); - try { luabind::call_function(luaState, "node_function", &osmObject); - } catch (const luabind::error &er) { - cerr << er.what() << endl << "-- " << lua_tostring(er.state(), -1) << endl; - return -1; - } + luaState["node_function"](&osmObject); if (!osmObject.empty()) { uint32_t index = latpLon2index(node, baseZoom); for (auto jt = osmObject.outputs.begin(); jt != osmObject.outputs.end(); ++jt) { @@ -496,12 +467,7 @@ int main(int argc, char* argv[]) { } osmObject.setWay(&pbfWay, &nodeVec); - // Call Lua to find what layers and tags we want - try { luabind::call_function(luaState, "way_function", &osmObject); - } catch (const luabind::error &er) { - cerr << er.what() << endl << "-- " << lua_tostring(er.state(), -1) << endl; - return -1; - } + luaState["way_function"](&osmObject); if (!osmObject.empty() || waysInRelation.count(wayId)) { // Store the way's nodes in the global way store @@ -570,12 +536,7 @@ int main(int argc, char* argv[]) { } osmObject.setRelation(&pbfRelation, &outerWayVec, &innerWayVec); - // Check with Lua if we want it - try { luabind::call_function(luaState, "way_function", &osmObject); - } catch (const luabind::error &er) { - cerr << er.what() << endl << "-- " << lua_tostring(er.state(), -1) << endl; - return -1; - } + luaState["way_function"](&osmObject); if (!osmObject.empty()) { WayID relID = osmObject.osmID; // Store the relation members in the global relation store @@ -819,16 +780,5 @@ int main(int argc, char* argv[]) { google::protobuf::ShutdownProtobufLibrary(); // ---- Call exit_function of Lua logic - lua_getglobal(luaState, "exit_function"); - int exists_exit_function = !lua_isnil(luaState, -1); - lua_pop(luaState, 1); - if (exists_exit_function) { - try { luabind::call_function(luaState, "exit_function"); - } catch (const luabind::error &er) { - cerr << er.what() << endl << "-- " << lua_tostring(er.state(), -1) << endl; - return -1; - } - } - - lua_close(luaState); + luaState("if exit_function~=nil then exit_function() end"); }