Struct State

pub struct State { /* private fields */ }

An idiomatic, Rust wrapper around lua_State.

Function names adhere to Rust naming conventions. Most of the time, this means breaking up long C function names using underscores; however, there are some cases where different names are used. Typically, these are cases where the name itself is a reserved Rust keyword (such as ref in luaL_ref or where in luaL_where) or where the name is used in both the base Lua library and the auxiliary Lua library (such as lua_getmetatable and luaL_getmetatable). More descriptive names have been chosen for these functions. Finally, any reference to C functions has been replaced by the term native functions. lua_iscfunction is is_native_fn and lua_tocfunction is to_native_fn.

Implementations

impl State

pub fn new() -> State

Initializes a new Lua state. This function does not open any libraries by default. Calls lua_newstate internally.

Examples found in repository

examples/userdata/main.rs (line 81)

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

  state.open_libs();

  // make a Point2D table globally available to the lua state and register
  // our functions there:
  state.new_table();
  state.set_fns(&POINT2D_LIB, 0);
  // copy reference to Point2D table so we can keep the original reference on
  // the stack for later
  state.push_value(-1);
  state.set_global("Point2D");

  // create a metatable for Point2D in the lua registry that refers to the
  // global Point2D table:
  state.new_metatable("Point2D");
  // copy reference to Point2D table
  state.push_value(-2);
  // Point2Dmetatable.__index = Point2D
  state.set_field(-2, "__index");

  // pop metatable and Point2D table from the stack
  state.pop(2);

  // try it out:
  state.do_string("local p = Point2D.new(12, 34)
                   print(p:x(), p:y())");
}

examples/userdata-with-drop/main.rs (line 106)

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

    state.open_libs();

    // make a VecWrapper table globally available to the lua state and register
    // our functions there:
    state.new_table();
    state.set_fns(&VECWRAPPER_LIB, 0);
    // copy reference to VecWrapper table so we can keep the original reference
    // on the stack for later
    state.push_value(-1);
    state.set_global("VecWrapper");

    // create a metatable for VecWrapper in the lua registry that refers to the
    // global VecWrapper table:
    state.new_metatable("VecWrapper");
    // copy reference to VecWrapper table
    state.push_value(-2);
    // VecWrappermetatable.__index = VecWrapper
    state.set_field(-2, "__index");
    // VecWrappermetatable.__gc = lua_gc
    state.push_fn(Some(VecWrapper::lua_gc));
    state.set_field(-2, "__gc");

    // pop metatable and VecWrapper table from the stack
    state.pop(2);

    // try it out:
    state.do_string("local v = VecWrapper.new()
                     v:push(12)
                     v:push(34)
                     -- should print 2
                     print('length of vec is', v:len())
                     -- should print 12 34 nil
                     print(v:get(0), v:get(1), v:get(2))");
}

pub unsafe fn from_ptr(L: *mut lua_State) -> State

Constructs a wrapper State from a raw pointer. This is suitable for use inside of native functions that accept a lua_State to obtain a wrapper.

Examples found in repository

examples/userdata-with-drop/main.rs (line 44)

  unsafe extern "C" fn lua_new(L: *mut lua_State) -> c_int {
    let mut state = State::from_ptr(L);
    // construct new userdata in lua space and initialize it
    let v: *mut VecWrapper = state.new_userdata_typed();
    std::ptr::write(v, VecWrapper::new());
    // set the userdata's metatable so we can call methods on it
    state.set_metatable_from_registry("VecWrapper");
    // return the userdata on top of the stack
    1
  }

  /// Returns the value in the underlying Vec at index `i`. If the index is out
  /// of bounds, this function returns nil instead.
  #[allow(non_snake_case)]
  unsafe extern "C" fn lua_get(L: *mut lua_State) -> c_int {
    let mut state = State::from_ptr(L);
    let v = state.check_userdata(1, "VecWrapper") as *mut VecWrapper;
    let i = state.check_integer(2) as usize;
    // push integer if index is not out of bounds, otherwise nil
    match (*v).data.get(i) {
      Some(value) => state.push_integer(*value),
      None        => state.push_nil()
    };
    1
  }

  /// Pushes a value into the underlying Vec.
  #[allow(non_snake_case)]
  unsafe extern "C" fn lua_push(L: *mut lua_State) -> c_int {
    let mut state = State::from_ptr(L);
    let v = state.check_userdata(1, "VecWrapper") as *mut VecWrapper;
    let i = state.check_integer(2);
    (*v).data.push(i);
    1
  }

  /// Returns the length of the underlying Vec.
  #[allow(non_snake_case)]
  unsafe extern "C" fn lua_len(L: *mut lua_State) -> c_int {
    let mut state = State::from_ptr(L);
    let v = state.check_userdata(1, "VecWrapper") as *mut VecWrapper;
    state.push_integer((*v).data.len() as i64);
    1
  }

  /// Garbage collects a VecWrapper.
  #[allow(non_snake_case)]
  unsafe extern "C" fn lua_gc(L: *mut lua_State) -> c_int {
    let mut state = State::from_ptr(L);
    let v = state.check_userdata(1, "VecWrapper") as *mut VecWrapper;
    std::ptr::drop_in_place(v);
    0
  }

examples/userdata/main.rs (line 45)

  unsafe extern "C" fn lua_new(L: *mut lua_State) -> c_int {
    let mut state = State::from_ptr(L);
    // takes two optional integer parameters
    let x = state.opt_integer(1, 0);
    let y = state.opt_integer(2, 0);
    // construct new userdata in lua space and initialize it
    *state.new_userdata_typed::<Point2D>() = Point2D::new(x, y);
    // set the userdata's metatable so we can call methods on it
    state.set_metatable_from_registry("Point2D");
    // return the userdata on top of the stack
    1
  }

  #[allow(non_snake_case)]
  unsafe extern "C" fn lua_x(L: *mut lua_State) -> c_int {
    let mut state = State::from_ptr(L);
    let point = state.check_userdata(1, "Point2D") as *mut Point2D;
    state.push_integer((*point).x);
    1
  }

  #[allow(non_snake_case)]
  unsafe extern "C" fn lua_y(L: *mut lua_State) -> c_int {
    let mut state = State::from_ptr(L);
    let point = state.check_userdata(1, "Point2D") as *mut Point2D;
    state.push_integer((*point).y);
    1
  }

pub fn as_ptr(&self) -> *mut lua_State

Returns an unsafe pointer to the wrapped lua_State.

pub fn open_libs(&mut self)

Maps to luaL_openlibs.

Examples found in repository

