delta/mlua
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

format with up-to-date rustfmt

Browse source
This commit is contained in:
kyren 2018-08-05 09:51:39 -04:00
parent e6688e1db2
commit 2e1bdb64c0
20 changed files with 227 additions and 191 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

33
benches/benchmark.rs
View file

@ -58,14 +58,15 @@ fn call_add_function(c: &mut Criterion) {
|| {
let lua = Lua::new();
let f = {
let f: LuaFunction = lua.eval(
r#"
let f: LuaFunction =
lua.eval(
r#"
function(a, b, c)
return a + b + c
end
"#,
None,
).unwrap();
None,
).unwrap();
lua.create_registry_value(f).unwrap()
};
(lua, f)
@ -89,20 +90,21 @@ fn call_add_callback(c: &mut Criterion) {
|| {
let lua = Lua::new();
let f = {
let c: LuaFunction = lua.create_function(|_, (a, b, c): (i64, i64, i64)| {
Ok(a + b + c)
}).unwrap();
let c: LuaFunction = lua
.create_function(|_, (a, b, c): (i64, i64, i64)| Ok(a + b + c))
.unwrap();
lua.globals().set("callback", c).unwrap();
let f: LuaFunction = lua.eval(
r#"
let f: LuaFunction =
lua.eval(
r#"
function()
for i = 1,10 do
callback(i, i, i)
end
end
"#,
None,
).unwrap();
None,
).unwrap();
lua.create_registry_value(f).unwrap()
};
(lua, f)
@ -129,16 +131,17 @@ fn call_append_callback(c: &mut Criterion) {
Ok(format!("{}{}", a.to_str()?, b.to_str()?))
}).unwrap();
lua.globals().set("callback", c).unwrap();
let f: LuaFunction = lua.eval(
r#"
let f: LuaFunction =
lua.eval(
r#"
function()
for _ = 1,10 do
callback("a", "b")
end
end
"#,
None,
).unwrap();
None,
).unwrap();
lua.create_registry_value(f).unwrap()
};
(lua, f)

16
src/conversion.rs
View file

@ -3,14 +3,14 @@ use std::hash::{BuildHasher, Hash};
use std::string::String as StdString;
use error::{Error, Result};
use types::{Integer, LightUserData, Number};
use function::Function;
use lua::Lua;
use string::String;
use table::Table;
use userdata::{AnyUserData, UserData};
use function::Function;
use thread::Thread;
use types::{Integer, LightUserData, Number};
use userdata::{AnyUserData, UserData};
use value::{FromLua, Nil, ToLua, Value};
use lua::Lua;
impl<'lua> ToLua<'lua> for Value<'lua> {
fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
@ -204,7 +204,7 @@ impl<'lua, 'a> ToLua<'lua> for &'a str {
}
macro_rules! lua_convert_int {
($x: ty) => {
($x:ty) => {
impl<'lua> ToLua<'lua> for $x {
fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
Ok(Value::Integer(self as Integer))
@ -216,7 +216,7 @@ macro_rules! lua_convert_int {
Ok(lua.coerce_integer(value)? as $x)
}
}
}
};
}
lua_convert_int!(i8);
@ -231,7 +231,7 @@ lua_convert_int!(isize);
lua_convert_int!(usize);
macro_rules! lua_convert_float {
($x: ty) => {
($x:ty) => {
impl<'lua> ToLua<'lua> for $x {
fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
Ok(Value::Number(self as Number))
@ -243,7 +243,7 @@ macro_rules! lua_convert_float {
Ok(lua.coerce_number(value)? as $x)
}
}
}
};
}
lua_convert_float!(f32);

2
src/ffi.rs
View file

@ -2,9 +2,9 @@
#![allow(non_snake_case)]
#![allow(unused)]
use std::ptr;
use std::mem;
use std::os::raw::{c_char, c_double, c_int, c_longlong, c_uchar, c_void};
use std::ptr;
pub type lua_Integer = c_longlong;
pub type lua_Number = c_double;

8
src/function.rs
View file

@ -1,10 +1,12 @@
use std::ptr;
use std::os::raw::c_int;
use std::ptr;
use ffi;
use error::{Error, Result};
use util::{assert_stack, check_stack, error_traceback, pop_error, protect_lua_closure, StackGuard};
use ffi;
use types::LuaRef;
use util::{
assert_stack, check_stack, error_traceback, pop_error, protect_lua_closure, StackGuard,
};
use value::{FromLuaMulti, MultiValue, ToLuaMulti};
/// Handle to an internal Lua function.

22
src/lib.rs
View file

@ -44,36 +44,36 @@
extern crate failure;
extern crate libc;
mod ffi;
mod error;
mod ffi;
#[macro_use]
mod macros;
mod util;
mod value;
mod types;
mod lua;
mod conversion;
mod function;
mod lua;
mod multi;
mod scope;
mod string;
mod table;
mod function;
mod thread;
mod types;
mod userdata;
mod scope;
mod util;
mod value;
#[cfg(test)]
mod tests;
pub use error::{Error, ExternalError, ExternalResult, Result};
pub use types::{Integer, LightUserData, Number, RegistryKey};
pub use function::Function;
pub use lua::Lua;
pub use multi::Variadic;
pub use scope::Scope;
pub use string::String;
pub use table::{Table, TablePairs, TableSequence};
pub use function::Function;
pub use thread::{Thread, ThreadStatus};
pub use types::{Integer, LightUserData, Number, RegistryKey};
pub use userdata::{AnyUserData, MetaMethod, UserData, UserDataMethods};
pub use value::{FromLua, FromLuaMulti, MultiValue, Nil, ToLua, ToLuaMulti, Value};
pub use lua::Lua;
pub use scope::Scope;
pub mod prelude;

32
src/lua.rs
View file

@ -1,28 +1,29 @@
use std::{mem, ptr, str};
use std::sync::{Arc, Mutex};
use std::cell::{RefCell, UnsafeCell};
use std::ffi::CString;
use std::any::TypeId;
use std::marker::PhantomData;
use std::cell::{RefCell, UnsafeCell};
use std::collections::HashMap;
use std::ffi::CString;
use std::marker::PhantomData;
use std::os::raw::{c_char, c_int, c_void};
use std::sync::{Arc, Mutex};
use std::{mem, ptr, str};
use libc;
use ffi;
use error::{Error, Result};
use util::{assert_stack, callback_error, check_stack, gc_guard, get_userdata, get_wrapped_error,
init_error_metatables, main_state, pop_error, protect_lua, protect_lua_closure,
push_string, push_userdata, push_wrapped_error, safe_pcall, safe_xpcall,
userdata_destructor, StackGuard};
use value::{FromLua, FromLuaMulti, MultiValue, Nil, ToLua, ToLuaMulti, Value};
use types::{Callback, Integer, LightUserData, LuaRef, Number, RegistryKey};
use ffi;
use function::Function;
use scope::Scope;
use string::String;
use table::Table;
use function::Function;
use thread::Thread;
use types::{Callback, Integer, LightUserData, LuaRef, Number, RegistryKey};
use userdata::{AnyUserData, MetaMethod, UserData, UserDataMethods};
use scope::Scope;
use util::{
assert_stack, callback_error, check_stack, gc_guard, get_userdata, get_wrapped_error,
init_error_metatables, main_state, pop_error, protect_lua, protect_lua_closure, push_string,
push_userdata, push_wrapped_error, safe_pcall, safe_xpcall, userdata_destructor, StackGuard,
};
use value::{FromLua, FromLuaMulti, MultiValue, Nil, ToLua, ToLuaMulti, Value};
/// Top level Lua struct which holds the Lua state itself.
pub struct Lua {
@ -285,7 +286,8 @@ impl Lua {
{
let func = RefCell::new(func);
self.create_function(move |lua, args| {
(&mut *func.try_borrow_mut()
(&mut *func
.try_borrow_mut()
.map_err(|_| Error::RecursiveMutCallback)?)(lua, args)
})
}

7
src/macros.rs
View file

@ -1,7 +1,8 @@
macro_rules! cstr {
($s:expr) => (
concat!($s, "\0") as *const str as *const [::std::os::raw::c_char] as *const ::std::os::raw::c_char
);
($s:expr) => {
concat!($s, "\0") as *const str as *const [::std::os::raw::c_char]
as *const ::std::os::raw::c_char
};
}
macro_rules! abort {

4
src/multi.rs
View file

@ -1,10 +1,10 @@
use std::ops::{Deref, DerefMut};
use std::iter::FromIterator;
use std::ops::{Deref, DerefMut};
use std::result::Result as StdResult;
use error::Result;
use value::{FromLua, FromLuaMulti, MultiValue, Nil, ToLua, ToLuaMulti};
use lua::Lua;
use value::{FromLua, FromLuaMulti, MultiValue, Nil, ToLua, ToLuaMulti};
/// Result is convertible to `MultiValue` following the common Lua idiom of returning the result
/// on success, or in the case of an error, returning `nil` and an error message.

19
src/prelude.rs
View file

@ -1,11 +1,12 @@
//! Re-exports most types with an extra `Lua*` prefix to prevent name clashes.
pub use {AnyUserData as LuaAnyUserData, Error as LuaError, ExternalError as LuaExternalError,
ExternalResult as LuaExternalResult, FromLua, FromLuaMulti, Function as LuaFunction,
Integer as LuaInteger, LightUserData as LuaLightUserData, Lua,
MetaMethod as LuaMetaMethod, MultiValue as LuaMultiValue, Nil as LuaNil,
Number as LuaNumber, RegistryKey as LuaRegistryKey, Result as LuaResult,
Scope as LuaScope, String as LuaString, Table as LuaTable, TablePairs as LuaTablePairs,
TableSequence as LuaTableSequence, Thread as LuaThread, ThreadStatus as LuaThreadStatus,
ToLua, ToLuaMulti, UserData as LuaUserData, UserDataMethods as LuaUserDataMethods,
Value as LuaValue};
pub use {
AnyUserData as LuaAnyUserData, Error as LuaError, ExternalError as LuaExternalError,
ExternalResult as LuaExternalResult, FromLua, FromLuaMulti, Function as LuaFunction,
Integer as LuaInteger, LightUserData as LuaLightUserData, Lua, MetaMethod as LuaMetaMethod,
MultiValue as LuaMultiValue, Nil as LuaNil, Number as LuaNumber, RegistryKey as LuaRegistryKey,
Result as LuaResult, Scope as LuaScope, String as LuaString, Table as LuaTable,
TablePairs as LuaTablePairs, TableSequence as LuaTableSequence, Thread as LuaThread,
ThreadStatus as LuaThreadStatus, ToLua, ToLuaMulti, UserData as LuaUserData,
UserDataMethods as LuaUserDataMethods, Value as LuaValue,
};

20
src/scope.rs
View file

@ -1,16 +1,16 @@
use std::mem;
use std::cell::RefCell;
use std::any::Any;
use std::cell::RefCell;
use std::marker::PhantomData;
use std::mem;
use ffi;
use error::{Error, Result};
use ffi;
use function::Function;
use lua::Lua;
use types::Callback;
use userdata::{AnyUserData, UserData};
use util::{assert_stack, take_userdata, StackGuard};
use value::{FromLuaMulti, ToLuaMulti};
use types::Callback;
use lua::Lua;
use function::Function;
use userdata::{AnyUserData, UserData};
/// Constructed by the [`Lua::scope`] method, allows temporarily passing to Lua userdata that is
/// !Send, and callbacks that are !Send and not 'static.
@ -109,7 +109,8 @@ impl<'scope> Scope<'scope> {
{
let func = RefCell::new(func);
self.create_function(move |lua, args| {
(&mut *func.try_borrow_mut()
(&mut *func
.try_borrow_mut()
.map_err(|_| Error::RecursiveMutCallback)?)(lua, args)
})
}
@ -148,7 +149,8 @@ impl<'scope> Drop for Scope<'scope> {
// userdata type into two phases. This is so that, in the event a userdata drop panics, we
// can be sure that all of the userdata in Lua is actually invalidated.
let to_drop = self.destructors
let to_drop = self
.destructors
.get_mut()
.drain(..)
.map(|destructor| destructor())

4
src/string.rs
View file

@ -1,9 +1,9 @@
use std::{slice, str};
use ffi;
use error::{Error, Result};
use util::{assert_stack, StackGuard};
use ffi;
use types::LuaRef;
use util::{assert_stack, StackGuard};
/// Handle to an internal Lua string.
///

4
src/table.rs
View file

@ -1,10 +1,10 @@
use std::marker::PhantomData;
use std::os::raw::c_int;
use ffi;
use error::Result;
use util::{assert_stack, protect_lua, protect_lua_closure, StackGuard};
use ffi;
use types::{Integer, LuaRef};
use util::{assert_stack, protect_lua, protect_lua_closure, StackGuard};
use value::{FromLua, Nil, ToLua, Value};
/// Handle to an internal Lua table.

156
src/tests/mod.rs
View file

@ -5,15 +5,17 @@ mod thread;
mod types;
mod userdata;
use std::{error, fmt};
use std::iter::FromIterator;
use std::rc::Rc;
use std::cell::Cell;
use std::sync::Arc;
use std::iter::FromIterator;
use std::panic::catch_unwind;
use std::rc::Rc;
use std::sync::Arc;
use std::{error, fmt};
use {Error, ExternalError, Function, Lua, Nil, Result, String, Table, UserData, UserDataMethods,
Value, Variadic};
use {
Error, ExternalError, Function, Lua, Nil, Result, String, Table, UserData, UserDataMethods,
Value, Variadic,
};
#[test]
fn test_load() {
@ -51,8 +53,9 @@ fn test_exec() {
).unwrap();
assert_eq!(globals.get::<_, String>("res").unwrap(), "foobar");
let module: Table = lua.exec(
r#"
let module: Table =
lua.exec(
r#"
local module = {}
function module.func()
@ -61,8 +64,8 @@ fn test_exec() {
return module
"#,
None,
).unwrap();
None,
).unwrap();
assert!(module.contains_key("func").unwrap());
assert_eq!(
module
@ -214,9 +217,9 @@ fn test_error() {
None,
).unwrap();
let rust_error_function = lua.create_function(|_, ()| -> Result<()> {
Err(TestError.to_lua_err())
}).unwrap();
let rust_error_function = lua
.create_function(|_, ()| -> Result<()> { Err(TestError.to_lua_err()) })
.unwrap();
globals
.set("rust_error_function", rust_error_function)
.unwrap();
@ -281,9 +284,9 @@ fn test_error() {
"#,
None,
)?;
let rust_panic_function = lua.create_function(|_, ()| -> Result<()> {
panic!("test_panic")
}).unwrap();
let rust_panic_function = lua
.create_function(|_, ()| -> Result<()> { panic!("test_panic") })
.unwrap();
globals.set("rust_panic_function", rust_panic_function)?;
let rust_panic = globals.get::<_, Function>("rust_panic")?;
@ -307,9 +310,9 @@ fn test_error() {
"#,
None,
)?;
let rust_panic_function = lua.create_function(|_, ()| -> Result<()> {
panic!("test_panic")
}).unwrap();
let rust_panic_function = lua
.create_function(|_, ()| -> Result<()> { panic!("test_panic") })
.unwrap();
globals.set("rust_panic_function", rust_panic_function)?;
let rust_panic = globals.get::<_, Function>("rust_panic")?;
@ -327,12 +330,14 @@ fn test_result_conversions() {
let lua = Lua::new();
let globals = lua.globals();
let err = lua.create_function(|_, ()| {
Ok(Err::<String, _>(
format_err!("only through failure can we succeed").to_lua_err(),
))
}).unwrap();
let ok = lua.create_function(|_, ()| Ok(Ok::<_, Error>("!".to_owned())))
let err =
lua.create_function(|_, ()| {
Ok(Err::<String, _>(
format_err!("only through failure can we succeed").to_lua_err(),
))
}).unwrap();
let ok = lua
.create_function(|_, ()| Ok(Ok::<_, Error>("!".to_owned())))
.unwrap();
globals.set("err", err).unwrap();
@ -389,12 +394,14 @@ fn test_pcall_xpcall() {
// Make sure that the return values from are correct on success
let (r, e) = lua.eval::<(bool, String)>("pcall(function(p) return p end, 'foo')", None)
let (r, e) = lua
.eval::<(bool, String)>("pcall(function(p) return p end, 'foo')", None)
.unwrap();
assert!(r);
assert_eq!(e, "foo");
let (r, e) = lua.eval::<(bool, String)>("xpcall(function(p) return p end, print, 'foo')", None)
let (r, e) = lua
.eval::<(bool, String)>("xpcall(function(p) return p end, print, 'foo')", None)
.unwrap();
assert!(r);
assert_eq!(e, "foo");
@ -444,23 +451,26 @@ fn test_recursive_mut_callback_error() {
let lua = Lua::new();
let mut v = Some(Box::new(123));
let f = lua.create_function_mut::<_, (), _>(move |lua, mutate: bool| {
if mutate {
v = None;
} else {
// Produce a mutable reference
let r = v.as_mut().unwrap();
// Whoops, this will recurse into the function and produce another mutable reference!
lua.globals().get::<_, Function>("f")?.call::<_, ()>(true)?;
println!("Should not get here, mutable aliasing has occurred!");
println!("value at {:p}", r as *mut _);
println!("value is {}", r);
}
let f = lua
.create_function_mut::<_, (), _>(move |lua, mutate: bool| {
if mutate {
v = None;
} else {
// Produce a mutable reference
let r = v.as_mut().unwrap();
// Whoops, this will recurse into the function and produce another mutable reference!
lua.globals().get::<_, Function>("f")?.call::<_, ()>(true)?;
println!("Should not get here, mutable aliasing has occurred!");
println!("value at {:p}", r as *mut _);
println!("value is {}", r);
}
Ok(())
}).unwrap();
Ok(())
})
.unwrap();
lua.globals().set("f", f).unwrap();
match lua.globals()
match lua
.globals()
.get::<_, Function>("f")
.unwrap()
.call::<_, ()>(false)
@ -516,10 +526,11 @@ fn test_named_registry_value() {
let lua = Lua::new();
lua.set_named_registry_value::<i32>("test", 42).unwrap();
let f = lua.create_function(move |lua, ()| {
assert_eq!(lua.named_registry_value::<i32>("test")?, 42);
Ok(())
}).unwrap();
let f =
lua.create_function(move |lua, ()| {
assert_eq!(lua.named_registry_value::<i32>("test")?, 42);
Ok(())
}).unwrap();
f.call::<_, ()>(()).unwrap();
@ -535,15 +546,16 @@ fn test_registry_value() {
let lua = Lua::new();
let mut r = Some(lua.create_registry_value::<i32>(42).unwrap());
let f = lua.create_function_mut(move |lua, ()| {
if let Some(r) = r.take() {
assert_eq!(lua.registry_value::<i32>(&r)?, 42);
lua.remove_registry_value(r).unwrap();
} else {
panic!();
}
Ok(())
}).unwrap();
let f =
lua.create_function_mut(move |lua, ()| {
if let Some(r) = r.take() {
assert_eq!(lua.registry_value::<i32>(&r)?, 42);
lua.remove_registry_value(r).unwrap();
} else {
panic!();
}
Ok(())
}).unwrap();
f.call::<_, ()>(()).unwrap();
}
@ -628,7 +640,8 @@ fn scope_func() {
assert_eq!(rc.get(), 42);
assert_eq!(Rc::strong_count(&rc), 1);
match lua.globals()
match lua
.globals()
.get::<_, Function>("bad")
.unwrap()
.call::<_, ()>(())
@ -706,7 +719,8 @@ fn outer_lua_access() {
#[test]
fn too_many_returns() {
let lua = Lua::new();
let f = lua.create_function(|_, ()| Ok(Variadic::from_iter(1..1000000)))
let f = lua
.create_function(|_, ()| Ok(Variadic::from_iter(1..1000000)))
.unwrap();
assert!(f.call::<_, Vec<u32>>(()).is_err());
}
@ -729,9 +743,9 @@ fn too_many_arguments() {
fn too_many_recursions() {
let lua = Lua::new();
let f = lua.create_function(move |lua, ()| {
lua.globals().get::<_, Function>("f")?.call::<_, ()>(())
}).unwrap();
let f = lua
.create_function(move |lua, ()| lua.globals().get::<_, Function>("f")?.call::<_, ()>(()))
.unwrap();
lua.globals().set("f", f).unwrap();
assert!(
@ -783,14 +797,15 @@ fn large_args() {
)
.unwrap();
let f: Function = lua.eval(
r#"
let f: Function =
lua.eval(
r#"
return function(...)
return c(...)
end
"#,
None,
).unwrap();
None,
).unwrap();
assert_eq!(
f.call::<_, usize>((0..100).collect::<Variadic<usize>>())
@ -803,12 +818,13 @@ fn large_args() {
fn large_args_ref() {
let lua = Lua::new();
let f = lua.create_function(|_, args: Variadic<String>| {
for i in 0..args.len() {
assert_eq!(args[i], i.to_string());
}
Ok(())
}).unwrap();
let f =
lua.create_function(|_, args: Variadic<String>| {
for i in 0..args.len() {
assert_eq!(args[i], i.to_string());
}
Ok(())
}).unwrap();
f.call::<_, ()>((0..100).map(|i| i.to_string()).collect::<Variadic<_>>())
.unwrap();

42
src/tests/thread.rs
View file

@ -5,8 +5,10 @@ use {Error, Function, Lua, Result, Thread, ThreadStatus};
#[test]
fn test_thread() {
let lua = Lua::new();
let thread = lua.create_thread(lua.eval::<Function>(
r#"
let thread =
lua.create_thread(
lua.eval::<Function>(
r#"
function (s)
local sum = s
for i = 1,4 do
@ -15,9 +17,9 @@ fn test_thread() {
return sum
end
"#,
None,
).unwrap())
.unwrap();
None,
).unwrap(),
).unwrap();
assert_eq!(thread.status(), ThreadStatus::Resumable);
assert_eq!(thread.resume::<_, i64>(0).unwrap(), 0);
@ -31,17 +33,19 @@ fn test_thread() {
assert_eq!(thread.resume::<_, i64>(4).unwrap(), 10);
assert_eq!(thread.status(), ThreadStatus::Unresumable);
let accumulate = lua.create_thread(lua.eval::<Function>(
r#"
let accumulate =
lua.create_thread(
lua.eval::<Function>(
r#"
function (sum)
while true do
sum = sum + coroutine.yield(sum)
end
end
"#,
None,
).unwrap())
.unwrap();
None,
).unwrap(),
).unwrap();
for i in 0..4 {
accumulate.resume::<_, ()>(i).unwrap();
@ -51,21 +55,23 @@ fn test_thread() {
assert!(accumulate.resume::<_, ()>("error").is_err());
assert_eq!(accumulate.status(), ThreadStatus::Error);
let thread = lua.eval::<Thread>(
r#"
let thread =
lua.eval::<Thread>(
r#"
coroutine.create(function ()
while true do
coroutine.yield(42)
end
end)
"#,
None,
).unwrap();
None,
).unwrap();
assert_eq!(thread.status(), ThreadStatus::Resumable);
assert_eq!(thread.resume::<_, i64>(()).unwrap(), 42);
let thread: Thread = lua.eval(
r#"
let thread: Thread =
lua.eval(
r#"
coroutine.create(function(arg)
assert(arg == 42)
local yieldarg = coroutine.yield(123)
@ -73,8 +79,8 @@ fn test_thread() {
return 987
end)
"#,
None,
).unwrap();
None,
).unwrap();
assert_eq!(thread.resume::<_, u32>(42).unwrap(), 123);
assert_eq!(thread.resume::<_, u32>(43).unwrap(), 987);

10
src/tests/userdata.rs
View file

@ -131,8 +131,9 @@ fn test_gc_userdata() {
globals.set("userdata", MyUserdata { id: 123 }).unwrap();
}
assert!(lua.eval::<()>(
r#"
assert!(
lua.eval::<()>(
r#"
local tbl = setmetatable({
userdata = userdata
}, { __gc = function(self)
@ -145,8 +146,9 @@ fn test_gc_userdata() {
collectgarbage("collect")
hatch:access()
"#,
None
).is_err());
None
).is_err()
);
}
#[test]

4
src/thread.rs
View file

@ -1,9 +1,9 @@
use std::os::raw::c_int;
use ffi;
use error::{Error, Result};
use util::{assert_stack, check_stack, error_traceback, pop_error, StackGuard};
use ffi;
use types::LuaRef;
use util::{assert_stack, check_stack, error_traceback, pop_error, StackGuard};
use value::{FromLuaMulti, MultiValue, ToLuaMulti};
/// Status of a Lua thread (or coroutine).

6
src/types.rs
View file

@ -1,11 +1,11 @@
use std::{fmt, mem, ptr};
use std::os::raw::{c_int, c_void};
use std::sync::{Arc, Mutex};
use std::{fmt, mem, ptr};
use ffi;
use error::Result;
use value::MultiValue;
use ffi;
use lua::Lua;
use value::MultiValue;
/// Type of Lua integer numbers.
pub type Integer = ffi::lua_Integer;

13
src/userdata.rs
View file

@ -1,14 +1,14 @@
use std::cell::{Ref, RefCell, RefMut};
use std::marker::PhantomData;
use std::collections::HashMap;
use std::marker::PhantomData;
use std::string::String as StdString;
use ffi;
use error::{Error, Result};
use util::{assert_stack, get_userdata, StackGuard};
use types::{Callback, LuaRef};
use value::{FromLua, FromLuaMulti, ToLua, ToLuaMulti};
use ffi;
use lua::Lua;
use types::{Callback, LuaRef};
use util::{assert_stack, get_userdata, StackGuard};
use value::{FromLua, FromLuaMulti, ToLua, ToLuaMulti};
/// Kinds of metamethods that can be overridden.
///
@ -403,7 +403,8 @@ impl<'lua> AnyUserData<'lua> {
/// `UserDataTypeMismatch` if the userdata is not of type `T`.
pub fn borrow_mut<T: UserData>(&self) -> Result<RefMut<T>> {
self.inspect(|cell| {
Ok(cell.try_borrow_mut()
Ok(cell
.try_borrow_mut()
.map_err(|_| Error::UserDataBorrowMutError)?)
})
}

8
src/util.rs
View file

@ -1,12 +1,12 @@
use std::{mem, ptr};
use std::sync::Arc;
use std::ffi::CStr;
use std::any::Any;
use std::ffi::CStr;
use std::os::raw::{c_char, c_int, c_void};
use std::panic::{catch_unwind, resume_unwind, AssertUnwindSafe};
use std::sync::Arc;
use std::{mem, ptr};
use ffi;
use error::{Error, Result};
use ffi;
// Checks that Lua has enough free stack space for future stack operations. On failure, this will
// panic with an internal error message.

8
src/value.rs
View file

@ -1,14 +1,14 @@
use std::{slice, str, vec};
use std::iter::{self, FromIterator};
use std::{slice, str, vec};
use error::{Error, Result};
use types::{Integer, LightUserData, Number};
use function::Function;
use lua::Lua;
use string::String;
use table::Table;
use function::Function;
use thread::Thread;
use types::{Integer, LightUserData, Number};
use userdata::AnyUserData;
use lua::Lua;
/// A dynamically typed Lua value. The `String`, `Table`, `Function`, `Thread`, and `UserData`
/// variants contain handle types into the internal Lua state. It is a logic error to mix handle