1 files changed, 33 insertions, 33 deletions

diff --git a/src/universe.cpp b/src/universe.cpp
index a5c28f0..f05cc6f 100644
--- a/src/universe.cpp
+++ b/src/universe.cpp
@@ -68,13 +68,13 @@ Universe::Universe()
 [[nodiscard]] Universe* universe_create(lua_State* L_)
 {
     LUA_ASSERT(L_, universe_get(L_) == nullptr);
-    Universe* const U{ lua_newuserdatauv<Universe>(L_, 0) }; // universe
-    U->Universe::Universe();
+    Universe* const _U{ lua_newuserdatauv<Universe>(L_, 0) }; // universe
+    _U->Universe::Universe();
     STACK_CHECK_START_REL(L_, 1);
     kUniverseFullRegKey.setValue(L_, [](lua_State* L_) { lua_pushvalue(L_, -2); });
-    kUniverseLightRegKey.setValue(L_, [U](lua_State* L_) { lua_pushlightuserdata(L_, U); });
+    kUniverseLightRegKey.setValue(L_, [U = _U](lua_State* L_) { lua_pushlightuserdata(L_, U); });
     STACK_CHECK(L_, 1);
-    return U;
+    return _U;
 }
 
 // #################################################################################################
@@ -84,22 +84,22 @@ void Universe::terminateFreeRunningLanes(lua_State* L_, lua_Duration shutdownTim
     if (selfdestructFirst != SELFDESTRUCT_END) {
         // Signal _all_ still running threads to exit (including the timer thread)
         {
-            std::lock_guard<std::mutex> guard{ selfdestructMutex };
-            Lane* lane{ selfdestructFirst };
-            while (lane != SELFDESTRUCT_END) {
+            std::lock_guard<std::mutex> _guard{ selfdestructMutex };
+            Lane* _lane{ selfdestructFirst };
+            while (_lane != SELFDESTRUCT_END) {
                 // attempt the requested cancel with a small timeout.
                 // if waiting on a linda, they will raise a cancel_error.
                 // if a cancellation hook is desired, it will be installed to try to raise an error
-                if (lane->thread.joinable()) {
-                    std::ignore = thread_cancel(lane, op_, 1, std::chrono::steady_clock::now() + 1us, true);
+                if (_lane->thread.joinable()) {
+                    std::ignore = thread_cancel(_lane, op_, 1, std::chrono::steady_clock::now() + 1us, true);
                 }
-                lane = lane->selfdestruct_next;
+                _lane = _lane->selfdestruct_next;
             }
         }
 
         // When noticing their cancel, the lanes will remove themselves from the selfdestruct chain.
         {
-            std::chrono::time_point<std::chrono::steady_clock> t_until{ std::chrono::steady_clock::now() + std::chrono::duration_cast<std::chrono::steady_clock::duration>(shutdownTimeout_) };
+            std::chrono::time_point<std::chrono::steady_clock> _until{ std::chrono::steady_clock::now() + std::chrono::duration_cast<std::chrono::steady_clock::duration>(shutdownTimeout_) };
 
             while (selfdestructFirst != SELFDESTRUCT_END) {
                 // give threads time to act on their cancel
@@ -107,17 +107,17 @@ void Universe::terminateFreeRunningLanes(lua_State* L_, lua_Duration shutdownTim
                 // count the number of cancelled thread that didn't have the time to act yet
                 int n{ 0 };
                 {
-                    std::lock_guard<std::mutex> guard{ selfdestructMutex };
-                    Lane* lane{ selfdestructFirst };
-                    while (lane != SELFDESTRUCT_END) {
-                        if (lane->cancelRequest != CancelRequest::None)
+                    std::lock_guard<std::mutex> _guard{ selfdestructMutex };
+                    Lane* _lane{ selfdestructFirst };
+                    while (_lane != SELFDESTRUCT_END) {
+                        if (_lane->cancelRequest != CancelRequest::None)
                             ++n;
-                        lane = lane->selfdestruct_next;
+                        _lane = _lane->selfdestruct_next;
                     }
                 }
                 // if timeout elapsed, or we know all threads have acted, stop waiting
-                std::chrono::time_point<std::chrono::steady_clock> t_now = std::chrono::steady_clock::now();
-                if (n == 0 || (t_now >= t_until)) {
+                std::chrono::time_point<std::chrono::steady_clock> _now = std::chrono::steady_clock::now();
+                if (n == 0 || (_now >= _until)) {
                     DEBUGSPEW_CODE(fprintf(stderr, "%d uncancelled lane(s) remain after waiting %fs at process end.\n", n, shutdownTimeout_.count()));
                     break;
                 }
@@ -133,11 +133,11 @@ void Universe::terminateFreeRunningLanes(lua_State* L_, lua_Duration shutdownTim
 
     // If after all this, we still have some free-running lanes, it's an external user error, they should have stopped appropriately
     {
-        std::lock_guard<std::mutex> guard{ selfdestructMutex };
-        Lane* lane{ selfdestructFirst };
-        if (lane != SELFDESTRUCT_END) {
+        std::lock_guard<std::mutex> _guard{ selfdestructMutex };
+        Lane* _lane{ selfdestructFirst };
+        if (_lane != SELFDESTRUCT_END) {
             // this causes a leak because we don't call U's destructor (which could be bad if the still running lanes are accessing it)
-            raise_luaL_error(L_, "Zombie thread %s refuses to die!", lane->debugName);
+            raise_luaL_error(L_, "Zombie thread %s refuses to die!", _lane->debugName);
         }
     }
 }
@@ -147,25 +147,25 @@ void Universe::terminateFreeRunningLanes(lua_State* L_, lua_Duration shutdownTim
 // process end: cancel any still free-running threads
 int universe_gc(lua_State* L_)
 {
-    lua_Duration const shutdown_timeout{ lua_tonumber(L_, lua_upvalueindex(1)) };
-    [[maybe_unused]] char const* const op_string{ lua_tostring(L_, lua_upvalueindex(2)) };
-    Universe* const U{ lua_tofulluserdata<Universe>(L_, 1) };
-    U->terminateFreeRunningLanes(L_, shutdown_timeout, which_cancel_op(op_string));
+    lua_Duration const _shutdown_timeout{ lua_tonumber(L_, lua_upvalueindex(1)) };
+    [[maybe_unused]] char const* const _op_string{ lua_tostring(L_, lua_upvalueindex(2)) };
+    Universe* const _U{ lua_tofulluserdata<Universe>(L_, 1) };
+    _U->terminateFreeRunningLanes(L_, _shutdown_timeout, which_cancel_op(_op_string));
 
     // no need to mutex-protect this as all threads in the universe are gone at that point
-    if (U->timerLinda != nullptr) { // test in case some early internal error prevented Lanes from creating the deep timer
-        [[maybe_unused]] int const prev_ref_count{ U->timerLinda->refcount.fetch_sub(1, std::memory_order_relaxed) };
+    if (_U->timerLinda != nullptr) { // test in case some early internal error prevented Lanes from creating the deep timer
+        [[maybe_unused]] int const prev_ref_count{ _U->timerLinda->refcount.fetch_sub(1, std::memory_order_relaxed) };
         LUA_ASSERT(L_, prev_ref_count == 1); // this should be the last reference
-        DeepFactory::DeleteDeepObject(L_, U->timerLinda);
-        U->timerLinda = nullptr;
+        DeepFactory::DeleteDeepObject(L_, _U->timerLinda);
+        _U->timerLinda = nullptr;
     }
 
-    close_keepers(U);
+    close_keepers(_U);
 
     // remove the protected allocator, if any
-    U->protectedAllocator.removeFrom(L_);
+    _U->protectedAllocator.removeFrom(L_);
 
-    U->Universe::~Universe();
+    _U->Universe::~Universe();
 
     return 0;
 }