examples/userdata/main.rs (line 83)

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

  state.open_libs();

  // make a Point2D table globally available to the lua state and register
  // our functions there:
  state.new_table();
  state.set_fns(&POINT2D_LIB, 0);
  // copy reference to Point2D table so we can keep the original reference on
  // the stack for later
  state.push_value(-1);
  state.set_global("Point2D");

  // create a metatable for Point2D in the lua registry that refers to the
  // global Point2D table:
  state.new_metatable("Point2D");
  // copy reference to Point2D table
  state.push_value(-2);
  // Point2Dmetatable.__index = Point2D
  state.set_field(-2, "__index");

  // pop metatable and Point2D table from the stack
  state.pop(2);

  // try it out:
  state.do_string("local p = Point2D.new(12, 34)
                   print(p:x(), p:y())");
}

examples/userdata-with-drop/main.rs (line 108)

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

    state.open_libs();

    // make a VecWrapper table globally available to the lua state and register
    // our functions there:
    state.new_table();
    state.set_fns(&VECWRAPPER_LIB, 0);
    // copy reference to VecWrapper table so we can keep the original reference
    // on the stack for later
    state.push_value(-1);
    state.set_global("VecWrapper");

    // create a metatable for VecWrapper in the lua registry that refers to the
    // global VecWrapper table:
    state.new_metatable("VecWrapper");
    // copy reference to VecWrapper table
    state.push_value(-2);
    // VecWrappermetatable.__index = VecWrapper
    state.set_field(-2, "__index");
    // VecWrappermetatable.__gc = lua_gc
    state.push_fn(Some(VecWrapper::lua_gc));
    state.set_field(-2, "__gc");

    // pop metatable and VecWrapper table from the stack
    state.pop(2);

    // try it out:
    state.do_string("local v = VecWrapper.new()
                     v:push(12)
                     v:push(34)
                     -- should print 2
                     print('length of vec is', v:len())
                     -- should print 12 34 nil
                     print(v:get(0), v:get(1), v:get(2))");
}

pub fn preload_library(&mut self, lib: Library)

Preloads library, i.e. it’s not exposed, but can be required

pub fn load_library(&mut self, lib: Library)

Loads a built-in library and exposes it into lua code

pub fn open_base(&mut self) -> c_int

Maps to luaopen_base.

pub fn open_coroutine(&mut self) -> c_int

Maps to luaopen_coroutine.

pub fn open_table(&mut self) -> c_int

Maps to luaopen_table.

pub fn open_io(&mut self) -> c_int

Maps to luaopen_io.

pub fn open_os(&mut self) -> c_int

Maps to luaopen_os.

pub fn open_string(&mut self) -> c_int

Maps to luaopen_string.

pub fn open_utf8(&mut self) -> c_int

Maps to luaopen_utf8.

pub fn open_bit32(&mut self) -> c_int

Maps to luaopen_bit32.

pub fn open_math(&mut self) -> c_int

Maps to luaopen_math.

pub fn open_debug(&mut self) -> c_int

Maps to luaopen_debug.

pub fn open_package(&mut self) -> c_int

Maps to luaopen_package.

pub fn do_file(&mut self, filename: &str) -> ThreadStatus

Maps to luaL_dofile.

pub fn do_string(&mut self, s: &str) -> ThreadStatus

Maps to luaL_dostring.

Examples found in repository

examples/userdata/main.rs (lines 106-107)

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

  state.open_libs();

  // make a Point2D table globally available to the lua state and register
  // our functions there:
  state.new_table();
  state.set_fns(&POINT2D_LIB, 0);
  // copy reference to Point2D table so we can keep the original reference on
  // the stack for later
  state.push_value(-1);
  state.set_global("Point2D");

  // create a metatable for Point2D in the lua registry that refers to the
  // global Point2D table:
  state.new_metatable("Point2D");
  // copy reference to Point2D table
  state.push_value(-2);
  // Point2Dmetatable.__index = Point2D
  state.set_field(-2, "__index");

  // pop metatable and Point2D table from the stack
  state.pop(2);

  // try it out:
  state.do_string("local p = Point2D.new(12, 34)
                   print(p:x(), p:y())");
}

examples/userdata-with-drop/main.rs (lines 134-140)

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

    state.open_libs();

    // make a VecWrapper table globally available to the lua state and register
    // our functions there:
    state.new_table();
    state.set_fns(&VECWRAPPER_LIB, 0);
    // copy reference to VecWrapper table so we can keep the original reference
    // on the stack for later
    state.push_value(-1);
    state.set_global("VecWrapper");

    // create a metatable for VecWrapper in the lua registry that refers to the
    // global VecWrapper table:
    state.new_metatable("VecWrapper");
    // copy reference to VecWrapper table
    state.push_value(-2);
    // VecWrappermetatable.__index = VecWrapper
    state.set_field(-2, "__index");
    // VecWrappermetatable.__gc = lua_gc
    state.push_fn(Some(VecWrapper::lua_gc));
    state.set_field(-2, "__gc");

    // pop metatable and VecWrapper table from the stack
    state.pop(2);

    // try it out:
    state.do_string("local v = VecWrapper.new()
                     v:push(12)
                     v:push(34)
                     -- should print 2
                     print('length of vec is', v:len())
                     -- should print 12 34 nil
                     print(v:get(0), v:get(1), v:get(2))");
}

pub fn push<T: ToLua>(&mut self, value: T)

Pushes the given value onto the stack.

pub fn to_type<T: FromLua>(&mut self, index: Index) -> Option<T>

Converts the value on top of the stack to a value of type T and returns it.

pub fn close(self)

Maps to lua_close.

pub fn new_thread(&mut self) -> State

Maps to lua_newthread.

pub fn at_panic(&mut self, panicf: Function) -> Function

Maps to lua_atpanic.

pub fn version(state: Option<&mut State>) -> Number

Maps to lua_version.

pub fn abs_index(&mut self, idx: Index) -> Index

Maps to lua_absindex.

pub fn get_top(&mut self) -> Index

Maps to lua_gettop.

pub fn set_top(&mut self, index: Index)

Maps to lua_settop.

pub fn push_value(&mut self, index: Index)

Maps to lua_pushvalue.

Examples found in repository

examples/userdata/main.rs (line 91)

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

  state.open_libs();

  // make a Point2D table globally available to the lua state and register
  // our functions there:
  state.new_table();
  state.set_fns(&POINT2D_LIB, 0);
  // copy reference to Point2D table so we can keep the original reference on
  // the stack for later
  state.push_value(-1);
  state.set_global("Point2D");

  // create a metatable for Point2D in the lua registry that refers to the
  // global Point2D table:
  state.new_metatable("Point2D");
  // copy reference to Point2D table
  state.push_value(-2);
  // Point2Dmetatable.__index = Point2D
  state.set_field(-2, "__index");

  // pop metatable and Point2D table from the stack
  state.pop(2);

  // try it out:
  state.do_string("local p = Point2D.new(12, 34)
                   print(p:x(), p:y())");
}

