Fix storage types in vtable

.clang-format

@@ -19,7 +19,10 @@ IndentPPDirectives: AfterHash
 IfMacros:
   ["if LIBCOPP_UTIL_LIKELY_CONDITION", "if LIBCOPP_UTIL_UNLIKELY_CONDITION"]
 AttributeMacros:
+  - LIBCOPP_COPP_API
   - LIBCOPP_COPP_API_HEAD_ONLY
+  - LIBCOPP_COTASK_API
+  - LIBCOPP_COTASK_API_HEAD_ONLY
   - LIBCOPP_UTIL_SYMBOL_LOCAL
   - LIBCOPP_UTIL_SYMBOL_EXPORT
   - LIBCOPP_UTIL_SYMBOL_IMPORT
@@ -35,20 +38,6 @@ AttributeMacros:
   - LIBCOPP_UTIL_MACRO_INLINE_VARIABLE
   - LIBCOPP_UTIL_ATTRIBUTE_REINITIALIZES
   - LIBCOPP_UTIL_ATTRIBUTE_RETURNS_NONNULL
-  - LIBCOPP_UTIL_SYMBOL_LOCAL
-  - LIBCOPP_UTIL_SYMBOL_EXPORT
-  - LIBCOPP_UTIL_SYMBOL_IMPORT
-  - LIBCOPP_UTIL_SYMBOL_VISIBLE
-  - LIBCOPP_UTIL_NOINLINE_NOCLONE
-  - LIBCOPP_UTIL_CONST_INIT
-  - LIBCOPP_UTIL_ATTRIBUTE_LIFETIME_BOUND
-  - LIBCOPP_UTIL_SANITIZER_NO_MEMORY
-  - LIBCOPP_UTIL_SANITIZER_NO_THREAD
-  - LIBCOPP_UTIL_SANITIZER_NO_ADDRESS
-  - LIBCOPP_UTIL_SANITIZER_NO_UNDEFINED
-  - LIBCOPP_UTIL_MACRO_INLINE_VARIABLE
-  - LIBCOPP_UTIL_ATTRIBUTE_REINITIALIZES
-  - LIBCOPP_UTIL_ATTRIBUTE_RETURNS_NONNULL
   - LIBCOPP_UTIL_ATTRIBUTE_WARN_UNUSED
   - LIBCOPP_UTIL_ATTRIBUTE_UNINITIALIZED
   - LIBCOPP_UTIL_ATTRIBUTE_NO_UNIQUE_ADDRESS

CHANGELOG.md

@@ -1,12 +1,17 @@
 # CHANGELOG
 
+## 2.3.1
+
+1. Fixes storage types in `generator_vtable`.
+2. Fixes format rule.
+
 ## 2.3.0
 
-1. Rename all macros `COPP_*` to `LIBCOPP_*`
-2. Make all macros in compile_optimize.h and explicit_declare. standalone from atframework
-3. Merge boost.fcontext 1.87
-4. Remove `LIBCOPP_MACRO_HAS_EXCEPTION`
-5. Add nostd type_traits and `strong_rc_ptr` for non thread-safety smart pointer
+1. Rename all macros `COPP_*` to `LIBCOPP_*` .
+2. Make all macros in compile_optimize.h and explicit_declare. standalone from atframework.
+3. Merge boost.fcontext 1.87.
+4. Remove `LIBCOPP_MACRO_HAS_EXCEPTION`.
+5. Add nostd type_traits and `strong_rc_ptr` for non thread-safety smart pointer.
 6. Remove `LIBCOPP_DISABLE_ATOMIC_LOCK`, `LIBCOPP_LOCK_DISABLE_THIS_MT` and `LIBCOPP_LOCK_DISABLE_MT`. We use the only one option `LIBCOPP_ENABLE_MULTI_THREAD` now.
 7. Allow to disable multi-thread support for stack pool and C++20 coroutine to reduce cache miss.
 8. We allow use lightweight callback or channel mode(without callback) for C++20 coroutine generator.

