summaryrefslogtreecommitdiff
path: root/src/lua.rs
AgeCommit message (Collapse)Author
2018-09-30Allow arbitrary [u8] Lua stringskyren
2018-09-26Improve the situation with numerical conversionkyren
This is a somewhat involved change with two breaking API changes: 1) Lua::coerce_xxx methods now return Option (this is easier and faster than dealing with Result) 2) rlua numeric conversions now allow more loss of precision conversions (e.g. 1.5f32 to 1i32) The logic for the first breaking change is that mostly the coerce methods are probably used internally, and they make sense as low-level fallible casts and are now used as such, and there's no reason to confuse things with a Result with a large error type and force the user to match on the error which will hopefully only be FromLuaConversionError anyway. The logic for the second change is that it matches the behavior of num_traits::cast, and is more consistent in that *some* loss of precision conversions were previously allowed (e.g. f64 to f32). The problem is that now, Lua::coerce_integer and Lua::unpack::<i64> have different behavior when given, for example, the number 1.5. I still think this is the best option, though, because the Lua::coerce_xxx methods represent how Lua works internally and the standard C API cast functions that Lua provides, and the ToLua / FromLua code represents the most common form of fallible Rust numeric conversion. I could revert this change and turn `Lua::eval::<i64>("1.5", None)` back into an error, but it seems inconsistent to allow f64 -> f32 loss of precision but not f64 -> i64 loss of precision.
2018-09-04comment terminology... fix?kyren
2018-09-04code re-org have slightly less pub(crate) itemskyren
2018-09-04Comment updates that I really hope are correctkyren
Tried to explain the rationale for safety around callbacks in Lua and Scope a bit better, because every time I don't look at this for a while I forget my reasoning. I'm not always so great at using the right terminology, so to whoever reads this, if I got this wrong please tell me.
2018-09-04Initial design for non-'static scoped userdatakyren
Uses the same UserData trait, and should at least in theory support everything that 'static UserData does, except that any functions added that rely on AnyUserData are pretty much useless. Probably pretty slow and I'm not sure how to make it dramatically faster, which is a shame because generally when you need non'-static userdata you might be creating it kind of a lot (if it was long-lived, it would probably be 'static). Haven't added tests yet, will do that next.
2018-09-04Don't leak userdata if the metatable creation errors or panicskyren
2018-08-05format with up-to-date rustfmtkyren
2018-08-05very small doc fixeskyren
2018-03-28New approach for ref types, use an auxillary thread stackkyren
Vastly simpler and less magical than using a fixed size magical section of the active stack, and seems to be no slower. The only real downside is that it *seems* extremely extremely hacky (and to be fair, it is).
2018-03-19Small renames and comments to better communicate the intention of stack ↵kyren
checking functions
2018-03-19Where possible, don't call to_lua / from_lua / to_lua_multi / from_lua_multi ↵kyren
callbacks during Lua stack manipulation This should protect against being able to trigger a stack assert in Lua. Lua and associated types shoul be able to assume that LUA_MINSTACK stack slots are available on any user entry point. In the future, we could turn check_stack into something that only checked the Lua stack when debug_assertions is true.
2018-03-19Always ensure LUA_MINSTACK available stack spaces on callbackkyren
Otherwise, cleanly error with an appropriate stack error. Part of an effort to ensure that it should not be possible to trigger a stack space assert.
2018-03-12Fix some bad potential unsafety on inner callback calls.kyren
Since we now optionally use stack spaces for handle values, we have to be mindful of whether our stack handle points to the stack in an outer level of Lua "stack protection". We now keep track of the "recursion level" of Lua instances, and do not allow ref manipulation on "outer" Lua instances until the inner callback has returned. Also, update the documentation to reflect the additional panic behavior.
2018-03-12Use rlua_ asserts instead of unreachable!, changelog updates for 0.14kyren
0.14 will be released alongside `failure` 1.0 with a dependency update.
2018-03-12Documentation updates for new handle behavior, and some minor cleanupkyren
2018-03-12Move several asserts to only be active with debug, bump alpha version numberkyren
2018-03-12Documentation improvements, split scope into its own module, improved testskyren
Also makes `Lua` and associated types !UnwindSafe and !RefUnwindSafe, which they should be because they are intensely internally mutable. Lua IS still panic safe, but that doesn't mean it should be marked as UnwindSafe (as I understand it).
2018-03-12Remove `stack_guard` function and instead just use StackGuard directlykyren
2018-03-11A lot of performance changes.kyren
Okay, so this is kind of a mega-commit of a lot of performance related changes to rlua, some of which are pretty complicated. There are some small improvements here and there, but most of the benefits of this change are from a few big changes. The simplest big change is that there is now `protect_lua` as well as `protect_lua_call`, which allows skipping a lightuserdata parameter and some stack manipulation in some cases. Second simplest is the change to use Vec instead of VecDeque for MultiValue, and to have MultiValue be used as a sort of "backwards-only" Vec so that ToLuaMulti / FromLuaMulti still work correctly. The most complex change, though, is a change to the way LuaRef works, so that LuaRef can optionally point into the Lua stack instead of only registry values. At state creation a set number of stack slots is reserved for the first N LuaRef types (currently 16), and space for these are also allocated separately allocated at callback time. There is a huge breaking change here, which is that now any LuaRef types MUST only be used with the Lua on which they were created, and CANNOT be used with any other Lua callback instance. This mostly will affect people using LuaRef types from inside a scope callback, but hopefully in those cases `Function::bind` will be a suitable replacement. On the plus side, the rules for LuaRef types are easier to state now. There is probably more easy-ish perf on the table here, but here's the preliminary results, based on my very limited benchmarks: create table time: [314.13 ns 315.71 ns 317.44 ns] change: [-36.154% -35.670% -35.205%] (p = 0.00 < 0.05) create array 10 time: [2.9731 us 2.9816 us 2.9901 us] change: [-16.996% -16.600% -16.196%] (p = 0.00 < 0.05) Performance has improved. create string table 10 time: [5.6904 us 5.7164 us 5.7411 us] change: [-53.536% -53.309% -53.079%] (p = 0.00 < 0.05) Performance has improved. call add function 3 10 time: [5.1134 us 5.1222 us 5.1320 us] change: [-4.1095% -3.6910% -3.1781%] (p = 0.00 < 0.05) Performance has improved. call callback add 2 10 time: [5.4408 us 5.4480 us 5.4560 us] change: [-6.4203% -5.7780% -5.0013%] (p = 0.00 < 0.05) Performance has improved. call callback append 10 time: [9.8243 us 9.8410 us 9.8586 us] change: [-26.937% -26.702% -26.469%] (p = 0.00 < 0.05) Performance has improved. create registry 10 time: [3.7005 us 3.7089 us 3.7174 us] change: [-8.4965% -8.1042% -7.6926%] (p = 0.00 < 0.05) Performance has improved. I think that a lot of these benchmarks are too "easy", and most API usage is going to be more like the 'create string table 10' benchmark, where there are a lot of handles and tables and strings, so I think that 25%-50% improvement is a good guess for most use cases.
2018-03-08Enable stack leak panic universallykyren
This will potentially panic on Drop of a `Lua` instance, which may be an abort if this is a double panic, but that is more desirable than such a bug being hidden.
2018-03-08Simplify stack_guard / stack_err_guardkyren
The expected change is always zero, because stack_guard / stack_err_guard are always used at `rlua` entry / exit points.
2018-03-08Whoops, fix an assert that was improperly changed to an internal errorkyren
2018-03-08Change strategies for handling the Lua stack during panicskyren
Previously, on an internal panic, the Lua stack would be reset before panicking in an attempt to make sure that such panics would not cause stack leaks or leave the stack in an unknown state. Now, such panic handling is done in stack_guard and stack_err_guard instead, and this is for a few reasons: 1) The previous approach did NOT handle user triggered panics that were outside of `rlua`, such as a panic in a ToLua / FromLua implementation. This is especially bad since most other panics would be indicative of an internal bug anyway, so the utility of keeping `rlua` types usable after such panics was questionable. It is much more sensible to ensure that `rlua` types are usable after *user generated* panics. 2) Every entry point into `rlua` should be guarded by a stack_guard or stack_err_guard anyway, so this should restore the Lua stack on exiting back to user code in all cases. 3) The method of stack restoration no longer *clears* the stack, only resets it to what it previously was. This allows us, potentially, to keep values at the beginning of the Lua stack long term and know that panics will not clobber them. There may be a way of dramatically speeding up ref types by using a small static area at the beginning of the stack instead of only the registry, so this may be important.
2018-02-19Remove terrible awful no-good evil hackkyren
The breakage is being addressed in rust itself.
2018-02-19Letting scope handles escape the scope was unsafekyren
This simplifies the Scope lifetimes, and should make it a compile error for scope created handles to exit the scope. This should be strictly better, as you would never WANT to do this, but I hope that I have not caused a subtle lifetime problem that would prevent passing those created handles back into Lua. I've tested every situation I can think of, and it doesn't appear to be an issue, but I admit that I don't fully understand everything involved and I could be missing something. The reason that I needed to do this is that if you can let a scope handle escape the scope, you have a LuaRef with an unused registry id, and that can lead to UB. Since not letting the scope references escape is a strict improvement ANYWAY (if I haven't caused a lifetime issue), this is the easiest fix. This is technically a breaking change but I think in most cases if you notice it you would be invoking UB, or you had a function that accepted a Scope or something. I don't know if it's worth a version bump?
2018-02-18Fix several bugs found while doing C conversionkyren
Fixing these in master in case I need to back out the change I'm making
2018-02-16Can.. can I do this? Is this a thing that actually works?kyren
Drastic times and all that.
2018-02-15Provisional "fix" for #71. Requires nightly :(kyren
2018-02-12Some changes for panic correctness, stack usage correctness, and speedkyren
2018-02-11More documentation fixeskyren
2018-02-11Documentation fixes / additionskyren
2018-02-11shave this yak some more, make `Callback` type alias have two lifetimeskyren
2018-02-11Specify the types exactly in the scary transmutekyren
If I happen to change the definition of the Callback type alias, instead of creating a potentially arbitrary transmute, it will now instead fail to compile.
2018-02-11clarify the scary transmutekyren
2018-02-10fix unused process import warningskyren
2018-02-10lua_abort / lua_internal_abort macroskyren
2018-02-09Error correctly on too many arguments / returns / binds / recursionskyren
There are also some other drive-by changes to fix panicking in extern "C" functions and other edge case stack errors
2018-02-09Explicit error type for destructed callbackskyren
Also removes some cleverness if debug_assertions was disabled, as it really doesn't make much of a performance difference.
2018-02-09Actually unref scope created types from the registry AS WELL AS destructing themkyren
2018-02-08Fix some strange lifetime usage on `Lua::create_function`kyren
I don't think that the lifetime of the &Lua in the callback and the lifetime of the &Lua from creating the callback need to be related at all. I'm not sure if this has any actual effect, but it makes more sense (I think?).
2018-02-08Make the `Scope` lifetimes more sensiblekyren
Avoids messy lifetime issues when interacting with other handle types with scope produced values. The whole lifetime situation with 'lua on most methods could actually probably use some looking at, I'm sure it probably has lots of less than optimal decisions in it. This also adds a proper comment to the 'scope lifetime to explain that the key is that 'scope needs to be invariant to make things safe. Disregard my previous commit message, the real problem is that I had a poor understanding of lifetime variance / invaraince.
2018-02-08TERRIBLE HACK FIX I DO NOT UNDERSTANDkyren
Okay, so this is the fix for the previously mentioned lifetime problem. I mimicked the API for `crossbeam::scope` extremely closely for `Lua::scope`, and for some reason things that would not compile with `crossbeam::scope` WOULD compile with `Lua::scope`, and I could not figure it out. So I took the crossbeam source and made tiny edits until I determined the crossover point where invalid borrows would compile, and it was.. not what I expected it to be. Simply replacing a RefCell<Option<DtorChain<'a>>> with a PhantomData<&'a ()> would suddenly cause this to compile with crossbeam: ``` struct Test { field: i32, } crossbeam::scope(|scope| { let mut t = Test { field: 0, }; scope.spawn(|| t.field = 42); drop(t); // ...anything }) ``` which is precisely the same problem as `rlua`. To say I am unsatisfied by this fix is a drastic understatement. SURELY this must be a compiler bug?
2018-02-08This SHOULD fix the lifetime problem with scope... but it doesn't!kyren
The following code should not compile: ``` struct Test { field: i32, } let lua = Lua::new(); lua.scope(|scope| { let mut test = Test { field: 0 }; let f = scope .create_function(|_, ()| { test.field = 42; Ok(()) }) .unwrap(); lua.globals().set("bad!", f).unwrap(); }); ``` yet it does with this commit. However, I have a fix for this, which I do not in any way understand.
2018-02-07slightly faster, less obnoxious scope dropkyren
2018-02-07More correct scope drop behaviorkyren
now no longer aborts if a Drop impl panics
2018-02-07Don't keep the unref list around forever after Lua is droppedkyren
2018-02-06Lots of changes, not sure if actually safe yet.kyren
* Make Lua Send * Add Send bounds to (nearly) all instances where userdata and functions are passed to Lua * Add a "scope" method which takes a callback that accepts a `Scope`, and give `Scope` the ability to create functions and userdata that are !Send, *and also functions that are not even 'static!*.
2018-02-06Don't panic on mismatched `RegistryKey` use, instead return errorkyren
2018-02-06Slightly different strategy with RegistryKey valueskyren
Provide a method for automatic cleanup of expired RegistryKey values, so that manually cleaning up registry values is optional.