mlua/src/lib.rs

// Deny warnings inside doc tests / examples
#![doc(test(attr(deny(warnings))))]

extern crate libc;

pub mod ffi;
#[macro_use]
mod util;
mod error;
mod lua;
mod conversion;
mod multi;

#[cfg(test)]
mod tests;

pub use error::{Error, Result, ExternalError, ExternalResult};
pub use lua::{Value, Nil, ToLua, FromLua, MultiValue, ToLuaMulti, FromLuaMulti, Integer, Number,
              LightUserData, String, Table, TablePairs, TableSequence, Function, ThreadStatus,
              Thread, MetaMethod, UserDataMethods, UserData, AnyUserData, Lua};
pub use multi::Variadic;

pub mod prelude;
Riiight, doctests don't even show warnings by default, this flag is important. 2017-08-02 16:12:34 -05:00			`// Deny warnings inside doc tests / examples`
			`#![doc(test(attr(deny(warnings))))]`

Whoops, was testing removing that and placed it back in the wrong place 2017-08-02 15:37:30 -05:00			`extern crate libc;`

Update to use hlist_macro for hlist macros. You will type hlist! hlist_pat! and HList! so often that every character counts. Apologize for the API churn in the README. 2017-05-22 02:09:59 -05:00			`pub mod ffi;`
Another major API change, out of stack space is not an Err It, ahem "should not" be possible to exhaust lua stack space in normal usage, and causing stack errors to be Err is slightly obnoxious. I have been wanting to make this change for a while, and removing the callback API from tables makes this sensible I think. I can think of a couple of ways that this is not technically true, but I think that they are acceptable, or should be handled differently. One, you can make arbitrarily sized LuaVariadic values. I think this is maybe a bug already, because there is an argument limit in Lua which is lower than the stack limit. I'm not sure what happens there, but if it is a stack based panic, (or any panic?) it is a bug. Two, I believe that if you recurse over and over between lua -> rust -> lua -> rust etc, and call rlua API functions, you might get a stack panic. I think for trusted lua code, this is morally equivalent to a regular stack overflow in plain rust, which is already.. well it's not a panic but it's some kind of safe crash I'm not sure, so I think this is acceptable. For untrusted lua code, this could theoretically be a problem if the API provided a callback that would call back into lua, then some lua script could force a stack based panic. There are so many concerns with untrusted lua code, and this library is NOT safe enough yet for untrusted code (it doesn't even provide an option to limit lua to the safe API subset yet!), so this is not currently an issue. When the library provides support for "safe lua", it should come with big warnings anyway, and being able to force a stack panic is pretty minor in comparison. I think if there are other ways to cause unbounded stack usage, that it is a bug, or there can be an error just for that situation, like argument count limits. This commit also fixes several stupid bugs with tests, stack checking, and panics. 2017-06-25 15:52:32 -05:00			`#[macro_use]`
Initial import 2017-05-21 18:50:59 -05:00			`mod util;`
			`mod error;`
			`mod lua;`
			`mod conversion;`
			`mod multi;`

			`#[cfg(test)]`
			`mod tests;`

Do several more Lua prefix renames, add prelude module Rename the following: LuaNil => Nil LuaExternalError => ExternalError LuaExternalResult => ExternalResult LuaCallback => Callback (internal only) Use qualified re-exports at the top of the module. Add a new public 'prelude' module which re-exports everything with a non-conflicting name (Adds back the Lua prefix), and is meant to be imported unqualified. 2017-07-24 06:12:52 -05:00			`pub use error::{Error, Result, ExternalError, ExternalResult};`
			`pub use lua::{Value, Nil, ToLua, FromLua, MultiValue, ToLuaMulti, FromLuaMulti, Integer, Number,`
			`LightUserData, String, Table, TablePairs, TableSequence, Function, ThreadStatus,`
			`Thread, MetaMethod, UserDataMethods, UserData, AnyUserData, Lua};`
			`pub use multi::Variadic;`

			`pub mod prelude;`