8 files changed, 49 insertions, 35 deletions

diff --git a/docs/index.html b/docs/index.html
index 92cc38a..f5a074f 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -183,7 +183,7 @@
         </tr>
 </table>
 <p>
-        <tt>luaopen_lanes_embedded</tt> leaves the module table on the stack. <tt>lanes.configure()</tt> must still be called in order to use Lanes.
+        <tt>luaopen_lanes_embedded</tt> leaves the module table on the stack. <a href="#initialization"><tt>lanes.configure()</tt></a> must still be called in order to use Lanes.
         <br/>
         If <tt>_luaopen_lanes</tt> is <tt>nullptr</tt>, a default loader will simply attempt the equivalent of <tt>luaL_dofile(L, "lanes.lua")</tt>.
 </p>
@@ -249,17 +249,17 @@
         Requiring the module follows Lua 5.2+ rules: the module is not available under the global name "lanes", but has to be accessed through <tt>require</tt>'s return value.
 </p>
 <p>
-        After lanes is required, it is necessary to call <tt>lanes.configure()</tt>, which is the only function exposed by the module at this point. Calling <tt>configure()</tt> will perform one-time initializations and make the rest of the API available.
+        After lanes is required, it is necessary to call <tt>lanes.configure()</tt>, which is the only function exposed by the module at this point. Calling <tt>lanes.configure()</tt> will perform one-time initializations and make the rest of the API available.
 </p>
 <p>
-        At the same time, <tt>configure()</tt> itself will be replaced by another function that raises an error if called again with differing arguments, if any.
+        At the same time, <tt>lanes.configure()</tt> itself will be replaced by another function that raises an error if called again with differing arguments, if any.
 </p>
 <p>
         Also, once Lanes is initialized, <tt>require()</tt> is replaced by another one that wraps it inside a mutex, both in the main state and in all created lanes. This prevents multiple thread-unsafe module initializations from several lanes to occur simultaneously.
         It remains to be seen whether this is actually useful or not: If a module is already threadsafe, protecting its initialization isn't useful. And if it is not, any parallel operation may crash without Lanes being able to do anything about it.
 </p>
 <p>
-        <b>IMPORTANT NOTE:</b> Only the first occurence of <tt>require "lanes"</tt> must be followed by a call to <tt>.configure()</tt>. From this point, a simple <tt>require "lanes"</tt> will do wherever you need to require lanes again.
+        <b>IMPORTANT NOTE:</b> Only the first occurence of <tt>require "lanes"</tt> must be followed by a call to <tt>lanes.configure()</tt>. From this point, a simple <tt>require "lanes"</tt> will be enough wherever you need to require lanes again.
 </p>
 
 <p>
@@ -758,8 +758,10 @@
         </table>
 
 <p>
-        Each lane also gets a global function <tt>set_debug_threadname()</tt> that it can use anytime to do as the name says. Supported debuggers are Microsoft Visual Studio (for the C side) and Decoda (for the Lua side).
-        <br/>
+        Each lane gets a global function <tt>set_debug_threadname()</tt> that it can use anytime to do as the name says. Supported debuggers are Microsoft Visual Studio (for the C side) and <a href="https://github.com/unknownworlds/decoda">Decoda</a> (for the Lua side).<br/>
+        Decoda support is limited to setting a special global variable <tt>decoda_name</tt>. This is disabled by default. Change <tt>HAVE_DECODA_NAME()</tt> in <tt>lanesconf.h</tt> if necessary.<br/>
+        The name is stored inside the Lua state registry so that it is available for error reporting. Changing <tt>decoda_name</tt> doesn't affect this hidden name or the OS thread name reported by MSVC.<br/>
+        When Lanes is initialized by the first <a href="#initialization"><tt>lanes.configure()</tt></a> call, <tt>"main"</tt> is stored in the registry in the same fashion (but <tt>decoda_name</tt> and the OS thread name are left unchanged).<br/>
         The lane also has a method <tt>lane:get_debug_threadname()</tt> that gives access to that name from the caller side (returns <tt>"&lt;unnamed&gt;"</tt> if unset, <tt>"&lt;closed&gt;"</tt> if the internal Lua state is closed).
 </p>
 
@@ -1334,7 +1336,7 @@
 
                 <li>
                         Performance. Changing any slot in a Linda causes all pending threads for that Linda to be momentarily awakened (at least in the C level).