examples/userdata-with-drop/main.rs (line 116)

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

    state.open_libs();

    // make a VecWrapper table globally available to the lua state and register
    // our functions there:
    state.new_table();
    state.set_fns(&VECWRAPPER_LIB, 0);
    // copy reference to VecWrapper table so we can keep the original reference
    // on the stack for later
    state.push_value(-1);
    state.set_global("VecWrapper");

    // create a metatable for VecWrapper in the lua registry that refers to the
    // global VecWrapper table:
    state.new_metatable("VecWrapper");
    // copy reference to VecWrapper table
    state.push_value(-2);
    // VecWrappermetatable.__index = VecWrapper
    state.set_field(-2, "__index");
    // VecWrappermetatable.__gc = lua_gc
    state.push_fn(Some(VecWrapper::lua_gc));
    state.set_field(-2, "__gc");

    // pop metatable and VecWrapper table from the stack
    state.pop(2);

    // try it out:
    state.do_string("local v = VecWrapper.new()
                     v:push(12)
                     v:push(34)
                     -- should print 2
                     print('length of vec is', v:len())
                     -- should print 12 34 nil
                     print(v:get(0), v:get(1), v:get(2))");
}

pub fn rotate(&mut self, idx: Index, n: c_int)

Maps to lua_rotate.

pub fn copy(&mut self, from_idx: Index, to_idx: Index)

Maps to lua_copy.

pub fn check_stack(&mut self, extra: c_int) -> bool

Maps to lua_checkstack.

pub fn xmove(&mut self, to: &mut State, n: c_int)

Maps to lua_xmove.

pub fn is_number(&mut self, index: Index) -> bool

Maps to lua_isnumber.

pub fn is_string(&mut self, index: Index) -> bool

Maps to lua_isstring.

pub fn is_native_fn(&mut self, index: Index) -> bool

Maps to lua_iscfunction.

pub fn is_integer(&mut self, index: Index) -> bool

Maps to lua_isinteger.

pub fn is_userdata(&mut self, index: Index) -> bool

Maps to lua_isuserdata.

pub fn type_of(&mut self, index: Index) -> Option<Type>

Maps to lua_type.

pub fn typename_of(&mut self, tp: Type) -> &'static str

Maps to lua_typename.

pub fn to_numberx(&mut self, index: Index) -> Option<Number>

Maps to lua_tonumberx.

pub fn to_integerx(&mut self, index: Index) -> Option<Integer>

Maps to lua_tointegerx.

pub fn to_bool(&mut self, index: Index) -> bool

Maps to lua_toboolean.

pub fn raw_len(&mut self, index: Index) -> size_t

Maps to lua_rawlen.

pub fn to_native_fn(&mut self, index: Index) -> Function

Maps to lua_tocfunction.

pub fn to_userdata(&mut self, index: Index) -> *mut c_void

Maps to lua_touserdata.

pub unsafe fn to_userdata_typed<'a, T>( &'a mut self, index: Index, ) -> Option<&'a mut T>

Convenience function that calls to_userdata and performs a cast.

pub fn to_thread(&mut self, index: Index) -> Option<State>

Maps to lua_tothread.

pub fn to_pointer(&mut self, index: Index) -> *const c_void

Maps to lua_topointer.

pub fn arith(&mut self, op: Arithmetic)

Maps to lua_arith.

pub fn raw_equal(&mut self, idx1: Index, idx2: Index) -> bool

Maps to lua_rawequal.

pub fn compare(&mut self, idx1: Index, idx2: Index, op: Comparison) -> bool

Maps to lua_compare.

pub fn push_nil(&mut self)

Maps to lua_pushnil.

Examples found in repository

examples/userdata-with-drop/main.rs (line 64)

  unsafe extern "C" fn lua_get(L: *mut lua_State) -> c_int {
    let mut state = State::from_ptr(L);
    let v = state.check_userdata(1, "VecWrapper") as *mut VecWrapper;
    let i = state.check_integer(2) as usize;
    // push integer if index is not out of bounds, otherwise nil
    match (*v).data.get(i) {
      Some(value) => state.push_integer(*value),
      None        => state.push_nil()
    };
    1
  }

pub fn push_number(&mut self, n: Number)

Maps to lua_pushnumber.

pub fn push_integer(&mut self, i: Integer)

Maps to lua_pushinteger.

Examples found in repository

examples/userdata/main.rs (line 61)

  unsafe extern "C" fn lua_x(L: *mut lua_State) -> c_int {
    let mut state = State::from_ptr(L);
    let point = state.check_userdata(1, "Point2D") as *mut Point2D;
    state.push_integer((*point).x);
    1
  }

  #[allow(non_snake_case)]
  unsafe extern "C" fn lua_y(L: *mut lua_State) -> c_int {
    let mut state = State::from_ptr(L);
    let point = state.check_userdata(1, "Point2D") as *mut Point2D;
    state.push_integer((*point).y);
    1
  }

examples/userdata-with-drop/main.rs (line 63)

  unsafe extern "C" fn lua_get(L: *mut lua_State) -> c_int {
    let mut state = State::from_ptr(L);
    let v = state.check_userdata(1, "VecWrapper") as *mut VecWrapper;
    let i = state.check_integer(2) as usize;
    // push integer if index is not out of bounds, otherwise nil
    match (*v).data.get(i) {
      Some(value) => state.push_integer(*value),
      None        => state.push_nil()
    };
    1
  }

  /// Pushes a value into the underlying Vec.
  #[allow(non_snake_case)]
  unsafe extern "C" fn lua_push(L: *mut lua_State) -> c_int {
    let mut state = State::from_ptr(L);
    let v = state.check_userdata(1, "VecWrapper") as *mut VecWrapper;
    let i = state.check_integer(2);
    (*v).data.push(i);
    1
  }

  /// Returns the length of the underlying Vec.
  #[allow(non_snake_case)]
  unsafe extern "C" fn lua_len(L: *mut lua_State) -> c_int {
    let mut state = State::from_ptr(L);
    let v = state.check_userdata(1, "VecWrapper") as *mut VecWrapper;
    state.push_integer((*v).data.len() as i64);
    1
  }

pub fn push_string(&mut self, s: &str)

Maps to lua_pushlstring.

pub fn push_closure(&mut self, f: Function, n: c_int)

Maps to lua_pushcclosure.

