1 files changed, 150 insertions, 239 deletions

diff --git a/src/linda.cpp b/src/linda.cpp
index f88158a..82f5f98 100644
--- a/src/linda.cpp
+++ b/src/linda.cpp
@@ -2,7 +2,7 @@
  * LINDA.CPP                        Copyright (c) 2018-2024, Benoit Germain
  *
  * Linda deep userdata.
-*/
+ */
 
 /*
 ===============================================================================
@@ -62,8 +62,7 @@ Linda::Linda(Universe* U_, LindaGroup group_, char const* name_, size_t len_)
 
 Linda::~Linda()
 {
-    if (std::holds_alternative<AllocatedName>(m_name))
-    {
+    if (std::holds_alternative<AllocatedName>(m_name)) {
         AllocatedName& name = std::get<AllocatedName>(m_name);
         U->internal_allocator.free(name.name, name.len);
     }
@@ -74,19 +73,15 @@ Linda::~Linda()
 void Linda::setName(char const* name_, size_t len_)
 {
     // keep default
-    if (!name_ || len_ == 0)
-    {
+    if (!name_ || len_ == 0) {
         return;
     }
     ++len_; // don't forget terminating 0
-    if (len_ < kEmbeddedNameLength)
-    {
+    if (len_ < kEmbeddedNameLength) {
         m_name.emplace<EmbeddedName>();
         char* const name{ std::get<EmbeddedName>(m_name).data() };
         memcpy(name, name_, len_);
-    }
-    else
-    {
+    } else {
         AllocatedName& name = std::get<AllocatedName>(m_name);
         name.name = static_cast<char*>(U->internal_allocator.alloc(len_));
         name.len = len_;
@@ -98,13 +93,11 @@ void Linda::setName(char const* name_, size_t len_)
 
 char const* Linda::getName() const
 {
-    if (std::holds_alternative<AllocatedName>(m_name))
-    {
+    if (std::holds_alternative<AllocatedName>(m_name)) {
         AllocatedName const& name = std::get<AllocatedName>(m_name);
         return name.name;
     }
-    if (std::holds_alternative<EmbeddedName>(m_name))
-    {
+    if (std::holds_alternative<EmbeddedName>(m_name)) {
         char const* const name{ std::get<EmbeddedName>(m_name).data() };
         return name;
     }
@@ -117,8 +110,7 @@ template <bool OPT>
 [[nodiscard]] static inline Linda* ToLinda(lua_State* L_, int idx_)
 {
     Linda* const linda{ static_cast<Linda*>(LindaFactory::Instance.toDeep(L_, idx_)) };
-    if constexpr (!OPT)
-    {
+    if constexpr (!OPT) {
         luaL_argcheck(L_, linda != nullptr, idx_, "expecting a linda object"); // doesn't return if linda is nullptr
         LUA_ASSERT(L_, linda->U == universe_get(L_));
     }
@@ -129,26 +121,20 @@ template <bool OPT>
 
 static void check_key_types(lua_State* L_, int start_, int end_)
 {
-    for (int i{ start_ }; i <= end_; ++i)
-    {
+    for (int i{ start_ }; i <= end_; ++i) {
         LuaType const t{ lua_type_as_enum(L_, i) };
-        switch (t)
-        {
-            case LuaType::BOOLEAN:
-            case LuaType::NUMBER:
-            case LuaType::STRING:
+        switch (t) {
+        case LuaType::BOOLEAN:
+        case LuaType::NUMBER:
+        case LuaType::STRING:
             continue;
 
-            case LuaType::LIGHTUSERDATA:
-            {
-                static constexpr std::array<std::reference_wrapper<UniqueKey const>, 3> kKeysToCheck{ kLindaBatched, kCancelError, kNilSentinel };
-                for (UniqueKey const& key : kKeysToCheck)
-                {
-                    if (key.equals(L_, i))
-                    {
-                        raise_luaL_error(L_, "argument #%d: can't use %s as a key", i, key.m_debugName);
-                        break;
-                    }
+        case LuaType::LIGHTUSERDATA:
+            static constexpr std::array<std::reference_wrapper<UniqueKey const>, 3> kKeysToCheck{ kLindaBatched, kCancelError, kNilSentinel };
+            for (UniqueKey const& key : kKeysToCheck) {
+                if (key.equals(L_, i)) {
+                    raise_luaL_error(L_, "argument #%d: can't use %s as a key", i, key.m_debugName);
+                    break;
                 }
             }
             break;
@@ -184,8 +170,7 @@ int Linda::ProtectedCall(lua_State* L_, lua_CFunction f_)
     linda->releaseKeeper(K);
 
     // if there was an error, forward it
-    if (rc != LUA_OK)
-    {
+    if (rc != LUA_OK) {
         raise_lua_error(L_);
     }
     // return whatever the actual operation provided
@@ -195,39 +180,33 @@ int Linda::ProtectedCall(lua_State* L_, lua_CFunction f_)
 // #################################################################################################
 
 /*
-* bool= linda_send( linda_ud, [timeout_secs=-1,] [linda.null,] key_num|str|bool|lightuserdata, ... )
-*
-* Send one or more values to a Linda. If there is a limit, all values must fit.
-*
-* Returns:  'true' if the value was queued
-*           'false' for timeout (only happens when the queue size is limited)
-*           nil, kCancelError if cancelled
-*/
+ * bool= linda_send( linda_ud, [timeout_secs=-1,] [linda.null,] key_num|str|bool|lightuserdata, ... )
+ *
+ * Send one or more values to a Linda. If there is a limit, all values must fit.
+ *
+ * Returns:  'true' if the value was queued
+ *           'false' for timeout (only happens when the queue size is limited)
+ *           nil, kCancelError if cancelled
+ */
 LUAG_FUNC(linda_send)
 {
-    auto send = [](lua_State* L_)
-    {
+    auto send = [](lua_State* L_) {
         Linda* const linda{ ToLinda<false>(L_, 1) };
         std::chrono::time_point<std::chrono::steady_clock> until{ std::chrono::time_point<std::chrono::steady_clock>::max() };
         int key_i{ 2 }; // index of first key, if timeout not there
 
-        if (lua_type(L_, 2) == LUA_TNUMBER) // we don't want to use lua_isnumber() because of autocoercion
-        {
+        if (lua_type(L_, 2) == LUA_TNUMBER) { // we don't want to use lua_isnumber() because of autocoercion
             lua_Duration const duration{ lua_tonumber(L_, 2) };
-            if (duration.count() >= 0.0)
-            {
+            if (duration.count() >= 0.0) {
                 until = std::chrono::steady_clock::now() + std::chrono::duration_cast<std::chrono::steady_clock::duration>(duration);
             }
             ++key_i;
-        }
-        else if (lua_isnil(L_, 2)) // alternate explicit "infinite timeout" by passing nil before the key
-        {
+        } else if (lua_isnil(L_, 2)) { // alternate explicit "infinite timeout" by passing nil before the key
             ++key_i;
         }
 
         bool const as_nil_sentinel{ kNilSentinel.equals(L_, key_i) }; // if not nullptr, send() will silently send a single nil if nothing is provided
-        if (as_nil_sentinel)
-        {
+        if (as_nil_sentinel) {
             // the real key to send data to is after the kNilSentinel marker
             ++key_i;
         }
@@ -238,15 +217,11 @@ LUAG_FUNC(linda_send)
         STACK_GROW(L_, 1);
 
         // make sure there is something to send
-        if (lua_gettop(L_) == key_i)
-        {
-            if (as_nil_sentinel)
-            {
+        if (lua_gettop(L_) == key_i) {
+            if (as_nil_sentinel) {
                 // send a single nil if nothing is provided
                 kNilSentinel.pushKey(L_);
-            }
-            else
-            {
+            } else {
                 raise_luaL_error(L_, "no data to send");
             }
         }
@@ -264,24 +239,20 @@ LUAG_FUNC(linda_send)
                 return 0;
 
             STACK_CHECK_START_REL(KL, 0);
-            for (bool try_again{ true };;)
-            {
-                if (lane != nullptr)
-                {
+            for (bool try_again{ true };;) {
+                if (lane != nullptr) {
                     cancel = lane->cancel_request;
                 }
                 cancel = (cancel != CancelRequest::None) ? cancel : linda->simulate_cancel;
                 // if user wants to cancel, or looped because of a timeout, the call returns without sending anything
-                if (!try_again || cancel != CancelRequest::None)
-                {
+                if (!try_again || cancel != CancelRequest::None) {
                     pushed.emplace(0);
                     break;
                 }
 
                 STACK_CHECK(KL, 0);
                 pushed = keeper_call(linda->U, KL, KEEPER_API(send), L_, linda, key_i);
-                if (!pushed.has_value())
-                {
+                if (!pushed.has_value()) {
                     break;
                 }
                 LUA_ASSERT(L_, pushed.value() == 1);
@@ -289,26 +260,23 @@ LUAG_FUNC(linda_send)
                 ret = lua_toboolean(L_, -1) ? true : false;
                 lua_pop(L_, 1);
 
-                if (ret)
-                {
+                if (ret) {
                     // Wake up ALL waiting threads
                     linda->m_write_happened.notify_all();
                     break;
                 }
 
                 // instant timout to bypass the wait syscall
-                if (std::chrono::steady_clock::now() >= until)
-                {
+                if (std::chrono::steady_clock::now() >= until) {
                     break; /* no wait; instant timeout */
                 }
 
                 // storage limit hit, wait until timeout or signalled that we should try again
                 {
                     Lane::Status prev_status{ Lane::Error }; // prevent 'might be used uninitialized' warnings
-                    if (lane != nullptr)
-                    {
+                    if (lane != nullptr) {
                         // change status of lane to "waiting"
-                        prev_status = lane->m_status; // Running, most likely
+                        prev_status = lane->m_status;                 // Running, most likely
                         LUA_ASSERT(L_, prev_status == Lane::Running); // but check, just in case
                         lane->m_status = Lane::Waiting;
                         LUA_ASSERT(L_, lane->m_waiting_on == nullptr);
@@ -317,10 +285,9 @@ LUAG_FUNC(linda_send)
                     // could not send because no room: wait until some data was read before trying again, or until timeout is reached
                     std::unique_lock<std::mutex> keeper_lock{ K->m_mutex, std::adopt_lock };
                     std::cv_status const status{ linda->m_read_happened.wait_until(keeper_lock, until) };
-                    keeper_lock.release(); // we don't want to release the lock!
+                    keeper_lock.release();                              // we don't want to release the lock!
                     try_again = (status == std::cv_status::no_timeout); // detect spurious wakeups
-                    if (lane != nullptr)
-                    {
+                    if (lane != nullptr) {
                         lane->m_waiting_on = nullptr;
                         lane->m_status = prev_status;
                     }
@@ -329,23 +296,21 @@ LUAG_FUNC(linda_send)
             STACK_CHECK(KL, 0);
         }
 
-        if (!pushed.has_value())
-        {
+        if (!pushed.has_value()) {
             raise_luaL_error(L_, "tried to copy unsupported types");
         }
 
-        switch (cancel)
-        {
-            case CancelRequest::Soft:
+        switch (cancel) {
+        case CancelRequest::Soft:
             // if user wants to soft-cancel, the call returns lanes.cancel_error
             kCancelError.pushKey(L_);
             return 1;
 
-            case CancelRequest::Hard:
+        case CancelRequest::Hard:
             // raise an error interrupting execution only in case of hard cancel
             raise_cancel_error(L_); // raises an error and doesn't return
 
-            default:
+        default:
             lua_pushboolean(L_, ret); // true (success) or false (timeout)
             return 1;
         }
@@ -368,23 +333,18 @@ LUAG_FUNC(linda_send)
  */
 LUAG_FUNC(linda_receive)
 {
-    auto receive = [](lua_State* L_)
-    {
+    auto receive = [](lua_State* L_) {
         Linda* const linda{ ToLinda<false>(L_, 1) };
         std::chrono::time_point<std::chrono::steady_clock> until{ std::chrono::time_point<std::chrono::steady_clock>::max() };
         int key_i{ 2 }; // index of first key, if timeout not there
 
-        if (lua_type(L_, 2) == LUA_TNUMBER) // we don't want to use lua_isnumber() because of autocoercion
-        {
+        if (lua_type(L_, 2) == LUA_TNUMBER) { // we don't want to use lua_isnumber() because of autocoercion
             lua_Duration const duration{ lua_tonumber(L_, 2) };
-            if (duration.count() >= 0.0)
-            {
+            if (duration.count() >= 0.0) {
                 until = std::chrono::steady_clock::now() + std::chrono::duration_cast<std::chrono::steady_clock::duration>(duration);
             }
             ++key_i;
-        }
-        else if (lua_isnil(L_, 2)) // alternate explicit "infinite timeout" by passing nil before the key
-        {
+        } else if (lua_isnil(L_, 2)) { // alternate explicit "infinite timeout" by passing nil before the key
             ++key_i;
         }
 
@@ -394,8 +354,7 @@ LUAG_FUNC(linda_receive)
         kLindaBatched.pushKey(L_);
         int const is_batched{ lua501_equal(L_, key_i, -1) };
         lua_pop(L_, 1);
-        if (is_batched)
-        {
+        if (is_batched) {
             // no need to pass linda.batched in the keeper state
             ++key_i;
             // make sure the keys are of a valid type
@@ -408,13 +367,10 @@ LUAG_FUNC(linda_receive)
             // don't forget to count the key in addition to the values
             ++expected_pushed_min;
             ++expected_pushed_max;
-            if (expected_pushed_min > expected_pushed_max)
-            {
+            if (expected_pushed_min > expected_pushed_max) {
                 raise_luaL_error(L_, "batched min/max error");
             }
-        }
-        else
-        {
+        } else {
             // make sure the keys are of a valid type
             check_key_types(L_, key_i, lua_gettop(L_));
             // receive a single value, checking multiple slots
@@ -432,28 +388,23 @@ LUAG_FUNC(linda_receive)
         CancelRequest cancel{ CancelRequest::None };
         KeeperCallResult pushed;
         STACK_CHECK_START_REL(KL, 0);
-        for (bool try_again{ true };;)
-        {
-            if (lane != nullptr)
-            {
+        for (bool try_again{ true };;) {
+            if (lane != nullptr) {
                 cancel = lane->cancel_request;
             }
             cancel = (cancel != CancelRequest::None) ? cancel : linda->simulate_cancel;
             // if user wants to cancel, or looped because of a timeout, the call returns without sending anything
-            if (!try_again || cancel != CancelRequest::None)
-            {
+            if (!try_again || cancel != CancelRequest::None) {
                 pushed.emplace(0);
                 break;
             }
 
             // all arguments of receive() but the first are passed to the keeper's receive function
             pushed = keeper_call(linda->U, KL, selected_keeper_receive, L_, linda, key_i);
-            if (!pushed.has_value())
-            {
+            if (!pushed.has_value()) {
                 break;
             }
-            if (pushed.value() > 0)
-            {
+            if (pushed.value() > 0) {
                 LUA_ASSERT(L_, pushed.value() >= expected_pushed_min && pushed.value() <= expected_pushed_max);
                 // replace sentinels with real nils
                 keeper_toggle_nil_sentinels(L_, lua_gettop(L_) - pushed.value(), LookupMode::FromKeeper);
@@ -463,18 +414,16 @@ LUAG_FUNC(linda_receive)
                 break;
             }
 
-            if (std::chrono::steady_clock::now() >= until)
-            {
+            if (std::chrono::steady_clock::now() >= until) {
                 break; /* instant timeout */
             }
 
             // nothing received, wait until timeout or signalled that we should try again
             {
                 Lane::Status prev_status{ Lane::Error }; // prevent 'might be used uninitialized' warnings
-                if (lane != nullptr)
-                {
+                if (lane != nullptr) {
                     // change status of lane to "waiting"
-                    prev_status = lane->m_status; // Running, most likely
+                    prev_status = lane->m_status;                 // Running, most likely
                     LUA_ASSERT(L_, prev_status == Lane::Running); // but check, just in case
                     lane->m_status = Lane::Waiting;
                     LUA_ASSERT(L_, lane->m_waiting_on == nullptr);
@@ -483,10 +432,9 @@ LUAG_FUNC(linda_receive)
                 // not enough data to read: wakeup when data was sent, or when timeout is reached
                 std::unique_lock<std::mutex> keeper_lock{ K->m_mutex, std::adopt_lock };
                 std::cv_status const status{ linda->m_write_happened.wait_until(keeper_lock, until) };
-                keeper_lock.release(); // we don't want to release the lock!
+                keeper_lock.release();                              // we don't want to release the lock!
                 try_again = (status == std::cv_status::no_timeout); // detect spurious wakeups
-                if (lane != nullptr)
-                {
+                if (lane != nullptr) {
                     lane->m_waiting_on = nullptr;
                     lane->m_status = prev_status;
                 }
@@ -494,23 +442,21 @@ LUAG_FUNC(linda_receive)
         }
         STACK_CHECK(KL, 0);
 
-        if (!pushed.has_value())
-        {
+        if (!pushed.has_value()) {
             raise_luaL_error(L_, "tried to copy unsupported types");
         }
 
-        switch (cancel)
-        {
-            case CancelRequest::Soft:
+        switch (cancel) {
+        case CancelRequest::Soft:
             // if user wants to soft-cancel, the call returns kCancelError
             kCancelError.pushKey(L_);
             return 1;
 
-            case CancelRequest::Hard:
+        case CancelRequest::Hard:
             // raise an error interrupting execution only in case of hard cancel
             raise_cancel_error(L_); // raises an error and doesn't return
 
-            default:
+        default:
             return pushed.value();
         }
     };
@@ -520,17 +466,16 @@ LUAG_FUNC(linda_receive)
 // #################################################################################################
 
 /*
-* [true|lanes.cancel_error] = linda_set( linda_ud, key_num|str|bool|lightuserdata [, value [, ...]])
-*
-* Set one or more value to Linda.
-* TODO: what do we do if we set to non-nil and limit is 0?
-*
-* Existing slot value is replaced, and possible queued entries removed.
-*/
+ * [true|lanes.cancel_error] = linda_set( linda_ud, key_num|str|bool|lightuserdata [, value [, ...]])
+ *
+ * Set one or more value to Linda.
+ * TODO: what do we do if we set to non-nil and limit is 0?
+ *
+ * Existing slot value is replaced, and possible queued entries removed.
+ */
 LUAG_FUNC(linda_set)
 {
-    auto set = [](lua_State* L_)
-    {
+    auto set = [](lua_State* L_) {
         Linda* const linda{ ToLinda<false>(L_, 1) };
         bool const has_value{ lua_gettop(L_) > 2 };
         // make sure the key is of a valid type (throws an error if not the case)
@@ -538,33 +483,26 @@ LUAG_FUNC(linda_set)
 
         Keeper* const K{ linda->whichKeeper() };
         KeeperCallResult pushed;
-        if (linda->simulate_cancel == CancelRequest::None)
-        {
-            if (has_value)
-            {
+        if (linda->simulate_cancel == CancelRequest::None) {
+            if (has_value) {
                 // convert nils to some special non-nil sentinel in sent values
                 keeper_toggle_nil_sentinels(L_, 3, LookupMode::ToKeeper);
             }
             pushed = keeper_call(linda->U, K->L, KEEPER_API(set), L_, linda, 2);
-            if (pushed.has_value()) // no error?
-            {
+            if (pushed.has_value()) { // no error?
                 LUA_ASSERT(L_, pushed.value() == 0 || pushed.value() == 1);
 
-                if (has_value)
-                {
+                if (has_value) {
                     // we put some data in the slot, tell readers that they should wake
                     linda->m_write_happened.notify_all(); // To be done from within the 'K' locking area
                 }
-                if (pushed.value() == 1)
-                {
+                if (pushed.value() == 1) {
                     // the key was full, but it is no longer the case, tell writers they should wake
                     LUA_ASSERT(L_, lua_type(L_, -1) == LUA_TBOOLEAN && lua_toboolean(L_, -1) == 1);
                     linda->m_read_happened.notify_all(); // To be done from within the 'K' locking area
                 }
             }
-        }
-        else // linda is cancelled
-        {
+        } else { // linda is cancelled
             // do nothing and return lanes.cancel_error
             kCancelError.pushKey(L_);
             pushed.emplace(1);
@@ -585,8 +523,7 @@ LUAG_FUNC(linda_set)
  */
 LUAG_FUNC(linda_count)
 {
-    auto count = [](lua_State* L_)
-    {
+    auto count = [](lua_State* L_) {
         Linda* const linda{ ToLinda<false>(L_, 1) };
         // make sure the keys are of a valid type
         check_key_types(L_, 2, lua_gettop(L_));
@@ -601,14 +538,13 @@ LUAG_FUNC(linda_count)
 // #################################################################################################
 
 /*
-* [val [, ...]] = linda_get( linda_ud, key_num|str|bool|lightuserdata [, count = 1])
-*
-* Get one or more values from Linda.
-*/
+ * [val [, ...]] = linda_get( linda_ud, key_num|str|bool|lightuserdata [, count = 1])
+ *
+ * Get one or more values from Linda.
+ */
 LUAG_FUNC(linda_get)
 {
-    auto get = [](lua_State* L_)
-    {
+    auto get = [](lua_State* L_) {
         Linda* const linda{ ToLinda<false>(L_, 1) };
         lua_Integer const count{ luaL_optinteger(L_, 3, 1) };
         luaL_argcheck(L_, count >= 1, 3, "count should be >= 1");
@@ -617,17 +553,13 @@ LUAG_FUNC(linda_get)
         check_key_types(L_, 2, 2);
 
         KeeperCallResult pushed;
-        if (linda->simulate_cancel == CancelRequest::None)
-        {
+        if (linda->simulate_cancel == CancelRequest::None) {
             Keeper* const K{ linda->whichKeeper() };
             pushed = keeper_call(linda->U, K->L, KEEPER_API(get), L_, linda, 2);
-            if (pushed.value_or(0) > 0)
-            {
+            if (pushed.value_or(0) > 0) {
                 keeper_toggle_nil_sentinels(L_, lua_gettop(L_) - pushed.value(), LookupMode::FromKeeper);
             }
-        }
-        else // linda is cancelled
-        {
+        } else { // linda is cancelled
             // do nothing and return lanes.cancel_error
             kCancelError.pushKey(L_);
             pushed.emplace(1);
@@ -641,37 +573,32 @@ LUAG_FUNC(linda_get)
 // #################################################################################################
 
 /*
-* [true] = linda_limit( linda_ud, key_num|str|bool|lightuserdata, int)
-*
-* Set limit to 1 Linda keys.
-* Optionally wake threads waiting to write on the linda, in case the limit enables them to do so
-*/
+ * [true] = linda_limit( linda_ud, key_num|str|bool|lightuserdata, int)
+ *
+ * Set limit to 1 Linda keys.
+ * Optionally wake threads waiting to write on the linda, in case the limit enables them to do so
+ */
 LUAG_FUNC(linda_limit)
 {
-    auto limit = [](lua_State* L_)
-    {
+    auto limit = [](lua_State* L_) {
         Linda* const linda{ ToLinda<false>(L_, 1) };
         // make sure we got 3 arguments: the linda, a key and a limit
-        luaL_argcheck( L_, lua_gettop( L_) == 3, 2, "wrong number of arguments");
+        luaL_argcheck(L_, lua_gettop(L_) == 3, 2, "wrong number of arguments");
         // make sure we got a numeric limit
-        luaL_checknumber( L_, 3);
+        luaL_checknumber(L_, 3);
         // make sure the key is of a valid type
-        check_key_types( L_, 2, 2);
+        check_key_types(L_, 2, 2);
 
         KeeperCallResult pushed;
-        if (linda->simulate_cancel == CancelRequest::None)
-        {
+        if (linda->simulate_cancel == CancelRequest::None) {
             Keeper* const K{ linda->whichKeeper() };
             pushed = keeper_call(linda->U, K->L, KEEPER_API(limit), L_, linda, 2);
             LUA_ASSERT(L_, pushed.has_value() && (pushed.value() == 0 || pushed.value() == 1)); // no error, optional boolean value saying if we should wake blocked writer threads
-            if (pushed.value() == 1)
-            {
-                LUA_ASSERT(L_, lua_type( L_, -1) == LUA_TBOOLEAN && lua_toboolean( L_, -1) == 1);
+            if (pushed.value() == 1) {
+                LUA_ASSERT(L_, lua_type(L_, -1) == LUA_TBOOLEAN && lua_toboolean(L_, -1) == 1);
                 linda->m_read_happened.notify_all(); // To be done from within the 'K' locking area
             }
-        }
-        else // linda is cancelled
-        {
+        } else { // linda is cancelled
             // do nothing and return lanes.cancel_error
             kCancelError.pushKey(L_);
             pushed.emplace(1);
@@ -685,10 +612,10 @@ LUAG_FUNC(linda_limit)
 // #################################################################################################
 
 /*
-* (void) = linda_cancel( linda_ud, "read"|"write"|"both"|"none")
-*
-* Signal linda so that waiting threads wake up as if their own lane was cancelled
-*/
+ * (void) = linda_cancel( linda_ud, "read"|"write"|"both"|"none")
+ *
+ * Signal linda so that waiting threads wake up as if their own lane was cancelled
+ */
 LUAG_FUNC(linda_cancel)
 {
     Linda* const linda{ ToLinda<false>(L_, 1) };
@@ -697,25 +624,16 @@ LUAG_FUNC(linda_cancel)
     luaL_argcheck(L_, lua_gettop(L_) <= 2, 2, "wrong number of arguments");
 
     linda->simulate_cancel = CancelRequest::Soft;
-    if (strcmp(who, "both") == 0) // tell everyone writers to wake up
-    {
+    if (strcmp(who, "both") == 0) { // tell everyone writers to wake up
         linda->m_write_happened.notify_all();
         linda->m_read_happened.notify_all();
-    }
-    else if (strcmp(who, "none") == 0) // reset flag
-    {
+    } else if (strcmp(who, "none") == 0) { // reset flag
         linda->simulate_cancel = CancelRequest::None;
-    }
-    else if (strcmp(who, "read") == 0) // tell blocked readers to wake up
-    {
+    } else if (strcmp(who, "read") == 0) { // tell blocked readers to wake up
         linda->m_write_happened.notify_all();
-    }
-    else if (strcmp(who, "write") == 0) // tell blocked writers to wake up
-    {
+    } else if (strcmp(who, "write") == 0) { // tell blocked writers to wake up
         linda->m_read_happened.notify_all();
-    }
-    else
-    {
+    } else {
         raise_luaL_error(L_, "unknown wake hint '%s'", who);
     }
     return 0;
@@ -724,15 +642,15 @@ LUAG_FUNC(linda_cancel)
 // #################################################################################################
 
 /*
-* lightuserdata= linda_deep( linda_ud )
-*
-* Return the 'deep' userdata pointer, identifying the Linda.
-*
-* This is needed for using Lindas as key indices (timer system needs it);
-* separately created proxies of the same underlying deep object will have
-* different userdata and won't be known to be essentially the same deep one
-* without this.
-*/
+ * lightuserdata= linda_deep( linda_ud )
+ *
+ * Return the 'deep' userdata pointer, identifying the Linda.
+ *
+ * This is needed for using Lindas as key indices (timer system needs it);
+ * separately created proxies of the same underlying deep object will have
+ * different userdata and won't be known to be essentially the same deep one
+ * without this.
+ */
 LUAG_FUNC(linda_deep)
 {
     Linda* const linda{ ToLinda<false>(L_, 1) };
@@ -743,19 +661,18 @@ LUAG_FUNC(linda_deep)
 // #################################################################################################
 
 /*
-* string = linda:__tostring( linda_ud)
-*
-* Return the stringification of a linda
-*
-* Useful for concatenation or debugging purposes
-*/
+ * string = linda:__tostring( linda_ud)
+ *
+ * Return the stringification of a linda
+ *
+ * Useful for concatenation or debugging purposes
+ */
 
 template <bool OPT>
 [[nodiscard]] static int LindaToString(lua_State* L_, int idx_)
 {
     Linda* const linda{ ToLinda<OPT>(L_, idx_) };
-    if (linda != nullptr)
-    {
+    if (linda != nullptr) {
         char text[128];
         int len;
         if (linda->getName())
@@ -768,6 +685,8 @@ template <bool OPT>
     return 0;
 }
 
+// #################################################################################################
+
 LUAG_FUNC(linda_tostring)
 {
     return LindaToString<false>(L_, 1);
@@ -776,28 +695,25 @@ LUAG_FUNC(linda_tostring)
 // #################################################################################################
 
 /*
-* string = linda:__concat( a, b)
-*
-* Return the concatenation of a pair of items, one of them being a linda
-*
-* Useful for concatenation or debugging purposes
-*/
+ * string = linda:__concat( a, b)
+ *
+ * Return the concatenation of a pair of items, one of them being a linda
+ *
+ * Useful for concatenation or debugging purposes
+ */
 LUAG_FUNC(linda_concat)
-{ // linda1? linda2?
+{                                                                                                  // L_: linda1? linda2?
     bool atLeastOneLinda{ false };
     // Lua semantics enforce that one of the 2 arguments is a Linda, but not necessarily both.
-    if (LindaToString<true>(L_, 1))
-    {
+    if (LindaToString<true>(L_, 1)) {
         atLeastOneLinda = true;
         lua_replace(L_, 1);
     }
-    if (LindaToString<true>(L_, 2))
-    {
+    if (LindaToString<true>(L_, 2)) {
         atLeastOneLinda = true;
         lua_replace(L_, 2);
     }
-    if (!atLeastOneLinda) // should not be possible
-    {
+    if (!atLeastOneLinda) { // should not be possible
         raise_luaL_error(L_, "internal error: linda_concat called on non-Linda");
     }
     lua_concat(L_, 2);
@@ -812,8 +728,7 @@ LUAG_FUNC(linda_concat)
  */
 LUAG_FUNC(linda_dump)
 {
-    auto dump = [](lua_State* L_)
-    {
+    auto dump = [](lua_State* L_) {
         Linda* const linda{ ToLinda<false>(L_, 1) };
         return keeper_push_linda_storage(*linda, DestState{ L_ });
     };
@@ -830,8 +745,7 @@ LUAG_FUNC(linda_towatch)
 {
     Linda* const linda{ ToLinda<false>(L_, 1) };
     int pushed{ keeper_push_linda_storage(*linda, DestState{ L_ }) };
-    if (pushed == 0)
-    {
+    if (pushed == 0) {
         // if the linda is empty, don't return nil
         pushed = LindaToString<false>(L_, 1);
     }
@@ -872,13 +786,10 @@ LUAG_FUNC(linda)
 {
     int const top{ lua_gettop(L_) };
     luaL_argcheck(L_, top <= 2, top, "too many arguments");
-    if (top == 1)
-    {
+    if (top == 1) {
         LuaType const t{ lua_type_as_enum(L_, 1) };
         luaL_argcheck(L_, t == LuaType::STRING || t == LuaType::NUMBER, 1, "wrong parameter (should be a string or a number)");
-    }
-    else if (top == 2)
-    {
+    } else if (top == 2) {
         luaL_checktype(L_, 1, LUA_TSTRING);
         luaL_checktype(L_, 2, LUA_TNUMBER);
     }