-                        This can degrade performance due to unnecessary OS level context switches. The more keeper states you declared with <tt>lanes.configure()</tt> the less this should be a problem.
+                        This can degrade performance due to unnecessary OS level context switches. The more keeper states you declared with <a href="#initialization"><tt>lanes.configure()</tt></a> the less this should be a problem.
                 </li>
         </ul>
 
@@ -1356,7 +1358,7 @@ events to a common Linda, but... :).</font>
 </pre></td></tr></table>
 
 <p>
-        Timers are implemented as a lane. They can be enabled by setting "<tt><a href="#with_timers">with_timers</a></tt>" to <tt>true</tt> in <tt>lanes.configure()</tt> settings.
+        Timers are implemented as a lane. They can be enabled by setting "<tt><a href="#with_timers">with_timers</a></tt>" to <tt>true</tt> in <a href="#initialization"><tt>lanes.configure()</tt></a> settings.
 </p>
 
 <p>
@@ -1373,7 +1375,7 @@ events to a common Linda, but... :).</font>
 
 <table border="1" bgcolor="#FFFFE0" cellpadding="10" style="width:50%"><tr><td><pre>
         local lanes = require "lanes"
-        lanes.configure()
+        lanes.configure{with_timers = true}
 
         local linda = lanes.linda()
 
diff --git a/src/intercopycontext.cpp b/src/intercopycontext.cpp
index 6c72b1c..893305e 100644
--- a/src/intercopycontext.cpp
+++ b/src/intercopycontext.cpp
@@ -29,6 +29,7 @@ THE SOFTWARE.
 #include "debugspew.h"
 #include "deep.h"
 #include "keeper.h"
+#include "lane.h"
 #include "linda.h"
 #include "universe.h"
 