pub fn push_bool(&mut self, b: bool)

Maps to lua_pushboolean.

pub unsafe fn push_light_userdata<T>(&mut self, ud: *mut T)

Maps to lua_pushlightuserdata. The Lua state will receive a pointer to the given value. The caller is responsible for cleaning up the data. Any code that manipulates the userdata is free to modify its contents, so memory safety is not guaranteed.

pub fn push_thread(&mut self) -> bool

Maps to lua_pushthread.

pub fn get_global(&mut self, name: &str) -> Type

Maps to lua_getglobal.

pub fn get_table(&mut self, index: Index) -> Type

Maps to lua_gettable.

pub fn get_field(&mut self, index: Index, k: &str) -> Type

Maps to lua_getfield.

pub fn geti(&mut self, index: Index, i: Integer) -> Type

Maps to lua_geti.

pub fn raw_get(&mut self, index: Index) -> Type

Maps to lua_rawget.

pub fn raw_geti(&mut self, index: Index, n: Integer) -> Type

Maps to lua_rawgeti.

pub fn raw_getp<T>(&mut self, index: Index, p: *const T) -> Type

Maps to lua_rawgetp.

pub fn create_table(&mut self, narr: c_int, nrec: c_int)

Maps to lua_createtable.

pub fn new_userdata(&mut self, sz: size_t) -> *mut c_void

Maps to lua_newuserdata. The pointer returned is owned by the Lua state and it will be garbage collected when it is no longer in use or the state is closed. To specify custom cleanup behavior, use a __gc metamethod.

pub fn new_userdata_typed<T>(&mut self) -> *mut T

Convenience function that uses type information to call new_userdata and perform a cast.

Example

unsafe { *state.new_userdata_typed() = MyStruct::new(...); }
state.set_metatable_from_registry("MyStruct");

Examples found in repository

examples/userdata-with-drop/main.rs (line 46)

  unsafe extern "C" fn lua_new(L: *mut lua_State) -> c_int {
    let mut state = State::from_ptr(L);
    // construct new userdata in lua space and initialize it
    let v: *mut VecWrapper = state.new_userdata_typed();
    std::ptr::write(v, VecWrapper::new());
    // set the userdata's metatable so we can call methods on it
    state.set_metatable_from_registry("VecWrapper");
    // return the userdata on top of the stack
    1
  }

examples/userdata/main.rs (line 50)

  unsafe extern "C" fn lua_new(L: *mut lua_State) -> c_int {
    let mut state = State::from_ptr(L);
    // takes two optional integer parameters
    let x = state.opt_integer(1, 0);
    let y = state.opt_integer(2, 0);
    // construct new userdata in lua space and initialize it
    *state.new_userdata_typed::<Point2D>() = Point2D::new(x, y);
    // set the userdata's metatable so we can call methods on it
    state.set_metatable_from_registry("Point2D");
    // return the userdata on top of the stack
    1
  }

pub fn get_metatable(&mut self, objindex: Index) -> bool

Maps to lua_getmetatable.

pub fn get_uservalue(&mut self, idx: Index) -> Type

Maps to lua_getuservalue.

pub fn set_global(&mut self, var: &str)

Maps to lua_setglobal.

Examples found in repository

examples/userdata/main.rs (line 92)

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

  state.open_libs();

  // make a Point2D table globally available to the lua state and register
  // our functions there:
  state.new_table();
  state.set_fns(&POINT2D_LIB, 0);
  // copy reference to Point2D table so we can keep the original reference on
  // the stack for later
  state.push_value(-1);
  state.set_global("Point2D");

  // create a metatable for Point2D in the lua registry that refers to the
  // global Point2D table:
  state.new_metatable("Point2D");
  // copy reference to Point2D table
  state.push_value(-2);
  // Point2Dmetatable.__index = Point2D
  state.set_field(-2, "__index");

  // pop metatable and Point2D table from the stack
  state.pop(2);

  // try it out:
  state.do_string("local p = Point2D.new(12, 34)
                   print(p:x(), p:y())");
}

examples/userdata-with-drop/main.rs (line 117)

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

    state.open_libs();

    // make a VecWrapper table globally available to the lua state and register
    // our functions there:
    state.new_table();
    state.set_fns(&VECWRAPPER_LIB, 0);
    // copy reference to VecWrapper table so we can keep the original reference
    // on the stack for later
    state.push_value(-1);
    state.set_global("VecWrapper");

    // create a metatable for VecWrapper in the lua registry that refers to the
    // global VecWrapper table:
    state.new_metatable("VecWrapper");
    // copy reference to VecWrapper table
    state.push_value(-2);
    // VecWrappermetatable.__index = VecWrapper
    state.set_field(-2, "__index");
    // VecWrappermetatable.__gc = lua_gc
    state.push_fn(Some(VecWrapper::lua_gc));
    state.set_field(-2, "__gc");

    // pop metatable and VecWrapper table from the stack
    state.pop(2);

    // try it out:
    state.do_string("local v = VecWrapper.new()
                     v:push(12)
                     v:push(34)
                     -- should print 2
                     print('length of vec is', v:len())
                     -- should print 12 34 nil
                     print(v:get(0), v:get(1), v:get(2))");
}

pub fn set_table(&mut self, idx: Index)

Maps to lua_settable.

pub fn set_field(&mut self, idx: Index, k: &str)

Maps to lua_setfield.

Examples found in repository

examples/userdata/main.rs (line 100)

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

  state.open_libs();

  // make a Point2D table globally available to the lua state and register
  // our functions there:
  state.new_table();
  state.set_fns(&POINT2D_LIB, 0);
  // copy reference to Point2D table so we can keep the original reference on
  // the stack for later
  state.push_value(-1);
  state.set_global("Point2D");

  // create a metatable for Point2D in the lua registry that refers to the
  // global Point2D table:
  state.new_metatable("Point2D");
  // copy reference to Point2D table
  state.push_value(-2);
  // Point2Dmetatable.__index = Point2D
  state.set_field(-2, "__index");

  // pop metatable and Point2D table from the stack
  state.pop(2);

  // try it out:
  state.do_string("local p = Point2D.new(12, 34)
                   print(p:x(), p:y())");
}

