Struct luajit::state::State

pub struct State { /* fields omitted */ }

Methods

impl State

pub fn new() -> State

Calls LUA C API to instantiate a new Lua state.

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

Wraps an existing Lua state. Suitable for use in function handlers passed to Lua through the C API.

pub fn open_libs(&mut self)

Opens the Lua standard library on this state.

You can use the other open_* methods to fine tune what library functions should be available to Lua scripts.

pub fn open_base(&mut self)

Opens the Lua basic library on this state.

pub fn open_math(&mut self)

Opens the Lua math library on this state.

pub fn open_string(&mut self)

Opens the Lua string library on this state.

pub fn open_table(&mut self)

Opens the Lua table library on this state.

pub fn open_io(&mut self)

Opens the Lua io library on this state.

pub fn open_os(&mut self)

Opens the Lua os library on this state.

pub fn open_package(&mut self)

Opens the Lua package library on this state.

pub fn open_debug(&mut self)

Opens the Lua debug library on this state.

pub fn open_bit(&mut self)

Opens the Lua bit library on this state.

pub fn open_jit(&mut self)

Opens the LuaJIT JIT library on this state.

pub fn open_ffi(&mut self)

Opens the Lua FFI library on this state.

pub fn settop(&mut self, idx: i32)

Sets the top of the stack to the valid index idx

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

Pops a value from the top of the stack

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

Executes an arbitrary string as Lua code.

Examples

use luajit::{State, ThreadStatus};
 
let mut state = State::new(); // Create new Lua state
state.open_base(); // Need to open base libraries for `print` to be available
 
