Crate lua_macros

This crate contains useful macros for lua crate.

Clean up the stack for scope

Use auto_cleanup to revert top of stack to size before scope:

fn main() {
    let mut state = State::new();

    state.push(1);

    auto_cleanup!(state, {
        state.push(2);
        state.push(3);
        state.push(4);
        state.push(5);
    });

    assert_eq!(state.get_top(), 1);
}

Convert arguuments from lua

Library has macro convert_arguments to convert arguments for any types which implemented FromLua trait:

pub unsafe extern "C" fn fun_function(ls: *mut lua_State) -> c_int {
    let mut state = State::from_ptr(ls);
    let (_int, _float, _, _str) = convert_arguments!(state, Integer, Number, _, String)
        .map_err(|pos| {
            let msg = match pos {
                1 => "integer | integer expected as first argument",
                2 => "number | float expected as second argument",
                3 => "any | third argument expected",
                4 => "string | string expected as fourth argument",
                _ => "unknown argument for `do` funciton",
            };
            state.arg_error(pos, msg);
        }).unwrap();
    state.push_string("That's OK!");
    1
}

fn main() {
    let mut state = State::new();
    state.push_fn(Some(fun_function));
    state.set_global("fun");

    assert!(state.do_string("return fun()").is_err());
    assert!(state.to_str(-1).unwrap().contains("bad argument #1"));

    assert!(state.do_string("return fun(1)").is_err());
    assert!(state.to_str(-1).unwrap().contains("bad argument #2"));

    assert!(state.do_string("return fun(1, 2.3)").is_err());
    assert!(state.to_str(-1).unwrap().contains("bad argument #3"));

    assert!(state.do_string("return fun(1, 2.3, function() end)").is_err());
    assert!(state.to_str(-1).unwrap().contains("bad argument #4"));

    assert!(!state.do_string("return fun(1, 2.3, {}, \"string\")").is_err());
    assert!(state.to_str(-1).unwrap().contains("OK"));

    assert!(state.do_string("return fun({}, 2.3, {}, \"string\")").is_err());
    assert!(state.to_str(-1).unwrap().contains("bad argument #1"));

    assert!(state.do_string("return fun(1, 2.3, {}, \"string\", \"extra\")").is_err());
    assert!(state.to_str(-1).unwrap().contains("bad argument #5"));
}

Read HashMap from Lua’s table

Macro lua_table_type creates wrapper type to unpack tables:

lua_table_type!(UserTable<String, Integer>);

fn main() {
    let mut state = State::new();
    state.do_string("return {one = 1, two = 2, three = 3}");
    let UserTable(mut table) = state.to_type(-1).unwrap();
    assert_eq!(table.remove("one"), Some(1));
    assert_eq!(table.remove("two"), Some(2));
    assert_eq!(table.remove("three"), Some(3));
}

Read Vec from Lua’s array

Macro lua_array_type creates wrapper type to unpack arrays:

lua_array_type!(UserArray<Integer>);

fn main() {
    let mut state = State::new();
    state.do_string("return {1, 2, 3}");
    let UserArray(array) = state.to_type(-1).unwrap();
    assert_eq!(array[0], 1);
}

Adds own userdata

Macro lua_userdata implements userdata features for type:

enum UserEnum {
  One,
  Two,
  Three,
}

lua_userdata!(UserEnum);

fn main() {
    let mut state = State::new();
    UserEnum::attach(&mut state);

    let ud = UserEnum::One;
    state.push(ud);
    state.push_nil();

    let restored = state.to_type::<UserEnum>(-2).unwrap();
    let wrong = state.to_type::<UserEnum>(-1);

    assert_eq!(restored, UserEnum::One);
    assert!(wrong.is_none());
}

Re-exports

pub extern crate lua;

Macros

auto_cleanup

Clean up stack for the scope.

convert_arguments

Convert arguments using FromLua trait.

lua_array_type

Makes wrapper to read table to array.

lua_table_type

Makes wrapper to read table to hash map.

lua_userdata

Add userdata’s methods to user’s type.