examples/userdata-with-drop/main.rs (line 125)

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

    state.open_libs();

    // make a VecWrapper table globally available to the lua state and register
    // our functions there:
    state.new_table();
    state.set_fns(&VECWRAPPER_LIB, 0);
    // copy reference to VecWrapper table so we can keep the original reference
    // on the stack for later
    state.push_value(-1);
    state.set_global("VecWrapper");

    // create a metatable for VecWrapper in the lua registry that refers to the
    // global VecWrapper table:
    state.new_metatable("VecWrapper");
    // copy reference to VecWrapper table
    state.push_value(-2);
    // VecWrappermetatable.__index = VecWrapper
    state.set_field(-2, "__index");
    // VecWrappermetatable.__gc = lua_gc
    state.push_fn(Some(VecWrapper::lua_gc));
    state.set_field(-2, "__gc");

    // pop metatable and VecWrapper table from the stack
    state.pop(2);

    // try it out:
    state.do_string("local v = VecWrapper.new()
                     v:push(12)
                     v:push(34)
                     -- should print 2
                     print('length of vec is', v:len())
                     -- should print 12 34 nil
                     print(v:get(0), v:get(1), v:get(2))");
}

pub fn seti(&mut self, idx: Index, n: Integer)

Maps to lua_seti.

pub fn raw_set(&mut self, idx: Index)

Maps to lua_rawset.

pub fn raw_seti(&mut self, idx: Index, n: Integer)

Maps to lua_rawseti.

pub fn raw_setp<T>(&mut self, idx: Index, p: *const T)

Maps to lua_rawsetp.

pub fn set_metatable(&mut self, objindex: Index)

Maps to lua_setmetatable.

pub fn set_uservalue(&mut self, idx: Index)

Maps to lua_setuservalue.

pub fn callk<F>(&mut self, nargs: c_int, nresults: c_int, continuation: F)

where F: FnOnce(&mut State, ThreadStatus) -> c_int,

Maps to lua_callk.

pub fn call(&mut self, nargs: c_int, nresults: c_int)

Maps to lua_call.

pub fn pcallk<F>( &mut self, nargs: c_int, nresults: c_int, msgh: c_int, continuation: F, ) -> c_int

where F: FnOnce(&mut State, ThreadStatus) -> c_int,

Maps to lua_pcallk.

pub fn pcall( &mut self, nargs: c_int, nresults: c_int, msgh: c_int, ) -> ThreadStatus

Maps to lua_pcall.

pub fn load<F>(&mut self, reader: F, source: &str, mode: &str) -> ThreadStatus

where F: FnMut(&mut State) -> &[u8],

Maps to lua_load.

pub fn dump<F>(&mut self, writer: F, strip: bool) -> c_int

where F: FnMut(&mut State, &[u8]) -> c_int,

Maps to lua_dump.

pub fn co_yieldk<F>(&mut self, nresults: c_int, continuation: F) -> !

where F: FnOnce(&mut State, ThreadStatus) -> c_int,

Maps to lua_yieldk.

pub fn co_yield(&mut self, nresults: c_int) -> !

Maps to lua_yield. This function is not called yield because it is a reserved keyword.

pub fn resume(&mut self, from: Option<&mut State>, nargs: c_int) -> ThreadStatus

Maps to lua_resume.

pub fn status(&mut self) -> ThreadStatus

Maps to lua_status.

pub fn is_yieldable(&mut self) -> bool

Maps to lua_isyieldable.

pub fn gc(&mut self, what: GcOption, data: c_int) -> c_int

Maps to lua_gc.

pub fn error(&mut self) -> !

Maps to lua_error.

pub fn next(&mut self, idx: Index) -> bool

Maps to lua_next.

pub fn concat(&mut self, n: c_int)

Maps to lua_concat.

pub fn len(&mut self, idx: Index)

Maps to lua_len.

pub fn string_to_number(&mut self, s: &str) -> size_t

Maps to lua_stringtonumber.

pub fn get_alloc_fn(&mut self) -> (Allocator, *mut c_void)

Maps to lua_getallocf.

pub fn set_alloc_fn(&mut self, f: Allocator, ud: *mut c_void)

Maps to lua_setallocf.

pub fn set_extra(&mut self, extra: Option<Extra>) -> Option<Extra>

Set extra data. Return previous value if it was set.

pub fn with_extra<F, R>(&mut self, closure: F) -> R

where F: FnOnce(&mut Option<Extra>) -> R,

Do some actions with mutable extra.

pub fn with_extra_typed<T, F, R>(&mut self, closure: F) -> R

where T: Any, F: FnOnce(&mut T) -> R,

Unwrap and downcast extra to typed.

Panics

Panics if state has no attached Extra or it’s impossible to downcast to T.

pub fn to_number(&mut self, index: Index) -> Number

Maps to lua_tonumber.

pub fn to_integer(&mut self, index: Index) -> Integer

Maps to lua_tointeger.

pub fn pop(&mut self, n: c_int)

Maps to lua_pop.

Examples found in repository

examples/userdata/main.rs (line 103)

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

  state.open_libs();

  // make a Point2D table globally available to the lua state and register
  // our functions there:
  state.new_table();
  state.set_fns(&POINT2D_LIB, 0);
  // copy reference to Point2D table so we can keep the original reference on
  // the stack for later
  state.push_value(-1);
  state.set_global("Point2D");

  // create a metatable for Point2D in the lua registry that refers to the
  // global Point2D table:
  state.new_metatable("Point2D");
  // copy reference to Point2D table
  state.push_value(-2);
  // Point2Dmetatable.__index = Point2D
  state.set_field(-2, "__index");

  // pop metatable and Point2D table from the stack
  state.pop(2);

  // try it out:
  state.do_string("local p = Point2D.new(12, 34)
                   print(p:x(), p:y())");
}

examples/userdata-with-drop/main.rs (line 131)

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

    state.open_libs();

    // make a VecWrapper table globally available to the lua state and register
    // our functions there:
    state.new_table();
    state.set_fns(&VECWRAPPER_LIB, 0);
    // copy reference to VecWrapper table so we can keep the original reference
    // on the stack for later
    state.push_value(-1);
    state.set_global("VecWrapper");

    // create a metatable for VecWrapper in the lua registry that refers to the
    // global VecWrapper table:
    state.new_metatable("VecWrapper");
    // copy reference to VecWrapper table
    state.push_value(-2);
    // VecWrappermetatable.__index = VecWrapper
    state.set_field(-2, "__index");
    // VecWrappermetatable.__gc = lua_gc
    state.push_fn(Some(VecWrapper::lua_gc));
    state.set_field(-2, "__gc");

    // pop metatable and VecWrapper table from the stack
    state.pop(2);

    // try it out:
    state.do_string("local v = VecWrapper.new()
                     v:push(12)
                     v:push(34)
                     -- should print 2
                     print('length of vec is', v:len())
                     -- should print 12 34 nil
                     print(v:get(0), v:get(1), v:get(2))");
}

pub fn new_table(&mut self)

Maps to lua_newtable.