let status = state.do_string(r#"print("Hello world!")"#);
assert!(status == ThreadStatus::Ok);

pub fn call(&mut self, nargs: i32, nres: i32)

Maps to lua_call, calls the function on the top of the stack.

pub fn pcall(
    &mut self,
    nargs: i32,
    nres: i32,
    err_func: i32
) -> Result<(), (ThreadStatus, String)>

Maps to lua_pcall and automatically catches an error, returning the string on the top of the stack as an Err result.

pub fn pcallx(&mut self, nargs: i32, nres: i32, err_func: i32) -> ThreadStatus

Maps directly to lua_pcall without additional handling.

pub fn register(&mut self, name: &str, f: LuaFunction)

Registers function f as a Lua global named name

Examples

use luajit::{State, ThreadStatus, c_int};
use luajit::ffi::lua_State;
 
unsafe extern "C" fn hello(L: *mut lua_State) -> c_int {
    println!("Hello world!");
 
    0
}
 
let mut state = State::new();
state.register("hello", hello);
 
let status = state.do_string("hello()");
assert!(status == ThreadStatus::Ok);

Using an argument.

use luajit::{State, ThreadStatus, c_int};
use luajit::ffi::lua_State;
 
unsafe extern "C" fn hello_name(l: *mut lua_State) -> c_int {
    let mut state = State::from_ptr(l);
    match state.to_str(1) {
        Some(s) => println!("Hello {}", s),
        None => println!("You have no name!"),
    }
 
    0
}
 
let mut state = State::new();
state.register("hello", hello_name);
 
let status = state.do_string(r#"hello("world!")"#);
assert!(status == ThreadStatus::Ok);

pub fn is_number(&mut self, idx: c_int) -> bool

Test if the value at idx on the stack is a number.

pub fn is_string(&mut self, idx: c_int) -> bool

Test if the value at idx on the stack is a string.

pub fn is_bool(&mut self, idx: c_int) -> bool

Test if the value at idx on the stack is a boolean.

pub fn is_userdata(&mut self, idx: c_int) -> bool

Test if the value at idx on the stack is a userdata object

pub fn to_str(&mut self, idx: c_int) -> Option<&str>

Retrieves a string from the Lua stack.

pub fn to_int(&mut self, idx: c_int) -> Option<i32>

Return the value on the stack at idx as an integer.

pub fn to_long(&mut self, idx: c_int) -> Option<i64>

Return the value on the stack at idx as an integer.

pub fn to_bool(&mut self, idx: c_int) -> Option<bool>

Return the value on the stack at idx as an bool.

pub fn to_float(&mut self, idx: c_int) -> Option<f32>

Return the value on the stack at idx as an float.

pub fn to_double(&mut self, idx: c_int) -> Option<f64>

Return the value on the stack at idx as an double.

pub fn to_raw_userdata(&mut self, idx: c_int) -> Option<*mut c_void>

Returns the userdata on the top of the Lua stack as a raw pointer

pub fn to_userdata<T>(&mut self, idx: c_int) -> Option<*mut T>

Returns the userdata from the top of the Lua stack, cast as a pointer to type T

See new_userdata for more usage.

pub fn check_userdata_ex<T>(&mut self, idx: c_int, ty: &str) -> Option<*mut T>

Validates that the userdata at idx has metatable ty from the Lua registry and returns a pointer to the userdata object

pub fn check_userdata<T>(&mut self, idx: i32) -> Option<*mut T> where
    T: LuaObject, 

Validates that the userdata at idx is an instance of struct T where T implements LuaObject, and returns a pointer to the userdata object

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

Pops a value of the Lua stack and sets it as a global value named name

pub fn set_field(&mut self, idx: i32, name: &str)

Sets the value of name on the table t pointed to by idx as the value on the top of the stack.

Equivalent to t[name] = v where t is the value at idx and v is the value at the top of the stack

pub fn register_fns(&mut self, name: Option<&str>, fns: Vec<luaL_Reg>)

Registers all functions in fns on the global table name. If name is None, all functions are instead registered on the value on the top of the stack.

pub fn push_value(&mut self, idx: i32)

Copys the value at idx to the top of the stack

pub fn push<T>(&mut self, val: T) where
    T: LuaValue, 

Pushes a LuaValue to the lua stack.

Examples

use luajit::State;
 
let mut state = State::new();
state.push(5);
state.push("Hello world!");

Can also be used with structs that implement LuaObject

#[macro_use] extern crate luajit;
 
use luajit::{State, LuaObject, c_int};
use luajit::ffi::luaL_Reg;
 
struct Point2D {
    x: i32,
    y: i32,
}
 
impl LuaObject for Point2D {
    fn name() -> *const i8 {
        c_str!("Point2D")
    }
 
    fn lua_fns() -> Vec<luaL_Reg> {
        vec!(lua_method!("add", Point2D, Point2D::add))
    }
}
 
impl Point2D {
    fn add(&mut self, state: &mut State) -> c_int {
        state.push(self.x + self.y);
 
        1
    }
 
    fn new() -> Point2D {
        Point2D {
            x: 0,
            y: 0,
        }
    }
}
 
 
fn main() {
    let mut state = State::new();
    state.open_libs();
    state.push(Point2D::new());
    state.set_global("point");
    let res = state.do_string(r#"print(point:add())"#);
    assert_eq!(res, luajit::ThreadStatus::Ok);
}

pub fn push_nil(&mut self)

Push a new nil value onto the Lua stack.

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

Gets a value from the globals object and pushes it to the top of the stack.

pub fn get_field(&mut self, idx: i32, name: &str)

Gets a value name from the table on the stack at idx and and pushes the fetched value to the top of the stack.

pub fn new_table(&mut self)

Creates a new table and pushes it to the top of the stack

pub fn new_raw_userdata(&mut self, sz: usize) -> *mut c_void

Allocates a new Lua userdata block, and returns the pointer to it. The returned pointer is owned by the Lua state.

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

Allocates a new Lua userdata block of size sizeof(T) for use to store Rust objects on the Lua stack. The returned pointer is owned by the Lua state.

Examples

Useful for pushing an arbitrary struct to the Lua stack

extern crate luajit;
 
use luajit::State;
 
struct Point2D {
    x: i32,
    y: i32,
}
 
impl Point2D {
    fn add(&self) -> i32 {
        self.x + self.y
    }
     
    fn set_x(&mut self, x: i32) {
        self.x = x;
    }
 
    fn set_y(&mut self, y: i32) {
        self.y = y;
    }
 
    fn new() -> Point2D {
        Point2D {
            x: 0,
            y: 0,
        }
    }
}
 
 
fn main() {
    let mut state = State::new();
    state.open_libs();
    unsafe {
        *state.new_userdata() = Point2D::new();
    }
 
    let point: &mut Point2D = unsafe { &mut *state.to_userdata(-1).unwrap() };
     
    point.set_x(2);
    point.set_y(4);
 
    assert_eq!(point.add(), 6);
}

pub fn register_struct<T>(&mut self) where
    T: LuaObject, 

Registers all of the methods for LuaObject T as a global metatable with name struct_type and leaves it on the top of the stack.

pub fn load_file(&mut self, path: &Path) -> Result<(), (ThreadStatus, String)>

Maps to luaL_loadfile, this method validates that the file exists before passing it into the Lua C API.

pub fn do_file(&mut self, path: &Path) -> Result<(), (ThreadStatus, String)>

Equivalent of luaL_dofile, loads a file and then immediately executes it with pcall, returning the result.

pub fn checkstack(&mut self, n: usize) -> bool

Ensures that there are at least n free stack slots in the stack. Returns false if it cannot grow the stack to that size.

Trait Implementations

impl Drop for State

fn drop(&mut self)

Executes the destructor for this type.