aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorBenoit Germain <benoit.germain@ubisoft.com>2024-04-09 15:49:18 +0200
committerBenoit Germain <benoit.germain@ubisoft.com>2024-04-09 15:49:18 +0200
commit95932749a53f46ae5901798a17e1f0c4c33ac6b2 (patch)
tree327d85f6f634edfacc01dc587492d96f9200344d
parent98ff4191c2cd215c7d6a429e9ddd66f7a6a30316 (diff)
downloadlanes-95932749a53f46ae5901798a17e1f0c4c33ac6b2.tar.gz
lanes-95932749a53f46ae5901798a17e1f0c4c33ac6b2.tar.bz2
lanes-95932749a53f46ae5901798a17e1f0c4c33ac6b2.zip
C++ migration: use strong type safety for source and destination states in transfer functions
Diffstat (limited to '')
-rw-r--r--CHANGES744
-rw-r--r--lanes-4.0.0-0.rockspec (renamed from lanes-3.16.3-0.rockspec)4
-rw-r--r--src/cancel.cpp7
-rw-r--r--src/compat.cpp35
-rw-r--r--src/deep.cpp40
-rw-r--r--src/deep.h4
-rw-r--r--src/keeper.cpp16
-rw-r--r--src/keeper.h2
-rw-r--r--src/lanes.cpp20
-rw-r--r--src/lanes_private.h4
-rw-r--r--src/linda.cpp10
-rw-r--r--src/macros_and_utils.h18
-rw-r--r--src/state.cpp29
-rw-r--r--src/state.h3
-rw-r--r--src/threading.cpp12
-rw-r--r--src/threading.h1
-rw-r--r--src/tools.cpp85
-rw-r--r--src/tools.h14
-rw-r--r--src/universe.cpp8
19 files changed, 161 insertions, 895 deletions
diff --git a/CHANGES b/CHANGES
index d93f5b4..3725674 100644
--- a/CHANGES
+++ b/CHANGES
@@ -1,746 +1,6 @@
1CHANGES: 1CHANGES:
2 2
3CHANGE 159: BGe 19-Mar-24 3CHANGE 1: BGe 9-Apr-24
4 * fix small internal issue with when hitting timeout on thread kill during thread_cancel() in pthread implementation 4 * reset changelog, next entry will list API changes since last C-implementation.
5
6CHANGE 158: BGe 22-Feb-24
7 * naive luajit detection in PUC-Lua-based builds, and vice-versa to detect mismatches
8 * internal version bumped to 3.16.3
9
10CHANGE 157: Mitalie 17-Aug-23
11 * Prevent crash on linux as non-root
12 * internal version bumped to 3.16.2
13
14CHANGE 156: BGe 9-Aug-23
15 * new configuration option .internal_allocator to help LuaJIT users.
16 * internal version bumped to 3.16.1
17
18CHANGE 155: BGe 28-Jul-23
19 * tweaks to linux thread priority management: do nothing if not super-user. if super-user, do nothing if nothing is provided (instead of trying to force a prio when LINUX_SCHED_RR is defined).
20
21CHANGE 154: eligovision 1-Mar-22
22 * Fix 3-parametrized __lanesclone
23
24CHANGE 153: BGe 17-Feb-22
25 * NEVER use allocator obtained from lua_getallocf to allocate stuff manually when compiling for LuaJIT
26
27CHANGE 152: BGe 7-Feb-22
28 * bumped version to 3.16.0
29 * __lanesclone is now called only once with 3 parameters dest, source, size -> BREAKS CUSTOM DEEP USERDATA API
30
31CHANGE 151: BGe 7-Feb-22
32 * bumped version to 3.15.2
33 * Lanes no longer relies on malloc/free for internal allocations, but uses the primary alloc function from the master Lua state
34
35CHANGE 150: BGe 22-Sep-21
36 * fix require() wrapper to return all values returned by original require()
37
38CHANGE 149: BGe 8-Jul-21
39 * bumped version to 3.15.1
40 * fix function transfer with lua_dump for Lua 5.4 failing for functions big enough to necessitate a buffer reallocation
41
42CHANGE 148: BGe 23-Jun-21
43 * __lanesclone now receives the original as light userdata the first time it is called -> BREAKS CUSTOM DEEP USERDATA API
44
45CHANGE 147: BGe 16-Jun-21
46 * changed lanes.threads() output so that several lanes with the same name don't clobber each other in the result table -> BREAKS API
47 * bumped version to 3.15 because of the API change
48
49CHANGE 146: BGe 26-Apr-19
50 * lane:cancel() rework (see doc).
51 * opt.cancelstep is gone, hook is installed by lane:cancel() if requested
52
53CHANGE 145: BGe 28-Nov-18
54 * more code refacto
55 * don't test __lanesignore for POD types (-> slightly faster when trasnfering lots of data)
56
57CHANGE 144: BGe 28-Nov-18
58 * some code refacto
59
60CHANGE 143: BGe 27-Nov-18
61 * Lua 5.4 support
62 * __lanesclone and lanes.nameof support userdata uservalue(s)
63
64CHANGE 142: BGe 26-Nov-18
65 * Version is available in public header
66
67CHANGE 141: BGe 25-Nov-18
68 * protect_allocator configure option is gone, long live allocator (more embedders-friendly)
69
70CHANGE 140: BGe 22-Nov-18
71 * Raise an error instead of crashing when attempting to transfer a non-deep full userdata
72
73CHANGE 139: BGe 21-Nov-18
74 * more DEBUGSPEW
75
76CHANGE 138: BGe 19-Nov-18
77 * Registry access code utility macros
78 * CONFIG_REGKEY and LOOKUP_REGKEY are now lightuserdata instead of strings
79 * Stack checking debug macros improvements
80
81CHANGE 137: BGe 15-Nov-18
82 * Deep userdata must embed DeepPrelude to save an allocation (also changes Deep protocol)
83
84CHANGE 136: BGe 15-Nov-18
85 * split linda code in a separate file
86 * rockspec for version v3.13.0
87
88CHANGE 135: BGe 11-Nov-18
89 * fix a bunch of compilation warnings
90
91CHANGE 134: BGe 3-Dec-13
92 * new API lanes.set_thread_affinity()
93 * set_debug_threadname implemented with win32 pthread
94
95CHANGE 133: BGe 8-Nov-18
96 * Make sure any linda operation that can raise an error won't ever leave a mutex unreleased
97 * lane:join() now returns nil, "timeout" in case of timeout
98
99CHANGE 132: BGe 7-Nov-18
100 * __lanesclone mechanism should actually work now
101
102CHANGE 131: BGe 7-Nov-18
103 * Fix potential crash at application shutdown when deep userdata were created before Lanes is required
104
105CHANGE 130: BGe 2-Nov-18
106 * always duplicate the config structure in new lanes even when no libraries are initialized by the generator
107 (fixes an internal error trying to call on_state_create in a lane without any libs loaded)
108
109CHANGE 129: BGe 2-Nov-18
110 * Bumped version to 3.13
111 * fix error when autodetecting protect_allocator when running under LuaJIT
112
113CHANGE 128: BGe 31-Oct-18
114 * Better default value autodetection for protect_allocator setting
115
116CHANGE 127: BGe 30-Oct-18
117 * restrict internal light userdata constants to 47 significant bits when building against LuaJIT-x64
118
119CHANGE 126: Bge 29-Oct-18
120 * Add deep user data cloning support
121
122CHANGE 125: BGe 25-Oct-18
123 * Fix Lanes build by reorganizing types around a bit
124
125CHANGE 124: BGe 9-Jul-18
126 * Fix a stack overflow when copying large tables with verbose_errors option enabled
127 * Support for integer formatting in verbose errors
128
129CHANGE 123: BGe 2-Aug-17
130 * added support for user-provided __gc in deep userdata
131 * more complete deep userdata sample
132
133CHANGE 122: BGe 1-Aug-17
134 * fix crash trying to use a deep-aware module while not requiring Lanes
135 * bumped version to 3.12
136
137CHANGE 121: BGe 13-Jun-17
138 * no longer internally assert when an error message is not a string
139
140CHANGE 120: BGe 5-Jun-17
141 * new API function lanes.register( "name", module) to manually register a module table after it was required
142 * Transfering registered module tables will link the equivalent in the destination state instead of cloning it
143 * bumped version to 3.11
144
145CHANGE 119: BGe 10-May-17
146 * Fixed some compilation warnings
147 * Improved LuaJIT support
148
149CHANGE 118: trukanduk 21-Nov-16
150 * bumped version to 3.10.1
151 * objects with a metatable that contains __lanesignore are skipped during data transfers
152
153CHANGE 117: mpeterv 21-Nov-16
154 * Fix an implicit number-to-string conversion
155
156CHANGE 116: BGe, mpeterv 27-Apr-15
157 * bumped version to 3.10.0
158 * segfault fixed in LG_lane_new
159 * Lua 5.3 support
160
161CHANGE 115: BGe 18-Sep-14
162 * bumped version to 3.9.7
163 * new function lanes.sleep()
164
165CHANGE 114: BGe 8-Jul-14
166 * Postponed _G scan for function lookup database to after on_state_create invocation
167 * Fixed a crash when USE_DEBUG_SPEW == 1
168
169CHANGE 113: BGe 17-Jun-14
170 * bumped version to 3.9.6
171 * separate deep userdata code in a dedicated file to allow external modules to implement Lanes-compatible deep userdata without requiring a binary dependency against the Lanes module
172 because of this linda_id function(eDO_metatable) must push 2 values on the stack: a metatable and a deep version string obtained from luaG_pushdeepversion()
173
174CHANGE 112 BGe 16-May-14
175 * bumped version to 3.9.5
176 * fix linda.__towatch to return non-nil when the linda is empty
177 * lanes.gen() error reporting improvements
178
179CHANGE 111 BGe 24-Apr-14
180 * fixed linda:send() possibly returning an undefined value
181
182CHANGE 110 Stepets 20-Apr-14
183 * fix LuaJIT detection issues
184
185CHANGE 109 BGe 03-Apr-14
186 * moved some Lua-version compatibility code in separate source files
187
188CHANGE 108: BGe 20-Mar-14
189 * bumped version to 3.9.4
190 * set_finalizer throws an error if provided finalizer isn't a function
191 * fix error handling when the error doesn't generate an error handler call (IOW, all errors but LUA_ERRRUN)
192 * provide callstack if LUA_ERRRUN occurs inside a finalizer
193
194CHANGE 107: BGe 19-Mar-14
195 * Make sure we don't mutex-wrap require() more than once, just in case
196
197CHANGE 106: BGe 17-Mar-14
198 * Fixed crash when using protect_allocator option
199
200CHANGE 105: BGe 27-Feb-14
201 * Bumped version to 3.9.3
202 * new exposed variable linda.null that exposes the internal NIL_SENTINEL marker
203 * linda:send() interprets send key linda.null as authorization to silently send a single nil when not provided with anything to send
204 (useful when sending results of a function that can return nothing)
205
206CHANGE 104: BGe 25-Feb-14
207 * Bumped version to 3.9.2
208 * Internal rework: the whole Lanes engine now works "per universe" to allow concurrent Lanes execution in more than one embedded master state
209 * this universe is a full userdata created in the master state, selfdestruct_gc is the __gc for this userdata
210 * most of what was initialized only once is now per-universe
211 * Fixed potential crashes at desinit if problems occur during keeper states initialisation
212 * Fixed require() not always serialized properly
213 * Raise an error instead of crashing on deep userdata prelude memory allocation failure
214 * Added forgotten mutex desinitialisation at universe shutdown
215
216CHANGE 103: BGe 24-Feb-14
217 * Fix lookup database table not being created when it should if Lanes is required in more than one Lua master state
218
219CHANGE 102: BGe 18-Feb-14
220 * raise an error instead of dereferencing a NULL pointer on deep userdata creation and lane struct creation
221
222CHANGE 101: BGe 18-Feb-14
223 * version 3.9.1
224 * removed some keeper desinit legacy dead code
225 * keeper array is allocated with master state's alloc function instead of malloc()/free()
226 * prevent application crash when specifying a very large number of keepers in the configuration options
227 * any error occuring during one-time inits is raised outside the one-time mutex protected code region
228
229CHANGE 100: BGe 17-Feb-14
230 * lanes.linda() accepts an optional integer group to give control on keeper state repartition
231
232CHANGE 99: BGe 17-Feb-14
233 * version 3.9.0
234 * keepers now require "package", receive package.path & package.cpath, and call on_state_create() if it is a C function
235 * changed the deep public API (improved deep idfunc signature, renamed luaG_deep_userdata to luaG_newdeepuserdata)
236 * if an error occurs while copying a deep userdata, don't raise inside the keeper state
237 * fixed situations where raised errors could lead to memory leaks (deep gc)
238
239CHANGE 98: BGe 13-Feb-14
240 * version 3.8.5
241 * linda:limit() returns lanes.cancel_error on a limited linda
242 * lanes.genlock() and lanes.genatomic() support cancelled lindas by returning lanes.cancel_error whenever appropriate
243 * fixed a possible Lua stack overflow when calling linda:dump()
244 * fixed cases where linda:send() and linda:receive() would not return lanes.cancel_error when they should
245
246CHANGE 97: BGe 10-Feb-14
247 * version 3.8.4
248 * new API linda:cancel("read"|"write"|"both"|"none")
249 * all linda operations return lanes.cancel_error on a cancelled linda
250 * raised an internal string length so that longer linda names are fully output before truncation applies when doing tostring( linda)
251
252CHANGE 96: BGe 24-Jan-14
253 * another Lua stack overflow fix when sending complex function through lindas or as lane body
254
255CHANGE 95: BGe 22-Jan-14
256 * version 3.8.3
257 * fixed a possible Lua stack overflow when sending complex function through lindas or as lane body
258 * experimental: lanes.nameof() scans the registry if a regular search didn't yield anything interesting
259 * fixed lanes.nameof() misbehaving when encountering a LUA_TTHREAD object
260
261CHANGE 94: BGe 22-Jan-14
262 * version 3.8.2
263 * new lane launcher option gc_cb to set a callback that is invoked when a lane is garbage collected
264 * Fix more invalid memory accesses when fetching the name of a joined lane with lanes:threads() (because its lua_State is closed)
265
266CHANGE 93: BGe 20-Jan-14
267 * slightly improve linda performance when the producer/consumer scenario leaves leave the key empty
268
269CHANGE 92: BGe 20-Jan-14
270 * version 3.8.1
271 * new function lane:get_debug_threadname()
272 * Fix invalid memory accesses when fetching the name of a joined lane with lanes:threads() (because its lua_State is closed)
273 * use luaL_newmetatable() to create the metatable for lane objects
274 * prevent malicious code from crashing by calling lane methods without passing the lane as first argument (raise an error instead)
275 * set_debug_threadname() is no longer registered in the function lookup databases because it holds a C pointer as upvalue and it might crash if used maliciously
276
277CHANGE 91: BGe 20-Jan-14
278 * version 3.8.0
279 * linda:set() accepts multiple values to set in the specified slot
280 * linda:get() accepts an optional count to peek several values at once
281
282CHANGE 90: BGe 16-Jan-14
283 * version 3.7.8
284 * lane:cancel() now accepts a boolean second argument when soft cancelling (negative timeout) to wake the thread if necessary
285 * if a blocked linda send() or receive() call is interrupted by a cancellation request,
286 it returns CANCEL_ERROR so that this case can be differentiated from a simple timeout
287 * fixed WIN32 THREAD_CREATE() wrong _beginthreadex() error detection
288 * fatal WIN32 threading errors retrieve and output the error description string with FormatMessage()
289 * fixed missing lanes.set_singlethreaded
290 * fixed perftest.lua
291 * added test/cancel.lua
292
293CHANGE 89: BGe 09-Jan-14
294 * version 3.7.7
295 * fix crash when calling linda:count() on unknown keys
296 * purge key storage with linda:set( key, nil) on an unlimited key to reduce memory usage with lots of keys
297 * linda:limit() wakes write-blocked threads if necessary when the new limit enables writes to occur again
298 * linda:set() wakes write-blocked threads if necessary if the operation created some room to write into
299
300CHANGE 88: BGe 06-Jan-14
301 * version 3.7.6
302 * if config.on_state_create() is a C function, call it by direct C closure reconstruction in newly created states
303
304CHANGE 87: BGe 20-Dec-13
305 * version 3.7.5
306 * fixed a crash that can occur at shutdown when an object stored inside a keeper state performs a linda operation on a linda making use of another keeper
307 * new setting demote_full_userdata to select between light userdata demotion or raising an error when attempting to transfer a non-deep full userdata
308
309CHANGE 86: BGe 3-Dec-13
310 * version 3.7.4
311 * internal refactoring of pthread priority management code
312 * new API lanes.set_thread_priority()
313
314CHANGE 85: BGe 28-Nov-13
315 * version 3.7.3
316 * set pthread thread cancel type to PTHREAD_CANCEL_ASYNCHRONOUS
317 * lane_h:cancel() accepts a 3rd timeout argument used when waiting for actual thread termination (hitting the timeout raises an error)
318 * added PROPAGATE_ALLOCF macro to select state creation mode (lua_newstate or luaL_newstate)
319
320CHANGE 84: BGe 18-Nov-13
321 * Fix a deadlock when GCing during a linda operation.
322 * Fix a compilation warning about an unused variable
323 * Get rid of uintptr_t to remove dependency on stdint.h
324 * Fix internal error at lane creation when the generator doesn't open any base library
325
326CHANGE 83: BGe 16-Nov-13
327 * version 3.7.2
328 * Fixed function returned by lanes.genlock() not handling numeric keys properly when release lock
329 * Enable lanes.genlock() to attempt lock with an optional "try" mode
330 * make EnableCrashingOnCrashes a one-time operation
331
332CHANGE 82: BGe 13-Nov-13
333 * Fix a case where an error could be raised inside a keeper state
334
335CHANGE 81: BGe 07-Nov-13
336 * Make set_finalizer(), set_debug_threadname(), cancel_test() and set_error_reporting() transferable from lane to lane
337 * Improved some DEBUGSPEW output
338
339CHANGE 80: BGe 06-Nov-13
340 * Fix a few compilation warnings about uninitialized variables
341 * Fixed a bad extern variable declaration resulting in multiple instances (crashes the Pelles-C build)
342
343CHANGE 79: BGe 04-Nov-13
344 * Fix lanes.nameof() crashing when encountering a light userdata
345
346CHANGE 78: BGe 25-Oct-13
347 * Fix windows build not exporting public 'deep' API
348 * Don't call on_state_create in keeper states, as it is no longer necessary
349 * Remove inclusion of stdint.h
350 * Fix windows build for WINVER > 0x400
351
352CHANGE 77: BGe 22-Oct-13
353 * version 3.7.1
354 * errors inside finalizers generate a full stack just like any other error
355
356CHANGE 76: BGe 10-Oct-13
357 * version 3.7.0
358 * fix lanes.threads() not being available in a lane where lanes.configure() settings didn't contain track_lanes although the initial configure() call did.
359
360CHANGE 75: BGe 7-Oct-13
361 * require "lanes".configure() sequence is only necessary at the first require "lanes".
362
363CHANGE 74: BGe 7-Oct-13
364 * fix a crash at application shutdown where in some situations we could deinitialize the protected allocator mutex while a lane was still using it.
365
366CHANGE 73: BGe 4-Oct-13
367 * fix timers broken by change 69
368
369CHANGE 72: BGe 3-Oct-13
370 * bugfix: no longer create a global named "lanes.core" inside lanes having "*" as library list
371
372CHANGE 71: BGe 30-Sept-13
373 * version 3.6.6
374 * properly handle cases when a Lua C module is a C function
375
376CHANGE 70: BGe 27-Step-13
377 * no longer call core.configure with dummy params when requiring lanes more than once (fixes potential multithreading issues with LuaJIT allocator)
378 * activated EnableCrashingOnCrashes() is active on Win32 debug builds
379 * fixed some comments in code
380
381CHANGE 69: BGe 26-Sept-13
382 * version 3.6.5
383 * Reduce memory footprint, simplify module order setup in conjuction with Lanes, and send over native functions a bit faster as well
384 * Lanes no longer has to internally require modules inside the keeper states because they no longer need a lookup database
385 the lookup name is stored as-is and actually converted in the destination state
386 * optimisation: bypass cache when sending native functions over
387 * removed all the KEEPER_MODEL_LUA code, as it can no longer work anyway
388
389CHANGE 68: BGe 24-Sept-13
390 * version 3.6.4
391 * Fix possible application hang at shutdown if a keeper state referenced a linda.
392
393CHANGE 67: BGe 2-Aug-13
394 * version 3.6.3
395 * lane:cancel(<negative-timeout>) only causes cancel_test() to return true but won't interrupt execution of the lane during linda operations
396
397CHANGE 66: BGe 31-Jul-13
398 * more explicit errors when trying to transfer unknown source functions (with new configure option verbose_errors)
399
400CHANGE 65: BGe 23-Jul-13
401 * default options wrap allocator around a mutex when run by LuaJIT
402
403CHANGE 64: BGe 20-Jul-13
404 * WIN32 builds against pre-Vista versions no longer use PulseEvent to fix occasional hangs when a wake event is missed
405
406CHANGE 63: BGe 20-May-13
407 * version 3.6.2
408 * WIN32 builds use condition variables instead of PulseEvent() when available.
409 * first steps toward fixing make-vc.cmd
410
411CHANGE 62: BGe 05-Apr-13
412 * version 3.6.1
413 * function lookup database population keeps the 'smaller' name in case of multiple hits, to remove the no-LUA_COMPAT_ALL restriction on Lua5.2 builds
414
415CHANGE 61: BGe 14-Mar-13
416 * version 3.6.0
417 * protect_allocator is an API change -> version bump
418 * bugfix: allocator protection should be done once per primary Lua state, not once only the first time ever Lanes is required
419
420CHANGE 60: BGe 13-Mar-13
421 * version 3.5.2
422 * stricter validation of with_timers config option: validator was accepting any non-boolean value
423 * new configuration option protect_allocator for VMs with thread unsafe allocators (such as LuaJIT)
424 * removed some obsolete bits of dead code
425
426CHANGE 59: BGe 12-Feb-13
427 * version 3.5.1
428 * new lanes.h header and API call luaopen_lanes_embedded() for embedders
429 * "lanes.core" is an acceptable library in the generator libs argument
430 * library "*" wildcard also opens lanes.core
431 * tweaked code for Xbox 360 build
432
433CHANGE 58: BGe 30-Jan-13
434 * version 3.5.0
435 * new: API lanes.require(), use it instead of regular require() for modules that export C functions you need to send over.
436 * new: lanes no longer require 'lanes.core' by default in every created state. Use {required={"lanes.core"}} if you need to transfer lanes functions.
437 * internal: because of the above, reworked the timer implementation to remove upvalue-dependency on lanes.core
438 * new: API lanes.timer_lane, to be able to operate on timer lane if need be
439 * improved: if a module is a full userdata, scan its metatable for function database population
440 * improved: on_state_create can be a Lua function
441 * changed: on_state_create is called after the base libraries are loaded
442 * package[loaders|searchers] is no longer transfered as function naming depends on slot order
443 * internal: changed separator from '.' to '/' in lookup databases to be able to distinguish search levels and dot coming from module names
444 * added some mode debug spew
445 * updated tests to reflect the above changes
446
447CHANGE 57: BGe 28-Jan-13
448 * More detailed DEBUG_SPEW logs
449 * A bit of code cosmetics
450
451CHANGE 56: BGe 25-Jan-13
452 * version 3.4.4
453 * bugfix: take into account the fact that "coroutine" is no longer part of base library in Lua 5.2
454 * bugfix: if "bit32" was listed in the libraries, it wouldn't open (library list parsing failing on digits)
455 * bugfix: Use luaL_requiref() to open standard libraries in Lua 5.2 as we should
456 * bugfix: any Lua state created by Lanes reuses the allocator function of the originating state
457 * bugfix: don't call on_state_create() while GC is suspended during lua state initialization
458
459CHANGE 55: BGe 24-Jan-13
460 * version 3.4.3
461 * raise an error if lane generator libs specification contains a lib more than once
462 * bit32 is a valid lib name in the libs specification (silently ignored by the Lua 5.1 build)
463 * improved lanes.nameof to search inside table- and userdata- metatables for an object's name
464 * bugfix: fixed an unwarranted error when trying to discover a function name upon a failed transfer
465 * contents of package.[path,cpath,preload,loaders|searchers] are pulled *only once* inside keeper states at initialisation
466 * Lua function upvalues equal to the global environment aren't copied by value, but bound to the destination's global environment
467 especially useful for Lua 5.2 _ENV
468 * bugfix: fixed loading of base libraries that didn't create the global tables when built for Lua 5.2
469
470CHANGE 54: BGe 10-Jan-13
471 * version 3.4.2
472 * Don't pull "package" settings in the timer lane
473 * removed a limitation preventing Lua functions with indirect recursive upvalue references from being transferable
474
475CHANGE 53: BGe 11-Dec-2012
476 * version 3.4.1
477 * new function lanes.timers(), returns a list of all active timers.
478
479CHANGE 52: BGe 03-Dec-2012
480 * linda:send() and linda:receive() no longer triggers string->number autocoercion when checking for the optional timeout argument:
481 a string is always a linda slot, even if coercible.
482
483CHANGE 51: BGe 27-Nov-2012
484 * linux flavors with older glibc use prctl instead of pthread_setname_np
485 * selfdestruct chain handling is now the same on all platforms
486
487CHANGE 50: BGe 22-Nov-2012
488 * bugfix: linda:set() no longer clears the storage limit
489
490CHANGE 49: BGe 21-Nov-2012
491 * fix application shutdown crash by not registering anything with atexit()
492 * rockspec for version v3.4.0
493
494CHANGE 48: BGe 25-Sep-2012
495 * version 3.4.0
496 * new method linda:dump() that outputs the full contents of a linda as a table, also linked to __towatch for Decoda support
497 * linda:receive() API change!
498 * instead of [val, key], linda:receive( timeout, key) returns [key, val]
499 * instead of [val, [...]], linda:receive( timeout, linda.batched key) returns [key, val[, ...]]
500 this is to unify the return values of regular and batched mode, and to be able to tell when batched mode is interrupted by a lane cancellation
501 * fixed Lua 5.2 build to take into account the "loaders"->"searchers" name change in 'package' module.
502 * a bit of html cleanup and added some infos in the documentation regarding the Lanes internals
503
504CHANGE 47: BGe 13-Sep-2012
505 * implemented set_debug_threadname() for pthread builds where possible
506 * refactored linda __tostring and __concat
507
508CHANGE 46: BGe 10-Sep-2012
509 * version 3.3.0
510 * lane.status can return "killed" if lane was forcefully killed with lanes:cancel()
511 * lane:join(): return nil, "killed" if called on a killed lane.
512 * lane[<n>]: produces [1] = nil, [2] = "killed" if the lane was killed
513 * lane:join(): fixed an assertion in debug builds when joining a lane forcefully cancelled with lane:cancel( <x>, true).
514 * indexing a lane with a string other than "join", "cancel" or "status" raises an error.
515 * fixed configure() to correctly apply defaults when they are missing from the provided settings
516 * added a shutdown_timeout to control the duration Lanes will wait for graceful termination of running lanes at application shutdown. Default is 0.25.
517
518CHANGE 45: BGe 21-Aug-2012
519 * keeper internals implemented in C instead of Lua for better performances
520 * fixed arguments checks in linda:limit() and linda:set()
521
522CHANGE 44: BGe 13-Aug-2012
523 * lanes code updated to build against Lua 5.1 and Lua 5.2
524 * removed the search for MSVCR80.DLL when building for MinGW32 since it no longer seems to be necessary
525
526CHANGE 43: BGe 09-Aug-2012
527 * fix possible crash at application shutdown when a race condition causes linda objects to be collected after the keeper states are cleaned up.
528
529CHANGE 42: BGe 06-Aug-2012
530 * lanes.linda() accepts an optional name for debug purposes
531
532CHANGE 41: BGe 07-Jul-2012
533 * lua51-lanes renamed lanes/core
534 * keeper state microcode is no longer embedded inside lanes.core, but located and loaded with package.loaders[2]
535 * changed rockspec build type from "make" to "builtin"
536
537CHANGE 40: BGe 26-Jun-2012
538 * when a transfered function is not found in source, guess its name to help the user find out what's wrong
539 * new function lanes.nameof()
540
541CHANGE 39: BGe 23-Jun-2012
542 * lanes.timer() accepts a first_secs=nil to stop a timer
543 * timer lane catches errors and prints them
544 * fixed some typos in manual
545
546CHANGE 38: BGe 11-Jun-2012
547 * linda:receive() batched mode now accepts a max_count optional argument
548
549CHANGE 37: BGe 4-Jun-2012 (fix and idea courtesy of sonoro1234)
550 * fixed thread_cancel() not working when called without argument
551 * new lane-global function set_error_reporting() to enable more data detailed data provided by lane_error()
552
553CHANGE 36 BGe 26-Apr-2012
554 * improved LuaJIT2 compatibility by handling "*" library set through luaL_openlibs()
555
556CHANGE 35 BGe 17-Feb-2012
557 * changed lanes.configure signature to receive a table instead of individual parameters
558 * added support for an on_state_create callback called to load custom functions in a state in addition to the base libraries
559
560CHANGE 34 BGe 14-Nov-2011
561 * removed packagepath and packagecpath options, replaced by a package table, whose fields path, cpath, loaders, preload are transfered
562 * code cleanup to facilitate transition between WIN32 and PTHREAD implementations
563 * tentative fix for desinit crashes when free running lanes are killed at process shutdown
564
565CHANGE 33 BGe 5-Nov-2011: Lanes version 3.0-beta
566 * process exit change: close everything at GC when main state closes, not when atexit() handlers are processed
567 * Lua 5.2-style module:
568 * module() is no longer used to implement lanes.lua
569 * a global "lanes" variable is no longer created when the module is required
570 * the Lanes module table is returned instead
571 * Lanes must be initialized before used:
572 * the first occurence of 'require "lanes"' produces a minimal interface that only contains a configure() function
573 * the remainder of the interface is made available once this function is called
574 * subsequent calls to configure() do nothing
575 * configure() controls the number of keeper states and the startup of timers
576 * LuaJIT 2 compatibility
577 * non-Lua functions are no longer copied by creating a C closure from a C pointer, but through 2-way lookup tables
578 * this means that if a lane function body pulls non-Lua functions, the lane generator description must contain the list of libraries and modules that exports them
579 * introduces a change in configuration .globals management: contents are copied *after* std libs are loaded
580 * new .required configuration entry to list modules that must be require()'ed before lane body is transferred
581 * lane:cancel() wakes up waiting lindas like what is done at lane shutdown
582
583CHANGE 32 BGe 14-May-2011
584 * raise an error when linda:send() has nothing to send
585
586CHANGE 31 BGe 17-Apr-2011
587 * linda uses a fast FIFO implementation to speed up data exchanges
588 * new linda:count() method
589 * new linda batched data read mode
590 * proper key type check in all linda methods
591 * fix setup-vc.cmd to support Visual Studio 2010 and Windows 7 64 bits
592 * bugfix: release keeper state mutex at desinit
593
594CHANGE 30 BGe 30-Mar-2011
595 * linda honors __tostring and __concat
596 * new accessor linda:keys(), to retrieve the list of keys with pending data inside a linda
597 * new lanes options packagepath and packagecpath, in case one needs to set them differently than the default
598
599CHANGE 29 BGe 1-Mar-2011
600 fixed potential crash at application shutdown when calling lua_close() on a killed thread's VM.
601 exposed cancel_test() in the lanes to enable manual testing for cancellation requests.
602 removed kludgy {globals={threadName}} support, replaced with a new function set_debug_threadname().
603
604CHANGE 28 BGe 18-Feb-2011
605 - moved keeper-related code in a separate source file
606 - keeper.lua is now embedded in text form instead of bytecode to improve LuaJIT2-compatibility
607
608CHANGE 27 BGe 17-Feb-2011
609 - we know Lanes is loaded in the master state, so we don't force it
610 to be required in every lane too when a linda deep userdata is copied
611 - Refactor lane proxy implementation: it is now a full userdata instead
612 of a table, and its methods are implemented in C instead of Lua
613 * its metatable is no longer accessible
614 * writing to the proxy raises an error
615 * it is no longer possible to overwrite its join() and cancel() methods
616 - when a deep userdata idfunc requests a module to be required, manually
617 check that it is not loaded before requiring it instead of relying on
618 the require function's loop detection feature
619 - when a module must be required, raise an error if the 'require' function
620 is not found in the target state
621
622CHANGE 26 BGe 14-Feb-2011:
623 Fixed application hang-up because keeper state was not released in case of errors thrown by
624 inter-state data copy for unsupported types
625
626CHANGE 25 BGe 12-Feb-2011:
627 Changed idfunc signature and contract to clarify that fact it is not lua-callable
628 and to be able to require the module it was exported from in the target lanes
629
630CHANGE 24 DPtr 25-Jan-2011:
631 Changed lanes.c to export functions as a module rather than writing them directly to the globals table.
632
633CHANGE 23 DPtr 23-Jan-2011:
634 Fixed bug where reference to Linda object was dropped for a short time ( crashing if GC was run during that time ).
635 Changed the atexit code to trip the timer thread's write signal.
636
637CHANGE 22 DPtr 19-Jan-2011:
638 Changed luaG_push_proxy to cache deep userdata proxies.
639
640CHANGE 21 (bugfixes) BGe 3-Jan-2011:
641 Several fixes by Martin Krpan:
642 - linda_send was waiting on the wrong signal
643 - buildfix when using i586-mingw32msvc-gcc cross compiler
644 - lanes_h:cancel() returns a boolean as it should
645 - timers could get blocked sometimes because they were initialized with negative values
646 - prepare_timeout could generate an illegal setting
647
648CHANGE 20 BGe 3-Dec-2010:
649 Enable to specify a string as lane code instead of a function so that we dont use lua_dump, which
650 isn't supported by LuaJIT.
651
652CHANGE 19 BGe 2-Dec-2010:
653 No longer rely on global function 'tostring' to generate unique identifiers when caching data being transfered through la linda. Should fix a compatilibity issue with LuaJIT2.
654
655CHANGE 18 BGe 6-Oct-2010:
656 Fixed 'memory leak' in some situations where a free running lane is collected before application shutdown
657 A bit of code cleanup
658
659CHANGE 17 BGe 21-Sept-2010:
660 Fixed stupid compilation errors.
661
662CHANGE 16 PLM 24-Aug-2010:
663 Releasing memory at gc / atexit.
664 Finalizers actually get error strings.
665 Fixed missing argument propagation in lane:cancel
666 Added variable threadName sent trough globals-table. Set in s_lane, and in debuggers on windows.
667 Added argument checking for linda-objects, where missing them caused crashes.
668
669CHANGE 15 (minor) BGe 27-Jul-2010:
670 Version bump for a true upgrade release (2.0.4 package was only a renamed 2.0.3)
671
672CHANGE 14 (bug fix) BGe 09-Jul-2010:
673 Fixed lane status to be correctly returned as "waiting" when it should.
674
675CHANGE 13 (fix for multithreaded host apps) AKa 24-Jun-2009:
676 <borisusun-at-gmail> mentioned Lanes expects the host application to be singlethreaded,
677 and there are troubles if Lanes is used from multiple threads, opened by the host
678 (before requiring Lanes). This is true, and fix should now be in place.
679
680CHANGE 12 (bug fix on Windows, 2.0.3) AKa 25-Jan-2009:
681 Did CHANGE 9 the way it should be done.
682
683CHANGE 11 (new feature, 2.0.3) AKa 23-Jan-2009:
684 Finalizers ('set_finalizer()') for being able to do cleanup of a lane's
685 resources, whether it returned succesfully or via an error.
686
687CHANGE 10 (new feature, 2.0.3) AKa 23-Jan-2009:
688 Call stack showing where an error occurred is not merged with the error
689 message, but delivered as a separate stack table ({ "filename:line" [, ...] }).
690 Getting call stacks of errorred lanes is now possible.
691
692CHANGE 9 (bug fix on Windows) AKa 10-Dec-2008 (> 2.0.2):
693 Applied patch from Kriss Daniels to avoid issues on 'now_time()' in Win32
694 (http://luaforge.net/forum/forum.php?thread_id=22704&forum_id=1781).
695
696CHANGE 8 (bug fix) AKa 26-Oct-2008:
697 Avoids occasional segfault at process exit (on multicore CPUs). Does this
698 by keeping track of "free running" threads (s.a. the time thread) and
699 cancelling them at process exit.
700
701 Tested (2.0.2) on Linux 64,x86, OS X, WinXP.
702
703CHANGE 7 (bug fix) AKa 15-Oct-2008:
704 Recursive functions that use themselves as direct upvalue can now be
705 passed to other lanes, and used as a lane function.
706
707CHANGE 6 (bug fix) AKa 15-Oct-2008:
708 Added local caches of the following to src/lanes.lua (was otherwise getting
709 errors at least in 'tests/irayo_recursive.lua').
710
711 local assert= assert
712 local string_gmatch= assert( string.gmatch )
713 local select= assert( select )
714 local type= assert( type )
715 local pairs= assert( pairs )
716 local tostring= assert( tostring )
717 local error= assert( error )
718 local setmetatable= assert( setmetatable )
719 local rawget= assert( rawget )
720
721 Thanks to Irayo for detecting and reporting this.
722
723CHANGE 5 (new feature):
724 Modifying Makefile so it's better suited to LuaRocks.
725
726CHANGE 4 (new feature):
727 Metatable copying, allowing Lua objects to be copied across lanes.
728
729CHANGE 3 (bug fix) AKa 5-Aug-2008:
730 The '__gc' method was not tied to thread userdata, at all. Caused memory
731 lifespan problems at least on OS X when threads were cancelled (EINVAL).
732
733CHANGE 2 (bug fix) AKa 5-Aug-2008:
734 Better calculation of timeouts, always making them absolute (even in Win32)
735 to allow for events that wake the lane up but don't read/write the Linda
736 key that it was observing.
737
738CHANGE 1 (bug fix) AKa 4-Aug-2008:
739 Signalling woke up only one waiting thread, not all. This caused i.e.
740 receive to not wake up if there was another thread waiting on the same
741 Linda object.
742
743 PThread fix: using 'pthread_cond_broadcast()' instead of 'pthread_cond_signal()'
744 Win32 fix: using manual events and 'PulseEvent()'
745 5
746(end) 6(end)
diff --git a/lanes-3.16.3-0.rockspec b/lanes-4.0.0-0.rockspec
index 106a2d9..4e1b370 100644
--- a/lanes-3.16.3-0.rockspec
+++ b/lanes-4.0.0-0.rockspec
@@ -7,11 +7,11 @@
7 7
8package = "Lanes" 8package = "Lanes"
9 9
10version = "3.16.3-0" 10version = "4.0.0-0"
11 11
12source= { 12source= {
13 url= "git+https://github.com/LuaLanes/lanes.git", 13 url= "git+https://github.com/LuaLanes/lanes.git",
14 branch= "v3.16.3" 14 branch= "v4.0.0"
15} 15}
16 16
17description = { 17description = {
diff --git a/src/cancel.cpp b/src/cancel.cpp
index 437a6f0..e08e975 100644
--- a/src/cancel.cpp
+++ b/src/cancel.cpp
@@ -1,6 +1,6 @@
1/* 1/*
2-- 2--
3-- CANCEL.C 3-- CANCEL.CPP
4-- 4--
5-- Lane cancellation support 5-- Lane cancellation support
6-- 6--
@@ -9,7 +9,7 @@
9--[[ 9--[[
10=============================================================================== 10===============================================================================
11 11
12Copyright (C) 2011-2019 Benoit Germain <bnt.germain@gmail.com> 12Copyright (C) 2011-2024 Benoit Germain <bnt.germain@gmail.com>
13 13
14Permission is hereby granted, free of charge, to any person obtaining a copy 14Permission is hereby granted, free of charge, to any person obtaining a copy
15of this software and associated documentation files (the "Software"), to deal 15of this software and associated documentation files (the "Software"), to deal
@@ -35,9 +35,6 @@ THE SOFTWARE.
35 35
36#include "cancel.h" 36#include "cancel.h"
37 37
38// #include <assert.h>
39//#include <string.h>
40
41#include "lanes_private.h" 38#include "lanes_private.h"
42#include "threading.h" 39#include "threading.h"
43#include "tools.h" 40#include "tools.h"
diff --git a/src/compat.cpp b/src/compat.cpp
index 47fe37e..8acab25 100644
--- a/src/compat.cpp
+++ b/src/compat.cpp
@@ -1,6 +1,6 @@
1/* 1/*
2 * ############################################################################################### 2 * ###############################################################################################
3 * ######################################### Lua 5.1/5.2 ######################################### 3 * ####################################### Lua 5.1/5.2/5.3 #######################################
4 * ############################################################################################### 4 * ###############################################################################################
5 */ 5 */
6#include "compat.h" 6#include "compat.h"
@@ -9,7 +9,12 @@
9/* 9/*
10** Copied from Lua 5.2 loadlib.c 10** Copied from Lua 5.2 loadlib.c
11*/ 11*/
12// ################################################################################################
13// ################################################################################################
12#if LUA_VERSION_NUM == 501 14#if LUA_VERSION_NUM == 501
15// ################################################################################################
16// ################################################################################################
17
13static int luaL_getsubtable (lua_State *L, int idx, const char *fname) 18static int luaL_getsubtable (lua_State *L, int idx, const char *fname)
14{ 19{
15 lua_getfield(L, idx, fname); 20 lua_getfield(L, idx, fname);
@@ -26,6 +31,8 @@ static int luaL_getsubtable (lua_State *L, int idx, const char *fname)
26 } 31 }
27} 32}
28 33
34// ################################################################################################
35
29void luaL_requiref (lua_State *L, const char *modname, lua_CFunction openf, int glb) 36void luaL_requiref (lua_State *L, const char *modname, lua_CFunction openf, int glb)
30{ 37{
31 lua_pushcfunction(L, openf); 38 lua_pushcfunction(L, openf);
@@ -43,24 +50,30 @@ void luaL_requiref (lua_State *L, const char *modname, lua_CFunction openf, int
43} 50}
44#endif // LUA_VERSION_NUM 51#endif // LUA_VERSION_NUM
45 52
53// ################################################################################################
54// ################################################################################################
46#if LUA_VERSION_NUM < 504 55#if LUA_VERSION_NUM < 504
56// ################################################################################################
57// ################################################################################################
47 58
48void* lua_newuserdatauv( lua_State* L, size_t sz, int nuvalue) 59void* lua_newuserdatauv( lua_State* L, size_t sz, int nuvalue)
49{ 60{
50 ASSERT_L( nuvalue <= 1); 61 ASSERT_L( nuvalue <= 1);
51 return lua_newuserdata( L, sz); 62 return lua_newuserdata(L, sz);
52} 63}
53 64
65// ################################################################################################
66
54// push on stack uservalue #n of full userdata at idx 67// push on stack uservalue #n of full userdata at idx
55int lua_getiuservalue(lua_State* L, int idx, int n) 68int lua_getiuservalue(lua_State* L, int idx, int n)
56{ 69{
57 // full userdata can have only 1 uservalue before 5.4 70 // full userdata can have only 1 uservalue before 5.4
58 if( n > 1) 71 if( n > 1)
59 { 72 {
60 lua_pushnil( L); 73 lua_pushnil(L);
61 return LUA_TNONE; 74 return LUA_TNONE;
62 } 75 }
63 lua_getuservalue( L, idx); 76 lua_getuservalue(L, idx);
64 77
65#if LUA_VERSION_NUM == 501 78#if LUA_VERSION_NUM == 501
66 /* default environment is not a nil (see lua_getfenv) */ 79 /* default environment is not a nil (see lua_getfenv) */
@@ -68,30 +81,32 @@ int lua_getiuservalue(lua_State* L, int idx, int n)
68 if (lua_rawequal(L, -2, -1) || lua_rawequal(L, -2, LUA_GLOBALSINDEX)) 81 if (lua_rawequal(L, -2, -1) || lua_rawequal(L, -2, LUA_GLOBALSINDEX))
69 { 82 {
70 lua_pop(L, 2); 83 lua_pop(L, 2);
71 lua_pushnil( L); 84 lua_pushnil(L);
72 85
73 return LUA_TNONE; 86 return LUA_TNONE;
74 } 87 }
75 lua_pop(L, 1); /* remove package */ 88 lua_pop(L, 1); /* remove package */
76#endif 89#endif
77 90
78 return lua_type( L, -1); 91 return lua_type(L, -1);
79} 92}
80 93
94// ################################################################################################
95
81// pop stack top, sets it a uservalue #n of full userdata at idx 96// pop stack top, sets it a uservalue #n of full userdata at idx
82int lua_setiuservalue( lua_State* L, int idx, int n) 97int lua_setiuservalue(lua_State* L, int idx, int n)
83{ 98{
84 if( n > 1 99 if( n > 1
85#if LUA_VERSION_NUM == 501 100#if LUA_VERSION_NUM == 501
86 || lua_type( L, -1) != LUA_TTABLE 101 || lua_type(L, -1) != LUA_TTABLE
87#endif 102#endif
88 ) 103 )
89 { 104 {
90 lua_pop( L, 1); 105 lua_pop(L, 1);
91 return 0; 106 return 0;
92 } 107 }
93 108
94 (void) lua_setuservalue( L, idx); 109 std::ignore = lua_setuservalue(L, idx);
95 return 1; // I guess anything non-0 is ok 110 return 1; // I guess anything non-0 is ok
96} 111}
97 112
diff --git a/src/deep.cpp b/src/deep.cpp
index ac2905e..55063b3 100644
--- a/src/deep.cpp
+++ b/src/deep.cpp
@@ -1,5 +1,5 @@
1/* 1/*
2 * DEEP.C Copyright (c) 2017, Benoit Germain 2 * DEEP.CPP Copyright (c) 2024, Benoit Germain
3 * 3 *
4 * Deep userdata support, separate in its own source file to help integration 4 * Deep userdata support, separate in its own source file to help integration
5 * without enforcing a Lanes dependency 5 * without enforcing a Lanes dependency
@@ -9,7 +9,7 @@
9=============================================================================== 9===============================================================================
10 10
11Copyright (C) 2002-10 Asko Kauppi <akauppi@gmail.com> 11Copyright (C) 2002-10 Asko Kauppi <akauppi@gmail.com>
12 2011-17 Benoit Germain <bnt.germain@gmail.com> 12 2011-24 Benoit Germain <bnt.germain@gmail.com>
13 13
14Permission is hereby granted, free of charge, to any person obtaining a copy 14Permission is hereby granted, free of charge, to any person obtaining a copy
15of this software and associated documentation files (the "Software"), to deal 15of this software and associated documentation files (the "Software"), to deal
@@ -41,13 +41,6 @@ THE SOFTWARE.
41 41
42#include <bit> 42#include <bit>
43#include <cassert> 43#include <cassert>
44#include <ctype.h>
45#include <stdio.h>
46#include <string.h>
47#include <stdlib.h>
48#if !defined(__APPLE__)
49#include <malloc.h>
50#endif
51 44
52/*-- Metatable copying --*/ 45/*-- Metatable copying --*/
53 46
@@ -73,7 +66,7 @@ static constexpr UniqueKey DEEP_PROXY_CACHE_KEY{ 0x05773d6fc26be106ull };
73* Sets up [-1]<->[-2] two-way lookups, and ensures the lookup table exists. 66* Sets up [-1]<->[-2] two-way lookups, and ensures the lookup table exists.
74* Pops the both values off the stack. 67* Pops the both values off the stack.
75*/ 68*/
76static void set_deep_lookup( lua_State* L) 69static void set_deep_lookup(lua_State* L)
77{ 70{
78 STACK_GROW( L, 3); 71 STACK_GROW( L, 3);
79 STACK_CHECK_START_REL(L, 2); // a b 72 STACK_CHECK_START_REL(L, 2); // a b
@@ -88,11 +81,13 @@ static void set_deep_lookup( lua_State* L)
88 STACK_CHECK( L, 0); 81 STACK_CHECK( L, 0);
89} 82}
90 83
84// ################################################################################################
85
91/* 86/*
92* Pops the key (metatable or idfunc) off the stack, and replaces with the 87* Pops the key (metatable or idfunc) off the stack, and replaces with the
93* deep lookup value (idfunc/metatable/nil). 88* deep lookup value (idfunc/metatable/nil).
94*/ 89*/
95static void get_deep_lookup( lua_State* L) 90static void get_deep_lookup(lua_State* L)
96{ 91{
97 STACK_GROW( L, 1); 92 STACK_GROW( L, 1);
98 STACK_CHECK_START_REL(L, 1); // a 93 STACK_CHECK_START_REL(L, 1); // a
@@ -106,11 +101,13 @@ static void get_deep_lookup( lua_State* L)
106 STACK_CHECK( L, 1); 101 STACK_CHECK( L, 1);
107} 102}
108 103
104// ################################################################################################
105
109/* 106/*
110* Return the registered ID function for 'index' (deep userdata proxy), 107* Return the registered ID function for 'index' (deep userdata proxy),
111* or nullptr if 'index' is not a deep userdata proxy. 108* or nullptr if 'index' is not a deep userdata proxy.
112*/ 109*/
113static inline luaG_IdFunction get_idfunc( lua_State* L, int index, LookupMode mode_) 110static inline luaG_IdFunction get_idfunc(lua_State* L, int index, LookupMode mode_)
114{ 111{
115 // when looking inside a keeper, we are 100% sure the object is a deep userdata 112 // when looking inside a keeper, we are 100% sure the object is a deep userdata
116 if (mode_ == LookupMode::FromKeeper) 113 if (mode_ == LookupMode::FromKeeper)
@@ -142,8 +139,9 @@ static inline luaG_IdFunction get_idfunc( lua_State* L, int index, LookupMode mo
142 } 139 }
143} 140}
144 141
142// ################################################################################################
145 143
146void free_deep_prelude( lua_State* L, DeepPrelude* prelude_) 144void free_deep_prelude(lua_State* L, DeepPrelude* prelude_)
147{ 145{
148 ASSERT_L(prelude_->idfunc); 146 ASSERT_L(prelude_->idfunc);
149 STACK_CHECK_START_REL(L, 0); 147 STACK_CHECK_START_REL(L, 0);
@@ -154,6 +152,7 @@ void free_deep_prelude( lua_State* L, DeepPrelude* prelude_)
154 STACK_CHECK(L, 0); 152 STACK_CHECK(L, 0);
155} 153}
156 154
155// ################################################################################################
157 156
158/* 157/*
159 * void= mt.__gc( proxy_ud ) 158 * void= mt.__gc( proxy_ud )
@@ -161,7 +160,7 @@ void free_deep_prelude( lua_State* L, DeepPrelude* prelude_)
161 * End of life for a proxy object; reduce the deep reference count and clean it up if reaches 0. 160 * End of life for a proxy object; reduce the deep reference count and clean it up if reaches 0.
162 * 161 *
163 */ 162 */
164static int deep_userdata_gc( lua_State* L) 163static int deep_userdata_gc(lua_State* L)
165{ 164{
166 DeepPrelude** const proxy{ lua_tofulluserdata<DeepPrelude*>(L, 1) }; 165 DeepPrelude** const proxy{ lua_tofulluserdata<DeepPrelude*>(L, 1) };
167 DeepPrelude* p = *proxy; 166 DeepPrelude* p = *proxy;
@@ -193,6 +192,7 @@ static int deep_userdata_gc( lua_State* L)
193 return 0; 192 return 0;
194} 193}
195 194
195// ################################################################################################
196 196
197/* 197/*
198 * Push a proxy userdata on the stack. 198 * Push a proxy userdata on the stack.
@@ -203,7 +203,7 @@ static int deep_userdata_gc( lua_State* L)
203 * used in this Lua state (metatable, registring it). Otherwise, increments the 203 * used in this Lua state (metatable, registring it). Otherwise, increments the
204 * reference count. 204 * reference count.
205 */ 205 */
206char const* push_deep_proxy(lua_State* L, DeepPrelude* prelude, int nuv_, LookupMode mode_) 206char const* push_deep_proxy(Dest L, DeepPrelude* prelude, int nuv_, LookupMode mode_)
207{ 207{
208 // Check if a proxy already exists 208 // Check if a proxy already exists
209 push_registry_subtable_mode( L, DEEP_PROXY_CACHE_KEY, "v"); // DPC 209 push_registry_subtable_mode( L, DEEP_PROXY_CACHE_KEY, "v"); // DPC
@@ -278,7 +278,7 @@ char const* push_deep_proxy(lua_State* L, DeepPrelude* prelude, int nuv_, Lookup
278 // this is needed because we must make sure the shared library is still loaded as long as we hold a pointer on the idfunc 278 // this is needed because we must make sure the shared library is still loaded as long as we hold a pointer on the idfunc
279 { 279 {
280 int oldtop_module = lua_gettop( L); 280 int oldtop_module = lua_gettop( L);
281 modname = (char const*) prelude->idfunc( L, DeepOp::Module); // DPC proxy metatable 281 modname = (char const*) prelude->idfunc( L, DeepOp::Module); // DPC proxy metatable
282 // make sure the function pushed nothing on the stack! 282 // make sure the function pushed nothing on the stack!
283 if( lua_gettop( L) - oldtop_module != 0) 283 if( lua_gettop( L) - oldtop_module != 0)
284 { 284 {
@@ -348,6 +348,8 @@ char const* push_deep_proxy(lua_State* L, DeepPrelude* prelude, int nuv_, Lookup
348 return nullptr; 348 return nullptr;
349} 349}
350 350
351// ################################################################################################
352
351/* 353/*
352* Create a deep userdata 354* Create a deep userdata
353* 355*
@@ -370,7 +372,7 @@ char const* push_deep_proxy(lua_State* L, DeepPrelude* prelude, int nuv_, Lookup
370* 372*
371* Returns: 'proxy' userdata for accessing the deep data via 'luaG_todeep()' 373* Returns: 'proxy' userdata for accessing the deep data via 'luaG_todeep()'
372*/ 374*/
373int luaG_newdeepuserdata( lua_State* L, luaG_IdFunction idfunc, int nuv_) 375int luaG_newdeepuserdata(Dest L, luaG_IdFunction idfunc, int nuv_)
374{ 376{
375 STACK_GROW( L, 1); 377 STACK_GROW( L, 1);
376 STACK_CHECK_START_REL(L, 0); 378 STACK_CHECK_START_REL(L, 0);
@@ -409,6 +411,7 @@ int luaG_newdeepuserdata( lua_State* L, luaG_IdFunction idfunc, int nuv_)
409 return 1; 411 return 1;
410} 412}
411 413
414// ################################################################################################
412 415
413/* 416/*
414* Access deep userdata through a proxy. 417* Access deep userdata through a proxy.
@@ -430,6 +433,7 @@ DeepPrelude* luaG_todeep(lua_State* L, luaG_IdFunction idfunc, int index)
430 return *proxy; 433 return *proxy;
431} 434}
432 435
436// ################################################################################################
433 437
434/* 438/*
435 * Copy deep userdata between two separate Lua states (from L to L2) 439 * Copy deep userdata between two separate Lua states (from L to L2)
@@ -438,7 +442,7 @@ DeepPrelude* luaG_todeep(lua_State* L, luaG_IdFunction idfunc, int index)
438 * the id function of the copied value, or nullptr for non-deep userdata 442 * the id function of the copied value, or nullptr for non-deep userdata
439 * (not copied) 443 * (not copied)
440 */ 444 */
441bool copydeep(Universe* U, lua_State* L2, int L2_cache_i, lua_State* L, int i, LookupMode mode_, char const* upName_) 445bool copydeep(Universe* U, Dest L2, int L2_cache_i, Source L, int i, LookupMode mode_, char const* upName_)
442{ 446{
443 luaG_IdFunction const idfunc { get_idfunc(L, i, mode_) }; 447 luaG_IdFunction const idfunc { get_idfunc(L, i, mode_) };
444 if (idfunc == nullptr) 448 if (idfunc == nullptr)
diff --git a/src/deep.h b/src/deep.h
index c09af23..6cf33ec 100644
--- a/src/deep.h
+++ b/src/deep.h
@@ -54,8 +54,8 @@ struct DeepPrelude
54 std::atomic<int> m_refcount{ 0 }; 54 std::atomic<int> m_refcount{ 0 };
55}; 55};
56 56
57char const* push_deep_proxy(lua_State* L, DeepPrelude* prelude, int nuv_, LookupMode mode_); 57char const* push_deep_proxy(Dest L, DeepPrelude* prelude, int nuv_, LookupMode mode_);
58void free_deep_prelude( lua_State* L, DeepPrelude* prelude_); 58void free_deep_prelude( lua_State* L, DeepPrelude* prelude_);
59 59
60LANES_API int luaG_newdeepuserdata( lua_State* L, luaG_IdFunction idfunc, int nuv_); 60LANES_API int luaG_newdeepuserdata(Dest L, luaG_IdFunction idfunc, int nuv_);
61LANES_API DeepPrelude* luaG_todeep(lua_State* L, luaG_IdFunction idfunc, int index); 61LANES_API DeepPrelude* luaG_todeep(lua_State* L, luaG_IdFunction idfunc, int index);
diff --git a/src/keeper.cpp b/src/keeper.cpp
index 0aea18e..9718bda 100644
--- a/src/keeper.cpp
+++ b/src/keeper.cpp
@@ -14,7 +14,7 @@
14 --[[ 14 --[[
15 =============================================================================== 15 ===============================================================================
16 16
17 Copyright (C) 2011-2023 Benoit Germain <bnt.germain@gmail.com> 17 Copyright (C) 2011-2024 Benoit Germain <bnt.germain@gmail.com>
18 18
19 Permission is hereby granted, free of charge, to any person obtaining a copy 19 Permission is hereby granted, free of charge, to any person obtaining a copy
20 of this software and associated documentation files (the "Software"), to deal 20 of this software and associated documentation files (the "Software"), to deal
@@ -207,10 +207,10 @@ static void push_table(lua_State* L, int idx_)
207 207
208// ################################################################################################## 208// ##################################################################################################
209 209
210int keeper_push_linda_storage(Universe* U, lua_State* L, void* ptr_, uintptr_t magic_) 210int keeper_push_linda_storage(Universe* U, Dest L, void* ptr_, uintptr_t magic_)
211{ 211{
212 Keeper* const K{ which_keeper(U->keepers, magic_) }; 212 Keeper* const K{ which_keeper(U->keepers, magic_) };
213 lua_State* const KL{ K ? K->L : nullptr }; 213 Source const KL{ K ? K->L : nullptr };
214 if (KL == nullptr) 214 if (KL == nullptr)
215 return 0; 215 return 0;
216 STACK_GROW(KL, 4); 216 STACK_GROW(KL, 4);
@@ -412,7 +412,7 @@ int keepercall_limit(lua_State* L)
412 // set the new limit 412 // set the new limit
413 fifo->limit = limit; 413 fifo->limit = limit;
414 // return 0 or 1 value 414 // return 0 or 1 value
415 return lua_gettop( L); 415 return lua_gettop(L);
416} 416}
417 417
418// ################################################################################################## 418// ##################################################################################################
@@ -485,7 +485,7 @@ int keepercall_set(lua_State* L)
485 lua_insert(L, 3); // fifos key fifotbl [val [, ...]] 485 lua_insert(L, 3); // fifos key fifotbl [val [, ...]]
486 fifo_push(L, fifo, count); // fifos key fifotbl 486 fifo_push(L, fifo, count); // fifos key fifotbl
487 } 487 }
488 return should_wake_writers ? (lua_pushboolean( L, 1), 1) : 0; 488 return should_wake_writers ? (lua_pushboolean(L, 1), 1) : 0;
489} 489}
490 490
491// ################################################################################################## 491// ##################################################################################################
@@ -717,7 +717,7 @@ void init_keepers(Universe* U, lua_State* L)
717 if (!lua_isnil(L, -1)) 717 if (!lua_isnil(L, -1))
718 { 718 {
719 // when copying with mode LookupMode::ToKeeper, error message is pushed at the top of the stack, not raised immediately 719 // when copying with mode LookupMode::ToKeeper, error message is pushed at the top of the stack, not raised immediately
720 if (luaG_inter_copy_package(U, L, K, -1, LookupMode::ToKeeper)) 720 if (luaG_inter_copy_package(U, Source{ L }, Dest{ K }, -1, LookupMode::ToKeeper))
721 { 721 {
722 // if something went wrong, the error message is at the top of the stack 722 // if something went wrong, the error message is at the top of the stack
723 lua_remove(L, -2); // error_msg 723 lua_remove(L, -2); // error_msg
@@ -840,7 +840,7 @@ int keeper_call(Universe* U, lua_State* K, keeper_api_t func_, lua_State* L, voi
840 840
841 lua_pushlightuserdata(K, linda); 841 lua_pushlightuserdata(K, linda);
842 842
843 if ((args == 0) || luaG_inter_copy(U, L, K, args, LookupMode::ToKeeper) == 0) // L->K 843 if ((args == 0) || luaG_inter_copy(U, Source{ L }, Dest{ K }, args, LookupMode::ToKeeper) == 0) // L->K
844 { 844 {
845 lua_call(K, 1 + args, LUA_MULTRET); 845 lua_call(K, 1 + args, LUA_MULTRET);
846 retvals = lua_gettop(K) - Ktos; 846 retvals = lua_gettop(K) - Ktos;
@@ -848,7 +848,7 @@ int keeper_call(Universe* U, lua_State* K, keeper_api_t func_, lua_State* L, voi
848 // this may interrupt a lane, causing the destruction of the underlying OS thread 848 // this may interrupt a lane, causing the destruction of the underlying OS thread
849 // after this, another lane making use of this keeper can get an error code from the mutex-locking function 849 // after this, another lane making use of this keeper can get an error code from the mutex-locking function
850 // when attempting to grab the mutex again (WINVER <= 0x400 does this, but locks just fine, I don't know about pthread) 850 // when attempting to grab the mutex again (WINVER <= 0x400 does this, but locks just fine, I don't know about pthread)
851 if ((retvals > 0) && luaG_inter_move(U, K, L, retvals, LookupMode::FromKeeper) != 0) // K->L 851 if ((retvals > 0) && luaG_inter_move(U, Source{ K }, Dest{ L }, retvals, LookupMode::FromKeeper) != 0) // K->L
852 { 852 {
853 retvals = -1; 853 retvals = -1;
854 } 854 }
diff --git a/src/keeper.h b/src/keeper.h
index ba5a57b..89fa2ab 100644
--- a/src/keeper.h
+++ b/src/keeper.h
@@ -42,7 +42,7 @@ Keeper* which_keeper(Keepers* keepers_, uintptr_t magic_);
42Keeper* keeper_acquire(Keepers* keepers_, uintptr_t magic_); 42Keeper* keeper_acquire(Keepers* keepers_, uintptr_t magic_);
43void keeper_release(Keeper* K_); 43void keeper_release(Keeper* K_);
44void keeper_toggle_nil_sentinels(lua_State* L, int val_i_, LookupMode const mode_); 44void keeper_toggle_nil_sentinels(lua_State* L, int val_i_, LookupMode const mode_);
45int keeper_push_linda_storage(Universe* U, lua_State* L, void* ptr_, uintptr_t magic_); 45int keeper_push_linda_storage(Universe* U, Dest L, void* ptr_, uintptr_t magic_);
46 46
47using keeper_api_t = lua_CFunction; 47using keeper_api_t = lua_CFunction;
48#define KEEPER_API(_op) keepercall_##_op 48#define KEEPER_API(_op) keepercall_##_op
diff --git a/src/lanes.cpp b/src/lanes.cpp
index cf443f2..3d0c70d 100644
--- a/src/lanes.cpp
+++ b/src/lanes.cpp
@@ -1027,7 +1027,7 @@ LUAG_FUNC(lane_new)
1027 DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_add(1, std::memory_order_relaxed)); 1027 DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_add(1, std::memory_order_relaxed));
1028 1028
1029 // populate with selected libraries at the same time 1029 // populate with selected libraries at the same time
1030 lua_State* const L2{ luaG_newstate(U, L, libs_str) }; // L // L2 1030 lua_State* const L2{ luaG_newstate(U, Source{ L }, libs_str) }; // L // L2
1031 1031
1032 // 'lane' is allocated from heap, not Lua, since its life span may surpass the handle's (if free running thread) 1032 // 'lane' is allocated from heap, not Lua, since its life span may surpass the handle's (if free running thread)
1033 Lane* const lane{ new (U) Lane{ U, L2 } }; 1033 Lane* const lane{ new (U) Lane{ U, L2 } };
@@ -1134,7 +1134,7 @@ LUAG_FUNC(lane_new)
1134 { 1134 {
1135 DEBUGSPEW_CODE(fprintf(stderr, INDENT_BEGIN "lane_new: update 'package'\n" INDENT_END)); 1135 DEBUGSPEW_CODE(fprintf(stderr, INDENT_BEGIN "lane_new: update 'package'\n" INDENT_END));
1136 // when copying with mode LookupMode::LaneBody, should raise an error in case of problem, not leave it one the stack 1136 // when copying with mode LookupMode::LaneBody, should raise an error in case of problem, not leave it one the stack
1137 (void) luaG_inter_copy_package(U, L, L2, package_idx, LookupMode::LaneBody); 1137 std::ignore = luaG_inter_copy_package(U, Source{ L }, Dest{ L2 }, package_idx, LookupMode::LaneBody);
1138 } 1138 }
1139 1139
1140 // modules to require in the target lane *before* the function is transfered! 1140 // modules to require in the target lane *before* the function is transfered!
@@ -1150,7 +1150,7 @@ LUAG_FUNC(lane_new)
1150 } 1150 }
1151 1151
1152 lua_pushnil(L); // func libs priority globals package required gc_cb [... args ...] nil 1152 lua_pushnil(L); // func libs priority globals package required gc_cb [... args ...] nil
1153 while( lua_next(L, required_idx) != 0) // func libs priority globals package required gc_cb [... args ...] n "modname" 1153 while (lua_next(L, required_idx) != 0) // func libs priority globals package required gc_cb [... args ...] n "modname"
1154 { 1154 {
1155 if (lua_type(L, -1) != LUA_TSTRING || lua_type(L, -2) != LUA_TNUMBER || lua_tonumber(L, -2) != nbRequired) 1155 if (lua_type(L, -1) != LUA_TSTRING || lua_type(L, -2) != LUA_TNUMBER || lua_tonumber(L, -2) != nbRequired)
1156 { 1156 {
@@ -1176,7 +1176,7 @@ LUAG_FUNC(lane_new)
1176 if (lua_pcall( L2, 1, 1, 0) != LUA_OK) // ret/errcode 1176 if (lua_pcall( L2, 1, 1, 0) != LUA_OK) // ret/errcode
1177 { 1177 {
1178 // propagate error to main state if any 1178 // propagate error to main state if any
1179 luaG_inter_move(U, L2, L, 1, LookupMode::LaneBody); // func libs priority globals package required gc_cb [... args ...] n "modname" error 1179 luaG_inter_move(U, Source{ L2 }, Dest{ L }, 1, LookupMode::LaneBody); // func libs priority globals package required gc_cb [... args ...] n "modname" error
1180 raise_lua_error(L); 1180 raise_lua_error(L);
1181 } 1181 }
1182 // after requiring the module, register the functions it exported in our name<->function database 1182 // after requiring the module, register the functions it exported in our name<->function database
@@ -1209,7 +1209,7 @@ LUAG_FUNC(lane_new)
1209 lua_pushglobaltable(L2); // _G 1209 lua_pushglobaltable(L2); // _G
1210 while( lua_next(L, globals_idx)) // func libs priority globals package required gc_cb [... args ...] k v 1210 while( lua_next(L, globals_idx)) // func libs priority globals package required gc_cb [... args ...] k v
1211 { 1211 {
1212 luaG_inter_copy(U, L, L2, 2, LookupMode::LaneBody); // _G k v 1212 luaG_inter_copy(U, Source{ L }, Dest{ L2 }, 2, LookupMode::LaneBody); // _G k v
1213 // assign it in L2's globals table 1213 // assign it in L2's globals table
1214 lua_rawset(L2, -3); // _G 1214 lua_rawset(L2, -3); // _G
1215 lua_pop(L, 1); // func libs priority globals package required gc_cb [... args ...] k 1215 lua_pop(L, 1); // func libs priority globals package required gc_cb [... args ...] k
@@ -1227,7 +1227,7 @@ LUAG_FUNC(lane_new)
1227 DEBUGSPEW_CODE(fprintf( stderr, INDENT_BEGIN "lane_new: transfer lane body\n" INDENT_END)); 1227 DEBUGSPEW_CODE(fprintf( stderr, INDENT_BEGIN "lane_new: transfer lane body\n" INDENT_END));
1228 DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_add(1, std::memory_order_relaxed)); 1228 DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_add(1, std::memory_order_relaxed));
1229 lua_pushvalue(L, 1); // func libs priority globals package required gc_cb [... args ...] func 1229 lua_pushvalue(L, 1); // func libs priority globals package required gc_cb [... args ...] func
1230 int const res{ luaG_inter_move(U, L, L2, 1, LookupMode::LaneBody) };// func libs priority globals package required gc_cb [... args ...] // func 1230 int const res{ luaG_inter_move(U, Source{ L }, Dest{ L2 }, 1, LookupMode::LaneBody) }; // func libs priority globals package required gc_cb [... args ...] // func
1231 DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_sub(1, std::memory_order_relaxed)); 1231 DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_sub(1, std::memory_order_relaxed));
1232 if (res != 0) 1232 if (res != 0)
1233 { 1233 {
@@ -1253,7 +1253,7 @@ LUAG_FUNC(lane_new)
1253 int res; 1253 int res;
1254 DEBUGSPEW_CODE(fprintf( stderr, INDENT_BEGIN "lane_new: transfer lane arguments\n" INDENT_END)); 1254 DEBUGSPEW_CODE(fprintf( stderr, INDENT_BEGIN "lane_new: transfer lane arguments\n" INDENT_END));
1255 DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_add(1, std::memory_order_relaxed)); 1255 DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_add(1, std::memory_order_relaxed));
1256 res = luaG_inter_move(U, L, L2, nargs, LookupMode::LaneBody); // func libs priority globals package required gc_cb // func [... args ...] 1256 res = luaG_inter_move(U, Source{ L }, Dest{ L2 }, nargs, LookupMode::LaneBody); // func libs priority globals package required gc_cb // func [... args ...]
1257 DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_sub(1, std::memory_order_relaxed)); 1257 DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_sub(1, std::memory_order_relaxed));
1258 if (res != 0) 1258 if (res != 0)
1259 { 1259 {
@@ -1418,7 +1418,7 @@ LUAG_FUNC(thread_join)
1418 case Lane::Done: 1418 case Lane::Done:
1419 { 1419 {
1420 int const n{ lua_gettop(L2) }; // whole L2 stack 1420 int const n{ lua_gettop(L2) }; // whole L2 stack
1421 if ((n > 0) && (luaG_inter_move(U, L2, L, n, LookupMode::LaneBody) != 0)) 1421 if ((n > 0) && (luaG_inter_move(U, Source{ L2 }, Dest{ L }, n, LookupMode::LaneBody) != 0))
1422 { 1422 {
1423 return luaL_error(L, "tried to copy unsupported types"); 1423 return luaL_error(L, "tried to copy unsupported types");
1424 } 1424 }
@@ -1432,7 +1432,7 @@ LUAG_FUNC(thread_join)
1432 STACK_GROW(L, 3); 1432 STACK_GROW(L, 3);
1433 lua_pushnil(L); 1433 lua_pushnil(L);
1434 // even when ERROR_FULL_STACK, if the error is not LUA_ERRRUN, the handler wasn't called, and we only have 1 error message on the stack ... 1434 // even when ERROR_FULL_STACK, if the error is not LUA_ERRRUN, the handler wasn't called, and we only have 1 error message on the stack ...
1435 if (luaG_inter_move(U, L2, L, n, LookupMode::LaneBody) != 0) // nil "err" [trace] 1435 if (luaG_inter_move(U, Source{ L2 }, Dest{ L }, n, LookupMode::LaneBody) != 0) // nil "err" [trace]
1436 { 1436 {
1437 return luaL_error(L, "tried to copy unsupported types: %s", lua_tostring(L, -n)); 1437 return luaL_error(L, "tried to copy unsupported types: %s", lua_tostring(L, -n));
1438 } 1438 }
@@ -1832,7 +1832,7 @@ LUAG_FUNC(configure)
1832 STACK_CHECK(L, 2); 1832 STACK_CHECK(L, 2);
1833 1833
1834 { 1834 {
1835 char const* errmsg{ push_deep_proxy(L, U->timer_deep, 0, LookupMode::LaneBody) }; // settings M timer_deep 1835 char const* errmsg{ push_deep_proxy(Dest{ L }, U->timer_deep, 0, LookupMode::LaneBody) }; // settings M timer_deep
1836 if (errmsg != nullptr) 1836 if (errmsg != nullptr)
1837 { 1837 {
1838 return luaL_error(L, errmsg); 1838 return luaL_error(L, errmsg);
diff --git a/src/lanes_private.h b/src/lanes_private.h
index 3ed52fe..0fcbbfc 100644
--- a/src/lanes_private.h
+++ b/src/lanes_private.h
@@ -98,6 +98,6 @@ static constexpr UniqueKey LANE_POINTER_REGKEY{ 0xB3022205633743BCull }; // used
98// 'Lane' are malloc/free'd and the handle only carries a pointer. 98// 'Lane' are malloc/free'd and the handle only carries a pointer.
99// This is not deep userdata since the handle's not portable among lanes. 99// This is not deep userdata since the handle's not portable among lanes.
100// 100//
101#define lua_toLane( L, i) (*((Lane**) luaL_checkudata( L, i, "Lane"))) 101#define lua_toLane(L, i) (*((Lane**) luaL_checkudata( L, i, "Lane")))
102 102
103int push_thread_status( lua_State* L, Lane* s); 103int push_thread_status(lua_State* L, Lane* s);
diff --git a/src/linda.cpp b/src/linda.cpp
index fb74abe..39977bc 100644
--- a/src/linda.cpp
+++ b/src/linda.cpp
@@ -804,7 +804,7 @@ LUAG_FUNC(linda_concat)
804LUAG_FUNC(linda_dump) 804LUAG_FUNC(linda_dump)
805{ 805{
806 Linda* const linda{ lua_toLinda<false>(L, 1) }; 806 Linda* const linda{ lua_toLinda<false>(L, 1) };
807 return keeper_push_linda_storage(linda->U, L, linda, linda->hashSeed()); 807 return keeper_push_linda_storage(linda->U, Dest{ L }, linda, linda->hashSeed());
808} 808}
809 809
810// ################################################################################################# 810// #################################################################################################
@@ -816,7 +816,7 @@ LUAG_FUNC(linda_dump)
816LUAG_FUNC(linda_towatch) 816LUAG_FUNC(linda_towatch)
817{ 817{
818 Linda* const linda{ lua_toLinda<false>(L, 1) }; 818 Linda* const linda{ lua_toLinda<false>(L, 1) };
819 int pushed{ keeper_push_linda_storage(linda->U, L, linda, linda->hashSeed()) }; 819 int pushed{ keeper_push_linda_storage(linda->U, Dest{ L }, linda, linda->hashSeed()) };
820 if (pushed == 0) 820 if (pushed == 0)
821 { 821 {
822 // if the linda is empty, don't return nil 822 // if the linda is empty, don't return nil
@@ -1009,11 +1009,11 @@ static void* linda_id( lua_State* L, DeepOp op_)
1009 */ 1009 */
1010LUAG_FUNC(linda) 1010LUAG_FUNC(linda)
1011{ 1011{
1012 int const top = lua_gettop(L); 1012 int const top{ lua_gettop(L) };
1013 luaL_argcheck(L, top <= 2, top, "too many arguments"); 1013 luaL_argcheck(L, top <= 2, top, "too many arguments");
1014 if (top == 1) 1014 if (top == 1)
1015 { 1015 {
1016 int const t = lua_type(L, 1); 1016 int const t{ lua_type(L, 1) };
1017 luaL_argcheck(L, t == LUA_TSTRING || t == LUA_TNUMBER, 1, "wrong parameter (should be a string or a number)"); 1017 luaL_argcheck(L, t == LUA_TSTRING || t == LUA_TNUMBER, 1, "wrong parameter (should be a string or a number)");
1018 } 1018 }
1019 else if (top == 2) 1019 else if (top == 2)
@@ -1021,5 +1021,5 @@ LUAG_FUNC(linda)
1021 luaL_checktype(L, 1, LUA_TSTRING); 1021 luaL_checktype(L, 1, LUA_TSTRING);
1022 luaL_checktype(L, 2, LUA_TNUMBER); 1022 luaL_checktype(L, 2, LUA_TNUMBER);
1023 } 1023 }
1024 return luaG_newdeepuserdata(L, linda_id, 0); 1024 return luaG_newdeepuserdata(Dest{ L }, linda_id, 0);
1025} 1025}
diff --git a/src/macros_and_utils.h b/src/macros_and_utils.h
index 997b452..47ce90c 100644
--- a/src/macros_and_utils.h
+++ b/src/macros_and_utils.h
@@ -44,8 +44,8 @@ extern char const* debugspew_indent;
44 44
45#else // NDEBUG 45#else // NDEBUG
46 46
47#define _ASSERT_L( L, cond_) if( (cond_) == 0) { (void) luaL_error( L, "ASSERT failed: %s:%d '%s'", __FILE__, __LINE__, #cond_);} 47#define _ASSERT_L(L, cond_) if( (cond_) == 0) { (void) luaL_error(L, "ASSERT failed: %s:%d '%s'", __FILE__, __LINE__, #cond_);}
48#define STACK_DUMP( L) luaG_dump( L) 48#define STACK_DUMP(L) luaG_dump(L)
49 49
50class StackChecker 50class StackChecker
51{ 51{
@@ -172,3 +172,17 @@ T* lua_newuserdatauv(lua_State* L, int nuvalue_)
172} 172}
173 173
174using lua_Duration = std::chrono::template duration<lua_Number>; 174using lua_Duration = std::chrono::template duration<lua_Number>;
175
176// #################################################################################################
177
178template <typename T, auto = []{}>
179struct Unique
180{
181 T m_val;
182 Unique() = default;
183 operator T() const { return m_val; }
184 explicit Unique(T b_) : m_val{ b_ } {}
185};
186
187using Source = Unique<lua_State*>;
188using Dest = Unique<lua_State*>;
diff --git a/src/state.cpp b/src/state.cpp
index 512009a..6a9ada7 100644
--- a/src/state.cpp
+++ b/src/state.cpp
@@ -1,5 +1,5 @@
1/* 1/*
2* STATE.C 2* STATE.CPP
3* 3*
4* Lua tools to support Lanes. 4* Lua tools to support Lanes.
5*/ 5*/
@@ -31,20 +31,11 @@ THE SOFTWARE.
31=============================================================================== 31===============================================================================
32*/ 32*/
33 33
34#include <stdio.h> 34#include "state.h"
35#include <assert.h> 35
36#include <string.h>
37#include <ctype.h>
38#include <stdlib.h>
39#if !defined(__APPLE__)
40#include <malloc.h>
41#endif // __APPLE__
42
43#include "compat.h"
44#include "macros_and_utils.h"
45#include "universe.h"
46#include "tools.h"
47#include "lanes.h" 36#include "lanes.h"
37#include "tools.h"
38#include "universe.h"
48 39
49// ################################################################################################ 40// ################################################################################################
50 41
@@ -194,9 +185,9 @@ static void open1lib( DEBUGSPEW_PARAM_COMMA( Universe* U) lua_State* L, char con
194 185
195 186
196// just like lua_xmove, args are (from, to) 187// just like lua_xmove, args are (from, to)
197static void copy_one_time_settings( Universe* U, lua_State* L, lua_State* L2) 188static void copy_one_time_settings(Universe* U, Source L, Dest L2)
198{ 189{
199 STACK_GROW( L, 2); 190 STACK_GROW(L, 2);
200 STACK_CHECK_START_REL(L, 0); 191 STACK_CHECK_START_REL(L, 0);
201 STACK_CHECK_START_REL(L2, 0); 192 STACK_CHECK_START_REL(L2, 0);
202 193
@@ -326,11 +317,11 @@ void call_on_state_create(Universe* U, lua_State* L, lua_State* from_, LookupMod
326* *NOT* called for keeper states! 317* *NOT* called for keeper states!
327* 318*
328*/ 319*/
329lua_State* luaG_newstate( Universe* U, lua_State* from_, char const* libs_) 320lua_State* luaG_newstate(Universe* U, Source from_, char const* libs_)
330{ 321{
331 lua_State* L = create_state( U, from_); 322 Dest const L{ create_state(U, from_) };
332 323
333 STACK_GROW( L, 2); 324 STACK_GROW(L, 2);
334 STACK_CHECK_START_ABS(L, 0); 325 STACK_CHECK_START_ABS(L, 0);
335 326
336 // copy the universe as a light userdata (only the master state holds the full userdata) 327 // copy the universe as a light userdata (only the master state holds the full userdata)
diff --git a/src/state.h b/src/state.h
index 0e069da..2601f77 100644
--- a/src/state.h
+++ b/src/state.h
@@ -3,6 +3,7 @@
3#include "macros_and_utils.h" 3#include "macros_and_utils.h"
4 4
5// forwards 5// forwards
6enum class LookupMode;
6class Universe; 7class Universe;
7 8
8void serialize_require(DEBUGSPEW_PARAM_COMMA(Universe* U) lua_State* L); 9void serialize_require(DEBUGSPEW_PARAM_COMMA(Universe* U) lua_State* L);
@@ -10,7 +11,7 @@ void serialize_require(DEBUGSPEW_PARAM_COMMA(Universe* U) lua_State* L);
10// ################################################################################################ 11// ################################################################################################
11 12
12lua_State* create_state(Universe* U, lua_State* from_); 13lua_State* create_state(Universe* U, lua_State* from_);
13lua_State* luaG_newstate(Universe* U, lua_State* _from, char const* libs); 14lua_State* luaG_newstate(Universe* U, Source _from, char const* libs);
14 15
15// ################################################################################################ 16// ################################################################################################
16 17
diff --git a/src/threading.cpp b/src/threading.cpp
index 4d210d6..d278bb1 100644
--- a/src/threading.cpp
+++ b/src/threading.cpp
@@ -1,6 +1,6 @@
1/* 1/*
2 * THREADING.C Copyright (c) 2007-08, Asko Kauppi 2 * THREADING.CPP Copyright (c) 2007-08, Asko Kauppi
3 * Copyright (C) 2009-19, Benoit Germain 3 * Copyright (C) 2009-24, Benoit Germain
4 * 4 *
5 * Lua Lanes OS threading specific code. 5 * Lua Lanes OS threading specific code.
6 * 6 *
@@ -12,7 +12,7 @@
12=============================================================================== 12===============================================================================
13 13
14Copyright (C) 2007-10 Asko Kauppi <akauppi@gmail.com> 14Copyright (C) 2007-10 Asko Kauppi <akauppi@gmail.com>
15Copyright (C) 2009-14, Benoit Germain <bnt.germain@gmail.com> 15Copyright (C) 2009-24, Benoit Germain <bnt.germain@gmail.com>
16 16
17Permission is hereby granted, free of charge, to any person obtaining a copy 17Permission is hereby granted, free of charge, to any person obtaining a copy
18of this software and associated documentation files (the "Software"), to deal 18of this software and associated documentation files (the "Software"), to deal
@@ -47,12 +47,6 @@ THE SOFTWARE.
47 47
48#endif // __linux__ 48#endif // __linux__
49 49
50#include <stdio.h>
51#include <stdlib.h>
52#include <assert.h>
53#include <errno.h>
54#include <math.h>
55
56#include "threading.h" 50#include "threading.h"
57 51
58#if !defined( PLATFORM_XBOX) && !defined( PLATFORM_WIN32) && !defined( PLATFORM_POCKETPC) 52#if !defined( PLATFORM_XBOX) && !defined( PLATFORM_WIN32) && !defined( PLATFORM_POCKETPC)
diff --git a/src/threading.h b/src/threading.h
index f38b2de..fc35730 100644
--- a/src/threading.h
+++ b/src/threading.h
@@ -2,7 +2,6 @@
2 2
3#include "platform.h" 3#include "platform.h"
4 4
5#include <time.h>
6#include <thread> 5#include <thread>
7 6
8#define THREADAPI_WINDOWS 1 7#define THREADAPI_WINDOWS 1
diff --git a/src/tools.cpp b/src/tools.cpp
index ac5f7c5..07f9ae6 100644
--- a/src/tools.cpp
+++ b/src/tools.cpp
@@ -31,24 +31,12 @@ THE SOFTWARE.
31=============================================================================== 31===============================================================================
32*/ 32*/
33 33
34#include <stdio.h>
35#include <assert.h>
36#include <string.h>
37#include <ctype.h>
38#include <stdlib.h>
39#if !defined(__APPLE__)
40#include <malloc.h>
41#endif // __APPLE__
42
43#include "tools.h" 34#include "tools.h"
44#include "compat.h" 35
45#include "universe.h" 36#include "universe.h"
46#include "keeper.h"
47#include "lanes.h"
48#include "uniquekey.h"
49 37
50// functions implemented in deep.c 38// functions implemented in deep.c
51extern bool copydeep(Universe* U, lua_State* L2, int L2_cache_i, lua_State* L, int i, LookupMode mode_, char const* upName_); 39extern bool copydeep(Universe* U, Dest L2, int L2_cache_i, Source L, int i, LookupMode mode_, char const* upName_);
52extern void push_registry_subtable( lua_State* L, UniqueKey key_); 40extern void push_registry_subtable( lua_State* L, UniqueKey key_);
53 41
54DEBUGSPEW_CODE( char const* debugspew_indent = "----+----!----+----!----+----!----+----!----+----!----+----!----+----!----+"); 42DEBUGSPEW_CODE( char const* debugspew_indent = "----+----!----+----!----+----!----+----!----+----!----+----!----+----!----+");
@@ -554,10 +542,10 @@ static void populate_func_lookup_table_recur(DEBUGSPEW_PARAM_COMMA(Universe* U)
554/* 542/*
555 * create a "fully.qualified.name" <-> function equivalence database 543 * create a "fully.qualified.name" <-> function equivalence database
556 */ 544 */
557void populate_func_lookup_table( lua_State* L, int _i, char const* name_) 545void populate_func_lookup_table(lua_State* L, int i_, char const* name_)
558{ 546{
559 int const ctx_base = lua_gettop( L) + 1; 547 int const ctx_base = lua_gettop(L) + 1;
560 int const in_base = lua_absindex( L, _i); 548 int const in_base = lua_absindex(L, i_);
561 int start_depth = 0; 549 int start_depth = 0;
562 DEBUGSPEW_CODE( Universe* U = universe_get( L)); 550 DEBUGSPEW_CODE( Universe* U = universe_get( L));
563 DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "%p: populate_func_lookup_table('%s')\n" INDENT_END, L, name_ ? name_ : "nullptr")); 551 DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "%p: populate_func_lookup_table('%s')\n" INDENT_END, L, name_ ? name_ : "nullptr"));
@@ -765,7 +753,7 @@ static char const* find_lookup_name(lua_State* L, int i, LookupMode mode_, char
765/* 753/*
766 * Push a looked-up table, or nothing if we found nothing 754 * Push a looked-up table, or nothing if we found nothing
767 */ 755 */
768static bool lookup_table(lua_State* L2, lua_State* L, int i, LookupMode mode_, char const* upName_) 756static bool lookup_table(Dest L2, Source L, int i, LookupMode mode_, char const* upName_)
769{ 757{
770 // get the name of the table we want to send 758 // get the name of the table we want to send
771 size_t len; 759 size_t len;
@@ -775,7 +763,7 @@ static bool lookup_table(lua_State* L2, lua_State* L, int i, LookupMode mode_, c
775 return false; 763 return false;
776 } 764 }
777 // push the equivalent table in the destination's stack, retrieved from the lookup table 765 // push the equivalent table in the destination's stack, retrieved from the lookup table
778 STACK_CHECK_START_REL(L2, 0); // L // L2 766 STACK_CHECK_START_REL(L2, 0); // L // L2
779 STACK_GROW( L2, 3); // up to 3 slots are necessary on error 767 STACK_GROW( L2, 3); // up to 3 slots are necessary on error
780 switch( mode_) 768 switch( mode_)
781 { 769 {
@@ -785,34 +773,34 @@ static bool lookup_table(lua_State* L2, lua_State* L, int i, LookupMode mode_, c
785 773
786 case LookupMode::ToKeeper: 774 case LookupMode::ToKeeper:
787 // push a sentinel closure that holds the lookup name as upvalue 775 // push a sentinel closure that holds the lookup name as upvalue
788 lua_pushlstring( L2, fqn, len); // "f.q.n" 776 lua_pushlstring(L2, fqn, len); // "f.q.n"
789 lua_pushcclosure( L2, table_lookup_sentinel, 1); // f 777 lua_pushcclosure(L2, table_lookup_sentinel, 1); // f
790 break; 778 break;
791 779
792 case LookupMode::LaneBody: 780 case LookupMode::LaneBody:
793 case LookupMode::FromKeeper: 781 case LookupMode::FromKeeper:
794 LOOKUP_REGKEY.pushValue(L2); // {} 782 LOOKUP_REGKEY.pushValue(L2); // {}
795 STACK_CHECK( L2, 1); 783 STACK_CHECK(L2, 1);
796 ASSERT_L( lua_istable( L2, -1)); 784 ASSERT_L(lua_istable(L2, -1));
797 lua_pushlstring( L2, fqn, len); // {} "f.q.n" 785 lua_pushlstring(L2, fqn, len); // {} "f.q.n"
798 lua_rawget( L2, -2); // {} t 786 lua_rawget(L2, -2); // {} t
799 // we accept destination lookup failures in the case of transfering the Lanes body function (this will result in the source table being cloned instead) 787 // we accept destination lookup failures in the case of transfering the Lanes body function (this will result in the source table being cloned instead)
800 // but not when we extract something out of a keeper, as there is nothing to clone! 788 // but not when we extract something out of a keeper, as there is nothing to clone!
801 if (lua_isnil(L2, -1) && mode_ == LookupMode::LaneBody) 789 if (lua_isnil(L2, -1) && mode_ == LookupMode::LaneBody)
802 { 790 {
803 lua_pop( L2, 2); // 791 lua_pop(L2, 2); //
804 STACK_CHECK( L2, 0); 792 STACK_CHECK(L2, 0);
805 return false; 793 return false;
806 } 794 }
807 else if( !lua_istable( L2, -1)) 795 else if( !lua_istable(L2, -1))
808 { 796 {
809 char const* from, *to; 797 char const* from, *to;
810 lua_getglobal( L, "decoda_name"); // ... t ... decoda_name 798 lua_getglobal(L, "decoda_name"); // ... t ... decoda_name
811 from = lua_tostring( L, -1); 799 from = lua_tostring(L, -1);
812 lua_pop( L, 1); // ... t ... 800 lua_pop(L, 1); // ... t ...
813 lua_getglobal( L2, "decoda_name"); // {} t decoda_name 801 lua_getglobal(L2, "decoda_name"); // {} t decoda_name
814 to = lua_tostring( L2, -1); 802 to = lua_tostring( L2, -1);
815 lua_pop( L2, 1); // {} t 803 lua_pop(L2, 1); // {} t
816 // 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 804 // 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
817 (void) luaL_error( 805 (void) luaL_error(
818 (mode_ == LookupMode::FromKeeper) ? L2 : L 806 (mode_ == LookupMode::FromKeeper) ? L2 : L
@@ -823,7 +811,7 @@ static bool lookup_table(lua_State* L2, lua_State* L, int i, LookupMode mode_, c
823 ); 811 );
824 return false; 812 return false;
825 } 813 }
826 lua_remove( L2, -2); // t 814 lua_remove(L2, -2); // t
827 break; 815 break;
828 } 816 }
829 STACK_CHECK( L2, 1); 817 STACK_CHECK( L2, 1);
@@ -1194,7 +1182,7 @@ static int buf_writer( lua_State* L, void const* b, size_t size, void* ud)
1194 1182
1195// ################################################################################################# 1183// #################################################################################################
1196 1184
1197static void copy_func(Universe* U, lua_State* L2, int L2_cache_i, lua_State* L, int i, LookupMode mode_, char const* upName_) 1185static void copy_func(Universe* U, Dest L2, int L2_cache_i, Source L, int i, LookupMode mode_, char const* upName_)
1198{ 1186{
1199 int n, needToPush; 1187 int n, needToPush;
1200 luaL_Buffer B; 1188 luaL_Buffer B;
@@ -1348,7 +1336,7 @@ static void copy_func(Universe* U, lua_State* L2, int L2_cache_i, lua_State* L,
1348 * 1336 *
1349 * Always pushes a function to 'L2'. 1337 * Always pushes a function to 'L2'.
1350 */ 1338 */
1351static void copy_cached_func(Universe* U, lua_State* L2, int L2_cache_i, lua_State* L, int i, LookupMode mode_, char const* upName_) 1339static void copy_cached_func(Universe* U, Dest L2, int L2_cache_i, Source L, int i, LookupMode mode_, char const* upName_)
1352{ 1340{
1353 FuncSubType funcSubType; 1341 FuncSubType funcSubType;
1354 /*lua_CFunction cfunc =*/ luaG_tocfunction( L, i, &funcSubType); // nullptr for LuaJIT-fast && bytecode functions 1342 /*lua_CFunction cfunc =*/ luaG_tocfunction( L, i, &funcSubType); // nullptr for LuaJIT-fast && bytecode functions
@@ -1403,7 +1391,7 @@ static void copy_cached_func(Universe* U, lua_State* L2, int L2_cache_i, lua_Sta
1403 1391
1404// ################################################################################################# 1392// #################################################################################################
1405 1393
1406static bool push_cached_metatable(Universe* U, lua_State* L2, int L2_cache_i, lua_State* L, int i, LookupMode mode_, char const* upName_) 1394static bool push_cached_metatable(Universe* U, Dest L2, int L2_cache_i, Source L, int i, LookupMode mode_, char const* upName_)
1407{ 1395{
1408 STACK_CHECK_START_REL(L, 0); 1396 STACK_CHECK_START_REL(L, 0);
1409 if( lua_getmetatable( L, i)) // ... mt 1397 if( lua_getmetatable( L, i)) // ... mt
@@ -1454,7 +1442,7 @@ static bool push_cached_metatable(Universe* U, lua_State* L2, int L2_cache_i, lu
1454 1442
1455// ################################################################################################# 1443// #################################################################################################
1456 1444
1457static void inter_copy_keyvaluepair(Universe* U, lua_State* L2, int L2_cache_i, lua_State* L, VT vt_, LookupMode mode_, char const* upName_) 1445static void inter_copy_keyvaluepair(Universe* U, Dest L2, int L2_cache_i, Source L, VT vt_, LookupMode mode_, char const* upName_)
1458{ 1446{
1459 int val_i = lua_gettop(L); 1447 int val_i = lua_gettop(L);
1460 int key_i = val_i - 1; 1448 int key_i = val_i - 1;
@@ -1526,7 +1514,7 @@ static void inter_copy_keyvaluepair(Universe* U, lua_State* L2, int L2_cache_i,
1526*/ 1514*/
1527static constexpr UniqueKey CLONABLES_CACHE_KEY{ 0xD04EE018B3DEE8F5ull }; 1515static constexpr UniqueKey CLONABLES_CACHE_KEY{ 0xD04EE018B3DEE8F5ull };
1528 1516
1529static bool copyclone(Universe* U, lua_State* L2, int L2_cache_i, lua_State* L, int source_i_, LookupMode mode_, char const* upName_) 1517static bool copyclone(Universe* U, Dest L2, int L2_cache_i, Source L, int source_i_, LookupMode mode_, char const* upName_)
1530{ 1518{
1531 void* const source = lua_touserdata( L, source_i_); 1519 void* const source = lua_touserdata( L, source_i_);
1532 source_i_ = lua_absindex( L, source_i_); 1520 source_i_ = lua_absindex( L, source_i_);
@@ -1641,7 +1629,7 @@ static bool copyclone(Universe* U, lua_State* L2, int L2_cache_i, lua_State* L,
1641 1629
1642// ################################################################################################# 1630// #################################################################################################
1643 1631
1644static bool inter_copy_userdata(Universe* U, lua_State* L2, int L2_cache_i, lua_State* L, int i, VT vt_, LookupMode mode_, char const* upName_) 1632static bool inter_copy_userdata(Universe* U, Dest L2, int L2_cache_i, Source L, int i, VT vt_, LookupMode mode_, char const* upName_)
1645{ 1633{
1646 STACK_CHECK_START_REL(L, 0); 1634 STACK_CHECK_START_REL(L, 0);
1647 STACK_CHECK_START_REL(L2, 0); 1635 STACK_CHECK_START_REL(L2, 0);
@@ -1691,7 +1679,7 @@ static bool inter_copy_userdata(Universe* U, lua_State* L2, int L2_cache_i, lua_
1691 1679
1692// ################################################################################################# 1680// #################################################################################################
1693 1681
1694static bool inter_copy_function(Universe* U, lua_State* L2, int L2_cache_i, lua_State* L, int source_i_, VT vt_, LookupMode mode_, char const* upName_) 1682static bool inter_copy_function(Universe* U, Dest L2, int L2_cache_i, Source L, int source_i_, VT vt_, LookupMode mode_, char const* upName_)
1695{ 1683{
1696 if (vt_ == VT::KEY) 1684 if (vt_ == VT::KEY)
1697 { 1685 {
@@ -1786,7 +1774,7 @@ static bool inter_copy_function(Universe* U, lua_State* L2, int L2_cache_i, lua_
1786 1774
1787// ################################################################################################# 1775// #################################################################################################
1788 1776
1789static bool inter_copy_table(Universe* U, lua_State* L2, int L2_cache_i, lua_State* L, int i, VT vt_, LookupMode mode_, char const* upName_) 1777static bool inter_copy_table(Universe* U, Dest L2, int L2_cache_i, Source L, int i, VT vt_, LookupMode mode_, char const* upName_)
1790{ 1778{
1791 if (vt_ == VT::KEY) 1779 if (vt_ == VT::KEY)
1792 { 1780 {
@@ -1858,7 +1846,7 @@ static bool inter_copy_table(Universe* U, lua_State* L2, int L2_cache_i, lua_Sta
1858* 1846*
1859* Returns true if value was pushed, false if its type is non-supported. 1847* Returns true if value was pushed, false if its type is non-supported.
1860*/ 1848*/
1861bool inter_copy_one(Universe* U, lua_State* L2, int L2_cache_i, lua_State* L, int i, VT vt_, LookupMode mode_, char const* upName_) 1849bool inter_copy_one(Universe* U, Dest L2, int L2_cache_i, Source L, int i, VT vt_, LookupMode mode_, char const* upName_)
1862{ 1850{
1863 bool ret{ true }; 1851 bool ret{ true };
1864 int val_type = lua_type( L, i); 1852 int val_type = lua_type( L, i);
@@ -1974,6 +1962,8 @@ bool inter_copy_one(Universe* U, lua_State* L2, int L2_cache_i, lua_State* L, in
1974 return ret; 1962 return ret;
1975} 1963}
1976 1964
1965// #################################################################################################
1966
1977/* 1967/*
1978* Akin to 'lua_xmove' but copies values between _any_ Lua states. 1968* Akin to 'lua_xmove' but copies values between _any_ Lua states.
1979* 1969*
@@ -1981,7 +1971,7 @@ bool inter_copy_one(Universe* U, lua_State* L2, int L2_cache_i, lua_State* L, in
1981* 1971*
1982* Note: Parameters are in this order ('L' = from first) to be same as 'lua_xmove'. 1972* Note: Parameters are in this order ('L' = from first) to be same as 'lua_xmove'.
1983*/ 1973*/
1984int luaG_inter_copy(Universe* U, lua_State* L, lua_State* L2, int n, LookupMode mode_) 1974int luaG_inter_copy(Universe* U, Source L, Dest L2, int n, LookupMode mode_)
1985{ 1975{
1986 int top_L = lua_gettop(L); // ... {}n 1976 int top_L = lua_gettop(L); // ... {}n
1987 int top_L2 = lua_gettop(L2); // ... 1977 int top_L2 = lua_gettop(L2); // ...
@@ -2043,15 +2033,16 @@ int luaG_inter_copy(Universe* U, lua_State* L, lua_State* L2, int n, LookupMode
2043 return -2; 2033 return -2;
2044} 2034}
2045 2035
2036// #################################################################################################
2046 2037
2047int luaG_inter_move(Universe* U, lua_State* L, lua_State* L2, int n, LookupMode mode_) 2038int luaG_inter_move(Universe* U, Source L, Dest L2, int n, LookupMode mode_)
2048{ 2039{
2049 int ret = luaG_inter_copy( U, L, L2, n, mode_); 2040 int ret = luaG_inter_copy( U, L, L2, n, mode_);
2050 lua_pop( L, (int) n); 2041 lua_pop( L, (int) n);
2051 return ret; 2042 return ret;
2052} 2043}
2053 2044
2054int luaG_inter_copy_package(Universe* U, lua_State* L, lua_State* L2, int package_idx_, LookupMode mode_) 2045int luaG_inter_copy_package(Universe* U, Source L, Dest L2, int package_idx_, LookupMode mode_)
2055{ 2046{
2056 DEBUGSPEW_CODE(fprintf(stderr, INDENT_BEGIN "luaG_inter_copy_package()\n" INDENT_END)); 2047 DEBUGSPEW_CODE(fprintf(stderr, INDENT_BEGIN "luaG_inter_copy_package()\n" INDENT_END));
2057 DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_add(1, std::memory_order_relaxed)); 2048 DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_add(1, std::memory_order_relaxed));
diff --git a/src/tools.h b/src/tools.h
index 7d9aaab..8e95a4f 100644
--- a/src/tools.h
+++ b/src/tools.h
@@ -25,19 +25,19 @@ enum class VT
25 KEY, 25 KEY,
26 METATABLE 26 METATABLE
27}; 27};
28bool inter_copy_one(Universe* U, lua_State* L2, int L2_cache_i, lua_State* L, int i, VT vt_, LookupMode mode_, char const* upName_); 28bool inter_copy_one(Universe* U, Dest L2, int L2_cache_i, Source L, int i, VT vt_, LookupMode mode_, char const* upName_);
29 29
30// ################################################################################################ 30// ################################################################################################
31 31
32int luaG_inter_copy_package( Universe* U, lua_State* L, lua_State* L2, int package_idx_, LookupMode mode_); 32int luaG_inter_copy_package(Universe* U, Source L, Dest L2, int package_idx_, LookupMode mode_);
33 33
34int luaG_inter_copy(Universe* U, lua_State* L, lua_State* L2, int n, LookupMode mode_); 34int luaG_inter_copy(Universe* U, Source L, Dest L2, int n, LookupMode mode_);
35int luaG_inter_move(Universe* U, lua_State* L, lua_State* L2, int n, LookupMode mode_); 35int luaG_inter_move(Universe* U, Source L, Dest L2, int n, LookupMode mode_);
36 36
37int luaG_nameof( lua_State* L); 37int luaG_nameof(lua_State* L);
38 38
39void populate_func_lookup_table( lua_State* L, int _i, char const* _name); 39void populate_func_lookup_table(lua_State* L, int _i, char const* _name);
40void initialize_allocator_function( Universe* U, lua_State* L); 40void initialize_allocator_function(Universe* U, lua_State* L);
41 41
42// ################################################################################################ 42// ################################################################################################
43 43
diff --git a/src/universe.cpp b/src/universe.cpp
index 290e547..4c53987 100644
--- a/src/universe.cpp
+++ b/src/universe.cpp
@@ -80,7 +80,7 @@ Universe* universe_create(lua_State* L)
80 U->Universe::Universe(); 80 U->Universe::Universe();
81 STACK_CHECK_START_REL(L, 1); 81 STACK_CHECK_START_REL(L, 1);
82 UNIVERSE_FULL_REGKEY.setValue(L, [](lua_State* L) { lua_pushvalue(L, -2); }); 82 UNIVERSE_FULL_REGKEY.setValue(L, [](lua_State* L) { lua_pushvalue(L, -2); });
83 UNIVERSE_LIGHT_REGKEY.setValue(L, [U](lua_State* L) { lua_pushlightuserdata( L, U); }); 83 UNIVERSE_LIGHT_REGKEY.setValue(L, [U](lua_State* L) { lua_pushlightuserdata(L, U); });
84 STACK_CHECK(L, 1); 84 STACK_CHECK(L, 1);
85 return U; 85 return U;
86} 86}
@@ -91,8 +91,8 @@ void universe_store(lua_State* L, Universe* U)
91{ 91{
92 ASSERT_L(!U || universe_get(L) == nullptr); 92 ASSERT_L(!U || universe_get(L) == nullptr);
93 STACK_CHECK_START_REL(L, 0); 93 STACK_CHECK_START_REL(L, 0);
94 UNIVERSE_LIGHT_REGKEY.setValue(L, [U](lua_State* L) { U ? lua_pushlightuserdata( L, U) : lua_pushnil( L); }); 94 UNIVERSE_LIGHT_REGKEY.setValue(L, [U](lua_State* L) { U ? lua_pushlightuserdata(L, U) : lua_pushnil(L); });
95 STACK_CHECK( L, 0); 95 STACK_CHECK(L, 0);
96} 96}
97 97
98// ################################################################################################ 98// ################################################################################################
@@ -101,6 +101,6 @@ Universe* universe_get(lua_State* L)
101{ 101{
102 STACK_CHECK_START_REL(L, 0); 102 STACK_CHECK_START_REL(L, 0);
103 Universe* const universe{ UNIVERSE_LIGHT_REGKEY.readLightUserDataValue<Universe>(L) }; 103 Universe* const universe{ UNIVERSE_LIGHT_REGKEY.readLightUserDataValue<Universe>(L) };
104 STACK_CHECK( L, 0); 104 STACK_CHECK(L, 0);
105 return universe; 105 return universe;
106} 106}
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-04-04 21:55:35 +0000