CMakeLists.txt

@@ -28,7 +28,7 @@ enable_testing()
 
 project(
   libcopp
-  VERSION "2.3.0"
+  VERSION "2.3.1"
   DESCRIPTION "Cross-platform coroutine library in C++ ."
   HOMEPAGE_URL "https://libcopp.atframe.work"
   LANGUAGES C CXX ASM)

ci/do_ci.sh

@@ -98,9 +98,7 @@ elif [[ "$1" == "gcc.test" ]] || [[ "$1" == "gcc.legacy.test" ]] || [[ "$1" == "
   cmake --install .
   ls -lh prebuilt/include/libcopp/utils/config/libcopp_build_features.h
 elif [[ "$1" == "msys2.mingw.test" ]]; then
-  pacman -S --needed --noconfirm mingw-w64-x86_64-cmake git m4 curl wget tar autoconf automake \
-    mingw-w64-x86_64-git-lfs mingw-w64-x86_64-toolchain mingw-w64-x86_64-libtool \
-    mingw-w64-x86_64-python mingw-w64-x86_64-python-pip mingw-w64-x86_64-python-setuptools || true
+  pacman -S --needed --noconfirm mingw-w64-x86_64-cmake git curl mingw-w64-x86_64-git-lfs mingw-w64-x86_64-toolchain || true
   git config --global http.sslBackend openssl
   mkdir -p build_jobs_ci
   cd build_jobs_ci

include/libcopp/coroutine/generator_promise.h

@@ -34,6 +34,12 @@ enum class generator_vtable_type : uint8_t {
   kNone = 2,
 };
 
+template <class TCONTEXT, generator_vtable_type VTABLE_TYPE = generator_vtable_type::kDefault>
+class LIBCOPP_COPP_API_HEAD_ONLY generator_vtable;
+
+template <class TCONTEXT, generator_vtable_type VTABLE_TYPE = generator_vtable_type::kDefault>
+struct LIBCOPP_COPP_API_HEAD_ONLY generator_vtable_type_trait;
+
 template <class TVALUE>
 class LIBCOPP_COPP_API_HEAD_ONLY generator_context_base;
 
@@ -252,13 +258,33 @@ class LIBCOPP_COPP_API_HEAD_ONLY generator_context
 };
 
 template <class TCONTEXT>
-class LIBCOPP_COPP_API_HEAD_ONLY generator_vtable {
- public:
+struct LIBCOPP_COPP_API_HEAD_ONLY generator_vtable_type_trait<TCONTEXT, generator_vtable_type::kDefault> {
   using context_type = TCONTEXT;
   using context_pointer_type = LIBCOPP_COPP_NAMESPACE_ID::memory::default_strong_rc_ptr<context_type>;
   using value_type = typename context_type::value_type;
   using await_suspend_callback_type = std::function<void(context_pointer_type)>;
   using await_resume_callback_type = std::function<void(const context_type&)>;
+};
+
+template <class TCONTEXT>
+struct LIBCOPP_COPP_API_HEAD_ONLY generator_vtable_type_trait<TCONTEXT, generator_vtable_type::kLightWeight> {
+  using context_type = TCONTEXT;
+  using context_pointer_type = LIBCOPP_COPP_NAMESPACE_ID::memory::default_strong_rc_ptr<context_type>;
+  using value_type = typename context_type::value_type;
+  using await_suspend_callback_type = void (*)(context_pointer_type);
+  using await_resume_callback_type = void (*)(const context_type&);
+};
+
+template <class TCONTEXT, generator_vtable_type VTABLE_TYPE>
+class LIBCOPP_COPP_API_HEAD_ONLY generator_vtable {
+ public:
+  using context_type = typename generator_vtable_type_trait<TCONTEXT, VTABLE_TYPE>::context_type;
+  using context_pointer_type = typename generator_vtable_type_trait<TCONTEXT, VTABLE_TYPE>::context_pointer_type;
+  using value_type = typename generator_vtable_type_trait<TCONTEXT, VTABLE_TYPE>::value_type;
+  using await_suspend_callback_type =
+      typename generator_vtable_type_trait<TCONTEXT, VTABLE_TYPE>::await_suspend_callback_type;
+  using await_resume_callback_type =
+      typename generator_vtable_type_trait<TCONTEXT, VTABLE_TYPE>::await_resume_callback_type;
 
  public:
   template <class TSUSPEND, class TRESUME>
@@ -331,11 +357,11 @@ template <class TCONTEXT>
 class LIBCOPP_COPP_API_HEAD_ONLY generator_vtable_delegate<TCONTEXT, generator_vtable_type::kDefault> {
  public:
   using context_type = TCONTEXT;
-  using vtable_type = generator_vtable<context_type>;
+  using vtable_type = generator_vtable<context_type, generator_vtable_type::kDefault>;
   using context_pointer_type = LIBCOPP_COPP_NAMESPACE_ID::memory::default_strong_rc_ptr<context_type>;
   using value_type = typename context_type::value_type;
-  using await_suspend_callback_type = std::function<void(context_pointer_type)>;
-  using await_resume_callback_type = std::function<void(const context_type&)>;
+  using await_suspend_callback_type = typename vtable_type::await_suspend_callback_type;
+  using await_resume_callback_type = typename vtable_type::await_resume_callback_type;
 
   template <class TSUSPEND, class TRESUME>
   LIBCOPP_UTIL_FORCEINLINE generator_vtable_delegate(
@@ -376,23 +402,21 @@ template <class TCONTEXT>
 class LIBCOPP_COPP_API_HEAD_ONLY generator_vtable_delegate<TCONTEXT, generator_vtable_type::kLightWeight> {
  public:
   using context_type = TCONTEXT;
-  using vtable_type = generator_vtable<context_type>;
+  using vtable_type = generator_vtable<context_type, generator_vtable_type::kLightWeight>;
   using context_pointer_type = LIBCOPP_COPP_NAMESPACE_ID::memory::default_strong_rc_ptr<context_type>;
   using value_type = typename context_type::value_type;
-  using await_suspend_callback_type = void (*)(context_pointer_type);
-  using await_resume_callback_type = void (*)(const context_type&);
+  using await_suspend_callback_type = typename vtable_type::await_suspend_callback_type;
+  using await_resume_callback_type = typename vtable_type::await_resume_callback_type;
 
   template <class TSUSPEND, class TRESUME>
-  LIBCOPP_UTIL_FORCEINLINE generator_vtable_delegate(
-      TSUSPEND&& await_suspend_callback,
-      TRESUME&& await_resume_callback) noexcept(std::is_nothrow_constructible<vtable_type, TSUSPEND, TRESUME>::value)
+  LIBCOPP_UTIL_FORCEINLINE generator_vtable_delegate(TSUSPEND&& await_suspend_callback,
+                                                     TRESUME&& await_resume_callback) noexcept
       : vtable_(new vtable_type(std::forward<TSUSPEND>(await_suspend_callback),
                                 std::forward<TRESUME>(await_resume_callback))) {}
 
   template <class TSUSPEND>
-  LIBCOPP_UTIL_FORCEINLINE generator_vtable_delegate(TSUSPEND&& await_suspend_callback) noexcept(
-      std::is_nothrow_constructible<vtable_type, TSUSPEND>::value)
-      : vtable_(new vtable_type(std::forward<TSUSPEND>(await_suspend_callback))) {}
+  LIBCOPP_UTIL_FORCEINLINE generator_vtable_delegate(TSUSPEND&& await_suspend_callback) noexcept
+      : vtable_(new vtable_type(std::forward<TSUSPEND>(await_suspend_callback), nullptr)) {}
 
   LIBCOPP_UTIL_FORCEINLINE generator_vtable_delegate() noexcept : vtable_(nullptr) {}
 
@@ -421,8 +445,6 @@ class LIBCOPP_COPP_API_HEAD_ONLY generator_vtable_delegate<TCONTEXT, generator_v
   using context_type = TCONTEXT;
   using context_pointer_type = LIBCOPP_COPP_NAMESPACE_ID::memory::default_strong_rc_ptr<context_type>;
   using value_type = typename context_type::value_type;
-  using await_suspend_callback_type = std::function<void(context_pointer_type)>;
-  using await_resume_callback_type = std::function<void(const context_type&)>;
 
   LIBCOPP_UTIL_FORCEINLINE generator_vtable_delegate() noexcept {}
   LIBCOPP_UTIL_FORCEINLINE generator_vtable_delegate(const generator_vtable_delegate&) noexcept {}

include/libcopp/utils/config/libcopp_build_features.h.in

@@ -46,7 +46,6 @@
 #  endif
 #endif
 #define LIBCOPP_COPP_API_HEAD_ONLY LIBCOPP_UTIL_SYMBOL_VISIBLE
-#define LIBCOPP_COPP_API_C(R) extern "C" LIBCOPP_COPP_API R __cdecl
 
 #if defined(LIBCOPP_API_COTASK_NATIVE) && LIBCOPP_API_COTASK_NATIVE
 #  if defined(LIBCOPP_API_DLL) && LIBCOPP_API_DLL
@@ -62,7 +61,6 @@
 #  endif
 #endif
 #define LIBCOPP_COTASK_API_HEAD_ONLY LIBCOPP_UTIL_SYMBOL_VISIBLE
-#define LIBCOPP_COTASK_API_C(R) extern "C" LIBCOPP_COTASK_API R __cdecl
 
 #cmakedefine LIBCOPP_MACRO_USE_SEGMENTED_STACKS @LIBCOPP_MACRO_USE_SEGMENTED_STACKS@
 #cmakedefine LIBCOPP_MACRO_SYS_POSIX @LIBCOPP_MACRO_SYS_POSIX@

include/libcopp/utils/lock_holder.h

@@ -29,61 +29,53 @@ namespace util {
 namespace lock {
 namespace detail {
 template <typename TLock>
-struct LIBCOPP_COPP_API_HEAD_ONLY default_lock_action{inline bool operator()(TLock &lock) const noexcept {lock.lock();
-return true;
-}  // namespace detail
+struct LIBCOPP_COPP_API_HEAD_ONLY default_lock_action {
+  inline bool operator()(TLock &lock) const noexcept {
+    lock.lock();
+    return true;
+  }  // namespace detail
 };  // namespace lock
 
 template <typename TLock>
-struct LIBCOPP_COPP_API_HEAD_ONLY default_try_lock_action{inline bool operator()(TLock &lock)
-                                                              const noexcept {return lock.try_lock();
-}  // namespace util
-}
-;
+struct LIBCOPP_COPP_API_HEAD_ONLY default_try_lock_action {
+  inline bool operator()(TLock &lock) const noexcept { return lock.try_lock(); }  // namespace util
+};
 
 template <typename TLock>
-struct LIBCOPP_COPP_API_HEAD_ONLY default_unlock_action{inline void operator()(TLock &lock)
-                                                            const noexcept {lock.unlock();
-}
-}
-;
+struct LIBCOPP_COPP_API_HEAD_ONLY default_unlock_action {
+  inline void operator()(TLock &lock) const noexcept { lock.unlock(); }
+};
 
 template <typename TLock>
-struct LIBCOPP_COPP_API_HEAD_ONLY default_try_unlock_action{inline bool operator()(TLock &lock)
-                                                                const noexcept {return lock.try_unlock();
-}
-}
-;
+struct LIBCOPP_COPP_API_HEAD_ONLY default_try_unlock_action {
+  inline bool operator()(TLock &lock) const noexcept { return lock.try_unlock(); }
+};
 
 template <typename TLock>
-struct LIBCOPP_COPP_API_HEAD_ONLY default_read_lock_action{inline bool operator()(TLock &lock)
-                                                               const noexcept {lock.read_lock();
-return true;
-}
-}
-;
+struct LIBCOPP_COPP_API_HEAD_ONLY default_read_lock_action {
+  inline bool operator()(TLock &lock) const noexcept {
+    lock.read_lock();
+    return true;
+  }
+};
 
 template <typename TLock>
-struct LIBCOPP_COPP_API_HEAD_ONLY default_read_unlock_action{inline void operator()(TLock &lock)
-                                                                 const noexcept {lock.read_unlock();
-}
-}
-;
+struct LIBCOPP_COPP_API_HEAD_ONLY default_read_unlock_action {
+  inline void operator()(TLock &lock) const noexcept { lock.read_unlock(); }
+};
 
 template <typename TLock>
-struct LIBCOPP_COPP_API_HEAD_ONLY default_write_lock_action{inline bool operator()(TLock &lock)
-                                                                const noexcept {lock.write_lock();
-return true;
-}
-}
-;
+struct LIBCOPP_COPP_API_HEAD_ONLY default_write_lock_action {
+  inline bool operator()(TLock &lock) const noexcept {
+    lock.write_lock();
+    return true;
+  }
+};
 
 template <typename TLock>
-struct LIBCOPP_COPP_API_HEAD_ONLY default_write_unlock_action{inline void operator()(TLock &lock)
-                                                                  const noexcept {lock.write_unlock();
-}
-}
-;
+struct LIBCOPP_COPP_API_HEAD_ONLY default_write_unlock_action {
+  inline void operator()(TLock &lock) const noexcept { lock.write_unlock(); }
+};
 }  // namespace detail
 
 template <typename TLock, typename TLockAct = detail::default_lock_action<TLock>,

include/libcopp/utils/memory/rc_ptr.h

@@ -311,10 +311,10 @@ class LIBCOPP_COPP_API_HEAD_ONLY __rc_ptr_counted_data_with_deleter_allocator fi
 };
 
 template <class T>
-struct LIBCOPP_COPP_API_HEAD_ONLY __strong_rc_default_alloc_shared_tag{};
+struct LIBCOPP_COPP_API_HEAD_ONLY __strong_rc_default_alloc_shared_tag {};
 
 template <class T>
-struct LIBCOPP_COPP_API_HEAD_ONLY __strong_rc_with_alloc_shared_tag{};
+struct LIBCOPP_COPP_API_HEAD_ONLY __strong_rc_with_alloc_shared_tag {};
 
 template <class T>
 class LIBCOPP_COPP_API_HEAD_ONLY __weak_rc_counter;

include/libcotask/core/standard_new_allocator.h

@@ -16,22 +16,20 @@
 
 LIBCOPP_COTASK_NAMESPACE_BEGIN
 namespace core {
-class LIBCOPP_COTASK_API_HEAD_ONLY standard_new_allocator{
-  public :
-      /**
-       * @brief allocate a object
-       * @param args construct parameters
-       * @return pointer of new object
-       */
-      template <class Ty, class... TARGS>
-      static LIBCOPP_COPP_NAMESPACE_ID::memory::default_strong_rc_ptr<Ty>
-          allocate(Ty *, TARGS &&...args){
-              return LIBCOPP_COPP_NAMESPACE_ID::memory::default_make_strong<Ty>(std::forward<TARGS>(args)...);
-}
+class LIBCOPP_COTASK_API_HEAD_ONLY standard_new_allocator {
+ public:
+  /**
+   * @brief allocate a object
+   * @param args construct parameters
+   * @return pointer of new object
+   */
+  template <class Ty, class... TARGS>
+  static LIBCOPP_COPP_NAMESPACE_ID::memory::default_strong_rc_ptr<Ty> allocate(Ty *, TARGS &&...args) {
+    return LIBCOPP_COPP_NAMESPACE_ID::memory::default_make_strong<Ty>(std::forward<TARGS>(args)...);
+  }
 
-template <class Ty>
-static void deallocate(LIBCOPP_COPP_NAMESPACE_ID::memory::default_strong_rc_ptr<Ty> &) {}
-}
-;
+  template <class Ty>
+  static void deallocate(LIBCOPP_COPP_NAMESPACE_ID::memory::default_strong_rc_ptr<Ty> &) {}
+};
 }  // namespace core
 LIBCOPP_COTASK_NAMESPACE_END

src/libcopp/fcontext/asm/tail_ontop_ppc32_sysv.cpp

@@ -12,7 +12,6 @@ using copp::transfer_t;
 // This C++ tail of ontop_fcontext() allocates transfer_t{ from, vp }
 // on the stack.  If fn() throws a C++ exception, then the C++ runtime
 // must remove this tail's stack frame.
-extern "C" transfer_t
-ontop_fcontext_tail( int ignore, void * vp, transfer_t (* fn)(transfer_t), fcontext_t const from) {
-    return fn( transfer_t{ from, vp });
+extern "C" transfer_t ontop_fcontext_tail(int ignore, void* vp, transfer_t (*fn)(transfer_t), fcontext_t const from) {
+  return fn(transfer_t{from, vp});
 }

src/libcopp/stack/allocator/stack_allocator_split_segment.cpp

@@ -43,16 +43,15 @@ namespace allocator {
 
 LIBCOPP_COPP_API stack_allocator_split_segment::stack_allocator_split_segment() LIBCOPP_MACRO_NOEXCEPT {}
 LIBCOPP_COPP_API stack_allocator_split_segment::~stack_allocator_split_segment() {}
-LIBCOPP_COPP_API
-stack_allocator_split_segment::stack_allocator_split_segment(const stack_allocator_split_segment &)
+LIBCOPP_COPP_API stack_allocator_split_segment::stack_allocator_split_segment(const stack_allocator_split_segment &)
     LIBCOPP_MACRO_NOEXCEPT {}
 LIBCOPP_COPP_API stack_allocator_split_segment &stack_allocator_split_segment::operator=(
     const stack_allocator_split_segment &) LIBCOPP_MACRO_NOEXCEPT {
   return *this;
 }
 
-LIBCOPP_COPP_API
-stack_allocator_split_segment::stack_allocator_split_segment(stack_allocator_split_segment &&) LIBCOPP_MACRO_NOEXCEPT {}
+LIBCOPP_COPP_API stack_allocator_split_segment::stack_allocator_split_segment(stack_allocator_split_segment &&)
+    LIBCOPP_MACRO_NOEXCEPT {}
 LIBCOPP_COPP_API stack_allocator_split_segment &stack_allocator_split_segment::operator=(
     stack_allocator_split_segment &&) LIBCOPP_MACRO_NOEXCEPT {
   return *this;

src/libcopp/stack/stack_traits/stack_traits_posix.cpp

@@ -70,7 +70,9 @@ LIBCOPP_COPP_API std::size_t stack_traits::default_size() LIBCOPP_MACRO_NOEXCEPT
   return maximum_size() == size ? size : (std::min)(size, maximum_size());
 }
 
-LIBCOPP_COPP_API std::size_t stack_traits::minimum_size() LIBCOPP_MACRO_NOEXCEPT { return static_cast<size_t>(MINSIGSTKSZ); }
+LIBCOPP_COPP_API std::size_t stack_traits::minimum_size() LIBCOPP_MACRO_NOEXCEPT {
+  return static_cast<size_t>(MINSIGSTKSZ);
+}
 
 LIBCOPP_COPP_API std::size_t stack_traits::maximum_size() LIBCOPP_MACRO_NOEXCEPT {
   if (is_unbounded()) return std::numeric_limits<std::size_t>::max();