Examples found in repository

examples/userdata/main.rs (line 87)

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

  state.open_libs();

  // make a Point2D table globally available to the lua state and register
  // our functions there:
  state.new_table();
  state.set_fns(&POINT2D_LIB, 0);
  // copy reference to Point2D table so we can keep the original reference on
  // the stack for later
  state.push_value(-1);
  state.set_global("Point2D");

  // create a metatable for Point2D in the lua registry that refers to the
  // global Point2D table:
  state.new_metatable("Point2D");
  // copy reference to Point2D table
  state.push_value(-2);
  // Point2Dmetatable.__index = Point2D
  state.set_field(-2, "__index");

  // pop metatable and Point2D table from the stack
  state.pop(2);

  // try it out:
  state.do_string("local p = Point2D.new(12, 34)
                   print(p:x(), p:y())");
}

examples/userdata-with-drop/main.rs (line 112)

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

    state.open_libs();

    // make a VecWrapper table globally available to the lua state and register
    // our functions there:
    state.new_table();
    state.set_fns(&VECWRAPPER_LIB, 0);
    // copy reference to VecWrapper table so we can keep the original reference
    // on the stack for later
    state.push_value(-1);
    state.set_global("VecWrapper");

    // create a metatable for VecWrapper in the lua registry that refers to the
    // global VecWrapper table:
    state.new_metatable("VecWrapper");
    // copy reference to VecWrapper table
    state.push_value(-2);
    // VecWrappermetatable.__index = VecWrapper
    state.set_field(-2, "__index");
    // VecWrappermetatable.__gc = lua_gc
    state.push_fn(Some(VecWrapper::lua_gc));
    state.set_field(-2, "__gc");

    // pop metatable and VecWrapper table from the stack
    state.pop(2);

    // try it out:
    state.do_string("local v = VecWrapper.new()
                     v:push(12)
                     v:push(34)
                     -- should print 2
                     print('length of vec is', v:len())
                     -- should print 12 34 nil
                     print(v:get(0), v:get(1), v:get(2))");
}

pub fn register(&mut self, n: &str, f: Function)

Maps to lua_register.

pub fn push_fn(&mut self, f: Function)

Maps to lua_pushcfunction.

Examples found in repository

examples/userdata-with-drop/main.rs (line 127)

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

    state.open_libs();

    // make a VecWrapper table globally available to the lua state and register
    // our functions there:
    state.new_table();
    state.set_fns(&VECWRAPPER_LIB, 0);
    // copy reference to VecWrapper table so we can keep the original reference
    // on the stack for later
    state.push_value(-1);
    state.set_global("VecWrapper");

    // create a metatable for VecWrapper in the lua registry that refers to the
    // global VecWrapper table:
    state.new_metatable("VecWrapper");
    // copy reference to VecWrapper table
    state.push_value(-2);
    // VecWrappermetatable.__index = VecWrapper
    state.set_field(-2, "__index");
    // VecWrappermetatable.__gc = lua_gc
    state.push_fn(Some(VecWrapper::lua_gc));
    state.set_field(-2, "__gc");

    // pop metatable and VecWrapper table from the stack
    state.pop(2);

    // try it out:
    state.do_string("local v = VecWrapper.new()
                     v:push(12)
                     v:push(34)
                     -- should print 2
                     print('length of vec is', v:len())
                     -- should print 12 34 nil
                     print(v:get(0), v:get(1), v:get(2))");
}

pub fn is_fn(&mut self, index: Index) -> bool

Maps to lua_isfunction.

pub fn is_table(&mut self, index: Index) -> bool

Maps to lua_istable.

pub fn is_light_userdata(&mut self, index: Index) -> bool

Maps to lua_islightuserdata.

pub fn is_nil(&mut self, index: Index) -> bool

Maps to lua_isnil.

pub fn is_bool(&mut self, index: Index) -> bool

Maps to lua_isboolean.

pub fn is_thread(&mut self, index: Index) -> bool

Maps to lua_isthread.

pub fn is_none(&mut self, index: Index) -> bool

Maps to lua_isnone.

pub fn is_none_or_nil(&mut self, index: Index) -> bool

Maps to lua_isnoneornil.

pub fn push_global_table(&mut self)

Maps to lua_pushglobaltable.

pub fn insert(&mut self, idx: Index)

Maps to lua_insert.

pub fn remove(&mut self, idx: Index)

Maps to lua_remove.

pub fn replace(&mut self, idx: Index)

Maps to lua_replace.

pub fn get_stack(&mut self, level: c_int) -> Option<lua_Debug>

Maps to lua_getstack.

pub fn get_info(&mut self, what: &str) -> Option<lua_Debug>

Maps to lua_getinfo.

pub fn get_local(&mut self, ar: &lua_Debug, n: c_int) -> Option<&str>

Maps to lua_getlocal.

pub fn set_local(&mut self, ar: &lua_Debug, n: c_int) -> Option<&str>

Maps to lua_setlocal.

pub fn get_upvalue(&mut self, funcindex: Index, n: c_int) -> Option<&str>

Maps to lua_getupvalue.

pub fn set_upvalue(&mut self, funcindex: Index, n: c_int) -> Option<&str>

Maps to lua_setupvalue.

pub fn upvalue_id(&mut self, funcindex: Index, n: c_int) -> *mut c_void

Maps to lua_upvalueid.

pub fn upvalue_join(&mut self, fidx1: Index, n1: c_int, fidx2: Index, n2: c_int)

Maps to lua_upvaluejoin.

pub fn set_hook(&mut self, func: Hook, mask: HookMask, count: c_int)

Maps to lua_sethook.

pub fn get_hook(&mut self) -> Hook

Maps to lua_gethook.

pub fn get_hook_mask(&mut self) -> HookMask

Maps to lua_gethookmask.

pub fn get_hook_count(&mut self) -> c_int

Maps to lua_gethookcount.

pub fn check_version(&mut self)

Maps to luaL_checkversion.

pub fn get_metafield(&mut self, obj: Index, e: &str) -> bool

Maps to luaL_getmetafield.

pub fn call_meta(&mut self, obj: Index, e: &str) -> bool

Maps to luaL_callmeta.

pub fn to_str(&mut self, index: Index) -> Option<&str>

Maps to luaL_tolstring. This function is not called to_string because that method name is used for the ToString trait. This function returns a reference to the string at the given index, on which to_owned may be called.

pub fn to_str_in_place(&mut self, index: Index) -> Option<&str>

Maps to lua_tolstring. This function is not called to_string because that method name is used for the ToString trait. This function returns a reference to the string at the given index, on which to_owned may be called.