@@ -106,11 +107,11 @@ THE SOFTWARE.
     if (_fqn.empty() && !lua_istable(L1, L1_i)) { // raise an error if we try to send an unknown function (but not for tables)
         _fqn = std::string_view{}; // just in case
         // try to discover the name of the function we want to send
-        lua_getglobal(L1, "decoda_name");                                                          // L1: ... v ... decoda_name
+        kLaneNameRegKey.pushValue(L1);                                                             // L1: ... v ... lane_name
         char const* _from{ lua_tostring(L1, -1) };
-        lua_pushcfunction(L1, luaG_nameof);                                                        // L1: ... v ... decoda_name luaG_nameof
-        lua_pushvalue(L1, L1_i);                                                                   // L1: ... v ... decoda_name luaG_nameof t
-        lua_call(L1, 1, 2);                                                                        // L1: ... v ... decoda_name "type" "name"|nil
+        lua_pushcfunction(L1, luaG_nameof);                                                        // L1: ... v ... lane_name luaG_nameof
+        lua_pushvalue(L1, L1_i);                                                                   // L1: ... v ... lane_name luaG_nameof t
+        lua_call(L1, 1, 2);                                                                        // L1: ... v ... lane_name "type" "name"|nil
         char const* _typewhat{ (lua_type(L1, -2) == LUA_TSTRING) ? lua_tostring(L1, -2) : luaL_typename(L1, -2) };
         // second return value can be nil if the table was not found
         // probable reason: the function was removed from the source Lua state before Lanes was required.
@@ -325,10 +326,10 @@ void InterCopyContext::lookup_native_func() const
         // nil means we don't know how to transfer stuff: user should do something
         // anything other than function or table should not happen!
         if (!lua_isfunction(L2, -1) && !lua_istable(L2, -1)) {
-            lua_getglobal(L1, "decoda_name"); // L1: ... f ... decoda_name
+            kLaneNameRegKey.pushValue(L1);                                                         // L1: ... f ... lane_name
             char const* const _from{ lua_tostring(L1, -1) };
             lua_pop(L1, 1);                                                                        // L1: ... f ...
-            lua_getglobal(L2, "decoda_name");                                                      // L1: ... f ...                                  L2: {} f decoda_name
+            kLaneNameRegKey.pushValue(L2);                                                         // L1: ... f ...                                  L2: {} f lane_name
             char const* const _to{ lua_tostring(L2, -1) };
             lua_pop(L2, 1);                                                                        //                                                L2: {} f
             // when mode_ == LookupMode::FromKeeper, L is a keeper state and L2 is not, therefore L2 is the state where we want to raise the error
@@ -449,10 +450,10 @@ void InterCopyContext::copy_cached_func() const
             STACK_CHECK(L2, 0);
             return false;
         } else if (!lua_istable(L2, -1)) { // this can happen if someone decides to replace same already registered item (for a example a standard lib function) with a table
-            lua_getglobal(L1, "decoda_name"); // L1: ... t ... decoda_name
+            kLaneNameRegKey.pushValue(L1);                                                         // L1: ... t ... lane_name
             char const* _from{ lua_tostring(L1, -1) };
             lua_pop(L1, 1);                                                                        // L1: ... t ...
-            lua_getglobal(L2, "decoda_name");                                                      // L1: ... t ...                                  L2: {} t decoda_name
+            kLaneNameRegKey.pushValue(L2);                                                         // L1: ... t ...                                  L2: {} t lane_name
             char const* _to{ lua_tostring(L2, -1) };
             lua_pop(L2, 1);                                                                        // L1: ... t ...                                  L2: {} t
             raise_luaL_error(
diff --git a/src/lane.cpp b/src/lane.cpp
index f220bce..ada1846 100644
--- a/src/lane.cpp
+++ b/src/lane.cpp
@@ -802,20 +802,20 @@ Lane::~Lane()
 
 // #################################################################################################
 
-void Lane::changeDebugName(int nameIdx_)
+void Lane::changeDebugName(int const nameIdx_)
 {
-    // xxh64 of string "debugName" generated at https://www.pelock.com/products/hash-calculator
-    static constexpr RegistryUniqueKey kRegKey{ 0xA194E2645C57F6DDull };
-    nameIdx_ = lua_absindex(L, nameIdx_);
-    luaL_checktype(L, nameIdx_, LUA_TSTRING);                                                      // L: ... "name" ...
+    int const _nameIdx{ lua_absindex(L, nameIdx_) };
+    luaL_checktype(L, _nameIdx, LUA_TSTRING);                                                      // L: ... "name" ...
     STACK_CHECK_START_REL(L, 0);
     // store a hidden reference in the registry to make sure the string is kept around even if a lane decides to manually change the "decoda_name" global...
-    kRegKey.setValue(L, [nameIdx = nameIdx_](lua_State* L_) { lua_pushvalue(L_, nameIdx); });      // L: ... "name" ...
+    kLaneNameRegKey.setValue(L, [idx = _nameIdx](lua_State* L_) { lua_pushvalue(L_, idx); });      // L: ... "name" ...
     // keep a direct pointer on the string
-    debugName = lua_tostringview(L, nameIdx_);
-    // to see VM name in Decoda debugger Virtual Machine window
-    lua_pushvalue(L, nameIdx_);                                                                    // L: ... "name" ... "name"
-    lua_setglobal(L, "decoda_name");                                                               // L: ... "name" ...
+    debugName = lua_tostringview(L, _nameIdx);
+    if constexpr (HAVE_DECODA_NAME()) {
+        // to see VM name in Decoda debugger Virtual Machine window
+        lua_pushvalue(L, _nameIdx);                                                                // L: ... "name" ... "name"
+        lua_setglobal(L, "decoda_name");                                                           // L: ... "name" ...
+    }
     // and finally set the OS thread name
     THREAD_SETNAME(debugName.data());
     STACK_CHECK(L, 0);
diff --git a/src/lane.h b/src/lane.h
index 1fdd955..4dcb99e 100644
--- a/src/lane.h
+++ b/src/lane.h
@@ -13,6 +13,9 @@
 
 // #################################################################################################
 
+// xxh64 of string "kExtendedStackTraceRegKey" generated at https://www.pelock.com/products/hash-calculator
+static constexpr RegistryUniqueKey kExtendedStackTraceRegKey{ 0x38147AD48FB426E2ull }; // used as registry key
+
 /*
  * registry[FINALIZER_REG_KEY] is either nil (no finalizers) or a table
  * of functions that Lanes will call after the executing 'pcall' has ended.
@@ -24,15 +27,15 @@
 // xxh64 of string "kFinalizerRegKey" generated at https://www.pelock.com/products/hash-calculator
 static constexpr RegistryUniqueKey kFinalizerRegKey{ 0xFE936BFAA718FEEAull };
 
-// xxh64 of string "kExtendedStackTraceRegKey" generated at https://www.pelock.com/products/hash-calculator
-static constexpr RegistryUniqueKey kExtendedStackTraceRegKey{ 0x38147AD48FB426E2ull }; // used as registry key
-
 // xxh64 of string "kLaneGC" generated at https://www.pelock.com/products/hash-calculator
 static constexpr UniqueKey kLaneGC{ 0x5D6122141727F960ull };
 
 // xxh64 of string "kLanePointerRegKey" generated at https://www.pelock.com/products/hash-calculator
 static constexpr RegistryUniqueKey kLanePointerRegKey{ 0x2D8CF03FE9F0A51Aull }; // used as registry key
 
+    // xxh64 of string "debugName" generated at https://www.pelock.com/products/hash-calculator
+static constexpr RegistryUniqueKey kLaneNameRegKey{ 0xA194E2645C57F6DDull };
+
 // #################################################################################################
 
 // The chain is ended by '(Lane*)(-1)', not nullptr: 'selfdestructFirst -> ... -> ... -> (-1)'
@@ -124,7 +127,7 @@ class Lane
     Lane(Universe* U_, lua_State* L_, ErrorTraceLevel errorTraceLevel_);
     ~Lane();
 
-    void changeDebugName(int nameIdx_);
+    void changeDebugName(int const nameIdx_);
     void close() { lua_State* _L{ L }; L = nullptr; lua_close(_L); }
     [[nodiscard]] std::string_view errorTraceLevelString() const;
     [[nodiscard]] int pushErrorHandler() const;
diff --git a/src/lanes.cpp b/src/lanes.cpp
index 20636b2..0ea0900 100644
--- a/src/lanes.cpp
+++ b/src/lanes.cpp
@@ -676,6 +676,9 @@ LUAG_FUNC(configure)
         // increment refcount so that this linda remains alive as long as the universe exists.
         _U->timerLinda->refcount.fetch_add(1, std::memory_order_relaxed);
         lua_pop(L_, 1);                                                                            // L_: settings
+        // store a hidden reference in the registry to make sure the string is kept around even if a lane decides to manually change the "decoda_name" global...
+        kLaneNameRegKey.setValue(L_, [](lua_State* L_) { std::ignore = lua_pushstringview(L_, "main"); });
+
     }
     STACK_CHECK(L_, 1);
 
diff --git a/src/lanesconf.h b/src/lanesconf.h
index 3836848..2df7a71 100644
--- a/src/lanesconf.h
+++ b/src/lanesconf.h
@@ -42,3 +42,4 @@
 #endif // (defined PLATFORM_WIN32) || (defined PLATFORM_POCKETPC)
 
 #define USE_DEBUG_SPEW() 0
+#define HAVE_DECODA_NAME() 0
diff --git a/src/uniquekey.h b/src/uniquekey.h
index 9981bb8..cfc8ab0 100644
--- a/src/uniquekey.h
+++ b/src/uniquekey.h
@@ -62,9 +62,9 @@ class RegistryUniqueKey
     void setValue(lua_State* L_, OP operation_) const
     {
         // Note we can't check stack consistency because operation is not always a push (could be insert, replace, whatever)
-        pushKey(L_); // ... key
-        operation_(L_); // ... key value
-        lua_rawset(L_, LUA_REGISTRYINDEX); // ...
+        pushKey(L_);                                                                               // ... key
+        operation_(L_);                                                                            // ... key value
+        lua_rawset(L_, LUA_REGISTRYINDEX);                                                         // ...
     }
     // ---------------------------------------------------------------------------------------------
     template <typename T>
diff --git a/src/universe.cpp b/src/universe.cpp
index 9e1ac5f..5fe53d5 100644
--- a/src/universe.cpp
+++ b/src/universe.cpp
@@ -286,7 +286,11 @@ void Universe::initializeKeepers(lua_State* L_)
 
         // to see VM name in Decoda debugger
         lua_pushfstring(_K, "Keeper #%d", _i + 1);                                                 // L_: settings                                    K: "Keeper #n"
-        lua_setglobal(_K, "decoda_name");                                                          // L_: settings                                    K:
+        if constexpr (HAVE_DECODA_NAME()) {
+            lua_pushvalue(_K, -1);                                                                 //                                                 K: "Keeper #n" Keeper #n"
+            lua_setglobal(_K, "decoda_name");                                                      // L_: settings                                    K: "Keeper #n"
+        }
+        kLaneNameRegKey.setValue(_K, [](lua_State* L_) { lua_insert(L_, -2); });                   //                                                 K:
         // create the fifos table in the keeper state
         Keepers::CreateFifosTable(_K);
         STACK_CHECK(_K, 0);