Merge pull request #17 from jonas-schievink/remove-lua-prefix
Remove the `Lua*` prefix from most types
This commit is contained in:
commit
1eaa201441
|
@ -4,9 +4,9 @@ extern crate rlua;
|
|||
|
||||
use std::f32;
|
||||
|
||||
use rlua::*;
|
||||
use rlua::{Lua, Result, Function, Variadic, UserData, UserDataMethods, MetaMethod};
|
||||
|
||||
fn examples() -> LuaResult<()> {
|
||||
fn examples() -> Result<()> {
|
||||
// Create a Lua context with Lua::new(). Eventually, this will allow
|
||||
// further control on the lua std library, and will specifically allow
|
||||
// limiting Lua to a subset of "safe" functionality.
|
||||
|
@ -56,7 +56,7 @@ fn examples() -> LuaResult<()> {
|
|||
let v: i64 = map_table.get("two")?;
|
||||
assert_eq!(v, 2);
|
||||
|
||||
// You can pass values like LuaTable back into Lua
|
||||
// You can pass values like Table back into Lua
|
||||
|
||||
globals.set("array_table", array_table)?;
|
||||
globals.set("map_table", map_table)?;
|
||||
|
@ -76,7 +76,7 @@ fn examples() -> LuaResult<()> {
|
|||
|
||||
// You can load lua functions
|
||||
|
||||
let print: LuaFunction = globals.get("print")?;
|
||||
let print: Function = globals.get("print")?;
|
||||
print.call::<_, ()>("hello from rust")?;
|
||||
|
||||
// This API handles variadics using Heterogeneous Lists. This is one way to
|
||||
|
@ -90,8 +90,8 @@ fn examples() -> LuaResult<()> {
|
|||
|
||||
let check_equal = lua.create_function(|lua, args| {
|
||||
// Functions wrapped in lua receive their arguments packed together as
|
||||
// LuaMultiValue. The first thing that most wrapped functions will do
|
||||
// is "unpack" this LuaMultiValue into its parts. Due to lifetime type
|
||||
// MultiValue. The first thing that most wrapped functions will do
|
||||
// is "unpack" this MultiValue into its parts. Due to lifetime type
|
||||
// signature limitations, this cannot be done automatically from the
|
||||
// function signature, but this will be fixed with ATCs. Notice the use
|
||||
// of the hlist macros again.
|
||||
|
@ -99,7 +99,7 @@ fn examples() -> LuaResult<()> {
|
|||
|
||||
// This function just checks whether two string lists are equal, and in
|
||||
// an inefficient way. Results are returned with lua.pack, which takes
|
||||
// any number of values and turns them back into LuaMultiValue. In this
|
||||
// any number of values and turns them back into MultiValue. In this
|
||||
// way, multiple values can also be returned to Lua. Again, this cannot
|
||||
// be inferred as part of the function signature due to the same
|
||||
// lifetime type signature limitations.
|
||||
|
@ -110,7 +110,7 @@ fn examples() -> LuaResult<()> {
|
|||
// You can also accept variadic arguments to rust callbacks.
|
||||
|
||||
let join = lua.create_function(|lua, args| {
|
||||
let strings = lua.unpack::<LuaVariadic<String>>(args)?.0;
|
||||
let strings = lua.unpack::<Variadic<String>>(args)?.0;
|
||||
// (This is quadratic!, it's just an example!)
|
||||
lua.pack(strings.iter().fold("".to_owned(), |a, b| a + b))
|
||||
});
|
||||
|
@ -139,14 +139,14 @@ fn examples() -> LuaResult<()> {
|
|||
#[derive(Copy, Clone)]
|
||||
struct Vec2(f32, f32);
|
||||
|
||||
impl LuaUserDataType for Vec2 {
|
||||
fn add_methods(methods: &mut LuaUserDataMethods<Self>) {
|
||||
impl UserData for Vec2 {
|
||||
fn add_methods(methods: &mut UserDataMethods<Self>) {
|
||||
methods.add_method("magnitude", |lua, vec, _| {
|
||||
let mag_squared = vec.0 * vec.0 + vec.1 * vec.1;
|
||||
lua.pack(mag_squared.sqrt())
|
||||
});
|
||||
|
||||
methods.add_meta_function(LuaMetaMethod::Add, |lua, params| {
|
||||
methods.add_meta_function(MetaMethod::Add, |lua, params| {
|
||||
let hlist_pat![vec1, vec2] = lua.unpack::<HList![Vec2, Vec2]>(params)?;
|
||||
lua.pack(Vec2(vec1.0 + vec2.0, vec1.1 + vec2.1))
|
||||
});
|
||||
|
|
|
@ -2,7 +2,7 @@
|
|||
|
||||
extern crate rlua;
|
||||
|
||||
use rlua::*;
|
||||
use rlua::{Lua, MultiValue, Error};
|
||||
use std::io::prelude::*;
|
||||
use std::io::{stdin, stdout, stderr, BufReader};
|
||||
|
||||
|
@ -20,7 +20,7 @@ fn main() {
|
|||
loop {
|
||||
stdin.read_line(&mut line).unwrap();
|
||||
|
||||
match lua.eval::<LuaMultiValue>(&line, None) {
|
||||
match lua.eval::<MultiValue>(&line, None) {
|
||||
Ok(values) => {
|
||||
println!(
|
||||
"{}",
|
||||
|
@ -32,7 +32,7 @@ fn main() {
|
|||
);
|
||||
break;
|
||||
}
|
||||
Err(LuaError::IncompleteStatement(_)) => {
|
||||
Err(Error::IncompleteStatement(_)) => {
|
||||
// continue reading input and append it to `line`
|
||||
write!(stdout, ">> ").unwrap();
|
||||
stdout.flush().unwrap();
|
||||
|
|
|
@ -1,129 +1,130 @@
|
|||
use std::collections::{HashMap, BTreeMap};
|
||||
use std::hash::Hash;
|
||||
use std::string::String as StdString;
|
||||
|
||||
use error::*;
|
||||
use lua::*;
|
||||
|
||||
impl<'lua> ToLua<'lua> for LuaValue<'lua> {
|
||||
fn to_lua(self, _: &'lua Lua) -> LuaResult<LuaValue<'lua>> {
|
||||
impl<'lua> ToLua<'lua> for Value<'lua> {
|
||||
fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
|
||||
Ok(self)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'lua> FromLua<'lua> for LuaValue<'lua> {
|
||||
fn from_lua(lua_value: LuaValue<'lua>, _: &'lua Lua) -> LuaResult<Self> {
|
||||
impl<'lua> FromLua<'lua> for Value<'lua> {
|
||||
fn from_lua(lua_value: Value<'lua>, _: &'lua Lua) -> Result<Self> {
|
||||
Ok(lua_value)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'lua> ToLua<'lua> for LuaString<'lua> {
|
||||
fn to_lua(self, _: &'lua Lua) -> LuaResult<LuaValue<'lua>> {
|
||||
Ok(LuaValue::String(self))
|
||||
impl<'lua> ToLua<'lua> for String<'lua> {
|
||||
fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
|
||||
Ok(Value::String(self))
|
||||
}
|
||||
}
|
||||
|
||||
impl<'lua> FromLua<'lua> for LuaString<'lua> {
|
||||
fn from_lua(value: LuaValue<'lua>, lua: &'lua Lua) -> LuaResult<LuaString<'lua>> {
|
||||
impl<'lua> FromLua<'lua> for String<'lua> {
|
||||
fn from_lua(value: Value<'lua>, lua: &'lua Lua) -> Result<String<'lua>> {
|
||||
lua.coerce_string(value)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'lua> ToLua<'lua> for LuaTable<'lua> {
|
||||
fn to_lua(self, _: &'lua Lua) -> LuaResult<LuaValue> {
|
||||
Ok(LuaValue::Table(self))
|
||||
impl<'lua> ToLua<'lua> for Table<'lua> {
|
||||
fn to_lua(self, _: &'lua Lua) -> Result<Value> {
|
||||
Ok(Value::Table(self))
|
||||
}
|
||||
}
|
||||
|
||||
impl<'lua> FromLua<'lua> for LuaTable<'lua> {
|
||||
fn from_lua(value: LuaValue<'lua>, _: &'lua Lua) -> LuaResult<LuaTable<'lua>> {
|
||||
impl<'lua> FromLua<'lua> for Table<'lua> {
|
||||
fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<Table<'lua>> {
|
||||
match value {
|
||||
LuaValue::Table(table) => Ok(table),
|
||||
_ => Err(LuaError::FromLuaConversionError(
|
||||
Value::Table(table) => Ok(table),
|
||||
_ => Err(Error::FromLuaConversionError(
|
||||
"cannot convert lua value to table".to_owned(),
|
||||
)),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'lua> ToLua<'lua> for LuaFunction<'lua> {
|
||||
fn to_lua(self, _: &'lua Lua) -> LuaResult<LuaValue<'lua>> {
|
||||
Ok(LuaValue::Function(self))
|
||||
impl<'lua> ToLua<'lua> for Function<'lua> {
|
||||
fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
|
||||
Ok(Value::Function(self))
|
||||
}
|
||||
}
|
||||
|
||||
impl<'lua> FromLua<'lua> for LuaFunction<'lua> {
|
||||
fn from_lua(value: LuaValue<'lua>, _: &'lua Lua) -> LuaResult<LuaFunction<'lua>> {
|
||||
impl<'lua> FromLua<'lua> for Function<'lua> {
|
||||
fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<Function<'lua>> {
|
||||
match value {
|
||||
LuaValue::Function(table) => Ok(table),
|
||||
_ => Err(LuaError::FromLuaConversionError(
|
||||
Value::Function(table) => Ok(table),
|
||||
_ => Err(Error::FromLuaConversionError(
|
||||
"cannot convert lua value to function".to_owned(),
|
||||
)),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'lua> ToLua<'lua> for LuaThread<'lua> {
|
||||
fn to_lua(self, _: &'lua Lua) -> LuaResult<LuaValue<'lua>> {
|
||||
Ok(LuaValue::Thread(self))
|
||||
impl<'lua> ToLua<'lua> for Thread<'lua> {
|
||||
fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
|
||||
Ok(Value::Thread(self))
|
||||
}
|
||||
}
|
||||
|
||||
impl<'lua> FromLua<'lua> for LuaThread<'lua> {
|
||||
fn from_lua(value: LuaValue<'lua>, _: &'lua Lua) -> LuaResult<LuaThread<'lua>> {
|
||||
impl<'lua> FromLua<'lua> for Thread<'lua> {
|
||||
fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<Thread<'lua>> {
|
||||
match value {
|
||||
LuaValue::Thread(t) => Ok(t),
|
||||
_ => Err(LuaError::FromLuaConversionError(
|
||||
Value::Thread(t) => Ok(t),
|
||||
_ => Err(Error::FromLuaConversionError(
|
||||
"cannot convert lua value to thread".to_owned(),
|
||||
)),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'lua> ToLua<'lua> for LuaUserData<'lua> {
|
||||
fn to_lua(self, _: &'lua Lua) -> LuaResult<LuaValue<'lua>> {
|
||||
Ok(LuaValue::UserData(self))
|
||||
impl<'lua> ToLua<'lua> for AnyUserData<'lua> {
|
||||
fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
|
||||
Ok(Value::UserData(self))
|
||||
}
|
||||
}
|
||||
|
||||
impl<'lua> FromLua<'lua> for LuaUserData<'lua> {
|
||||
fn from_lua(value: LuaValue<'lua>, _: &'lua Lua) -> LuaResult<LuaUserData<'lua>> {
|
||||
impl<'lua> FromLua<'lua> for AnyUserData<'lua> {
|
||||
fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<AnyUserData<'lua>> {
|
||||
match value {
|
||||
LuaValue::UserData(ud) => Ok(ud),
|
||||
_ => Err(LuaError::FromLuaConversionError(
|
||||
Value::UserData(ud) => Ok(ud),
|
||||
_ => Err(Error::FromLuaConversionError(
|
||||
"cannot convert lua value to userdata".to_owned(),
|
||||
)),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'lua, T: LuaUserDataType> ToLua<'lua> for T {
|
||||
fn to_lua(self, lua: &'lua Lua) -> LuaResult<LuaValue<'lua>> {
|
||||
Ok(LuaValue::UserData(lua.create_userdata(self)))
|
||||
impl<'lua, T: UserData> ToLua<'lua> for T {
|
||||
fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
|
||||
Ok(Value::UserData(lua.create_userdata(self)))
|
||||
}
|
||||
}
|
||||
|
||||
impl<'lua, T: LuaUserDataType + Copy> FromLua<'lua> for T {
|
||||
fn from_lua(value: LuaValue<'lua>, _: &'lua Lua) -> LuaResult<T> {
|
||||
impl<'lua, T: UserData + Copy> FromLua<'lua> for T {
|
||||
fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<T> {
|
||||
match value {
|
||||
LuaValue::UserData(ud) => Ok(*ud.borrow::<T>()?),
|
||||
_ => Err(LuaError::FromLuaConversionError(
|
||||
Value::UserData(ud) => Ok(*ud.borrow::<T>()?),
|
||||
_ => Err(Error::FromLuaConversionError(
|
||||
"cannot convert lua value to userdata".to_owned(),
|
||||
)),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'lua> ToLua<'lua> for LuaError {
|
||||
fn to_lua(self, _: &'lua Lua) -> LuaResult<LuaValue<'lua>> {
|
||||
Ok(LuaValue::Error(self))
|
||||
impl<'lua> ToLua<'lua> for Error {
|
||||
fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
|
||||
Ok(Value::Error(self))
|
||||
}
|
||||
}
|
||||
|
||||
impl<'lua> FromLua<'lua> for LuaError {
|
||||
fn from_lua(value: LuaValue<'lua>, lua: &'lua Lua) -> LuaResult<LuaError> {
|
||||
impl<'lua> FromLua<'lua> for Error {
|
||||
fn from_lua(value: Value<'lua>, lua: &'lua Lua) -> Result<Error> {
|
||||
match value {
|
||||
LuaValue::Error(err) => Ok(err),
|
||||
val => Ok(LuaError::RuntimeError(
|
||||
Value::Error(err) => Ok(err),
|
||||
val => Ok(Error::RuntimeError(
|
||||
lua.coerce_string(val)
|
||||
.and_then(|s| Ok(s.to_str()?.to_owned()))
|
||||
.unwrap_or_else(|_| "<unprintable error>".to_owned()),
|
||||
|
@ -133,66 +134,66 @@ impl<'lua> FromLua<'lua> for LuaError {
|
|||
}
|
||||
|
||||
impl<'lua> ToLua<'lua> for bool {
|
||||
fn to_lua(self, _: &'lua Lua) -> LuaResult<LuaValue<'lua>> {
|
||||
Ok(LuaValue::Boolean(self))
|
||||
fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
|
||||
Ok(Value::Boolean(self))
|
||||
}
|
||||
}
|
||||
|
||||
impl<'lua> FromLua<'lua> for bool {
|
||||
fn from_lua(v: LuaValue, _: &'lua Lua) -> LuaResult<Self> {
|
||||
fn from_lua(v: Value, _: &'lua Lua) -> Result<Self> {
|
||||
match v {
|
||||
LuaValue::Nil => Ok(false),
|
||||
LuaValue::Boolean(b) => Ok(b),
|
||||
Value::Nil => Ok(false),
|
||||
Value::Boolean(b) => Ok(b),
|
||||
_ => Ok(true),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'lua> ToLua<'lua> for LuaLightUserData {
|
||||
fn to_lua(self, _: &'lua Lua) -> LuaResult<LuaValue<'lua>> {
|
||||
Ok(LuaValue::LightUserData(self))
|
||||
impl<'lua> ToLua<'lua> for LightUserData {
|
||||
fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
|
||||
Ok(Value::LightUserData(self))
|
||||
}
|
||||
}
|
||||
|
||||
impl<'lua> FromLua<'lua> for LuaLightUserData {
|
||||
fn from_lua(v: LuaValue, _: &'lua Lua) -> LuaResult<Self> {
|
||||
impl<'lua> FromLua<'lua> for LightUserData {
|
||||
fn from_lua(v: Value, _: &'lua Lua) -> Result<Self> {
|
||||
match v {
|
||||
LuaValue::LightUserData(ud) => Ok(ud),
|
||||
_ => Err(LuaError::FromLuaConversionError(
|
||||
Value::LightUserData(ud) => Ok(ud),
|
||||
_ => Err(Error::FromLuaConversionError(
|
||||
"cannot convert lua value to lightuserdata".to_owned(),
|
||||
)),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'lua> ToLua<'lua> for String {
|
||||
fn to_lua(self, lua: &'lua Lua) -> LuaResult<LuaValue<'lua>> {
|
||||
Ok(LuaValue::String(lua.create_string(&self)))
|
||||
impl<'lua> ToLua<'lua> for StdString {
|
||||
fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
|
||||
Ok(Value::String(lua.create_string(&self)))
|
||||
}
|
||||
}
|
||||
|
||||
impl<'lua> FromLua<'lua> for String {
|
||||
fn from_lua(value: LuaValue<'lua>, lua: &'lua Lua) -> LuaResult<Self> {
|
||||
impl<'lua> FromLua<'lua> for StdString {
|
||||
fn from_lua(value: Value<'lua>, lua: &'lua Lua) -> Result<Self> {
|
||||
Ok(lua.coerce_string(value)?.to_str()?.to_owned())
|
||||
}
|
||||
}
|
||||
|
||||
impl<'lua, 'a> ToLua<'lua> for &'a str {
|
||||
fn to_lua(self, lua: &'lua Lua) -> LuaResult<LuaValue<'lua>> {
|
||||
Ok(LuaValue::String(lua.create_string(self)))
|
||||
fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
|
||||
Ok(Value::String(lua.create_string(self)))
|
||||
}
|
||||
}
|
||||
|
||||
macro_rules! lua_convert_int {
|
||||
($x: ty) => {
|
||||
impl<'lua> ToLua<'lua> for $x {
|
||||
fn to_lua(self, _: &'lua Lua) -> LuaResult<LuaValue<'lua>> {
|
||||
Ok(LuaValue::Integer(self as LuaInteger))
|
||||
fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
|
||||
Ok(Value::Integer(self as Integer))
|
||||
}
|
||||
}
|
||||
|
||||
impl<'lua> FromLua<'lua> for $x {
|
||||
fn from_lua(value: LuaValue<'lua>, lua: &'lua Lua) -> LuaResult<Self> {
|
||||
fn from_lua(value: Value<'lua>, lua: &'lua Lua) -> Result<Self> {
|
||||
Ok(lua.coerce_integer(value)? as $x)
|
||||
}
|
||||
}
|
||||
|
@ -213,13 +214,13 @@ lua_convert_int!(usize);
|
|||
macro_rules! lua_convert_float {
|
||||
($x: ty) => {
|
||||
impl<'lua> ToLua<'lua> for $x {
|
||||
fn to_lua(self, _: &'lua Lua) -> LuaResult<LuaValue<'lua>> {
|
||||
Ok(LuaValue::Number(self as LuaNumber))
|
||||
fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
|
||||
Ok(Value::Number(self as Number))
|
||||
}
|
||||
}
|
||||
|
||||
impl<'lua> FromLua<'lua> for $x {
|
||||
fn from_lua(value: LuaValue<'lua>, lua: &'lua Lua) -> LuaResult<Self> {
|
||||
fn from_lua(value: Value<'lua>, lua: &'lua Lua) -> Result<Self> {
|
||||
Ok(lua.coerce_number(value)? as $x)
|
||||
}
|
||||
}
|
||||
|
@ -230,17 +231,17 @@ lua_convert_float!(f32);
|
|||
lua_convert_float!(f64);
|
||||
|
||||
impl<'lua, T: ToLua<'lua>> ToLua<'lua> for Vec<T> {
|
||||
fn to_lua(self, lua: &'lua Lua) -> LuaResult<LuaValue<'lua>> {
|
||||
Ok(LuaValue::Table(lua.create_sequence_from(self)?))
|
||||
fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
|
||||
Ok(Value::Table(lua.create_sequence_from(self)?))
|
||||
}
|
||||
}
|
||||
|
||||
impl<'lua, T: FromLua<'lua>> FromLua<'lua> for Vec<T> {
|
||||
fn from_lua(value: LuaValue<'lua>, _: &'lua Lua) -> LuaResult<Self> {
|
||||
if let LuaValue::Table(table) = value {
|
||||
fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<Self> {
|
||||
if let Value::Table(table) = value {
|
||||
table.sequence_values().collect()
|
||||
} else {
|
||||
Err(LuaError::FromLuaConversionError(
|
||||
Err(Error::FromLuaConversionError(
|
||||
"cannot convert lua value to table for Vec".to_owned(),
|
||||
))
|
||||
}
|
||||
|
@ -248,17 +249,17 @@ impl<'lua, T: FromLua<'lua>> FromLua<'lua> for Vec<T> {
|
|||
}
|
||||
|
||||
impl<'lua, K: Eq + Hash + ToLua<'lua>, V: ToLua<'lua>> ToLua<'lua> for HashMap<K, V> {
|
||||
fn to_lua(self, lua: &'lua Lua) -> LuaResult<LuaValue<'lua>> {
|
||||
Ok(LuaValue::Table(lua.create_table_from(self)?))
|
||||
fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
|
||||
Ok(Value::Table(lua.create_table_from(self)?))
|
||||
}
|
||||
}
|
||||
|
||||
impl<'lua, K: Eq + Hash + FromLua<'lua>, V: FromLua<'lua>> FromLua<'lua> for HashMap<K, V> {
|
||||
fn from_lua(value: LuaValue<'lua>, _: &'lua Lua) -> LuaResult<Self> {
|
||||
if let LuaValue::Table(table) = value {
|
||||
fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<Self> {
|
||||
if let Value::Table(table) = value {
|
||||
table.pairs().collect()
|
||||
} else {
|
||||
Err(LuaError::FromLuaConversionError(
|
||||
Err(Error::FromLuaConversionError(
|
||||
"cannot convert lua value to table for HashMap".to_owned(),
|
||||
))
|
||||
}
|
||||
|
@ -266,17 +267,17 @@ impl<'lua, K: Eq + Hash + FromLua<'lua>, V: FromLua<'lua>> FromLua<'lua> for Has
|
|||
}
|
||||
|
||||
impl<'lua, K: Ord + ToLua<'lua>, V: ToLua<'lua>> ToLua<'lua> for BTreeMap<K, V> {
|
||||
fn to_lua(self, lua: &'lua Lua) -> LuaResult<LuaValue<'lua>> {
|
||||
Ok(LuaValue::Table(lua.create_table_from(self)?))
|
||||
fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
|
||||
Ok(Value::Table(lua.create_table_from(self)?))
|
||||
}
|
||||
}
|
||||
|
||||
impl<'lua, K: Ord + FromLua<'lua>, V: FromLua<'lua>> FromLua<'lua> for BTreeMap<K, V> {
|
||||
fn from_lua(value: LuaValue<'lua>, _: &'lua Lua) -> LuaResult<Self> {
|
||||
if let LuaValue::Table(table) = value {
|
||||
fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<Self> {
|
||||
if let Value::Table(table) = value {
|
||||
table.pairs().collect()
|
||||
} else {
|
||||
Err(LuaError::FromLuaConversionError(
|
||||
Err(Error::FromLuaConversionError(
|
||||
"cannot convert lua value to table for BTreeMap".to_owned(),
|
||||
))
|
||||
}
|
||||
|
@ -284,18 +285,18 @@ impl<'lua, K: Ord + FromLua<'lua>, V: FromLua<'lua>> FromLua<'lua> for BTreeMap<
|
|||
}
|
||||
|
||||
impl<'lua, T: ToLua<'lua>> ToLua<'lua> for Option<T> {
|
||||
fn to_lua(self, lua: &'lua Lua) -> LuaResult<LuaValue<'lua>> {
|
||||
fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
|
||||
match self {
|
||||
Some(val) => val.to_lua(lua),
|
||||
None => Ok(LuaNil),
|
||||
None => Ok(Nil),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'lua, T: FromLua<'lua>> FromLua<'lua> for Option<T> {
|
||||
fn from_lua(value: LuaValue<'lua>, lua: &'lua Lua) -> LuaResult<Self> {
|
||||
fn from_lua(value: Value<'lua>, lua: &'lua Lua) -> Result<Self> {
|
||||
match value {
|
||||
LuaNil => Ok(None),
|
||||
Nil => Ok(None),
|
||||
value => Ok(Some(T::from_lua(value, lua)?)),
|
||||
}
|
||||
}
|
||||
|
|
122
src/error.rs
122
src/error.rs
|
@ -1,10 +1,10 @@
|
|||
use std::fmt;
|
||||
use std::sync::Arc;
|
||||
use std::result::Result;
|
||||
use std::error::Error;
|
||||
use std::error::Error as StdError;
|
||||
use std::result::Result as StdResult;
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub enum LuaError {
|
||||
pub enum Error {
|
||||
/// Lua syntax error, aka `LUA_ERRSYNTAX` that is NOT an incomplete statement.
|
||||
SyntaxError(String),
|
||||
/// Lua syntax error that IS an incomplete statement. Useful for implementing a REPL.
|
||||
|
@ -17,95 +17,95 @@ pub enum LuaError {
|
|||
ToLuaConversionError(String),
|
||||
/// A generic Lua -> Rust conversion error.
|
||||
FromLuaConversionError(String),
|
||||
/// A `LuaThread` was resumed and the coroutine was no longer active.
|
||||
/// A `Thread` was resumed and the coroutine was no longer active.
|
||||
CoroutineInactive,
|
||||
/// A `LuaUserData` is not the expected type in a borrow.
|
||||
/// An `AnyUserData` is not the expected type in a borrow.
|
||||
UserDataTypeMismatch,
|
||||
/// A `LuaUserData` immutable borrow failed because it is already borrowed mutably.
|
||||
/// An `AnyUserData` immutable borrow failed because it is already borrowed mutably.
|
||||
UserDataBorrowError,
|
||||
/// A `LuaUserData` mutable borrow failed because it is already borrowed.
|
||||
/// An `AnyUserData` mutable borrow failed because it is already borrowed.
|
||||
UserDataBorrowMutError,
|
||||
/// Lua error that originated as a LuaError in a callback. The first field is the lua error as
|
||||
/// a string, the second field is the Arc holding the original LuaError.
|
||||
CallbackError(String, Arc<LuaError>),
|
||||
/// Lua error that originated as a Error in a callback. The first field is the lua error as
|
||||
/// a string, the second field is the Arc holding the original Error.
|
||||
CallbackError(String, Arc<Error>),
|
||||
/// Any custom external error type, mostly useful for returning external error types from
|
||||
/// callbacks.
|
||||
ExternalError(Arc<Error + Send + Sync>),
|
||||
ExternalError(Arc<StdError + Send + Sync>),
|
||||
}
|
||||
|
||||
pub type LuaResult<T> = Result<T, LuaError>;
|
||||
pub type Result<T> = StdResult<T, Error>;
|
||||
|
||||
impl fmt::Display for LuaError {
|
||||
fn fmt(&self, fmt: &mut fmt::Formatter) -> Result<(), fmt::Error> {
|
||||
match self {
|
||||
&LuaError::SyntaxError(ref msg) => write!(fmt, "Lua syntax error: {}", msg),
|
||||
&LuaError::IncompleteStatement(ref msg) => {
|
||||
impl fmt::Display for Error {
|
||||
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
|
||||
match *self {
|
||||
Error::SyntaxError(ref msg) => write!(fmt, "Lua syntax error: {}", msg),
|
||||
Error::IncompleteStatement(ref msg) => {
|
||||
write!(fmt, "Lua syntax error (incomplete statement): {}", msg)
|
||||
}
|
||||
&LuaError::RuntimeError(ref msg) => write!(fmt, "Lua runtime error: {}", msg),
|
||||
&LuaError::ErrorError(ref msg) => write!(fmt, "Lua error in error handler: {}", msg),
|
||||
&LuaError::ToLuaConversionError(ref msg) => {
|
||||
Error::RuntimeError(ref msg) => write!(fmt, "Lua runtime error: {}", msg),
|
||||
Error::ErrorError(ref msg) => write!(fmt, "Lua error in error handler: {}", msg),
|
||||
Error::ToLuaConversionError(ref msg) => {
|
||||
write!(fmt, "Error converting rust type to lua: {}", msg)
|
||||
}
|
||||
&LuaError::FromLuaConversionError(ref msg) => {
|
||||
Error::FromLuaConversionError(ref msg) => {
|
||||
write!(fmt, "Error converting lua type to rust: {}", msg)
|
||||
}
|
||||
&LuaError::CoroutineInactive => write!(fmt, "Cannot resume inactive coroutine"),
|
||||
&LuaError::UserDataTypeMismatch => write!(fmt, "Userdata not expected type"),
|
||||
&LuaError::UserDataBorrowError => write!(fmt, "Userdata already mutably borrowed"),
|
||||
&LuaError::UserDataBorrowMutError => write!(fmt, "Userdata already borrowed"),
|
||||
&LuaError::CallbackError(ref msg, _) => {
|
||||
Error::CoroutineInactive => write!(fmt, "Cannot resume inactive coroutine"),
|
||||
Error::UserDataTypeMismatch => write!(fmt, "Userdata not expected type"),
|
||||
Error::UserDataBorrowError => write!(fmt, "Userdata already mutably borrowed"),
|
||||
Error::UserDataBorrowMutError => write!(fmt, "Userdata already borrowed"),
|
||||
Error::CallbackError(ref msg, _) => {
|
||||
write!(fmt, "Error during lua callback: {}", msg)
|
||||
}
|
||||
&LuaError::ExternalError(ref err) => err.fmt(fmt),
|
||||
Error::ExternalError(ref err) => err.fmt(fmt),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Error for LuaError {
|
||||
impl StdError for Error {
|
||||
fn description(&self) -> &str {
|
||||
match self {
|
||||
&LuaError::SyntaxError(_) => "lua syntax error",
|
||||
&LuaError::IncompleteStatement(_) => "lua incomplete statement",
|
||||
&LuaError::RuntimeError(_) => "lua runtime error",
|
||||
&LuaError::ErrorError(_) => "lua error handling error",
|
||||
&LuaError::ToLuaConversionError(_) => "conversion error to lua",
|
||||
&LuaError::FromLuaConversionError(_) => "conversion error from lua",
|
||||
&LuaError::CoroutineInactive => "lua coroutine inactive",
|
||||
&LuaError::UserDataTypeMismatch => "lua userdata type mismatch",
|
||||
&LuaError::UserDataBorrowError => "lua userdata already mutably borrowed",
|
||||
&LuaError::UserDataBorrowMutError => "lua userdata already borrowed",
|
||||
&LuaError::CallbackError(_, _) => "lua callback error",
|
||||
&LuaError::ExternalError(ref err) => err.description(),
|
||||
match *self {
|
||||
Error::SyntaxError(_) => "lua syntax error",
|
||||
Error::IncompleteStatement(_) => "lua incomplete statement",
|
||||
Error::RuntimeError(_) => "lua runtime error",
|
||||
Error::ErrorError(_) => "lua error handling error",
|
||||
Error::ToLuaConversionError(_) => "conversion error to lua",
|
||||
Error::FromLuaConversionError(_) => "conversion error from lua",
|
||||
Error::CoroutineInactive => "lua coroutine inactive",
|
||||
Error::UserDataTypeMismatch => "lua userdata type mismatch",
|
||||
Error::UserDataBorrowError => "lua userdata already mutably borrowed",
|
||||
Error::UserDataBorrowMutError => "lua userdata already borrowed",
|
||||
Error::CallbackError(_, _) => "lua callback error",
|
||||
Error::ExternalError(ref err) => err.description(),
|
||||
}
|
||||
}
|
||||
|
||||
fn cause(&self) -> Option<&Error> {
|
||||
match self {
|
||||
&LuaError::CallbackError(_, ref cause) => Some(cause.as_ref()),
|
||||
&LuaError::ExternalError(ref err) => err.cause(),
|
||||
fn cause(&self) -> Option<&StdError> {
|
||||
match *self {
|
||||
Error::CallbackError(_, ref cause) => Some(cause.as_ref()),
|
||||
Error::ExternalError(ref err) => err.cause(),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl LuaError {
|
||||
pub fn external<T: 'static + Error + Send + Sync>(err: T) -> LuaError {
|
||||
LuaError::ExternalError(Arc::new(err))
|
||||
impl Error {
|
||||
pub fn external<T: 'static + StdError + Send + Sync>(err: T) -> Error {
|
||||
Error::ExternalError(Arc::new(err))
|
||||
}
|
||||
}
|
||||
|
||||
pub trait LuaExternalError {
|
||||
fn to_lua_err(self) -> LuaError;
|
||||
pub trait ExternalError {
|
||||
fn to_lua_err(self) -> Error;
|
||||
}
|
||||
|
||||
impl<E> LuaExternalError for E
|
||||
impl<E> ExternalError for E
|
||||
where
|
||||
E: Into<Box<Error + Send + Sync>>,
|
||||
E: Into<Box<StdError + Send + Sync>>,
|
||||
{
|
||||
fn to_lua_err(self) -> LuaError {
|
||||
fn to_lua_err(self) -> Error {
|
||||
#[derive(Debug)]
|
||||
struct WrapError(Box<Error + Send + Sync>);
|
||||
struct WrapError(Box<StdError + Send + Sync>);
|
||||
|
||||
impl fmt::Display for WrapError {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
|
@ -113,25 +113,25 @@ where
|
|||
}
|
||||
}
|
||||
|
||||
impl Error for WrapError {
|
||||
impl StdError for WrapError {
|
||||
fn description(&self) -> &str {
|
||||
self.0.description()
|
||||
}
|
||||
}
|
||||
|
||||
LuaError::external(WrapError(self.into()))
|
||||
Error::external(WrapError(self.into()))
|
||||
}
|
||||
}
|
||||
|
||||
pub trait LuaExternalResult<T> {
|
||||
fn to_lua_err(self) -> LuaResult<T>;
|
||||
pub trait ExternalResult<T> {
|
||||
fn to_lua_err(self) -> Result<T>;
|
||||
}
|
||||
|
||||
impl<T, E> LuaExternalResult<T> for Result<T, E>
|
||||
impl<T, E> ExternalResult<T> for StdResult<T, E>
|
||||
where
|
||||
E: LuaExternalError,
|
||||
E: ExternalError,
|
||||
{
|
||||
fn to_lua_err(self) -> LuaResult<T> {
|
||||
fn to_lua_err(self) -> Result<T> {
|
||||
self.map_err(|e| e.to_lua_err())
|
||||
}
|
||||
}
|
||||
|
|
10
src/lib.rs
10
src/lib.rs
|
@ -12,6 +12,10 @@ mod multi;
|
|||
#[cfg(test)]
|
||||
mod tests;
|
||||
|
||||
pub use error::*;
|
||||
pub use lua::*;
|
||||
pub use multi::*;
|
||||
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;
|
||||
|
|
465
src/lua.rs
465
src/lua.rs
File diff suppressed because it is too large
Load Diff
64
src/multi.rs
64
src/multi.rs
|
@ -1,30 +1,32 @@
|
|||
use std::result::{Result as StdResult};
|
||||
|
||||
use hlist_macro::{HNil, HCons};
|
||||
|
||||
use error::*;
|
||||
use lua::*;
|
||||
|
||||
impl<'lua> ToLuaMulti<'lua> for () {
|
||||
fn to_lua_multi(self, _: &'lua Lua) -> LuaResult<LuaMultiValue> {
|
||||
Ok(LuaMultiValue::new())
|
||||
fn to_lua_multi(self, _: &'lua Lua) -> Result<MultiValue> {
|
||||
Ok(MultiValue::new())
|
||||
}
|
||||
}
|
||||
|
||||
impl<'lua> FromLuaMulti<'lua> for () {
|
||||
fn from_lua_multi(_: LuaMultiValue, _: &'lua Lua) -> LuaResult<Self> {
|
||||
fn from_lua_multi(_: MultiValue, _: &'lua Lua) -> Result<Self> {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
/// Result is convertible to `LuaMultiValue` following the common lua idiom of returning the result
|
||||
/// 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 followed by the error
|
||||
impl<'lua, T: ToLua<'lua>, E: ToLua<'lua>> ToLuaMulti<'lua> for Result<T, E> {
|
||||
fn to_lua_multi(self, lua: &'lua Lua) -> LuaResult<LuaMultiValue<'lua>> {
|
||||
let mut result = LuaMultiValue::new();
|
||||
impl<'lua, T: ToLua<'lua>, E: ToLua<'lua>> ToLuaMulti<'lua> for StdResult<T, E> {
|
||||
fn to_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
|
||||
let mut result = MultiValue::new();
|
||||
|
||||
match self {
|
||||
Ok(v) => result.push_back(v.to_lua(lua)?),
|
||||
Err(e) => {
|
||||
result.push_back(LuaNil);
|
||||
result.push_back(Nil);
|
||||
result.push_back(e.to_lua(lua)?);
|
||||
}
|
||||
}
|
||||
|
@ -34,27 +36,27 @@ impl<'lua, T: ToLua<'lua>, E: ToLua<'lua>> ToLuaMulti<'lua> for Result<T, E> {
|
|||
}
|
||||
|
||||
impl<'lua, T: ToLua<'lua>> ToLuaMulti<'lua> for T {
|
||||
fn to_lua_multi(self, lua: &'lua Lua) -> LuaResult<LuaMultiValue<'lua>> {
|
||||
let mut v = LuaMultiValue::new();
|
||||
fn to_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
|
||||
let mut v = MultiValue::new();
|
||||
v.push_back(self.to_lua(lua)?);
|
||||
Ok(v)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'lua, T: FromLua<'lua>> FromLuaMulti<'lua> for T {
|
||||
fn from_lua_multi(mut values: LuaMultiValue<'lua>, lua: &'lua Lua) -> LuaResult<Self> {
|
||||
Ok(T::from_lua(values.pop_front().unwrap_or(LuaNil), lua)?)
|
||||
fn from_lua_multi(mut values: MultiValue<'lua>, lua: &'lua Lua) -> Result<Self> {
|
||||
Ok(T::from_lua(values.pop_front().unwrap_or(Nil), lua)?)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'lua> ToLuaMulti<'lua> for LuaMultiValue<'lua> {
|
||||
fn to_lua_multi(self, _: &'lua Lua) -> LuaResult<LuaMultiValue<'lua>> {
|
||||
impl<'lua> ToLuaMulti<'lua> for MultiValue<'lua> {
|
||||
fn to_lua_multi(self, _: &'lua Lua) -> Result<MultiValue<'lua>> {
|
||||
Ok(self)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'lua> FromLuaMulti<'lua> for LuaMultiValue<'lua> {
|
||||
fn from_lua_multi(values: LuaMultiValue<'lua>, _: &'lua Lua) -> LuaResult<Self> {
|
||||
impl<'lua> FromLuaMulti<'lua> for MultiValue<'lua> {
|
||||
fn from_lua_multi(values: MultiValue<'lua>, _: &'lua Lua) -> Result<Self> {
|
||||
Ok(values)
|
||||
}
|
||||
}
|
||||
|
@ -63,44 +65,44 @@ impl<'lua> FromLuaMulti<'lua> for LuaMultiValue<'lua> {
|
|||
/// the values is all the same and the number of values is defined at runtime. This can be included
|
||||
/// in an hlist when unpacking, but must be the final entry, and will consume the rest of the
|
||||
/// parameters given.
|
||||
pub struct LuaVariadic<T>(pub Vec<T>);
|
||||
pub struct Variadic<T>(pub Vec<T>);
|
||||
|
||||
impl<'lua, T: ToLua<'lua>> ToLuaMulti<'lua> for LuaVariadic<T> {
|
||||
fn to_lua_multi(self, lua: &'lua Lua) -> LuaResult<LuaMultiValue<'lua>> {
|
||||
impl<'lua, T: ToLua<'lua>> ToLuaMulti<'lua> for Variadic<T> {
|
||||
fn to_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
|
||||
self.0.into_iter().map(|e| e.to_lua(lua)).collect()
|
||||
}
|
||||
}
|
||||
|
||||
impl<'lua, T: FromLua<'lua>> FromLuaMulti<'lua> for LuaVariadic<T> {
|
||||
fn from_lua_multi(values: LuaMultiValue<'lua>, lua: &'lua Lua) -> LuaResult<Self> {
|
||||
impl<'lua, T: FromLua<'lua>> FromLuaMulti<'lua> for Variadic<T> {
|
||||
fn from_lua_multi(values: MultiValue<'lua>, lua: &'lua Lua) -> Result<Self> {
|
||||
values
|
||||
.into_iter()
|
||||
.map(|e| T::from_lua(e, lua))
|
||||
.collect::<LuaResult<Vec<T>>>()
|
||||
.map(LuaVariadic)
|
||||
.collect::<Result<Vec<T>>>()
|
||||
.map(Variadic)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'lua> ToLuaMulti<'lua> for HNil {
|
||||
fn to_lua_multi(self, _: &'lua Lua) -> LuaResult<LuaMultiValue<'lua>> {
|
||||
Ok(LuaMultiValue::new())
|
||||
fn to_lua_multi(self, _: &'lua Lua) -> Result<MultiValue<'lua>> {
|
||||
Ok(MultiValue::new())
|
||||
}
|
||||
}
|
||||
|
||||
impl<'lua> FromLuaMulti<'lua> for HNil {
|
||||
fn from_lua_multi(_: LuaMultiValue<'lua>, _: &'lua Lua) -> LuaResult<Self> {
|
||||
fn from_lua_multi(_: MultiValue<'lua>, _: &'lua Lua) -> Result<Self> {
|
||||
Ok(HNil)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'lua, T: ToLuaMulti<'lua>> ToLuaMulti<'lua> for HCons<T, HNil> {
|
||||
fn to_lua_multi(self, lua: &'lua Lua) -> LuaResult<LuaMultiValue<'lua>> {
|
||||
fn to_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
|
||||
self.0.to_lua_multi(lua)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'lua, T: FromLuaMulti<'lua>> FromLuaMulti<'lua> for HCons<T, HNil> {
|
||||
fn from_lua_multi(values: LuaMultiValue<'lua>, lua: &'lua Lua) -> LuaResult<Self> {
|
||||
fn from_lua_multi(values: MultiValue<'lua>, lua: &'lua Lua) -> Result<Self> {
|
||||
Ok(HCons(T::from_lua_multi(values, lua)?, HNil))
|
||||
}
|
||||
}
|
||||
|
@ -108,7 +110,7 @@ impl<'lua, T: FromLuaMulti<'lua>> FromLuaMulti<'lua> for HCons<T, HNil> {
|
|||
impl<'lua, H: ToLua<'lua>, A, B> ToLuaMulti<'lua> for HCons<H, HCons<A, B>>
|
||||
where HCons<A, B>: ToLuaMulti<'lua>
|
||||
{
|
||||
fn to_lua_multi(self, lua: &'lua Lua) -> LuaResult<LuaMultiValue<'lua>> {
|
||||
fn to_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
|
||||
let mut results = self.1.to_lua_multi(lua)?;
|
||||
results.push_front(self.0.to_lua(lua)?);
|
||||
Ok(results)
|
||||
|
@ -118,8 +120,8 @@ impl<'lua, H: ToLua<'lua>, A, B> ToLuaMulti<'lua> for HCons<H, HCons<A, B>>
|
|||
impl<'lua, H: FromLua<'lua>, A, B> FromLuaMulti<'lua> for HCons<H, HCons<A, B>>
|
||||
where HCons<A, B>: FromLuaMulti<'lua>
|
||||
{
|
||||
fn from_lua_multi(mut values: LuaMultiValue<'lua>, lua: &'lua Lua) -> LuaResult<Self> {
|
||||
let val = H::from_lua(values.pop_front().unwrap_or(LuaNil), lua)?;
|
||||
fn from_lua_multi(mut values: MultiValue<'lua>, lua: &'lua Lua) -> Result<Self> {
|
||||
let val = H::from_lua(values.pop_front().unwrap_or(Nil), lua)?;
|
||||
let res = HCons::<A, B>::from_lua_multi(values, lua)?;
|
||||
Ok(HCons(val, res))
|
||||
}
|
||||
|
|
|
@ -0,0 +1,8 @@
|
|||
pub use {Error as LuaError, Result as LuaResult, ExternalError as LuaExternalError,
|
||||
ExternalResult as LuaExternalResult, Value as LuaValue, Nil as LuaNil, ToLua, FromLua,
|
||||
MultiValue as LuaMultiValue, ToLuaMulti, FromLuaMulti, Integer as LuaInteger,
|
||||
Number as LuaNumber, LightUserData as LuaLightUserData, String as LuaString,
|
||||
Table as LuaTable, TablePairs as LuaTablePairs, TableSequence as LuaTableSequence,
|
||||
Function as LuaFunction, ThreadStatus as LuaThreadStatus, Thread as LuaThread,
|
||||
MetaMethod as LuaMetaMethod, UserDataMethods as LuaUserDataMethods,
|
||||
UserData as LuaUserData, AnyUserData as LuaAnyUserData, Lua};
|
209
src/tests.rs
209
src/tests.rs
|
@ -1,10 +1,13 @@
|
|||
use std::fmt;
|
||||
use std::result::Result;
|
||||
use std::error::Error;
|
||||
use std::error;
|
||||
use std::panic::catch_unwind;
|
||||
use std::os::raw::c_void;
|
||||
|
||||
use super::*;
|
||||
use String as LuaString;
|
||||
use {
|
||||
Lua, Result, ExternalError, LightUserData, UserDataMethods, UserData, Table, Thread,
|
||||
ThreadStatus, Error, Function, Value, Variadic, MetaMethod
|
||||
};
|
||||
|
||||
#[test]
|
||||
fn test_set_get() {
|
||||
|
@ -38,7 +41,7 @@ fn test_exec() {
|
|||
).unwrap();
|
||||
assert_eq!(globals.get::<_, String>("res").unwrap(), "foobar");
|
||||
|
||||
let module: LuaTable = lua.exec(
|
||||
let module: Table = lua.exec(
|
||||
r#"
|
||||
local module = {}
|
||||
|
||||
|
@ -53,7 +56,7 @@ fn test_exec() {
|
|||
assert!(module.contains_key("func").unwrap());
|
||||
assert_eq!(
|
||||
module
|
||||
.get::<_, LuaFunction>("func")
|
||||
.get::<_, Function>("func")
|
||||
.unwrap()
|
||||
.call::<_, String>(())
|
||||
.unwrap(),
|
||||
|
@ -68,7 +71,7 @@ fn test_eval() {
|
|||
assert_eq!(lua.eval::<bool>("false == false", None).unwrap(), true);
|
||||
assert_eq!(lua.eval::<i32>("return 1 + 2", None).unwrap(), 3);
|
||||
match lua.eval::<()>("if true then", None) {
|
||||
Err(LuaError::IncompleteStatement(_)) => {}
|
||||
Err(Error::IncompleteStatement(_)) => {}
|
||||
r => panic!("expected IncompleteStatement, got {:?}", r),
|
||||
}
|
||||
}
|
||||
|
@ -79,8 +82,8 @@ fn test_table() {
|
|||
let globals = lua.globals();
|
||||
|
||||
globals.set("table", lua.create_table()).unwrap();
|
||||
let table1: LuaTable = globals.get("table").unwrap();
|
||||
let table2: LuaTable = globals.get("table").unwrap();
|
||||
let table1: Table = globals.get("table").unwrap();
|
||||
let table2: Table = globals.get("table").unwrap();
|
||||
|
||||
table1.set("foo", "bar").unwrap();
|
||||
table2.set("baz", "baf").unwrap();
|
||||
|
@ -97,16 +100,16 @@ fn test_table() {
|
|||
None,
|
||||
).unwrap();
|
||||
|
||||
let table1 = globals.get::<_, LuaTable>("table1").unwrap();
|
||||
let table2 = globals.get::<_, LuaTable>("table2").unwrap();
|
||||
let table3 = globals.get::<_, LuaTable>("table3").unwrap();
|
||||
let table1 = globals.get::<_, Table>("table1").unwrap();
|
||||
let table2 = globals.get::<_, Table>("table2").unwrap();
|
||||
let table3 = globals.get::<_, Table>("table3").unwrap();
|
||||
|
||||
assert_eq!(table1.len().unwrap(), 5);
|
||||
assert_eq!(
|
||||
table1
|
||||
.clone()
|
||||
.pairs()
|
||||
.collect::<LuaResult<Vec<(i64, i64)>>>()
|
||||
.collect::<Result<Vec<(i64, i64)>>>()
|
||||
.unwrap(),
|
||||
vec![(1, 1), (2, 2), (3, 3), (4, 4), (5, 5)]
|
||||
);
|
||||
|
@ -114,7 +117,7 @@ fn test_table() {
|
|||
table1
|
||||
.clone()
|
||||
.sequence_values()
|
||||
.collect::<LuaResult<Vec<i64>>>()
|
||||
.collect::<Result<Vec<i64>>>()
|
||||
.unwrap(),
|
||||
vec![1, 2, 3, 4, 5]
|
||||
);
|
||||
|
@ -124,14 +127,14 @@ fn test_table() {
|
|||
table2
|
||||
.clone()
|
||||
.pairs()
|
||||
.collect::<LuaResult<Vec<(i64, i64)>>>()
|
||||
.collect::<Result<Vec<(i64, i64)>>>()
|
||||
.unwrap(),
|
||||
vec![]
|
||||
);
|
||||
assert_eq!(
|
||||
table2
|
||||
.sequence_values()
|
||||
.collect::<LuaResult<Vec<i64>>>()
|
||||
.collect::<Result<Vec<i64>>>()
|
||||
.unwrap(),
|
||||
vec![]
|
||||
);
|
||||
|
@ -140,7 +143,7 @@ fn test_table() {
|
|||
assert_eq!(
|
||||
table3
|
||||
.sequence_values()
|
||||
.collect::<LuaResult<Vec<i64>>>()
|
||||
.collect::<Result<Vec<i64>>>()
|
||||
.unwrap(),
|
||||
vec![1, 2]
|
||||
);
|
||||
|
@ -151,11 +154,11 @@ fn test_table() {
|
|||
lua.create_sequence_from(vec![1, 2, 3, 4, 5]).unwrap(),
|
||||
)
|
||||
.unwrap();
|
||||
let table4 = globals.get::<_, LuaTable>("table4").unwrap();
|
||||
let table4 = globals.get::<_, Table>("table4").unwrap();
|
||||
assert_eq!(
|
||||
table4
|
||||
.pairs()
|
||||
.collect::<LuaResult<Vec<(i64, i64)>>>()
|
||||
.collect::<Result<Vec<(i64, i64)>>>()
|
||||
.unwrap(),
|
||||
vec![(1, 1), (2, 2), (3, 3), (4, 4), (5, 5)]
|
||||
);
|
||||
|
@ -174,7 +177,7 @@ fn test_function() {
|
|||
None,
|
||||
).unwrap();
|
||||
|
||||
let concat = globals.get::<_, LuaFunction>("concat").unwrap();
|
||||
let concat = globals.get::<_, Function>("concat").unwrap();
|
||||
assert_eq!(
|
||||
concat.call::<_, String>(hlist!["foo", "bar"]).unwrap(),
|
||||
"foobar"
|
||||
|
@ -198,7 +201,7 @@ fn test_bind() {
|
|||
None,
|
||||
).unwrap();
|
||||
|
||||
let mut concat = globals.get::<_, LuaFunction>("concat").unwrap();
|
||||
let mut concat = globals.get::<_, Function>("concat").unwrap();
|
||||
concat = concat.bind("foo").unwrap();
|
||||
concat = concat.bind("bar").unwrap();
|
||||
concat = concat.bind(hlist!["baz", "baf"]).unwrap();
|
||||
|
@ -226,7 +229,7 @@ fn test_rust_function() {
|
|||
None,
|
||||
).unwrap();
|
||||
|
||||
let lua_function = globals.get::<_, LuaFunction>("lua_function").unwrap();
|
||||
let lua_function = globals.get::<_, Function>("lua_function").unwrap();
|
||||
let rust_function = lua.create_function(|lua, _| {
|
||||
captured_var = 42;
|
||||
lua.pack("hello")
|
||||
|
@ -243,8 +246,8 @@ fn test_user_data() {
|
|||
struct UserData1(i64);
|
||||
struct UserData2(Box<i64>);
|
||||
|
||||
impl LuaUserDataType for UserData1 {};
|
||||
impl LuaUserDataType for UserData2 {};
|
||||
impl UserData for UserData1 {};
|
||||
impl UserData for UserData2 {};
|
||||
|
||||
let lua = Lua::new();
|
||||
|
||||
|
@ -262,10 +265,10 @@ fn test_user_data() {
|
|||
|
||||
#[test]
|
||||
fn test_methods() {
|
||||
struct UserData(i64);
|
||||
struct MyUserData(i64);
|
||||
|
||||
impl LuaUserDataType for UserData {
|
||||
fn add_methods(methods: &mut LuaUserDataMethods<Self>) {
|
||||
impl UserData for MyUserData {
|
||||
fn add_methods(methods: &mut UserDataMethods<Self>) {
|
||||
methods.add_method("get_value", |lua, data, _| lua.pack(data.0));
|
||||
methods.add_method_mut("set_value", |lua, data, args| {
|
||||
data.0 = lua.unpack(args)?;
|
||||
|
@ -276,7 +279,7 @@ fn test_methods() {
|
|||
|
||||
let lua = Lua::new();
|
||||
let globals = lua.globals();
|
||||
let userdata = lua.create_userdata(UserData(42));
|
||||
let userdata = lua.create_userdata(MyUserData(42));
|
||||
globals.set("userdata", userdata.clone()).unwrap();
|
||||
lua.exec::<()>(
|
||||
r#"
|
||||
|
@ -290,10 +293,10 @@ fn test_methods() {
|
|||
"#,
|
||||
None,
|
||||
).unwrap();
|
||||
let get = globals.get::<_, LuaFunction>("get_it").unwrap();
|
||||
let set = globals.get::<_, LuaFunction>("set_it").unwrap();
|
||||
let get = globals.get::<_, Function>("get_it").unwrap();
|
||||
let set = globals.get::<_, Function>("set_it").unwrap();
|
||||
assert_eq!(get.call::<_, i64>(()).unwrap(), 42);
|
||||
userdata.borrow_mut::<UserData>().unwrap().0 = 64;
|
||||
userdata.borrow_mut::<MyUserData>().unwrap().0 = 64;
|
||||
assert_eq!(get.call::<_, i64>(()).unwrap(), 64);
|
||||
set.call::<_, ()>(100).unwrap();
|
||||
assert_eq!(get.call::<_, i64>(()).unwrap(), 100);
|
||||
|
@ -302,20 +305,20 @@ fn test_methods() {
|
|||
#[test]
|
||||
fn test_metamethods() {
|
||||
#[derive(Copy, Clone)]
|
||||
struct UserData(i64);
|
||||
struct MyUserData(i64);
|
||||
|
||||
impl LuaUserDataType for UserData {
|
||||
fn add_methods(methods: &mut LuaUserDataMethods<Self>) {
|
||||
impl UserData for MyUserData {
|
||||
fn add_methods(methods: &mut UserDataMethods<Self>) {
|
||||
methods.add_method("get", |lua, data, _| lua.pack(data.0));
|
||||
methods.add_meta_function(LuaMetaMethod::Add, |lua, args| {
|
||||
let hlist_pat![lhs, rhs] = lua.unpack::<HList![UserData, UserData]>(args)?;
|
||||
lua.pack(UserData(lhs.0 + rhs.0))
|
||||
methods.add_meta_function(MetaMethod::Add, |lua, args| {
|
||||
let hlist_pat![lhs, rhs] = lua.unpack::<HList![MyUserData, MyUserData]>(args)?;
|
||||
lua.pack(MyUserData(lhs.0 + rhs.0))
|
||||
});
|
||||
methods.add_meta_function(LuaMetaMethod::Sub, |lua, args| {
|
||||
let hlist_pat![lhs, rhs] = lua.unpack::<HList![UserData, UserData]>(args)?;
|
||||
lua.pack(UserData(lhs.0 - rhs.0))
|
||||
methods.add_meta_function(MetaMethod::Sub, |lua, args| {
|
||||
let hlist_pat![lhs, rhs] = lua.unpack::<HList![MyUserData, MyUserData]>(args)?;
|
||||
lua.pack(MyUserData(lhs.0 - rhs.0))
|
||||
});
|
||||
methods.add_meta_method(LuaMetaMethod::Index, |lua, data, args| {
|
||||
methods.add_meta_method(MetaMethod::Index, |lua, data, args| {
|
||||
let index = lua.unpack::<LuaString>(args)?;
|
||||
if index.to_str()? == "inner" {
|
||||
lua.pack(data.0)
|
||||
|
@ -328,16 +331,16 @@ fn test_metamethods() {
|
|||
|
||||
let lua = Lua::new();
|
||||
let globals = lua.globals();
|
||||
globals.set("userdata1", UserData(7)).unwrap();
|
||||
globals.set("userdata2", UserData(3)).unwrap();
|
||||
globals.set("userdata1", MyUserData(7)).unwrap();
|
||||
globals.set("userdata2", MyUserData(3)).unwrap();
|
||||
assert_eq!(
|
||||
lua.eval::<UserData>("userdata1 + userdata2", None)
|
||||
lua.eval::<MyUserData>("userdata1 + userdata2", None)
|
||||
.unwrap()
|
||||
.0,
|
||||
10
|
||||
);
|
||||
assert_eq!(
|
||||
lua.eval::<UserData>("userdata1 - userdata2", None)
|
||||
lua.eval::<MyUserData>("userdata1 - userdata2", None)
|
||||
.unwrap()
|
||||
.0,
|
||||
4
|
||||
|
@ -363,8 +366,8 @@ fn test_scope() {
|
|||
// Make sure that table gets do not borrow the table, but instead just borrow lua.
|
||||
let tin;
|
||||
{
|
||||
let touter = globals.get::<_, LuaTable>("touter").unwrap();
|
||||
tin = touter.get::<_, LuaTable>("tin").unwrap();
|
||||
let touter = globals.get::<_, Table>("touter").unwrap();
|
||||
tin = touter.get::<_, Table>("tin").unwrap();
|
||||
}
|
||||
|
||||
assert_eq!(tin.get::<_, i64>(1).unwrap(), 1);
|
||||
|
@ -373,12 +376,12 @@ fn test_scope() {
|
|||
|
||||
// Should not compile, don't know how to test that
|
||||
// struct UserData;
|
||||
// impl LuaUserDataType for UserData {};
|
||||
// impl UserData for UserData {};
|
||||
// let userdata_ref;
|
||||
// {
|
||||
// let touter = globals.get::<_, LuaTable>("touter").unwrap();
|
||||
// let touter = globals.get::<_, Table>("touter").unwrap();
|
||||
// touter.set("userdata", lua.create_userdata(UserData).unwrap()).unwrap();
|
||||
// let userdata = touter.get::<_, LuaUserData>("userdata").unwrap();
|
||||
// let userdata = touter.get::<_, AnyUserData>("userdata").unwrap();
|
||||
// userdata_ref = userdata.borrow::<UserData>();
|
||||
// }
|
||||
}
|
||||
|
@ -400,8 +403,8 @@ fn test_lua_multi() {
|
|||
None,
|
||||
).unwrap();
|
||||
|
||||
let concat = globals.get::<_, LuaFunction>("concat").unwrap();
|
||||
let mreturn = globals.get::<_, LuaFunction>("mreturn").unwrap();
|
||||
let concat = globals.get::<_, Function>("concat").unwrap();
|
||||
let mreturn = globals.get::<_, Function>("mreturn").unwrap();
|
||||
|
||||
assert_eq!(
|
||||
concat.call::<_, String>(hlist!["foo", "bar"]).unwrap(),
|
||||
|
@ -409,8 +412,8 @@ fn test_lua_multi() {
|
|||
);
|
||||
let hlist_pat![a, b] = mreturn.call::<_, HList![u64, u64]>(hlist![]).unwrap();
|
||||
assert_eq!((a, b), (1, 2));
|
||||
let hlist_pat![a, b, LuaVariadic(v)] =
|
||||
mreturn.call::<_, HList![u64, u64, LuaVariadic<u64>]>(hlist![]).unwrap();
|
||||
let hlist_pat![a, b, Variadic(v)] =
|
||||
mreturn.call::<_, HList![u64, u64, Variadic<u64>]>(hlist![]).unwrap();
|
||||
assert_eq!((a, b), (1, 2));
|
||||
assert_eq!(v, vec![3, 4, 5, 6]);
|
||||
}
|
||||
|
@ -439,17 +442,17 @@ fn test_error() {
|
|||
pub struct TestError;
|
||||
|
||||
impl fmt::Display for TestError {
|
||||
fn fmt(&self, fmt: &mut fmt::Formatter) -> Result<(), fmt::Error> {
|
||||
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
|
||||
write!(fmt, "test error")
|
||||
}
|
||||
}
|
||||
|
||||
impl Error for TestError {
|
||||
impl error::Error for TestError {
|
||||
fn description(&self) -> &str {
|
||||
"test error"
|
||||
}
|
||||
|
||||
fn cause(&self) -> Option<&Error> {
|
||||
fn cause(&self) -> Option<&error::Error> {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
@ -514,44 +517,44 @@ fn test_error() {
|
|||
.set("rust_error_function", rust_error_function)
|
||||
.unwrap();
|
||||
|
||||
let no_error = globals.get::<_, LuaFunction>("no_error").unwrap();
|
||||
let lua_error = globals.get::<_, LuaFunction>("lua_error").unwrap();
|
||||
let rust_error = globals.get::<_, LuaFunction>("rust_error").unwrap();
|
||||
let return_error = globals.get::<_, LuaFunction>("return_error").unwrap();
|
||||
let no_error = globals.get::<_, Function>("no_error").unwrap();
|
||||
let lua_error = globals.get::<_, Function>("lua_error").unwrap();
|
||||
let rust_error = globals.get::<_, Function>("rust_error").unwrap();
|
||||
let return_error = globals.get::<_, Function>("return_error").unwrap();
|
||||
let return_string_error = globals
|
||||
.get::<_, LuaFunction>("return_string_error")
|
||||
.get::<_, Function>("return_string_error")
|
||||
.unwrap();
|
||||
let test_pcall = globals.get::<_, LuaFunction>("test_pcall").unwrap();
|
||||
let test_pcall = globals.get::<_, Function>("test_pcall").unwrap();
|
||||
let understand_recursion = globals
|
||||
.get::<_, LuaFunction>("understand_recursion")
|
||||
.get::<_, Function>("understand_recursion")
|
||||
.unwrap();
|
||||
|
||||
assert!(no_error.call::<_, ()>(()).is_ok());
|
||||
match lua_error.call::<_, ()>(()) {
|
||||
Err(LuaError::RuntimeError(_)) => {}
|
||||
Err(Error::RuntimeError(_)) => {}
|
||||
Err(_) => panic!("error is not RuntimeError kind"),
|
||||
_ => panic!("error not returned"),
|
||||
}
|
||||
match rust_error.call::<_, ()>(()) {
|
||||
Err(LuaError::CallbackError(_, _)) => {}
|
||||
Err(Error::CallbackError(_, _)) => {}
|
||||
Err(_) => panic!("error is not CallbackError kind"),
|
||||
_ => panic!("error not returned"),
|
||||
}
|
||||
|
||||
match return_error.call::<_, LuaValue>(()) {
|
||||
Ok(LuaValue::Error(_)) => {}
|
||||
_ => panic!("LuaValue::Error not returned"),
|
||||
match return_error.call::<_, Value>(()) {
|
||||
Ok(Value::Error(_)) => {}
|
||||
_ => panic!("Value::Error not returned"),
|
||||
}
|
||||
|
||||
assert!(return_string_error.call::<_, LuaError>(()).is_ok());
|
||||
assert!(return_string_error.call::<_, Error>(()).is_ok());
|
||||
|
||||
match lua.eval::<()>("if youre happy and you know it syntax error", None) {
|
||||
Err(LuaError::SyntaxError(_)) => {}
|
||||
Err(Error::SyntaxError(_)) => {}
|
||||
Err(_) => panic!("error is not LuaSyntaxError::Syntax kind"),
|
||||
_ => panic!("error not returned"),
|
||||
}
|
||||
match lua.eval::<()>("function i_will_finish_what_i()", None) {
|
||||
Err(LuaError::IncompleteStatement(_)) => {}
|
||||
Err(Error::IncompleteStatement(_)) => {}
|
||||
Err(_) => panic!("error is not LuaSyntaxError::IncompleteStatement kind"),
|
||||
_ => panic!("error not returned"),
|
||||
}
|
||||
|
@ -560,7 +563,7 @@ fn test_error() {
|
|||
|
||||
assert!(understand_recursion.call::<_, ()>(()).is_err());
|
||||
|
||||
match catch_unwind(|| -> LuaResult<()> {
|
||||
match catch_unwind(|| -> Result<()> {
|
||||
let lua = Lua::new();
|
||||
let globals = lua.globals();
|
||||
|
||||
|
@ -577,7 +580,7 @@ fn test_error() {
|
|||
});
|
||||
globals.set("rust_panic_function", rust_panic_function)?;
|
||||
|
||||
let rust_panic = globals.get::<_, LuaFunction>("rust_panic")?;
|
||||
let rust_panic = globals.get::<_, Function>("rust_panic")?;
|
||||
|
||||
rust_panic.call::<_, ()>(())
|
||||
}) {
|
||||
|
@ -586,7 +589,7 @@ fn test_error() {
|
|||
Err(_) => {}
|
||||
};
|
||||
|
||||
match catch_unwind(|| -> LuaResult<()> {
|
||||
match catch_unwind(|| -> Result<()> {
|
||||
let lua = Lua::new();
|
||||
let globals = lua.globals();
|
||||
|
||||
|
@ -603,7 +606,7 @@ fn test_error() {
|
|||
});
|
||||
globals.set("rust_panic_function", rust_panic_function)?;
|
||||
|
||||
let rust_panic = globals.get::<_, LuaFunction>("rust_panic")?;
|
||||
let rust_panic = globals.get::<_, Function>("rust_panic")?;
|
||||
|
||||
rust_panic.call::<_, ()>(())
|
||||
}) {
|
||||
|
@ -617,7 +620,7 @@ fn test_error() {
|
|||
fn test_thread() {
|
||||
let lua = Lua::new();
|
||||
let thread = lua.create_thread(
|
||||
lua.eval::<LuaFunction>(
|
||||
lua.eval::<Function>(
|
||||
r#"
|
||||
function (s)
|
||||
local sum = s
|
||||
|
@ -631,20 +634,20 @@ fn test_thread() {
|
|||
).unwrap(),
|
||||
);
|
||||
|
||||
assert_eq!(thread.status(), LuaThreadStatus::Active);
|
||||
assert_eq!(thread.status(), ThreadStatus::Active);
|
||||
assert_eq!(thread.resume::<_, i64>(0).unwrap(), 0);
|
||||
assert_eq!(thread.status(), LuaThreadStatus::Active);
|
||||
assert_eq!(thread.status(), ThreadStatus::Active);
|
||||
assert_eq!(thread.resume::<_, i64>(1).unwrap(), 1);
|
||||
assert_eq!(thread.status(), LuaThreadStatus::Active);
|
||||
assert_eq!(thread.status(), ThreadStatus::Active);
|
||||
assert_eq!(thread.resume::<_, i64>(2).unwrap(), 3);
|
||||
assert_eq!(thread.status(), LuaThreadStatus::Active);
|
||||
assert_eq!(thread.status(), ThreadStatus::Active);
|
||||
assert_eq!(thread.resume::<_, i64>(3).unwrap(), 6);
|
||||
assert_eq!(thread.status(), LuaThreadStatus::Active);
|
||||
assert_eq!(thread.status(), ThreadStatus::Active);
|
||||
assert_eq!(thread.resume::<_, i64>(4).unwrap(), 10);
|
||||
assert_eq!(thread.status(), LuaThreadStatus::Dead);
|
||||
assert_eq!(thread.status(), ThreadStatus::Dead);
|
||||
|
||||
let accumulate = lua.create_thread(
|
||||
lua.eval::<LuaFunction>(
|
||||
lua.eval::<Function>(
|
||||
r#"
|
||||
function (sum)
|
||||
while true do
|
||||
|
@ -660,11 +663,11 @@ fn test_thread() {
|
|||
accumulate.resume::<_, ()>(i).unwrap();
|
||||
}
|
||||
assert_eq!(accumulate.resume::<_, i64>(4).unwrap(), 10);
|
||||
assert_eq!(accumulate.status(), LuaThreadStatus::Active);
|
||||
assert_eq!(accumulate.status(), ThreadStatus::Active);
|
||||
assert!(accumulate.resume::<_, ()>("error").is_err());
|
||||
assert_eq!(accumulate.status(), LuaThreadStatus::Error);
|
||||
assert_eq!(accumulate.status(), ThreadStatus::Error);
|
||||
|
||||
let thread = lua.eval::<LuaThread>(
|
||||
let thread = lua.eval::<Thread>(
|
||||
r#"
|
||||
coroutine.create(function ()
|
||||
while true do
|
||||
|
@ -674,10 +677,10 @@ fn test_thread() {
|
|||
"#,
|
||||
None,
|
||||
).unwrap();
|
||||
assert_eq!(thread.status(), LuaThreadStatus::Active);
|
||||
assert_eq!(thread.status(), ThreadStatus::Active);
|
||||
assert_eq!(thread.resume::<_, i64>(()).unwrap(), 42);
|
||||
|
||||
let thread: LuaThread = lua.eval(
|
||||
let thread: Thread = lua.eval(
|
||||
r#"
|
||||
coroutine.create(function(arg)
|
||||
assert(arg == 42)
|
||||
|
@ -693,7 +696,7 @@ fn test_thread() {
|
|||
assert_eq!(thread.resume::<_, u32>(43).unwrap(), 987);
|
||||
|
||||
match thread.resume::<_, u32>(()) {
|
||||
Err(LuaError::CoroutineInactive) => {}
|
||||
Err(Error::CoroutineInactive) => {}
|
||||
Err(_) => panic!("resuming dead coroutine error is not CoroutineInactive kind"),
|
||||
_ => panic!("resuming dead coroutine did not return error"),
|
||||
}
|
||||
|
@ -712,11 +715,11 @@ fn test_lightuserdata() {
|
|||
None,
|
||||
).unwrap();
|
||||
let res = globals
|
||||
.get::<_, LuaFunction>("id")
|
||||
.get::<_, Function>("id")
|
||||
.unwrap()
|
||||
.call::<_, LuaLightUserData>(LuaLightUserData(42 as *mut c_void))
|
||||
.call::<_, LightUserData>(LightUserData(42 as *mut c_void))
|
||||
.unwrap();
|
||||
assert_eq!(res, LuaLightUserData(42 as *mut c_void));
|
||||
assert_eq!(res, LightUserData(42 as *mut c_void));
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
@ -741,7 +744,7 @@ fn test_table_error() {
|
|||
None,
|
||||
).unwrap();
|
||||
|
||||
let bad_table: LuaTable = globals.get("table").unwrap();
|
||||
let bad_table: Table = globals.get("table").unwrap();
|
||||
assert!(bad_table.set(1, 1).is_err());
|
||||
assert!(bad_table.get::<_, i32>(1).is_err());
|
||||
assert!(bad_table.len().is_err());
|
||||
|
@ -756,11 +759,11 @@ fn test_result_conversions() {
|
|||
let globals = lua.globals();
|
||||
|
||||
let err = lua.create_function(|lua, _| {
|
||||
lua.pack(Result::Err::<String, _>(
|
||||
lua.pack(Err::<String, _>(
|
||||
"only through failure can we succeed".to_lua_err(),
|
||||
))
|
||||
});
|
||||
let ok = lua.create_function(|lua, _| lua.pack(Result::Ok::<_, LuaError>("!".to_owned())));
|
||||
let ok = lua.create_function(|lua, _| lua.pack(Ok::<_, Error>("!".to_owned())));
|
||||
|
||||
globals.set("err", err).unwrap();
|
||||
globals.set("ok", ok).unwrap();
|
||||
|
@ -806,12 +809,12 @@ fn test_num_conversion() {
|
|||
#[test]
|
||||
#[should_panic]
|
||||
fn test_expired_userdata() {
|
||||
struct Userdata {
|
||||
struct MyUserdata {
|
||||
id: u8,
|
||||
}
|
||||
|
||||
impl LuaUserDataType for Userdata {
|
||||
fn add_methods(methods: &mut LuaUserDataMethods<Self>) {
|
||||
impl UserData for MyUserdata {
|
||||
fn add_methods(methods: &mut UserDataMethods<Self>) {
|
||||
methods.add_method("access", |lua, this, _| {
|
||||
assert!(this.id == 123);
|
||||
lua.pack(())
|
||||
|
@ -822,7 +825,7 @@ fn test_expired_userdata() {
|
|||
let lua = Lua::new();
|
||||
{
|
||||
let globals = lua.globals();
|
||||
globals.set("userdata", Userdata { id: 123 }).unwrap();
|
||||
globals.set("userdata", MyUserdata { id: 123 }).unwrap();
|
||||
}
|
||||
|
||||
lua.eval::<()>(r#"
|
||||
|
@ -846,11 +849,11 @@ fn detroys_userdata() {
|
|||
|
||||
static DROPPED: AtomicBool = ATOMIC_BOOL_INIT;
|
||||
|
||||
struct Userdata;
|
||||
struct MyUserdata;
|
||||
|
||||
impl LuaUserDataType for Userdata {}
|
||||
impl UserData for MyUserdata {}
|
||||
|
||||
impl Drop for Userdata {
|
||||
impl Drop for MyUserdata {
|
||||
fn drop(&mut self) {
|
||||
DROPPED.store(true, Ordering::SeqCst);
|
||||
}
|
||||
|
@ -859,7 +862,7 @@ fn detroys_userdata() {
|
|||
let lua = Lua::new();
|
||||
{
|
||||
let globals = lua.globals();
|
||||
globals.set("userdata", Userdata).unwrap();
|
||||
globals.set("userdata", MyUserdata).unwrap();
|
||||
}
|
||||
|
||||
assert_eq!(DROPPED.load(Ordering::SeqCst), false);
|
||||
|
|
44
src/util.rs
44
src/util.rs
|
@ -8,7 +8,7 @@ use std::os::raw::{c_char, c_int, c_void};
|
|||
use std::panic::{catch_unwind, resume_unwind, UnwindSafe};
|
||||
|
||||
use ffi;
|
||||
use error::{LuaResult, LuaError};
|
||||
use error::{Result, Error};
|
||||
|
||||
macro_rules! cstr {
|
||||
($s:expr) => (
|
||||
|
@ -114,9 +114,9 @@ pub unsafe fn stack_err_guard<F, R>(
|
|||
state: *mut ffi::lua_State,
|
||||
change: c_int,
|
||||
op: F,
|
||||
) -> LuaResult<R>
|
||||
) -> Result<R>
|
||||
where
|
||||
F: FnOnce() -> LuaResult<R>,
|
||||
F: FnOnce() -> Result<R>,
|
||||
{
|
||||
let expected = ffi::lua_gettop(state) + change;
|
||||
lua_assert!(
|
||||
|
@ -152,7 +152,7 @@ where
|
|||
}
|
||||
|
||||
// Protected version of lua_gettable, uses 3 stack spaces, does not call checkstack.
|
||||
pub unsafe fn pgettable(state: *mut ffi::lua_State, index: c_int) -> LuaResult<c_int> {
|
||||
pub unsafe fn pgettable(state: *mut ffi::lua_State, index: c_int) -> Result<c_int> {
|
||||
unsafe extern "C" fn gettable(state: *mut ffi::lua_State) -> c_int {
|
||||
ffi::lua_gettable(state, -2);
|
||||
1
|
||||
|
@ -170,7 +170,7 @@ pub unsafe fn pgettable(state: *mut ffi::lua_State, index: c_int) -> LuaResult<c
|
|||
}
|
||||
|
||||
// Protected version of lua_settable, uses 4 stack spaces, does not call checkstack.
|
||||
pub unsafe fn psettable(state: *mut ffi::lua_State, index: c_int) -> LuaResult<()> {
|
||||
pub unsafe fn psettable(state: *mut ffi::lua_State, index: c_int) -> Result<()> {
|
||||
unsafe extern "C" fn settable(state: *mut ffi::lua_State) -> c_int {
|
||||
ffi::lua_settable(state, -3);
|
||||
0
|
||||
|
@ -190,7 +190,7 @@ pub unsafe fn psettable(state: *mut ffi::lua_State, index: c_int) -> LuaResult<(
|
|||
}
|
||||
|
||||
// Protected version of luaL_len, uses 2 stack spaces, does not call checkstack.
|
||||
pub unsafe fn plen(state: *mut ffi::lua_State, index: c_int) -> LuaResult<ffi::lua_Integer> {
|
||||
pub unsafe fn plen(state: *mut ffi::lua_State, index: c_int) -> Result<ffi::lua_Integer> {
|
||||
unsafe extern "C" fn len(state: *mut ffi::lua_State) -> c_int {
|
||||
ffi::lua_pushinteger(state, ffi::luaL_len(state, -1));
|
||||
1
|
||||
|
@ -208,7 +208,7 @@ pub unsafe fn plen(state: *mut ffi::lua_State, index: c_int) -> LuaResult<ffi::l
|
|||
}
|
||||
|
||||
// Protected version of lua_geti, uses 3 stack spaces, does not call checkstack.
|
||||
pub unsafe fn pgeti(state: *mut ffi::lua_State, index: c_int, i: ffi::lua_Integer) -> LuaResult<c_int> {
|
||||
pub unsafe fn pgeti(state: *mut ffi::lua_State, index: c_int, i: ffi::lua_Integer) -> Result<c_int> {
|
||||
unsafe extern "C" fn geti(state: *mut ffi::lua_State) -> c_int {
|
||||
let i = ffi::lua_tointeger(state, -1);
|
||||
ffi::lua_geti(state, -2, i);
|
||||
|
@ -226,7 +226,7 @@ pub unsafe fn pgeti(state: *mut ffi::lua_State, index: c_int, i: ffi::lua_Intege
|
|||
}
|
||||
|
||||
// Protected version of lua_next, uses 3 stack spaces, does not call checkstack.
|
||||
pub unsafe fn pnext(state: *mut ffi::lua_State, index: c_int) -> LuaResult<c_int> {
|
||||
pub unsafe fn pnext(state: *mut ffi::lua_State, index: c_int) -> Result<c_int> {
|
||||
unsafe extern "C" fn next(state: *mut ffi::lua_State) -> c_int {
|
||||
if ffi::lua_next(state, -2) == 0 {
|
||||
0
|
||||
|
@ -257,7 +257,7 @@ pub unsafe fn pnext(state: *mut ffi::lua_State, index: c_int) -> LuaResult<c_int
|
|||
// stack continues the panic. If the error on the top of the stack is actually
|
||||
// a WrappedError, just returns it. Otherwise, interprets the error as the
|
||||
// appropriate lua error.
|
||||
pub unsafe fn handle_error(state: *mut ffi::lua_State, err: c_int) -> LuaResult<()> {
|
||||
pub unsafe fn handle_error(state: *mut ffi::lua_State, err: c_int) -> Result<()> {
|
||||
if err == ffi::LUA_OK || err == ffi::LUA_YIELD {
|
||||
Ok(())
|
||||
} else {
|
||||
|
@ -286,17 +286,17 @@ pub unsafe fn handle_error(state: *mut ffi::lua_State, err: c_int) -> LuaResult<
|
|||
ffi::lua_pop(state, 1);
|
||||
|
||||
Err(match err {
|
||||
ffi::LUA_ERRRUN => LuaError::RuntimeError(err_string),
|
||||
ffi::LUA_ERRRUN => Error::RuntimeError(err_string),
|
||||
ffi::LUA_ERRSYNTAX => {
|
||||
// This seems terrible, but as far as I can tell, this is exactly what the stock
|
||||
// lua repl does.
|
||||
if err_string.ends_with("<eof>") {
|
||||
LuaError::IncompleteStatement(err_string)
|
||||
Error::IncompleteStatement(err_string)
|
||||
} else {
|
||||
LuaError::SyntaxError(err_string)
|
||||
Error::SyntaxError(err_string)
|
||||
}
|
||||
}
|
||||
ffi::LUA_ERRERR => LuaError::ErrorError(err_string),
|
||||
ffi::LUA_ERRERR => Error::ErrorError(err_string),
|
||||
ffi::LUA_ERRMEM => {
|
||||
// This is not impossible to hit, but this library is not set up
|
||||
// to handle this properly. Lua does a longjmp on out of memory
|
||||
|
@ -358,7 +358,7 @@ pub unsafe extern "C" fn userdata_destructor<T>(state: *mut ffi::lua_State) -> c
|
|||
// the rust side, it will resume the panic.
|
||||
pub unsafe fn callback_error<R, F>(state: *mut ffi::lua_State, f: F) -> R
|
||||
where
|
||||
F: FnOnce() -> LuaResult<R> + UnwindSafe,
|
||||
F: FnOnce() -> Result<R> + UnwindSafe,
|
||||
{
|
||||
match catch_unwind(f) {
|
||||
Ok(Ok(r)) => r,
|
||||
|
@ -374,7 +374,7 @@ where
|
|||
}
|
||||
|
||||
// ffi::lua_pcall with a message handler that gives a nice traceback. If the
|
||||
// caught error is actually a LuaError, will simply pass the error along. Does
|
||||
// caught error is actually a Error, will simply pass the error along. Does
|
||||
// not call checkstack, and uses 2 extra stack spaces.
|
||||
pub unsafe fn pcall_with_traceback(
|
||||
state: *mut ffi::lua_State,
|
||||
|
@ -388,7 +388,7 @@ pub unsafe fn pcall_with_traceback(
|
|||
.to_str()
|
||||
.unwrap_or_else(|_| "<could not capture traceback>")
|
||||
.to_owned();
|
||||
push_wrapped_error(state, LuaError::CallbackError(traceback, Arc::new(error)));
|
||||
push_wrapped_error(state, Error::CallbackError(traceback, Arc::new(error)));
|
||||
} else if !is_wrapped_panic(state, 1) {
|
||||
let s = ffi::lua_tolstring(state, 1, ptr::null_mut());
|
||||
if !s.is_null() {
|
||||
|
@ -421,7 +421,7 @@ pub unsafe fn resume_with_traceback(
|
|||
.to_str()
|
||||
.unwrap_or_else(|_| "<could not capture traceback>")
|
||||
.to_owned();
|
||||
push_wrapped_error(from, LuaError::CallbackError(traceback, Arc::new(error)));
|
||||
push_wrapped_error(from, Error::CallbackError(traceback, Arc::new(error)));
|
||||
} else if !is_wrapped_panic(state, 1) {
|
||||
let s = ffi::lua_tolstring(state, 1, ptr::null_mut());
|
||||
if !s.is_null() {
|
||||
|
@ -491,11 +491,11 @@ pub unsafe fn main_state(state: *mut ffi::lua_State) -> *mut ffi::lua_State {
|
|||
state
|
||||
}
|
||||
|
||||
pub struct WrappedError(pub LuaError);
|
||||
pub struct WrappedError(pub Error);
|
||||
pub struct WrappedPanic(pub Option<Box<Any + Send>>);
|
||||
|
||||
// Pushes a WrappedError::Error to the top of the stack
|
||||
pub unsafe fn push_wrapped_error(state: *mut ffi::lua_State, err: LuaError) {
|
||||
pub unsafe fn push_wrapped_error(state: *mut ffi::lua_State, err: Error) {
|
||||
unsafe extern "C" fn error_tostring(state: *mut ffi::lua_State) -> c_int {
|
||||
callback_error(state, || if is_wrapped_error(state, -1) {
|
||||
let error = &*get_userdata::<WrappedError>(state, -1);
|
||||
|
@ -505,8 +505,8 @@ pub unsafe fn push_wrapped_error(state: *mut ffi::lua_State, err: LuaError) {
|
|||
Ok(1)
|
||||
|
||||
} else {
|
||||
Err(LuaError::FromLuaConversionError(
|
||||
"internal error: userdata mismatch in LuaError metamethod"
|
||||
Err(Error::FromLuaConversionError(
|
||||
"internal error: userdata mismatch in Error metamethod"
|
||||
.to_owned(),
|
||||
))
|
||||
})
|
||||
|
@ -582,7 +582,7 @@ pub unsafe fn push_wrapped_panic(state: *mut ffi::lua_State, panic: Box<Any + Se
|
|||
|
||||
// Pops a WrappedError off of the top of the stack, if it is a WrappedError. If
|
||||
// it is not a WrappedError, returns None and does not pop anything.
|
||||
pub unsafe fn pop_wrapped_error(state: *mut ffi::lua_State) -> Option<LuaError> {
|
||||
pub unsafe fn pop_wrapped_error(state: *mut ffi::lua_State) -> Option<Error> {
|
||||
if ffi::lua_gettop(state) == 0 || !is_wrapped_error(state, -1) {
|
||||
None
|
||||
} else {
|
||||
|
|
Loading…
Reference in New Issue