pub fn arg_error(&mut self, arg: Index, extramsg: &str) -> !

Maps to luaL_argerror.

pub fn check_number(&mut self, arg: Index) -> Number

Maps to luaL_checknumber.

pub fn opt_number(&mut self, arg: Index, def: Number) -> Number

Maps to luaL_optnumber.

pub fn check_integer(&mut self, arg: Index) -> Integer

Maps to luaL_checkinteger.

Examples found in repository

examples/userdata-with-drop/main.rs (line 60)

  unsafe extern "C" fn lua_get(L: *mut lua_State) -> c_int {
    let mut state = State::from_ptr(L);
    let v = state.check_userdata(1, "VecWrapper") as *mut VecWrapper;
    let i = state.check_integer(2) as usize;
    // push integer if index is not out of bounds, otherwise nil
    match (*v).data.get(i) {
      Some(value) => state.push_integer(*value),
      None        => state.push_nil()
    };
    1
  }

  /// Pushes a value into the underlying Vec.
  #[allow(non_snake_case)]
  unsafe extern "C" fn lua_push(L: *mut lua_State) -> c_int {
    let mut state = State::from_ptr(L);
    let v = state.check_userdata(1, "VecWrapper") as *mut VecWrapper;
    let i = state.check_integer(2);
    (*v).data.push(i);
    1
  }

pub fn opt_integer(&mut self, arg: Index, def: Integer) -> Integer

Maps to luaL_optinteger.

Examples found in repository

examples/userdata/main.rs (line 47)

  unsafe extern "C" fn lua_new(L: *mut lua_State) -> c_int {
    let mut state = State::from_ptr(L);
    // takes two optional integer parameters
    let x = state.opt_integer(1, 0);
    let y = state.opt_integer(2, 0);
    // construct new userdata in lua space and initialize it
    *state.new_userdata_typed::<Point2D>() = Point2D::new(x, y);
    // set the userdata's metatable so we can call methods on it
    state.set_metatable_from_registry("Point2D");
    // return the userdata on top of the stack
    1
  }

pub fn check_stack_msg(&mut self, sz: c_int, msg: &str)

Maps to luaL_checkstack.

pub fn check_type(&mut self, arg: Index, t: Type)

Maps to luaL_checktype.

pub fn check_any(&mut self, arg: Index)

Maps to luaL_checkany.

pub fn new_metatable(&mut self, tname: &str) -> bool

Maps to luaL_newmetatable.

Examples found in repository

examples/userdata/main.rs (line 96)

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

  state.open_libs();

  // make a Point2D table globally available to the lua state and register
  // our functions there:
  state.new_table();
  state.set_fns(&POINT2D_LIB, 0);
  // copy reference to Point2D table so we can keep the original reference on
  // the stack for later
  state.push_value(-1);
  state.set_global("Point2D");

  // create a metatable for Point2D in the lua registry that refers to the
  // global Point2D table:
  state.new_metatable("Point2D");
  // copy reference to Point2D table
  state.push_value(-2);
  // Point2Dmetatable.__index = Point2D
  state.set_field(-2, "__index");

  // pop metatable and Point2D table from the stack
  state.pop(2);

  // try it out:
  state.do_string("local p = Point2D.new(12, 34)
                   print(p:x(), p:y())");
}

examples/userdata-with-drop/main.rs (line 121)

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

    state.open_libs();

    // make a VecWrapper table globally available to the lua state and register
    // our functions there:
    state.new_table();
    state.set_fns(&VECWRAPPER_LIB, 0);
    // copy reference to VecWrapper table so we can keep the original reference
    // on the stack for later
    state.push_value(-1);
    state.set_global("VecWrapper");

    // create a metatable for VecWrapper in the lua registry that refers to the
    // global VecWrapper table:
    state.new_metatable("VecWrapper");
    // copy reference to VecWrapper table
    state.push_value(-2);
    // VecWrappermetatable.__index = VecWrapper
    state.set_field(-2, "__index");
    // VecWrappermetatable.__gc = lua_gc
    state.push_fn(Some(VecWrapper::lua_gc));
    state.set_field(-2, "__gc");

    // pop metatable and VecWrapper table from the stack
    state.pop(2);

    // try it out:
    state.do_string("local v = VecWrapper.new()
                     v:push(12)
                     v:push(34)
                     -- should print 2
                     print('length of vec is', v:len())
                     -- should print 12 34 nil
                     print(v:get(0), v:get(1), v:get(2))");
}

pub fn set_metatable_from_registry(&mut self, tname: &str)

Maps to luaL_setmetatable.

Examples found in repository

examples/userdata-with-drop/main.rs (line 49)

  unsafe extern "C" fn lua_new(L: *mut lua_State) -> c_int {
    let mut state = State::from_ptr(L);
    // construct new userdata in lua space and initialize it
    let v: *mut VecWrapper = state.new_userdata_typed();
    std::ptr::write(v, VecWrapper::new());
    // set the userdata's metatable so we can call methods on it
    state.set_metatable_from_registry("VecWrapper");
    // return the userdata on top of the stack
    1
  }

examples/userdata/main.rs (line 52)

  unsafe extern "C" fn lua_new(L: *mut lua_State) -> c_int {
    let mut state = State::from_ptr(L);
    // takes two optional integer parameters
    let x = state.opt_integer(1, 0);
    let y = state.opt_integer(2, 0);
    // construct new userdata in lua space and initialize it
    *state.new_userdata_typed::<Point2D>() = Point2D::new(x, y);
    // set the userdata's metatable so we can call methods on it
    state.set_metatable_from_registry("Point2D");
    // return the userdata on top of the stack
    1
  }

pub fn test_userdata(&mut self, arg: Index, tname: &str) -> *mut c_void

Maps to luaL_testudata.

pub unsafe fn test_userdata_typed<'a, T>( &'a mut self, arg: Index, tname: &str, ) -> Option<&'a mut T>

Convenience function that calls test_userdata and performs a cast.

pub fn check_userdata(&mut self, arg: Index, tname: &str) -> *mut c_void

Maps to luaL_checkudata.

Examples found in repository

examples/userdata/main.rs (line 60)

  unsafe extern "C" fn lua_x(L: *mut lua_State) -> c_int {
    let mut state = State::from_ptr(L);
    let point = state.check_userdata(1, "Point2D") as *mut Point2D;
    state.push_integer((*point).x);
    1
  }

  #[allow(non_snake_case)]
  unsafe extern "C" fn lua_y(L: *mut lua_State) -> c_int {
    let mut state = State::from_ptr(L);
    let point = state.check_userdata(1, "Point2D") as *mut Point2D;
    state.push_integer((*point).y);
    1
  }

examples/userdata-with-drop/main.rs (line 59)

  unsafe extern "C" fn lua_get(L: *mut lua_State) -> c_int {
    let mut state = State::from_ptr(L);
    let v = state.check_userdata(1, "VecWrapper") as *mut VecWrapper;
    let i = state.check_integer(2) as usize;
    // push integer if index is not out of bounds, otherwise nil
    match (*v).data.get(i) {
      Some(value) => state.push_integer(*value),
      None        => state.push_nil()
    };
    1
  }

  /// Pushes a value into the underlying Vec.
  #[allow(non_snake_case)]
  unsafe extern "C" fn lua_push(L: *mut lua_State) -> c_int {
    let mut state = State::from_ptr(L);
    let v = state.check_userdata(1, "VecWrapper") as *mut VecWrapper;
    let i = state.check_integer(2);
    (*v).data.push(i);
    1
  }

  /// Returns the length of the underlying Vec.
  #[allow(non_snake_case)]
  unsafe extern "C" fn lua_len(L: *mut lua_State) -> c_int {
    let mut state = State::from_ptr(L);
    let v = state.check_userdata(1, "VecWrapper") as *mut VecWrapper;
    state.push_integer((*v).data.len() as i64);
    1
  }

  /// Garbage collects a VecWrapper.
  #[allow(non_snake_case)]
  unsafe extern "C" fn lua_gc(L: *mut lua_State) -> c_int {
    let mut state = State::from_ptr(L);
    let v = state.check_userdata(1, "VecWrapper") as *mut VecWrapper;
    std::ptr::drop_in_place(v);
    0
  }

pub unsafe fn check_userdata_typed<'a, T>( &'a mut self, arg: Index, tname: &str, ) -> &'a mut T

Convenience function that calls check_userdata and performs a cast.

pub fn location(&mut self, lvl: c_int)

Maps to luaL_where. where is a reserved keyword.

pub fn check_option( &mut self, arg: Index, def: Option<&str>, lst: &[&str], ) -> usize

Maps to luaL_checkoption.

pub fn file_result(&mut self, stat: c_int, fname: &str) -> c_int

Maps to luaL_fileresult.

pub fn exec_result(&mut self, stat: c_int) -> c_int

Maps to luaL_execresult.

pub fn reference(&mut self, t: Index) -> Reference

Maps to luaL_ref.

pub fn unreference(&mut self, t: Index, reference: Reference)

Maps to luaL_unref.

pub fn load_filex(&mut self, filename: &str, mode: &str) -> ThreadStatus

Maps to luaL_loadfilex.

pub fn load_file(&mut self, filename: &str) -> ThreadStatus

Maps to luaL_loadfile.

pub fn load_bufferx( &mut self, buff: &[u8], name: &str, mode: &str, ) -> ThreadStatus

Maps to luaL_loadbufferx.

pub fn load_string(&mut self, source: &str) -> ThreadStatus

Maps to luaL_loadstring.

pub fn len_direct(&mut self, index: Index) -> Integer

Maps to luaL_len.

pub fn gsub(&mut self, s: &str, p: &str, r: &str) -> &str

Maps to luaL_gsub.

pub fn set_fns(&mut self, l: &[(&str, Function)], nup: c_int)

Maps to luaL_setfuncs.

Examples found in repository

examples/userdata/main.rs (line 88)

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

  state.open_libs();

  // make a Point2D table globally available to the lua state and register
  // our functions there:
  state.new_table();
  state.set_fns(&POINT2D_LIB, 0);
  // copy reference to Point2D table so we can keep the original reference on
  // the stack for later
  state.push_value(-1);
  state.set_global("Point2D");

  // create a metatable for Point2D in the lua registry that refers to the
  // global Point2D table:
  state.new_metatable("Point2D");
  // copy reference to Point2D table
  state.push_value(-2);
  // Point2Dmetatable.__index = Point2D
  state.set_field(-2, "__index");

  // pop metatable and Point2D table from the stack
  state.pop(2);

  // try it out:
  state.do_string("local p = Point2D.new(12, 34)
                   print(p:x(), p:y())");
}

examples/userdata-with-drop/main.rs (line 113)

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

    state.open_libs();

    // make a VecWrapper table globally available to the lua state and register
    // our functions there:
    state.new_table();
    state.set_fns(&VECWRAPPER_LIB, 0);
    // copy reference to VecWrapper table so we can keep the original reference
    // on the stack for later
    state.push_value(-1);
    state.set_global("VecWrapper");

    // create a metatable for VecWrapper in the lua registry that refers to the
    // global VecWrapper table:
    state.new_metatable("VecWrapper");
    // copy reference to VecWrapper table
    state.push_value(-2);
    // VecWrappermetatable.__index = VecWrapper
    state.set_field(-2, "__index");
    // VecWrappermetatable.__gc = lua_gc
    state.push_fn(Some(VecWrapper::lua_gc));
    state.set_field(-2, "__gc");

    // pop metatable and VecWrapper table from the stack
    state.pop(2);

    // try it out:
    state.do_string("local v = VecWrapper.new()
                     v:push(12)
                     v:push(34)
                     -- should print 2
                     print('length of vec is', v:len())
                     -- should print 12 34 nil
                     print(v:get(0), v:get(1), v:get(2))");
}

pub fn get_subtable(&mut self, idx: Index, fname: &str) -> bool

Maps to luaL_getsubtable.

pub fn traceback(&mut self, state: &mut State, msg: &str, level: c_int)

Maps to luaL_traceback.

pub fn requiref(&mut self, modname: &str, openf: Function, glb: bool)

Maps to luaL_requiref.

pub fn new_lib_table(&mut self, l: &[(&str, Function)])

Maps to luaL_newlibtable.

pub fn new_lib(&mut self, l: &[(&str, Function)])

Maps to luaL_newlib.

pub fn arg_check(&mut self, cond: bool, arg: Index, extramsg: &str)

Maps to luaL_argcheck.

pub fn check_string(&mut self, n: Index) -> &str

Maps to luaL_checklstring.

pub fn opt_string<'a>(&'a mut self, n: Index, default: &'a str) -> &'a str

Maps to luaL_optlstring.

pub fn typename_at(&mut self, n: Index) -> &'static str

Maps to luaL_typename.

pub fn get_metatable_from_registry(&mut self, tname: &str)

Maps to luaL_getmetatable.

pub fn load_buffer(&mut self, buff: &[u8], name: &str) -> ThreadStatus

Maps to luaL_loadbuffer.

Trait Implementations

impl Drop for State

fn drop(&mut self)

Executes the destructor for this type.

impl Send for State